import { Noosphere } from 'noosphere';

const ai = new Noosphere();

// Chat with any LLM
const response = await ai.chat({
  messages: [{ role: 'user', content: 'Hello!' }],
});
console.log(response.content);

// Generate an image with GPT-Image-1 (OpenAI) — just needs OPENAI_API_KEY
const image = await ai.image({
  prompt: 'A sunset over mountains',
  provider: 'openai-media',
});
// image.buffer contains the PNG data

// Generate an image with Imagen 4.0 (Google) — just needs GEMINI_API_KEY
const googleImage = await ai.image({
  prompt: 'A sunset over mountains',
  provider: 'google-media',
});
// googleImage.buffer contains the PNG data

// Generate an image with DALL-E 3
const dalle = await ai.image({
  prompt: 'A sunset over mountains',
  provider: 'openai-media',
  model: 'dall-e-3',
  width: 1024,
  height: 1024,
});
console.log(dalle.url);

// Generate a video
const video = await ai.video({
  prompt: 'Ocean waves crashing on rocks',
  duration: 5,
});
console.log(video.url);

// Text-to-speech with OpenAI TTS — just needs OPENAI_API_KEY
const audio = await ai.speak({
  text: 'Welcome to Noosphere',
  voice: 'alloy',
  format: 'mp3',
});
// audio.buffer contains the audio data

const models = await ai.getModels('llm');

for (const model of models) {
  console.log(model.id, model.logo);
  // "gpt-5"          { svg: "https://...cdn.../openai.svg", png: "https://...cdn.../openai.png" }
  // "claude-opus-4-6" { svg: "https://...cdn.../anthropic.svg", png: "https://...cdn.../anthropic.png" }
  // "gemini-2.5-pro"  { svg: "https://...cdn.../google.svg", png: "https://...cdn.../google.png" }
}

// Use directly in your UI:
// <img src={model.logo.svg} alt={model.provider} />
// <img src={model.logo.png} width={48} height={48} />;
}

// Providers also have logos:
const providers = await ai.getProviders();
providers.forEach(p => console.log(p.id, p.logo));

import { getProviderLogo, PROVIDER_LOGOS, getAllProviderLogos } from 'noosphere';

const logo = getProviderLogo('anthropic');
// { svg: "https://...cdn.../anthropic.svg", png: "https://...cdn.../anthropic.png" }

// Get all logos as a map:
const allLogos = getAllProviderLogos();
console.log(Object.keys(allLogos));
// ['openai', 'anthropic', 'google', 'groq', 'mistral', 'xai', 'openrouter', ...]

const hfModels = await ai.getModels('llm');
const qwen = hfModels.find(m => m.id === 'Qwen/Qwen2.5-72B-Instruct');

console.log(qwen.capabilities.inferenceProviderLogos);
// {
//   "together": { svg: "https://...cdn.../together.svg", png: "https://...cdn.../together.png" },
//   "fireworks-ai": { svg: "https://...cdn.../fireworks-ai.svg", png: "https://...cdn.../fireworks-ai.png" },
// }

// New model "gpt-4.5-turbo" discovered from OpenAI's /v1/models:
{
  id: 'gpt-4.5-turbo',
  name: 'gpt-4.5-turbo',
  api: 'openai-responses',              // Correct protocol for OpenAI
  provider: 'openai',
  baseUrl: 'https://api.openai.com/v1',
  reasoning: false,                      // Inferred from model ID prefix
  input: ['text', 'image'],
  cost: { input: 2.5, output: 10, ... },  // Inherited from template model
  contextWindow: 128000,                   // From template or API response
  maxTokens: 16384,
}
// This object is passed directly to pi-ai's complete()/stream() — works immediately

// FAL returns an array with ALL available endpoints + live pricing:
[
  { modelId: "fal-ai/flux-pro/v1.1-ultra", price: 0.06, unit: "per_image" },
  { modelId: "fal-ai/kling-video/v2/master/text-to-video", price: 0.10, unit: "per_second" },
  { modelId: "fal-ai/kokoro/american-english", price: 0.002, unit: "per_1k_chars" },
  // ... 867+ endpoints total
]

// Modality is auto-inferred from model ID + pricing unit:
// - unit contains 'char' OR id contains 'tts'/'kokoro'/'elevenlabs' → TTS
// - unit contains 'second' OR id contains 'video'/'kling'/'sora'/'veo' → Video
// - Everything else → Image

const ai = new Noosphere();

// Models are auto-fetched on first call — no action needed:
await ai.chat({ model: 'gemini-2.5-ultra', messages: [...] }); // works immediately

// Trigger a full sync across ALL providers:
const result = await ai.syncModels();
// result = { synced: 1200+, byProvider: { 'pi-ai': 300, 'fal': 867, 'huggingface': 130, ... }, errors: [] }

// Get all models for a specific modality:
const imageModels = await ai.getModels('image');
// Returns: FAL image models + HuggingFace image models + ComfyUI models

const ai = new Noosphere();
await ai.syncModels();

// 774 models discovered — cloud + local, all modalities
const all = await ai.getModels();

// Filter by what you can run locally
const localModels = all.filter(m => m.local || m.status === 'installed');

// What's installed vs what's available to download
const installed = all.filter(m => m.status === 'installed');   // 39 models ready to use
const available = all.filter(m => m.status === 'available');   // 251 models you can download

// Chat with a local Ollama model — same API as cloud
const result = await ai.chat({
  model: 'qwen3:8b',
  provider: 'ollama',
  messages: [{ role: 'user', content: 'Hello!' }],
});
console.log(result.content);   // "Hello! How can I help?"
console.log(result.usage);     // { cost: 0, input: 24, output: 198, unit: 'tokens' }

