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
const image = await ai.image({
  prompt: 'A sunset over mountains',
  width: 1024,
  height: 1024,
});
console.log(image.url);

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

// Text-to-speech
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;
  };
}

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
    }));
  }
}

const ai = new Noosphere({
  local: {
    comfyui: {
      enabled: true,                      // Default: true (auto-detected)
      host: 'http://localhost',           // Default: 'http://localhost'
      port: 8188,                         // Default: 8188
    },
  },
});

async listModels(modality?: Modality): Promise<ModelInfo[]> {
  // Fetches ComfyUI's full node registry:
  const res = await fetch(`${this.baseUrl}/object_info`);
  if (!res.ok) return [];

  // Does NOT parse the response — just uses it as a connectivity check.
  // Returns hardcoded model entries:
  const models: ModelInfo[] = [];
  if (!modality || modality === 'image') {
    models.push({
      id: 'comfyui-txt2img',
      provider: 'comfyui',
      name: 'ComfyUI Text-to-Image',
      modality: 'image',
      local: true,
      cost: { price: 0, unit: 'free' },
      capabilities: { maxWidth: 2048, maxHeight: 2048, supportsNegativePrompt: true },
    });
  }
  if (!modality || modality === 'video') {
    models.push({
      id: 'comfyui-txt2vid',
      provider: 'comfyui',
      name: 'ComfyUI Text-to-Video',
      modality: 'video',
      local: true,
      cost: { price: 0, unit: 'free' },
      capabilities: { maxDuration: 10, supportsImageToVideo: true },
    });
  }
  return models;
}
// NOTE: /object_info is fetched but the response is discarded.
// The actual model list is hardcoded. This means even if you have
// dozens of checkpoints in ComfyUI, Noosphere only exposes 2 model IDs.

async video(_options: VideoOptions): Promise<NoosphereResult> {
  throw new Error('ComfyUI video generation requires a configured AnimateDiff workflow');
}
// The 'comfyui-txt2vid' model ID is listed but will throw at runtime.
// This is a placeholder for future AnimateDiff/SVD workflow templates.

// The LocalTTSProvider constructor takes a config object:
interface LocalTTSConfig {
  id: string;     // Provider ID: 'piper' or 'kokoro'
  name: string;   // Display name: 'Piper TTS' or 'Kokoro TTS'
  host: string;   // Base URL host
  port: number;   // Port number
}

// Two separate instances are created during init():
new LocalTTSProvider({ id: 'piper',  name: 'Piper TTS',  host: piperCfg.host,  port: piperCfg.port })
new LocalTTSProvider({ id: 'kokoro', name: 'Kokoro TTS', host: kokoroCfg.host, port: kokoroCfg.port })

// Each instance is an independent provider in the registry.
// They don't share state or config.
// The baseUrl is constructed as: `${config.host}:${config.port}`
// Example: "http://localhost:5500"

async ping(): Promise<boolean> {
  try {
    const res = await fetch(`${this.baseUrl}/health`);
    return res.ok;  // true if HTTP 200-299
  } catch {
    return false;    // Network error, connection refused, etc.
  }
}
// Used during auto-detection in Noosphere.init()
// Also used by: the 2-second AbortController timeout in init()
// Note: /health is checked BEFORE the provider is registered.
// If /health fails, the provider is silently skipped.

async listModels(modality?: Modality): Promise<ModelInfo[]> {
  if (modality && modality !== 'tts') return [];

  let voices: Array<{ id: string; name?: string }> = [];

  // STRATEGY 1: Piper-style /voices endpoint
  // Expected response: Array<{ id: string, name?: string, ... }>
  try {
    const res = await fetch(`${this.baseUrl}/voices`);
    if (res.ok) {
      const data = await res.json();
      if (Array.isArray(data)) {
        voices = data;
        // Success — skip fallback
      }
    }
  } catch {
    // STRATEGY 2: OpenAI-compatible /v1/models endpoint
    // Expected response: { data: Array<{ id: string, ... }> }
    const res = await fetch(`${this.baseUrl}/v1/models`);
    if (res.ok) {
      const data = await res.json();
      voices = data.data ?? [];
    }
  }

  // Map voices to ModelInfo objects:
  return voices.map((v) => ({
    id: v.id,
    provider: this.id,              // 'piper' or 'kokoro'
    name: v.name ?? v.id,           // Fallback to ID if no name
    modality: 'tts' as const,
    local: true,
    cost: { price: 0, unit: 'free' },
    capabilities: {
      voices: voices.map((vv) => vv.id),  // All voice IDs as capabilities
    },
  }));
}

async speak(options: SpeakOptions): Promise<NoosphereResult> {
  const start = Date.now();

  // POST to OpenAI-compatible TTS endpoint:
  const res = await fetch(`${this.baseUrl}/v1/audio/speech`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      model: options.model ?? 'tts-1',        // Default model ID
      input: options.text,                     // Text to synthesize
      voice: options.voice ?? 'default',       // Voice selection
      speed: options.speed ?? 1.0,             // Playback speed multiplier
      response_format: options.format ?? 'mp3', // Output audio format
    }),
  });

  if (!res.ok) {
    throw new Error(`Local TTS failed: ${res.status} ${await res.text()}`);
    // Note: error includes the response body text for debugging
  }

  // Response is raw audio binary — convert to Buffer:
  const audioBuffer = Buffer.from(await res.arrayBuffer());

  return {
    buffer: audioBuffer,
    provider: this.id,                              // 'piper' or 'kokoro'
    model: options.model ?? options.voice ?? 'default',  // Fallback chain
    modality: 'tts',
    latencyMs: Date.now() - start,
    usage: {
      cost: 0,                                       // Always free (local)
      input: options.text.length,                     // CHARACTER count, not tokens
      unit: 'characters',                             // Track by characters
    },
    media: {
      format: options.format ?? 'mp3',               // Matches requested format
    },
  };
}