// Install a new model from Ollama library
await ai.installModel('deepseek-r1:14b');

// Uninstall
await ai.uninstallModel('deepseek-r1:14b');

// Sync only LLM providers (Ollama, pi-ai, openai-compat, huggingface)
await ai.syncModels('llm');

// Sync only image providers (hf-local, comfyui, fal, huggingface)
await ai.syncModels('image');

// Sync only STT providers (whisper-local, hf-local)
await ai.syncModels('stt');

// Sync everything (backward compatible)
await ai.syncModels();

const models = await ai.getModels();

// Filter by modality
const llm    = models.filter(m => m.modality === 'llm');    // 552 (cloud + Ollama local)
const image  = models.filter(m => m.modality === 'image');  // 101 (FLUX, SDXL, SD3, PixArt...)
const tts    = models.filter(m => m.modality === 'tts');    //  61 (MusicGen, Bark, Piper, Kokoro...)
const video  = models.filter(m => m.modality === 'video');  //  30 (Wan2.2, CogVideoX, AnimateDiff...)
const stt    = models.filter(m => m.modality === 'stt');    //  30 (Whisper, wav2vec2...)

// Auto-detected on startup — no config needed
// Models include full metadata from Ollama

const ollamaModels = models.filter(m => m.provider === 'ollama');
for (const m of ollamaModels) {
  console.log(m.id);                      // "llama3.3:70b"
  console.log(m.status);                  // "installed" | "available" | "running"
  console.log(m.localInfo.parameterSize); // "70.6B"
  console.log(m.localInfo.quantization);  // "Q4_K_M"
  console.log(m.localInfo.sizeBytes);     // 42520413916
  console.log(m.localInfo.family);        // "llama"
  console.log(m.logo);                    // { svg: "...meta.svg", png: "...meta.png" }
}

// Chat with streaming
const stream = ai.stream({
  model: 'qwen3:8b',
  provider: 'ollama',
  messages: [{ role: 'user', content: 'Explain quantum computing' }],
});

for await (const event of stream) {
  if (event.type === 'text_delta') process.stdout.write(event.delta);
}

const finalResult = await stream.result();

// Model management
await ai.installModel('deepseek-r1:14b');     // Downloads from Ollama library
await ai.uninstallModel('old-model:7b');       // Removes from disk

// Hardware info
const hw = await ai.getHardware();
// { ollama: true, runningModels: [{ name: 'qwen3:8b', size: 5200000000, ... }] }

// Auto-detects servers on common ports:
// llama.cpp (:8080), LM Studio (:1234), vLLM (:8000)
// LocalAI (:8080), TabbyAPI (:5000), KoboldCpp (:5001), Jan (:1337)

// Or configure manually:
const ai = new Noosphere({
  openaiCompat: [
    { baseUrl: 'http://localhost:1234/v1', name: 'LM Studio' },
    { baseUrl: 'http://192.168.1.100:8080/v1', name: 'Remote llama.cpp' },
  ],
});

const imageModels = models.filter(m => m.provider === 'hf-local' && m.modality === 'image');
// → FLUX.1-dev, FLUX.1-schnell, SDXL, SD 3.5, PixArt-Σ, Playground v2.5, Kolors...

const videoModels = models.filter(m => m.provider === 'hf-local' && m.modality === 'video');
// → Wan2.2-T2V, CogVideoX-5b, AnimateDiff, Stable Video Diffusion...

const ttsModels = models.filter(m => m.provider === 'hf-local' && m.modality === 'tts');
// → MusicGen, Stable Audio Open, Bark, ACE-Step...

const sttModels = models.filter(m => m.provider === 'hf-local' && m.modality === 'stt');
// → Whisper large-v3, Whisper large-v3-turbo, wav2vec2...

// Auto-detected on localhost:8188
const comfyModels = models.filter(m => m.provider === 'comfyui');
// → All checkpoints (SD 1.5, SDXL, FLUX, Pony, etc.)

// Also fetches top models from CivitAI as "available"
const civitai = comfyModels.filter(m => m.status === 'available');

const models = await ai.getModels('llm');

for (const m of models) {
  console.log(m.name, m.description);
  // "llama3.1"  "Llama 3.1 is a new state-of-the-art model from Meta available in 8B, 70B and 405B"
  // "qwen3"     "Qwen3 is the latest generation of large language models in Qwen series"
  // "gemma3"    "The current, most capable model that runs on a single GPU"
}

const imageModels = await ai.getModels('image');
for (const m of imageModels) {
  console.log(m.name, m.description);
  // "stable-diffusion-xl-base-1.0"  "Stable Diffusion XL (SDXL) is a latent text-to-image..."
  // "FLUX.1-dev"                     "FLUX.1 [dev] is a 12 billion parameter rectified flow..."
}

interface ModelInfo {
  id: string;
  provider: string;
  name: string;
  description?: string;          // Dynamic from source (Ollama library, HF README, CivitAI)
  modality: 'llm' | 'image' | 'video' | 'tts' | 'stt' | 'music' | 'embedding';
  status?: 'installed' | 'available' | 'downloading' | 'running' | 'error';
  local: boolean;
  logo?: { svg?: string; png?: string };
  localInfo?: {
    sizeBytes: number;
    family?: string;              // "llama", "gemma3", "qwen2"
    parameterSize?: string;       // "70.6B", "7B", "3.2B"
    quantization?: string;        // "Q4_K_M", "Q8_0", "F16"
    format?: string;              // "gguf", "safetensors", "onnx"
    digest?: string;
    modifiedAt?: string;
    running?: boolean;
    runtime: string;              // "ollama", "diffusers", "comfyui", "piper", "whisper"
  };
  capabilities: {
    contextWindow?: number;
    maxTokens?: number;
    supportsVision?: boolean;
    supportsStreaming?: boolean;
  };
}

// Via Noosphere instance (auto-routes by model)
const result = await ai.countTokens({
  messages: [
    { role: 'system', content: 'You are a helpful assistant.' },
    { role: 'user', content: 'Explain quantum computing.' },
  ],
  model: 'gpt-4o',
});
console.log(result.tokens);   // 26
console.log(result.method);   // "tiktoken" (instant, local)
console.log(result.provider); // "openai"

// Google — exact count via API
const google = await ai.countTokens({
  messages: [{ role: 'user', content: 'Hello!' }],
  model: 'gemini-2.5-flash',
});
console.log(google.tokens);   // 3
console.log(google.method);   // "api" (exact)

import {
  countTokensOpenAI, countTokensGoogle, countTokensAnthropic,
  countTokensGroq, countTokensMistral, countTokensXai,
  countTokensCerebras, countTokensOpenRouter, countTokensOllama,
} from 'noosphere';

// Local (instant, no API key needed)
const tokens = countTokensOpenAI(messages, 'gpt-4o');       // 26
const groq   = countTokensGroq(messages, 'llama-3.3-70b');  // 26
const ollama = countTokensOllama(messages, 'qwen3:8b');     // 26

// API-based (exact, needs key)
const google = await countTokensGoogle(messages, GEMINI_KEY, 'gemini-2.5-flash');     // 16
const claude = await countTokensAnthropic(messages, ANTHROPIC_KEY, 'claude-sonnet-4-20250514'); // exact

import { agentLoop, getPiModel, setApiKey, countTokensOpenAI } from 'noosphere';
import type { AgentLoopConfig, AgentContext, PiMessage } from 'noosphere';

setApiKey('openai', process.env.OPENAI_API_KEY!);

const config: AgentLoopConfig = {
  model: getPiModel('openai', 'gpt-4o'),

  // Preprocessor runs before each LLM call
  preprocessor: async (messages) => {
    // Strategy 1: Simple sliding window — keep last N messages
    if (messages.length > 50) {
      return messages.slice(-20);
    }
    return messages;
  },
};

// Start the agent loop
const context: AgentContext = {
  systemPrompt: 'You are a helpful assistant.',
  messages: [],
};

const userMessage = {
  role: 'user' as const,
  content: 'Hello!',
  timestamp: Date.now(),
};

const stream = agentLoop(userMessage, context, config);

for await (const event of stream) {
  if (event.type === 'message_update' && event.assistantMessageEvent.type === 'text_delta') {
    process.stdout.write(event.assistantMessageEvent.delta);
  }
}

preprocessor: async (messages) => {
  const model = getPiModel('openai', 'gpt-4o');
  const maxTokens = model.contextWindow * 0.8; // leave 20% for response

  let totalTokens = 0;
  const kept: PiMessage[] = [];

  // Keep messages from newest to oldest until we hit the limit
  for (let i = messages.length - 1; i >= 0; i--) {
    const msg = messages[i];
    const content = 'content' in msg && typeof msg.content === 'string' ? msg.content : '';
    const msgTokens = countTokensOpenAI([{ role: msg.role, content }], 'gpt-4o');

    if (totalTokens + msgTokens > maxTokens) break;
    totalTokens += msgTokens;
    kept.unshift(msg);
  }

  return kept;
},

preprocessor: async (messages) => {
  if (messages.length <= 20) return messages;

  // Summarize the older messages using the LLM itself
  const oldMessages = messages.slice(0, -10);
  const recentMessages = messages.slice(-10);

  const summary = await piCompleteSimple(getPiModel('openai', 'gpt-4o-mini'), {
    systemPrompt: 'Summarize this conversation in 2-3 sentences.',
    messages: oldMessages,
  });

  // Replace old messages with a summary message
  const summaryText = summary.content
    .filter((c): c is { type: 'text'; text: string } => c.type === 'text')
    .map((c) => c.text)
    .join('');

  return [
    { role: 'user' as const, content: `[Previous conversation summary: ${summaryText}]`, timestamp: Date.now() },
    ...recentMessages,
  ];
},

import { Type } from '@sinclair/typebox';
import type { AgentTool } from 'noosphere';

const weatherTool: AgentTool = {
  name: 'get_weather',
  label: 'Get Weather',
  description: 'Get the current weather for a location',
  parameters: Type.Object({
    location: Type.String({ description: 'City name' }),
  }),
  execute: async (toolCallId, params) => {
    const weather = await fetchWeather(params.location);
    return { output: JSON.stringify(weather), details: weather };
  },
};

const context: AgentContext = {
  systemPrompt: 'You are a helpful assistant with weather access.',
  messages: [],
  tools: [weatherTool],
};

const stream = agentLoop(userMessage, context, config);

for await (const event of stream) {
  if (event.type === 'tool_execution_start') {
    console.log(`Calling ${event.toolName}...`);
  }
  if (event.type === 'tool_execution_end') {
    console.log(`Result: ${event.result}`);
  }
}

import { calculateCost, getPiModel } from 'noosphere';

const model = getPiModel('openai', 'gpt-4o');
const usage = { input: 1000, output: 500, cacheRead: 0, cacheWrite: 0 };
const cost = calculateCost(model, usage);
console.log(cost.total);  // $0.00625
console.log(cost.input);  // $0.0025
console.log(cost.output); // $0.00375

import { piComplete, piStream, piCompleteSimple, setApiKey, getPiModel } from 'noosphere';

setApiKey('openai', process.env.OPENAI_API_KEY!);
const model = getPiModel('openai', 'gpt-4o');

// Simple completion
const result = await piCompleteSimple(model, {
  systemPrompt: 'You are helpful.',
  messages: [{ role: 'user', content: 'Hello!', timestamp: Date.now() }],
});

// Streaming
const stream = piStream(model, {
  messages: [{ role: 'user', content: 'Hello!', timestamp: Date.now() }],
});

for await (const event of stream) {
  if (event.type === 'text_delta') process.stdout.write(event.delta);
}

const ai = new Noosphere({
  keys: {
    openai: 'sk-...',
    anthropic: 'sk-ant-...',
    google: 'AIza...',
    fal: 'fal-...',
    huggingface: 'hf_...',
    groq: 'gsk_...',
    mistral: '...',
    xai: '...',
    openrouter: 'sk-or-...',
  },
});

const ai = new Noosphere({
  // API keys (or use env vars above)
  keys: { /* ... */ },

  // Default models per modality
  defaults: {
    llm: { provider: 'pi-ai', model: 'claude-sonnet-4-20250514' },
    image: { provider: 'fal', model: 'fal-ai/flux/schnell' },
    video: { provider: 'fal', model: 'fal-ai/kling-video/v2/master/text-to-video' },
    tts: { provider: 'fal', model: 'fal-ai/kokoro/american-english' },
  },

  // Local service configuration
  autoDetectLocal: true,  // env: NOOSPHERE_AUTO_DETECT_LOCAL
  local: {
    ollama: { enabled: true, host: 'http://localhost', port: 11434 },
    comfyui: { enabled: true, host: 'http://localhost', port: 8188 },
    piper: { enabled: true, host: 'http://localhost', port: 5500 },
    kokoro: { enabled: true, host: 'http://localhost', port: 5501 },
    custom: [],  // additional LocalServiceConfig[]
  },

  // Retry & failover
  retry: {
    maxRetries: 2,           // default: 2
    backoffMs: 1000,         // default: 1000 (exponential: 1s, 2s, 4s...)
    failover: true,          // default: true — try other providers on failure
    retryableErrors: ['PROVIDER_UNAVAILABLE', 'RATE_LIMITED', 'TIMEOUT'],
  },

  // Timeouts per modality (ms)
  timeout: {
    llm: 30000,    // 30s
    image: 120000, // 2min
    video: 300000, // 5min
    tts: 60000,    // 1min
  },

  // Model discovery cache (minutes)
  discoveryCacheTTL: 60,  // env: NOOSPHERE_DISCOVERY_CACHE_TTL

  // Real-time usage callback
  onUsage: (event) => {
    console.log(`${event.provider}/${event.model}: $${event.cost} (${event.latencyMs}ms)`);
  },
});

const result = await ai.chat({
  provider: 'anthropic',                // optional — auto-resolved if omitted
  model: 'claude-sonnet-4-20250514',    // optional — uses default or first available
  messages: [
    { role: 'system', content: 'You are helpful.' },
    { role: 'user', content: 'Explain quantum computing' },
  ],
  temperature: 0.7,     // optional (0-2)
  maxTokens: 1024,      // optional
  jsonMode: false,       // optional
});

console.log(result.content);          // response text
console.log(result.thinking);         // reasoning output (Claude, GPT-5, o3, Gemini, Grok-4)
console.log(result.usage.cost);       // cost in USD
console.log(result.usage.input);      // input tokens
console.log(result.usage.output);     // output tokens
console.log(result.latencyMs);        // response time in ms

const stream = ai.stream({
  messages: [{ role: 'user', content: 'Write a story' }],
});

for await (const event of stream) {
  switch (event.type) {
    case 'text_delta':
      process.stdout.write(event.delta!);
      break;
    case 'thinking_delta':
      console.log('[thinking]', event.delta);
      break;
    case 'done':
      console.log('\n\nUsage:', event.result!.usage);
      break;
    case 'error':
      console.error(event.error);
      break;
  }
}

// Or consume the full result
const result = await stream.result();

// Abort at any time
stream.abort();

const result = await ai.image({
  provider: 'fal',                              // optional
  model: 'fal-ai/flux-2-pro',                   // optional
  prompt: 'A futuristic cityscape at sunset',
  negativePrompt: 'blurry, low quality',         // optional
  width: 1024,                                   // optional
  height: 768,                                   // optional
  seed: 42,                                      // optional — reproducible results
  steps: 30,                                     // optional — inference steps (more = higher quality)
  guidanceScale: 7.5,                            // optional — prompt adherence (higher = stricter)
});

console.log(result.url);                // image URL (FAL)
console.log(result.buffer);             // image Buffer (HuggingFace, ComfyUI)
console.log(result.media?.width);       // actual dimensions
console.log(result.media?.height);
console.log(result.media?.format);      // 'png'

const result = await ai.video({
  provider: 'fal',
  model: 'fal-ai/kling-video/v2/master/text-to-video',
  prompt: 'A bird flying through clouds',
  imageUrl: 'https://...',    // optional — image-to-video
  duration: 5,                // optional — seconds
  fps: 24,                    // optional
  width: 1280,                // optional
  height: 720,                // optional
});

console.log(result.url);                // video URL
console.log(result.media?.duration);    // actual duration
console.log(result.media?.fps);         // frames per second
console.log(result.media?.format);      // 'mp4'

const result = await ai.speak({
  provider: 'fal',
  model: 'fal-ai/kokoro/american-english',
  text: 'Hello world',
  voice: 'af_heart',        // optional — voice ID
  language: 'en',            // optional
  speed: 1.0,                // optional
  format: 'mp3',             // optional — 'mp3' | 'wav' | 'ogg'
});

console.log(result.buffer);  // audio Buffer
console.log(result.url);     // audio URL (FAL)

const providers = await ai.getProviders('llm');
// [{ id: 'pi-ai', name: 'Pi-AI', modalities: ['llm'], local: false, status: 'online', modelCount: 246 }]

const models = await ai.getModels('image');
// Returns ModelInfo[] with id, provider, name, modality, local, cost, capabilities

const usage = ai.getUsage({
  since: '2024-01-01',    // optional — ISO date or Date object
  until: '2024-12-31',    // optional
  provider: 'openai',     // optional — filter by provider
  modality: 'llm',        // optional — filter by modality
});

console.log(usage.totalCost);        // total USD spent
console.log(usage.totalRequests);    // number of requests
console.log(usage.byProvider);       // { openai: 2.50, anthropic: 1.20, fal: 0.30 }
console.log(usage.byModality);       // { llm: 3.00, image: 0.70, video: 0.30, tts: 0.00 }

interface NoosphereResult {
  content?: string;        // LLM response text
  thinking?: string;       // reasoning/thinking output (supported models)
  url?: string;            // media URL (images, videos, audio from cloud providers)
  buffer?: Buffer;         // media binary data (local providers, HuggingFace)
  provider: string;        // which provider handled the request
  model: string;           // which model was used
  modality: Modality;      // 'llm' | 'image' | 'video' | 'tts'
  latencyMs: number;       // request duration in milliseconds
  usage: {
    cost: number;          // cost in USD
    input?: number;        // input tokens/characters
    output?: number;       // output tokens
    unit?: string;         // 'tokens' | 'characters' | 'per_image' | 'per_second' | 'free'
  };
  media?: {
    width?: number;        // image/video width
    height?: number;       // image/video height
    duration?: number;     // video/audio duration in seconds
    format?: string;       // 'png' | 'mp4' | 'mp3' | 'wav'
    fps?: number;          // video frames per second
  };
}

{
  id: "claude-opus-4-6",
  name: "Claude Opus 4.6",
  api: "anthropic-messages",
  provider: "anthropic",
  baseUrl: "https://api.anthropic.com",
  reasoning: true,
  input: ["text", "image"],
  cost: {
    input: 15,          // $15/M tokens
    output: 75,         // $75/M tokens
    cacheRead: 1.5,     // prompt cache hit
    cacheWrite: 18.75,  // prompt cache write
  },
  contextWindow: 200_000,
  maxTokens: 32_000,
} satisfies Model<"anthropic-messages">

// What happens inside Pi when you call Noosphere's chat():
async function* streamSimple(
  model: Model,           // includes model.api to determine protocol
  context: Context,       // { systemPrompt, messages, tools }
  options?: StreamOptions  // { signal, onPayload, thinkingLevel, ... }
): AsyncIterable<AssistantMessageEvent> {
  // 1. Format request according to model.api protocol
  // 2. Open SSE/WebSocket stream
  // 3. Parse provider-specific chunks
  // 4. Emit normalized events:
  //    → text_delta, thinking_delta, tool_call, message_end
}

import { type Tool, StringEnum } from '@mariozechner/pi-ai';
import { Type } from '@sinclair/typebox';

// Define a tool with typed parameters
const searchTool: Tool = {
  name: 'web_search',
  description: 'Search the web for information',
  parameters: Type.Object({
    query: Type.String({ description: 'Search query' }),
    maxResults: Type.Optional(Type.Number({ default: 5 })),
    type: StringEnum(['web', 'images', 'news'], { description: 'Search type' }),
  }),
};

// Pass tools in context — Pi handles the rest
const context = {
  systemPrompt: 'You are a helpful assistant.',
  messages: [{ role: 'user', content: 'Search for recent AI news' }],
  tools: [searchTool],
};

// Thinking is automatically extracted in Noosphere responses:
const result = await ai.chat({
  model: 'claude-opus-4-6',
  messages: [{ role: 'user', content: 'Solve this step by step: 15! / 13!' }],
});

console.log(result.thinking);  // "Let me work through this... 15! = 15 × 14 × 13!..."
console.log(result.content);   // "15! / 13! = 15 × 14 = 210"

// During streaming, thinking arrives as separate events:
const stream = ai.stream({ messages: [...] });
for await (const event of stream) {
  if (event.type === 'thinking_delta') console.log('[THINKING]', event.delta);
  if (event.type === 'text_delta') console.log('[RESPONSE]', event.delta);
}

// Send images to vision-capable models
const messages = [{
  role: 'user',
  content: [
    { type: 'text', text: 'What is in this image?' },
    { type: 'image', data: base64PngString, mimeType: 'image/png' },
  ],
}];

// Supported MIME types: image/png, image/jpeg, image/gif, image/webp
// Images are silently ignored when sent to non-vision models

import { agentLoop } from '@mariozechner/pi-ai';

const events = agentLoop(userMessage, agentContext, {
  model: getModel('anthropic', 'claude-opus-4-6'),
  tools: [searchTool, readFileTool, writeFileTool],
  signal: abortController.signal,
});

for await (const event of events) {
  switch (event.type) {
    case 'agent_start':           // Agent begins
    case 'turn_start':            // New LLM turn begins
    case 'message_start':         // LLM starts responding
    case 'message_update':        // Text/thinking delta received
    case 'tool_execution_start':  // About to execute a tool
    case 'tool_execution_end':    // Tool finished, result available
    case 'message_end':           // LLM finished this message
    case 'turn_end':              // Turn complete (may loop if tools were called)
    case 'agent_end':             // All done, final messages available
  }
}

import type { StreamFn } from '@mariozechner/pi-agent-core';
import { streamSimple } from '@mariozechner/pi-ai';

// Start with Pi's base streaming function
let fn: StreamFn = streamSimple;

// Wrap it with middleware that modifies requests per-provider
fn = createMyCustomWrapper(fn, {
  // Add custom headers for Anthropic
  onPayload: (payload) => {
    if (model.provider === 'anthropic') {
      payload.headers['anthropic-beta'] = 'fine-grained-tool-streaming-2025-05-14';
    }
  },
});

// Each wrapper calls the previous one, forming a chain:
// request → wrapper3 → wrapper2 → wrapper1 → streamSimple → API

import { createAgentSession, SessionManager } from '@mariozechner/pi-coding-agent';

// Create a session with full persistence
const session = await createAgentSession({
  model: 'claude-opus-4-6',
  tools: myTools,
  sessionManager,  // handles JSONL persistence
});

const result = await session.run('Build a REST API');
// Session is automatically saved to:
// ~/.pi/agent/sessions/session_abc123.jsonl

// Every model has 4 cost dimensions:
{
  input: 15,          // $15 per 1M input tokens
  output: 75,         // $75 per 1M output tokens
  cacheRead: 1.5,     // $1.50 per 1M cached prompt tokens (read)
  cacheWrite: 18.75,  // $18.75 per 1M cached prompt tokens (write)
}

// Usage tracking on every response:
{
  input: 1500,        // tokens consumed as input
  output: 800,        // tokens generated
  cacheRead: 5000,    // prompt cache hits
  cacheWrite: 1500,   // prompt cache writes
  cost: {
    total: 0.082,     // total cost in USD
    input: 0.0225,
    output: 0.06,
    cacheRead: 0.0075,
    cacheWrite: 0.028,
  },
}

// Extensions are TypeScript modules loaded at runtime via jiti
export default function(api: ExtensionAPI) {
  // Register a custom tool
  api.registerTool('my_tool', {
    description: 'Does something useful',
    parameters: { /* TypeBox schema */ },
    execute: async (args) => 'result',
  });

  // Register a slash command
  api.registerCommand('/mycommand', {
    handler: async (args) => { /* ... */ },
    description: 'Custom command',
  });

  // Hook into the agent lifecycle
  api.on('before_agent_start', async (context) => {
    context.systemPrompt += '\nExtra instructions';
  });

  api.on('tool_execution_end', async (event) => {
    // Post-process tool results
  });
}

// Exact request payload sent to FAL:
const response = await fal.subscribe(model, {
  input: {
    prompt: "A sunset over mountains",
    negative_prompt: "blurry",           // from options.negativePrompt
    image_size: { width: 1024, height: 768 }, // from options.width/height
    seed: 42,                            // from options.seed
    num_inference_steps: 30,             // from options.steps
    guidance_scale: 7.5,                 // from options.guidanceScale
  },
});

// Response parsing — URL from images array:
const image = response.data?.images?.[0];
// result.url    = image?.url
// result.media  = { width: image?.width, height: image?.height, format: 'png' }

const response = await fal.subscribe(model, {
  input: {
    prompt: "Ocean waves",
    image_url: "https://...",   // from options.imageUrl (image-to-video)
    duration: 5,                // from options.duration
    fps: 24,                    // from options.fps
  },
});

// Response parsing — URL from video object with fallback:
const video = response.data?.video;
// result.url = video?.url ?? response.data?.video_url
// Note: width/height/duration/fps come from INPUT options, not response

const response = await fal.run(model, {
  input: {
    text: "Hello world",
    voice: "af_heart",          // from options.voice
    speed: 1.0,                 // from options.speed
  },
});

// Response parsing — URL from audio object with fallback:
// result.url = response.data?.audio_url ?? response.data?.audio?.url

// Pricing fetched dynamically from FAL API during listModels():
const res = await fetch('https://api.fal.ai/v1/models/pricing', {
  headers: { Authorization: `Key ${this.apiKey}` },
});
// Returns: Array<{ modelId: string, price: number, unit: string }>

// Cached in memory Map, cleared on each listModels() call:
private pricingCache = new Map<string, { price: number; unit: string }>();

// Cost per request pulled from cache (defaults to 0 if not cached):
usage: { cost: pricingCache.get(model)?.price ?? 0 }

inferModality(modelId: string, unit: string): Modality {
  // TTS: unit contains 'char' OR modelId contains 'tts'/'kokoro'/'elevenlabs'
  // Video: unit contains 'second' OR modelId contains 'video'/'kling'/'sora'/'veo'
  // Image: everything else (default)
}

await ai.chat({
  provider: 'huggingface',
  model: 'mistralai/Mixtral-8x7B-v0.1',
  messages: [{ role: 'user', content: 'Hello' }],
});

// Constructor receives a single API token
constructor(token: string) {
  this.client = new HfInference(token);
  // HfInference stores the token internally and attaches it
  // as Authorization: Bearer <token> to every request
}

// ping() always returns true — HuggingFace is considered
// "available" if the token was provided. No actual HTTP check.
async ping(): Promise<boolean> { return true; }

// Default model: meta-llama/Llama-3.1-8B-Instruct
const model = options.model ?? 'meta-llama/Llama-3.1-8B-Instruct';

// Maps directly to HfInference.chatCompletion():
const response = await this.client.chatCompletion({
  model,                           // HuggingFace model ID or inference endpoint
  messages: options.messages,       // Array<{ role, content }> — passed directly
  temperature: options.temperature, // 0.0 - 2.0 (optional)
  max_tokens: options.maxTokens,    // Max output tokens (optional)
});

// Response parsing:
const choice = response.choices?.[0];           // OpenAI-compatible format
const usage = response.usage;                    // { prompt_tokens, completion_tokens }
// result.content = choice?.message?.content ?? ''
// result.usage.input = usage?.prompt_tokens
// result.usage.output = usage?.completion_tokens
// result.usage.cost = 0  (always free for HF Inference API)

// Default model: stabilityai/stable-diffusion-xl-base-1.0
const model = options.model ?? 'stabilityai/stable-diffusion-xl-base-1.0';

// Uses textToImage() which returns a Blob object:
const blob = await this.client.textToImage({
  model,
  inputs: options.prompt,        // The text prompt
  parameters: {
    negative_prompt: options.negativePrompt,  // What NOT to generate
    width: options.width,                      // Pixel width
    height: options.height,                    // Pixel height
    guidance_scale: options.guidanceScale,      // CFG scale
    num_inference_steps: options.steps,         // Denoising steps
  },
}, { outputType: 'blob' });  // <-- Forces Blob output (not ReadableStream)

// Blob → ArrayBuffer → Node.js Buffer conversion:
const buffer = Buffer.from(await blob.arrayBuffer());
// This is the critical step — HfInference returns a Web API Blob,
// which must be converted to a Node.js Buffer for downstream use.

// Result always reports PNG format regardless of actual model output:
// result.media = { width: options.width ?? 1024, height: options.height ?? 1024, format: 'png' }

// Default model: facebook/mms-tts-eng
const model = options.model ?? 'facebook/mms-tts-eng';

// Uses textToSpeech() — simpler API, just model + text:
const blob = await this.client.textToSpeech({
  model,
  inputs: options.text,    // Text to synthesize
  // Note: No voice, speed, or format parameters — these are model-dependent
});

// Same Blob → Buffer conversion:
const buffer = Buffer.from(await blob.arrayBuffer());

// Usage tracks character count, not tokens:
// result.usage = { cost: 0, input: options.text.length, unit: 'characters' }
// result.media = { format: 'wav' }

// HuggingFace now auto-fetches trending models from the Hub API:
async listModels(modality?: Modality): Promise<ModelInfo[]> {
  if (!this.dynamicModels) await this.fetchHubModels();
  // Returns: 3 hardcoded defaults + top 50 LLM + top 50 image + top 30 TTS
  // All filtered by inference_provider=all (only inference-ready models)
}

// Hub API request per modality:
// GET https://huggingface.co/api/models
//   ?pipeline_tag=text-generation
//   &inference_provider=all        ← Only models with active inference endpoints
//   &sort=trendingScore            ← Most popular first
//   &limit=50
//   &expand[]=inferenceProviderMapping  ← Include provider routing + pricing

// Response includes per model:
// - id: "Qwen/Qwen2.5-72B-Instruct"
// - inferenceProviderMapping: [{ provider: "together", status: "live",
//     providerDetails: { context_length: 32768, pricing: { input: 1.2 } } }]

// Pricing and context_length extracted from inferenceProviderMapping
// 3 hardcoded defaults always included as fallback
// Results cached in memory after first fetch

// Route through a specific inference provider:
const response = await client.chatCompletion({
  model: 'meta-llama/Llama-3.1-70B-Instruct',
  provider: 'together-ai',  // <-- Route through Together.ai
  messages: [...],
});

// NOTE: Noosphere does NOT currently expose the `provider` parameter
// in its ChatOptions type. To use a specific HF inference provider,
// you would need a custom provider or direct @huggingface/inference usage.

// Direct HfInference usage with a local/dedicated endpoint:
import { HfInference } from '@huggingface/inference';

const client = new HfInference('your-token');

// Point to your dedicated endpoint:
const response = await client.chatCompletion({
  model: 'tgi',
  endpointUrl: 'https://your-endpoint.endpoints.huggingface.cloud',
  messages: [{ role: 'user', content: 'Hello' }],
});

// For a truly local setup with TGI (Text Generation Inference):
const localClient = new HfInference();  // No token needed for local
const response = await localClient.chatCompletion({
  model: 'tgi',
  endpointUrl: 'http://localhost:8080',  // Local TGI server
  messages: [...],
});

// Node "3": KSampler — The core diffusion sampling node
'3': {
  class_type: 'KSampler',
  inputs: {
    seed: 0,                    // Random seed (overridden by options.seed)
    steps: 20,                  // Denoising steps (overridden by options.steps)
    cfg: 7,                     // CFG/guidance scale (overridden by options.guidanceScale)
    sampler_name: 'euler',      // Sampling algorithm
    scheduler: 'normal',        // Noise schedule
    denoise: 1,                 // Full denoise (1.0 = txt2img, <1.0 = img2img)
    model: ['4', 0],            // ← Connection: output 0 of node "4" (checkpoint model)
    positive: ['6', 0],         // ← Connection: output 0 of node "6" (positive prompt)
    negative: ['7', 0],         // ← Connection: output 0 of node "7" (negative prompt)
    latent_image: ['5', 0],     // ← Connection: output 0 of node "5" (empty latent)
  },
}

// Node "4": CheckpointLoaderSimple — Loads the SDXL model from disk
'4': {
  class_type: 'CheckpointLoaderSimple',
  inputs: {
    ckpt_name: 'sd_xl_base_1.0.safetensors',  // Checkpoint file on disk
    // Outputs: [0]=MODEL, [1]=CLIP, [2]=VAE
    // MODEL → KSampler.model
    // CLIP  → CLIPTextEncode nodes
    // VAE   → VAEDecode
  },
}

// Node "5": EmptyLatentImage — Creates the initial noise tensor
'5': {
  class_type: 'EmptyLatentImage',
  inputs: {
    width: 1024,       // Overridden by options.width
    height: 1024,      // Overridden by options.height
    batch_size: 1,     // Always 1 image per generation
  },
}

// Node "6": CLIPTextEncode — Positive prompt encoding
'6': {
  class_type: 'CLIPTextEncode',
  inputs: {
    text: '',           // Overridden by options.prompt
    clip: ['4', 1],     // ← Connection: output 1 of node "4" (CLIP model)
  },
}

// Node "7": CLIPTextEncode — Negative prompt encoding
'7': {
  class_type: 'CLIPTextEncode',
  inputs: {
    text: '',           // Overridden by options.negativePrompt ?? ''
    clip: ['4', 1],     // ← Same CLIP model as positive prompt
  },
}

// Node "8": VAEDecode — Converts latent space to pixel space
'8': {
  class_type: 'VAEDecode',
  inputs: {
    samples: ['3', 0],  // ← Connection: output 0 of node "3" (sampled latents)
    vae: ['4', 2],       // ← Connection: output 2 of node "4" (VAE decoder)
  },
}

// Node "9": SaveImage — Saves the final image
'9': {
  class_type: 'SaveImage',
  inputs: {
    filename_prefix: 'noosphere',   // Files saved as noosphere_00001.png, etc.
    images: ['8', 0],                // ← Connection: output 0 of node "8" (decoded image)
  },
}

// Deep-clone to avoid mutating the template:
const workflow = structuredClone(DEFAULT_TXT2IMG_WORKFLOW);

// Direct node mutations:
workflow['6'].inputs.text = options.prompt;                    // Positive prompt → Node 6
workflow['7'].inputs.text = options.negativePrompt ?? '';      // Negative prompt → Node 7
workflow['5'].inputs.width = options.width ?? 1024;            // Width → Node 5
workflow['5'].inputs.height = options.height ?? 1024;          // Height → Node 5

// Conditional overrides (only if user provided them):
if (options.seed !== undefined)          workflow['3'].inputs.seed = options.seed;
if (options.steps !== undefined)         workflow['3'].inputs.steps = options.steps;
if (options.guidanceScale !== undefined) workflow['3'].inputs.cfg = options.guidanceScale;
// Note: sampler_name, scheduler, and denoise are NOT configurable via Noosphere.
// They're hardcoded to euler/normal/1.0

const queueRes = await fetch(`${this.baseUrl}/prompt`, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({ prompt: workflow }),
  // ComfyUI expects: { prompt: <workflow_object>, client_id?: string }
});

if (!queueRes.ok) throw new Error(`ComfyUI queue failed: ${queueRes.status}`);

const { prompt_id } = await queueRes.json();
// prompt_id is a UUID like "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
// Used to track this specific generation in the history API

private async pollForResult(promptId: string, maxWaitMs = 300000): Promise<ArrayBuffer> {
  const deadline = Date.now() + maxWaitMs;  // 300,000ms = 5 minutes

  while (Date.now() < deadline) {
    // Check history for our prompt
    const res = await fetch(`${this.baseUrl}/history/${promptId}`);

    if (!res.ok) {
      await new Promise((r) => setTimeout(r, 1000));  // 1 second between polls
      continue;
    }

    const history = await res.json();
    // History format: { [promptId]: { outputs: { [nodeId]: { images: [...] } } } }

    const entry = history[promptId];
    if (!entry?.outputs) {
      await new Promise((r) => setTimeout(r, 1000));  // Not ready yet
      continue;
    }

    // Search ALL output nodes for images (not just node "9"):
    for (const nodeOutput of Object.values(entry.outputs)) {
      if (nodeOutput.images?.length > 0) {
        const img = nodeOutput.images[0];
        // Fetch the actual image binary:
        const imgRes = await fetch(
          `${this.baseUrl}/view?filename=${img.filename}&subfolder=${img.subfolder}&type=${img.type}`
        );
        return imgRes.arrayBuffer();
      }
    }

    await new Promise((r) => setTimeout(r, 1000));
  }

  throw new Error(`ComfyUI generation timed out after ${maxWaitMs}ms`);
}

// Ping the /system_stats endpoint with a 2-second timeout:
const pingUrl = async (url: string): Promise<boolean> => {
  const controller = new AbortController();
  const timer = setTimeout(() => controller.abort(), 2000);  // 2s hard timeout
  try {
    const res = await fetch(url, { signal: controller.signal });
    return res.ok;
  } finally {
    clearTimeout(timer);
  }
};

// Check ComfyUI specifically:
if (comfyuiCfg?.enabled) {
  const ok = await pingUrl(`${comfyuiCfg.host}:${comfyuiCfg.port}/system_stats`);
  if (ok) {
    this.registry.addProvider(new ComfyUIProvider({
      host: comfyuiCfg.host,  // Default: 'http://localhost'
      port: comfyuiCfg.port,  // Default: 8188
    }));
  }
}