llmist 2.3.0 → 2.4.0

package/dist/index.cjs

@@ -2555,7 +2555,27 @@ var init_cost_reporting_client = __esm({
       constructor(client, reportCost) {
         this.client = client;
         this.reportCost = reportCost;
+        this.image = {
+          generate: async (options) => {
+            const result = await this.client.image.generate(options);
+            if (result.cost !== void 0 && result.cost > 0) {
+              this.reportCost(result.cost);
+            }
+            return result;
+          }
+        };
+        this.speech = {
+          generate: async (options) => {
+            const result = await this.client.speech.generate(options);
+            if (result.cost !== void 0 && result.cost > 0) {
+              this.reportCost(result.cost);
+            }
+            return result;
+          }
+        };
       }
+      image;
+      speech;
       /**
        * Access to model registry for cost estimation.
        */
@@ -4648,6 +4668,28 @@ var init_anthropic = __esm({
       getModelSpecs() {
         return ANTHROPIC_MODELS;
       }
+      // =========================================================================
+      // Image Generation (Not Supported)
+      // =========================================================================
+      supportsImageGeneration(_modelId) {
+        return false;
+      }
+      async generateImage() {
+        throw new Error(
+          "Anthropic does not support image generation. Use OpenAI (DALL-E, GPT Image) or Google Gemini (Imagen) instead."
+        );
+      }
+      // =========================================================================
+      // Speech Generation (Not Supported)
+      // =========================================================================
+      supportsSpeechGeneration(_modelId) {
+        return false;
+      }
+      async generateSpeech() {
+        throw new Error(
+          "Anthropic does not support speech generation. Use OpenAI (TTS) or Google Gemini (TTS) instead."
+        );
+      }
       buildRequestPayload(options, descriptor, spec, messages) {
         const systemMessages = messages.filter((message) => message.role === "system");
         const system = systemMessages.length > 0 ? systemMessages.map((m, index) => ({
@@ -4802,6 +4844,182 @@ var init_anthropic = __esm({
   }
 });
 
+// src/providers/gemini-image-models.ts
+function getGeminiImageModelSpec(modelId) {
+  return geminiImageModels.find((m) => m.modelId === modelId);
+}
+function isGeminiImageModel(modelId) {
+  return geminiImageModels.some((m) => m.modelId === modelId);
+}
+function calculateGeminiImageCost(modelId, size = "1:1", n = 1) {
+  const spec = getGeminiImageModelSpec(modelId);
+  if (!spec) return void 0;
+  if (spec.pricing.perImage !== void 0) {
+    return spec.pricing.perImage * n;
+  }
+  if (spec.pricing.bySize) {
+    const sizePrice = spec.pricing.bySize[size];
+    if (typeof sizePrice === "number") {
+      return sizePrice * n;
+    }
+  }
+  return void 0;
+}
+var IMAGEN4_ASPECT_RATIOS, GEMINI_IMAGE_ASPECT_RATIOS, geminiImageModels;
+var init_gemini_image_models = __esm({
+  "src/providers/gemini-image-models.ts"() {
+    "use strict";
+    IMAGEN4_ASPECT_RATIOS = ["1:1", "3:4", "4:3", "9:16", "16:9"];
+    GEMINI_IMAGE_ASPECT_RATIOS = ["1:1", "3:4", "4:3", "9:16", "16:9"];
+    geminiImageModels = [
+      // Imagen 4 Family (standalone image generation)
+      {
+        provider: "gemini",
+        modelId: "imagen-4.0-fast-generate-001",
+        displayName: "Imagen 4 Fast",
+        pricing: {
+          perImage: 0.02
+        },
+        supportedSizes: [...IMAGEN4_ASPECT_RATIOS],
+        maxImages: 4,
+        defaultSize: "1:1",
+        features: {
+          textRendering: true
+        }
+      },
+      {
+        provider: "gemini",
+        modelId: "imagen-4.0-generate-001",
+        displayName: "Imagen 4",
+        pricing: {
+          perImage: 0.04
+        },
+        supportedSizes: [...IMAGEN4_ASPECT_RATIOS],
+        maxImages: 4,
+        defaultSize: "1:1",
+        features: {
+          textRendering: true
+        }
+      },
+      {
+        provider: "gemini",
+        modelId: "imagen-4.0-ultra-generate-001",
+        displayName: "Imagen 4 Ultra",
+        pricing: {
+          perImage: 0.06
+        },
+        supportedSizes: [...IMAGEN4_ASPECT_RATIOS],
+        maxImages: 4,
+        defaultSize: "1:1",
+        features: {
+          textRendering: true
+        }
+      },
+      // Preview versions
+      {
+        provider: "gemini",
+        modelId: "imagen-4.0-generate-preview-06-06",
+        displayName: "Imagen 4 (Preview)",
+        pricing: {
+          perImage: 0.04
+        },
+        supportedSizes: [...IMAGEN4_ASPECT_RATIOS],
+        maxImages: 4,
+        defaultSize: "1:1",
+        features: {
+          textRendering: true
+        }
+      },
+      {
+        provider: "gemini",
+        modelId: "imagen-4.0-ultra-generate-preview-06-06",
+        displayName: "Imagen 4 Ultra (Preview)",
+        pricing: {
+          perImage: 0.06
+        },
+        supportedSizes: [...IMAGEN4_ASPECT_RATIOS],
+        maxImages: 4,
+        defaultSize: "1:1",
+        features: {
+          textRendering: true
+        }
+      },
+      // Gemini Native Image Generation (multimodal models)
+      {
+        provider: "gemini",
+        modelId: "gemini-2.5-flash-image",
+        displayName: "Gemini 2.5 Flash Image",
+        pricing: {
+          perImage: 0.039
+        },
+        supportedSizes: [...GEMINI_IMAGE_ASPECT_RATIOS],
+        maxImages: 1,
+        defaultSize: "1:1",
+        features: {
+          conversational: true,
+          textRendering: true
+        }
+      },
+      {
+        provider: "gemini",
+        modelId: "gemini-2.5-flash-image-preview",
+        displayName: "Gemini 2.5 Flash Image (Preview)",
+        pricing: {
+          perImage: 0.039
+        },
+        supportedSizes: [...GEMINI_IMAGE_ASPECT_RATIOS],
+        maxImages: 1,
+        defaultSize: "1:1",
+        features: {
+          conversational: true,
+          textRendering: true
+        }
+      },
+      {
+        provider: "gemini",
+        modelId: "gemini-3-pro-image-preview",
+        displayName: "Gemini 3 Pro Image (Preview)",
+        pricing: {
+          // Token-based: ~$0.134 per 1K/2K image, $0.24 per 4K
+          // Using 2K as default
+          bySize: {
+            "1K": 0.134,
+            "2K": 0.134,
+            "4K": 0.24
+          }
+        },
+        supportedSizes: ["1K", "2K", "4K"],
+        maxImages: 1,
+        defaultSize: "2K",
+        features: {
+          conversational: true,
+          textRendering: true
+        }
+      },
+      // Alias: nano-banana-pro-preview is gemini-3-pro-image-preview
+      {
+        provider: "gemini",
+        modelId: "nano-banana-pro-preview",
+        displayName: "Nano Banana Pro (Gemini 3 Pro Image)",
+        pricing: {
+          bySize: {
+            "1K": 0.134,
+            "2K": 0.134,
+            "4K": 0.24
+          }
+        },
+        supportedSizes: ["1K", "2K", "4K"],
+        maxImages: 1,
+        defaultSize: "2K",
+        features: {
+          conversational: true,
+          textRendering: true
+        }
+      }
+    ];
+  }
+});
+
 // src/providers/gemini-models.ts
 var GEMINI_MODELS;
 var init_gemini_models = __esm({
@@ -4975,7 +5193,171 @@ var init_gemini_models = __esm({
   }
 });
 
+// src/providers/gemini-speech-models.ts
+function getGeminiSpeechModelSpec(modelId) {
+  return geminiSpeechModels.find((m) => m.modelId === modelId);
+}
+function isGeminiSpeechModel(modelId) {
+  return geminiSpeechModels.some((m) => m.modelId === modelId);
+}
+function calculateGeminiSpeechCost(modelId, characterCount, estimatedMinutes) {
+  const spec = getGeminiSpeechModelSpec(modelId);
+  if (!spec) return void 0;
+  if (spec.pricing.perMinute !== void 0) {
+    if (estimatedMinutes !== void 0) {
+      return estimatedMinutes * spec.pricing.perMinute;
+    }
+    const approxMinutes = characterCount / 750;
+    return approxMinutes * spec.pricing.perMinute;
+  }
+  return void 0;
+}
+var GEMINI_TTS_VOICES, GEMINI_TTS_FORMATS, geminiSpeechModels;
+var init_gemini_speech_models = __esm({
+  "src/providers/gemini-speech-models.ts"() {
+    "use strict";
+    GEMINI_TTS_VOICES = [
+      "Zephyr",
+      // Bright
+      "Puck",
+      // Upbeat
+      "Charon",
+      // Informative
+      "Kore",
+      // Firm
+      "Fenrir",
+      // Excitable
+      "Leda",
+      // Youthful
+      "Orus",
+      // Firm
+      "Aoede",
+      // Breezy
+      "Callirrhoe",
+      // Easy-going
+      "Autonoe",
+      // Bright
+      "Enceladus",
+      // Breathy
+      "Iapetus",
+      // Clear
+      "Umbriel",
+      // Easy-going
+      "Algieba",
+      // Smooth
+      "Despina",
+      // Smooth
+      "Erinome",
+      // Clear
+      "Algenib",
+      // Gravelly
+      "Rasalgethi",
+      // Informative
+      "Laomedeia",
+      // Upbeat
+      "Achernar",
+      // Soft
+      "Alnilam",
+      // Firm
+      "Schedar",
+      // Even
+      "Gacrux",
+      // Mature
+      "Pulcherrima",
+      // Forward
+      "Achird",
+      // Friendly
+      "Zubenelgenubi",
+      // Casual
+      "Vindemiatrix",
+      // Gentle
+      "Sadachbia",
+      // Lively
+      "Sadaltager",
+      // Knowledgeable
+      "Sulafat"
+      // Warm
+    ];
+    GEMINI_TTS_FORMATS = ["pcm", "wav"];
+    geminiSpeechModels = [
+      {
+        provider: "gemini",
+        modelId: "gemini-2.5-flash-preview-tts",
+        displayName: "Gemini 2.5 Flash TTS (Preview)",
+        pricing: {
+          // $0.50 per 1M input tokens = $0.0000005 per token
+          perInputToken: 5e-7,
+          // $10.00 per 1M audio output tokens = $0.00001 per token
+          perAudioOutputToken: 1e-5,
+          // Rough estimate: ~$0.01 per minute of audio
+          perMinute: 0.01
+        },
+        voices: [...GEMINI_TTS_VOICES],
+        formats: GEMINI_TTS_FORMATS,
+        maxInputLength: 8e3,
+        // bytes (text + prompt combined)
+        defaultVoice: "Zephyr",
+        defaultFormat: "wav",
+        features: {
+          multiSpeaker: true,
+          languages: 24,
+          voiceInstructions: true
+        }
+      },
+      {
+        provider: "gemini",
+        modelId: "gemini-2.5-pro-preview-tts",
+        displayName: "Gemini 2.5 Pro TTS (Preview)",
+        pricing: {
+          // $1.00 per 1M input tokens = $0.000001 per token
+          perInputToken: 1e-6,
+          // $20.00 per 1M audio output tokens = $0.00002 per token
+          perAudioOutputToken: 2e-5,
+          // Rough estimate: ~$0.02 per minute of audio
+          perMinute: 0.02
+        },
+        voices: [...GEMINI_TTS_VOICES],
+        formats: GEMINI_TTS_FORMATS,
+        maxInputLength: 8e3,
+        // bytes
+        defaultVoice: "Zephyr",
+        defaultFormat: "wav",
+        features: {
+          multiSpeaker: true,
+          languages: 24,
+          voiceInstructions: true
+        }
+      }
+    ];
+  }
+});
+
 // src/providers/gemini.ts
+function wrapPcmInWav(pcmData, sampleRate, bitsPerSample, numChannels) {
+  const byteRate = sampleRate * numChannels * bitsPerSample / 8;
+  const blockAlign = numChannels * bitsPerSample / 8;
+  const dataSize = pcmData.length;
+  const headerSize = 44;
+  const fileSize = headerSize + dataSize - 8;
+  const buffer = new ArrayBuffer(headerSize + dataSize);
+  const view = new DataView(buffer);
+  const uint8 = new Uint8Array(buffer);
+  view.setUint32(0, 1380533830, false);
+  view.setUint32(4, fileSize, true);
+  view.setUint32(8, 1463899717, false);
+  view.setUint32(12, 1718449184, false);
+  view.setUint32(16, 16, true);
+  view.setUint16(20, 1, true);
+  view.setUint16(22, numChannels, true);
+  view.setUint32(24, sampleRate, true);
+  view.setUint32(28, byteRate, true);
+  view.setUint16(32, blockAlign, true);
+  view.setUint16(34, bitsPerSample, true);
+  view.setUint32(36, 1684108385, false);
+  view.setUint32(40, dataSize, true);
+  uint8.set(pcmData, headerSize);
+  return buffer;
+}
 function createGeminiProviderFromEnv() {
   return createProviderFromEnv("GEMINI_API_KEY", import_genai.GoogleGenAI, GeminiGenerativeProvider);
 }
@@ -4986,7 +5368,9 @@ var init_gemini = __esm({
     import_genai = require("@google/genai");
     init_base_provider();
     init_constants2();
+    init_gemini_image_models();
     init_gemini_models();
+    init_gemini_speech_models();
     init_utils();
     GEMINI_ROLE_MAP = {
       system: "user",
@@ -5001,6 +5385,139 @@ var init_gemini = __esm({
       getModelSpecs() {
         return GEMINI_MODELS;
       }
+      // =========================================================================
+      // Image Generation
+      // =========================================================================
+      getImageModelSpecs() {
+        return geminiImageModels;
+      }
+      supportsImageGeneration(modelId) {
+        return isGeminiImageModel(modelId);
+      }
+      async generateImage(options) {
+        const client = this.client;
+        const spec = getGeminiImageModelSpec(options.model);
+        const isImagenModel = options.model.startsWith("imagen");
+        const aspectRatio = options.size ?? spec?.defaultSize ?? "1:1";
+        const n = options.n ?? 1;
+        if (isImagenModel) {
+          const response2 = await client.models.generateImages({
+            model: options.model,
+            prompt: options.prompt,
+            config: {
+              numberOfImages: n,
+              aspectRatio,
+              outputMimeType: options.responseFormat === "b64_json" ? "image/png" : "image/jpeg"
+            }
+          });
+          const images2 = response2.generatedImages ?? [];
+          const cost2 = calculateGeminiImageCost(options.model, aspectRatio, images2.length);
+          return {
+            // Gemini's imageBytes is already base64 encoded, so use it directly
+            images: images2.map((img) => ({
+              b64Json: img.image?.imageBytes ?? void 0
+            })),
+            model: options.model,
+            usage: {
+              imagesGenerated: images2.length,
+              size: aspectRatio,
+              quality: "standard"
+            },
+            cost: cost2
+          };
+        }
+        const response = await client.models.generateContent({
+          model: options.model,
+          contents: [{ role: "user", parts: [{ text: options.prompt }] }],
+          config: {
+            responseModalities: [import_genai.Modality.IMAGE, import_genai.Modality.TEXT]
+          }
+        });
+        const images = [];
+        const candidate = response.candidates?.[0];
+        if (candidate?.content?.parts) {
+          for (const part of candidate.content.parts) {
+            if ("inlineData" in part && part.inlineData) {
+              images.push({
+                b64Json: part.inlineData.data
+              });
+            }
+          }
+        }
+        const cost = calculateGeminiImageCost(options.model, aspectRatio, images.length);
+        return {
+          images,
+          model: options.model,
+          usage: {
+            imagesGenerated: images.length,
+            size: aspectRatio,
+            quality: "standard"
+          },
+          cost
+        };
+      }
+      // =========================================================================
+      // Speech Generation
+      // =========================================================================
+      getSpeechModelSpecs() {
+        return geminiSpeechModels;
+      }
+      supportsSpeechGeneration(modelId) {
+        return isGeminiSpeechModel(modelId);
+      }
+      async generateSpeech(options) {
+        const client = this.client;
+        const spec = getGeminiSpeechModelSpec(options.model);
+        const voice = options.voice ?? spec?.defaultVoice ?? "Zephyr";
+        const response = await client.models.generateContent({
+          model: options.model,
+          contents: [
+            {
+              role: "user",
+              parts: [{ text: options.input }]
+            }
+          ],
+          config: {
+            responseModalities: [import_genai.Modality.AUDIO],
+            speechConfig: {
+              voiceConfig: {
+                prebuiltVoiceConfig: {
+                  voiceName: voice
+                }
+              }
+            }
+          }
+        });
+        let pcmData;
+        const candidate = response.candidates?.[0];
+        if (candidate?.content?.parts) {
+          for (const part of candidate.content.parts) {
+            if ("inlineData" in part && part.inlineData?.data) {
+              const base64 = part.inlineData.data;
+              const binary = atob(base64);
+              pcmData = new Uint8Array(binary.length);
+              for (let i = 0; i < binary.length; i++) {
+                pcmData[i] = binary.charCodeAt(i);
+              }
+              break;
+            }
+          }
+        }
+        if (!pcmData) {
+          throw new Error("No audio data in Gemini TTS response");
+        }
+        const audioData = wrapPcmInWav(pcmData, 24e3, 16, 1);
+        const cost = calculateGeminiSpeechCost(options.model, options.input.length);
+        return {
+          audio: audioData,
+          model: options.model,
+          usage: {
+            characterCount: options.input.length
+          },
+          cost,
+          format: spec?.defaultFormat ?? "wav"
+        };
+      }
       buildRequestPayload(options, descriptor, _spec, messages) {
         const contents = this.convertMessagesToContents(messages);
         const generationConfig = this.buildGenerationConfig(options);
@@ -5196,6 +5713,121 @@ var init_gemini = __esm({
   }
 });
 
+// src/providers/openai-image-models.ts
+function getOpenAIImageModelSpec(modelId) {
+  return openaiImageModels.find((m) => m.modelId === modelId);
+}
+function isOpenAIImageModel(modelId) {
+  return openaiImageModels.some((m) => m.modelId === modelId);
+}
+function calculateOpenAIImageCost(modelId, size, quality = "standard", n = 1) {
+  const spec = getOpenAIImageModelSpec(modelId);
+  if (!spec) return void 0;
+  const sizePrice = spec.pricing.bySize?.[size];
+  if (sizePrice === void 0) return void 0;
+  let pricePerImage;
+  if (typeof sizePrice === "number") {
+    pricePerImage = sizePrice;
+  } else {
+    pricePerImage = sizePrice[quality];
+    if (pricePerImage === void 0) return void 0;
+  }
+  return pricePerImage * n;
+}
+var GPT_IMAGE_SIZES, GPT_IMAGE_QUALITIES, DALLE3_SIZES, DALLE3_QUALITIES, DALLE2_SIZES, openaiImageModels;
+var init_openai_image_models = __esm({
+  "src/providers/openai-image-models.ts"() {
+    "use strict";
+    GPT_IMAGE_SIZES = ["1024x1024", "1024x1536", "1536x1024"];
+    GPT_IMAGE_QUALITIES = ["low", "medium", "high"];
+    DALLE3_SIZES = ["1024x1024", "1024x1792", "1792x1024"];
+    DALLE3_QUALITIES = ["standard", "hd"];
+    DALLE2_SIZES = ["256x256", "512x512", "1024x1024"];
+    openaiImageModels = [
+      // GPT Image 1 Family (flagship)
+      {
+        provider: "openai",
+        modelId: "gpt-image-1",
+        displayName: "GPT Image 1",
+        pricing: {
+          bySize: {
+            "1024x1024": { low: 0.011, medium: 0.04, high: 0.17 },
+            "1024x1536": { low: 0.016, medium: 0.06, high: 0.25 },
+            "1536x1024": { low: 0.016, medium: 0.06, high: 0.25 }
+          }
+        },
+        supportedSizes: [...GPT_IMAGE_SIZES],
+        supportedQualities: [...GPT_IMAGE_QUALITIES],
+        maxImages: 1,
+        defaultSize: "1024x1024",
+        defaultQuality: "medium",
+        features: {
+          textRendering: true,
+          transparency: true
+        }
+      },
+      {
+        provider: "openai",
+        modelId: "gpt-image-1-mini",
+        displayName: "GPT Image 1 Mini",
+        pricing: {
+          bySize: {
+            "1024x1024": { low: 5e-3, medium: 0.02, high: 0.052 },
+            "1024x1536": { low: 75e-4, medium: 0.03, high: 0.078 },
+            "1536x1024": { low: 75e-4, medium: 0.03, high: 0.078 }
+          }
+        },
+        supportedSizes: [...GPT_IMAGE_SIZES],
+        supportedQualities: [...GPT_IMAGE_QUALITIES],
+        maxImages: 1,
+        defaultSize: "1024x1024",
+        defaultQuality: "medium",
+        features: {
+          textRendering: true,
+          transparency: true
+        }
+      },
+      // DALL-E Family
+      {
+        provider: "openai",
+        modelId: "dall-e-3",
+        displayName: "DALL-E 3",
+        pricing: {
+          bySize: {
+            "1024x1024": { standard: 0.04, hd: 0.08 },
+            "1024x1792": { standard: 0.08, hd: 0.12 },
+            "1792x1024": { standard: 0.08, hd: 0.12 }
+          }
+        },
+        supportedSizes: [...DALLE3_SIZES],
+        supportedQualities: [...DALLE3_QUALITIES],
+        maxImages: 1,
+        // DALL-E 3 only supports n=1
+        defaultSize: "1024x1024",
+        defaultQuality: "standard",
+        features: {
+          textRendering: true
+        }
+      },
+      {
+        provider: "openai",
+        modelId: "dall-e-2",
+        displayName: "DALL-E 2 (Legacy)",
+        pricing: {
+          bySize: {
+            "256x256": 0.016,
+            "512x512": 0.018,
+            "1024x1024": 0.02
+          }
+        },
+        supportedSizes: [...DALLE2_SIZES],
+        maxImages: 10,
+        defaultSize: "1024x1024"
+      }
+    ];
+  }
+});
+
 // src/providers/openai-models.ts
 var OPENAI_MODELS;
 var init_openai_models = __esm({
@@ -5560,6 +6192,144 @@ var init_openai_models = __esm({
   }
 });
 
+// src/providers/openai-speech-models.ts
+function getOpenAISpeechModelSpec(modelId) {
+  return openaiSpeechModels.find((m) => m.modelId === modelId);
+}
+function isOpenAISpeechModel(modelId) {
+  return openaiSpeechModels.some((m) => m.modelId === modelId);
+}
+function calculateOpenAISpeechCost(modelId, characterCount, estimatedMinutes) {
+  const spec = getOpenAISpeechModelSpec(modelId);
+  if (!spec) return void 0;
+  if (spec.pricing.perCharacter !== void 0) {
+    return characterCount * spec.pricing.perCharacter;
+  }
+  if (spec.pricing.perMinute !== void 0 && estimatedMinutes !== void 0) {
+    return estimatedMinutes * spec.pricing.perMinute;
+  }
+  if (spec.pricing.perMinute !== void 0) {
+    const approxMinutes = characterCount / 750;
+    return approxMinutes * spec.pricing.perMinute;
+  }
+  return void 0;
+}
+var OPENAI_TTS_VOICES, OPENAI_TTS_EXTENDED_VOICES, OPENAI_TTS_FORMATS, openaiSpeechModels;
+var init_openai_speech_models = __esm({
+  "src/providers/openai-speech-models.ts"() {
+    "use strict";
+    OPENAI_TTS_VOICES = [
+      "alloy",
+      "echo",
+      "fable",
+      "onyx",
+      "nova",
+      "shimmer"
+    ];
+    OPENAI_TTS_EXTENDED_VOICES = [
+      ...OPENAI_TTS_VOICES,
+      "ash",
+      "ballad",
+      "coral",
+      "sage",
+      "verse"
+    ];
+    OPENAI_TTS_FORMATS = ["mp3", "opus", "aac", "flac", "wav", "pcm"];
+    openaiSpeechModels = [
+      // Standard TTS models (character-based pricing)
+      {
+        provider: "openai",
+        modelId: "tts-1",
+        displayName: "TTS-1",
+        pricing: {
+          // $15 per 1M characters = $0.000015 per character
+          perCharacter: 15e-6
+        },
+        voices: [...OPENAI_TTS_VOICES],
+        formats: OPENAI_TTS_FORMATS,
+        maxInputLength: 4096,
+        defaultVoice: "alloy",
+        defaultFormat: "mp3",
+        features: {
+          voiceInstructions: false
+        }
+      },
+      {
+        provider: "openai",
+        modelId: "tts-1-1106",
+        displayName: "TTS-1 (Nov 2023)",
+        pricing: {
+          perCharacter: 15e-6
+        },
+        voices: [...OPENAI_TTS_VOICES],
+        formats: OPENAI_TTS_FORMATS,
+        maxInputLength: 4096,
+        defaultVoice: "alloy",
+        defaultFormat: "mp3",
+        features: {
+          voiceInstructions: false
+        }
+      },
+      {
+        provider: "openai",
+        modelId: "tts-1-hd",
+        displayName: "TTS-1 HD",
+        pricing: {
+          // $30 per 1M characters = $0.00003 per character
+          perCharacter: 3e-5
+        },
+        voices: [...OPENAI_TTS_VOICES],
+        formats: OPENAI_TTS_FORMATS,
+        maxInputLength: 4096,
+        defaultVoice: "alloy",
+        defaultFormat: "mp3",
+        features: {
+          voiceInstructions: false
+        }
+      },
+      {
+        provider: "openai",
+        modelId: "tts-1-hd-1106",
+        displayName: "TTS-1 HD (Nov 2023)",
+        pricing: {
+          perCharacter: 3e-5
+        },
+        voices: [...OPENAI_TTS_VOICES],
+        formats: OPENAI_TTS_FORMATS,
+        maxInputLength: 4096,
+        defaultVoice: "alloy",
+        defaultFormat: "mp3",
+        features: {
+          voiceInstructions: false
+        }
+      },
+      // Token-based TTS model with voice instructions support
+      {
+        provider: "openai",
+        modelId: "gpt-4o-mini-tts",
+        displayName: "GPT-4o Mini TTS",
+        pricing: {
+          // $0.60 per 1M input tokens = $0.0000006 per token
+          perInputToken: 6e-7,
+          // $12 per 1M audio output tokens = $0.000012 per token
+          perAudioOutputToken: 12e-6,
+          // ~$0.015 per minute of audio
+          perMinute: 0.015
+        },
+        voices: [...OPENAI_TTS_EXTENDED_VOICES],
+        formats: OPENAI_TTS_FORMATS,
+        maxInputLength: 2e3,
+        // tokens, not characters
+        defaultVoice: "alloy",
+        defaultFormat: "mp3",
+        features: {
+          voiceInstructions: true
+        }
+      }
+    ];
+  }
+});
+
 // src/providers/openai.ts
 function sanitizeExtra(extra, allowTemperature) {
   if (!extra) {
@@ -5581,7 +6351,9 @@ var init_openai = __esm({
     import_tiktoken = require("tiktoken");
     init_base_provider();
     init_constants2();
+    init_openai_image_models();
     init_openai_models();
+    init_openai_speech_models();
     init_utils();
     ROLE_MAP = {
       system: "system",
@@ -5596,6 +6368,87 @@ var init_openai = __esm({
       getModelSpecs() {
         return OPENAI_MODELS;
       }
+      // =========================================================================
+      // Image Generation
+      // =========================================================================
+      getImageModelSpecs() {
+        return openaiImageModels;
+      }
+      supportsImageGeneration(modelId) {
+        return isOpenAIImageModel(modelId);
+      }
+      async generateImage(options) {
+        const client = this.client;
+        const spec = getOpenAIImageModelSpec(options.model);
+        const size = options.size ?? spec?.defaultSize ?? "1024x1024";
+        const quality = options.quality ?? spec?.defaultQuality ?? "standard";
+        const n = options.n ?? 1;
+        const isDallE2 = options.model === "dall-e-2";
+        const isGptImage = options.model.startsWith("gpt-image");
+        const requestParams = {
+          model: options.model,
+          prompt: options.prompt,
+          size,
+          n
+        };
+        if (!isDallE2 && !isGptImage) {
+          requestParams.quality = quality;
+        }
+        if (isGptImage) {
+        } else if (!isDallE2) {
+          requestParams.response_format = options.responseFormat ?? "url";
+        }
+        const response = await client.images.generate(requestParams);
+        const cost = calculateOpenAIImageCost(options.model, size, quality, n);
+        const images = response.data ?? [];
+        return {
+          images: images.map((img) => ({
+            url: img.url,
+            b64Json: img.b64_json,
+            revisedPrompt: img.revised_prompt
+          })),
+          model: options.model,
+          usage: {
+            imagesGenerated: images.length,
+            size,
+            quality
+          },
+          cost
+        };
+      }
+      // =========================================================================
+      // Speech Generation
+      // =========================================================================
+      getSpeechModelSpecs() {
+        return openaiSpeechModels;
+      }
+      supportsSpeechGeneration(modelId) {
+        return isOpenAISpeechModel(modelId);
+      }
+      async generateSpeech(options) {
+        const client = this.client;
+        const spec = getOpenAISpeechModelSpec(options.model);
+        const format = options.responseFormat ?? spec?.defaultFormat ?? "mp3";
+        const voice = options.voice ?? spec?.defaultVoice ?? "alloy";
+        const response = await client.audio.speech.create({
+          model: options.model,
+          input: options.input,
+          voice,
+          response_format: format,
+          speed: options.speed ?? 1
+        });
+        const audioBuffer = await response.arrayBuffer();
+        const cost = calculateOpenAISpeechCost(options.model, options.input.length);
+        return {
+          audio: audioBuffer,
+          model: options.model,
+          usage: {
+            characterCount: options.input.length
+          },
+          cost,
+          format
+        };
+      }
       buildRequestPayload(options, descriptor, spec, messages) {
         const { maxTokens, temperature, topP, stopSequences, extra } = options;
         const supportsTemperature = spec?.metadata?.supportsTemperature !== false;
@@ -5936,30 +6789,109 @@ var init_model_registry = __esm({
   }
 });
 
-// src/core/options.ts
-var ModelIdentifierParser;
-var init_options = __esm({
-  "src/core/options.ts"() {
+// src/core/namespaces/image.ts
+var ImageNamespace;
+var init_image = __esm({
+  "src/core/namespaces/image.ts"() {
     "use strict";
-    ModelIdentifierParser = class {
-      constructor(defaultProvider = "openai") {
+    ImageNamespace = class {
+      constructor(adapters, defaultProvider) {
+        this.adapters = adapters;
         this.defaultProvider = defaultProvider;
       }
-      parse(identifier) {
-        const trimmed = identifier.trim();
-        if (!trimmed) {
-          throw new Error("Model identifier cannot be empty");
+      /**
+       * Generate images from a text prompt.
+       *
+       * @param options - Image generation options
+       * @returns Promise resolving to the generation result with images and cost
+       * @throws Error if the provider doesn't support image generation
+       */
+      async generate(options) {
+        const modelId = options.model;
+        const adapter = this.findImageAdapter(modelId);
+        if (!adapter || !adapter.generateImage) {
+          throw new Error(
+            `No provider supports image generation for model "${modelId}". Available image models: ${this.listModels().map((m) => m.modelId).join(", ")}`
+          );
         }
-        const [maybeProvider, ...rest] = trimmed.split(":");
-        if (rest.length === 0) {
-          return { provider: this.defaultProvider, name: maybeProvider };
+        return adapter.generateImage(options);
+      }
+      /**
+       * List all available image generation models.
+       */
+      listModels() {
+        const models = [];
+        for (const adapter of this.adapters) {
+          if (adapter.getImageModelSpecs) {
+            models.push(...adapter.getImageModelSpecs());
+          }
         }
-        const provider = maybeProvider;
-        const name = rest.join(":");
-        if (!name) {
-          throw new Error("Model name cannot be empty");
+        return models;
+      }
+      /**
+       * Check if a model is supported for image generation.
+       */
+      supportsModel(modelId) {
+        return this.findImageAdapter(modelId) !== void 0;
+      }
+      findImageAdapter(modelId) {
+        return this.adapters.find(
+          (adapter) => adapter.supportsImageGeneration?.(modelId) ?? false
+        );
+      }
+    };
+  }
+});
+
+// src/core/namespaces/speech.ts
+var SpeechNamespace;
+var init_speech = __esm({
+  "src/core/namespaces/speech.ts"() {
+    "use strict";
+    SpeechNamespace = class {
+      constructor(adapters, defaultProvider) {
+        this.adapters = adapters;
+        this.defaultProvider = defaultProvider;
+      }
+      /**
+       * Generate speech audio from text.
+       *
+       * @param options - Speech generation options
+       * @returns Promise resolving to the generation result with audio and cost
+       * @throws Error if the provider doesn't support speech generation
+       */
+      async generate(options) {
+        const modelId = options.model;
+        const adapter = this.findSpeechAdapter(modelId);
+        if (!adapter || !adapter.generateSpeech) {
+          throw new Error(
+            `No provider supports speech generation for model "${modelId}". Available speech models: ${this.listModels().map((m) => m.modelId).join(", ")}`
+          );
         }
-        return { provider, name };
+        return adapter.generateSpeech(options);
+      }
+      /**
+       * List all available speech generation models.
+       */
+      listModels() {
+        const models = [];
+        for (const adapter of this.adapters) {
+          if (adapter.getSpeechModelSpecs) {
+            models.push(...adapter.getSpeechModelSpecs());
+          }
+        }
+        return models;
+      }
+      /**
+       * Check if a model is supported for speech generation.
+       */
+      supportsModel(modelId) {
+        return this.findSpeechAdapter(modelId) !== void 0;
+      }
+      findSpeechAdapter(modelId) {
+        return this.adapters.find(
+          (adapter) => adapter.supportsSpeechGeneration?.(modelId) ?? false
+        );
       }
     };
   }
@@ -6008,6 +6940,69 @@ var init_quick_methods = __esm({
   }
 });
 
+// src/core/namespaces/text.ts
+var TextNamespace;
+var init_text = __esm({
+  "src/core/namespaces/text.ts"() {
+    "use strict";
+    init_quick_methods();
+    TextNamespace = class {
+      constructor(client) {
+        this.client = client;
+      }
+      /**
+       * Generate a complete text response.
+       *
+       * @param prompt - User prompt
+       * @param options - Optional configuration
+       * @returns Complete text response
+       */
+      async complete(prompt, options) {
+        return complete(this.client, prompt, options);
+      }
+      /**
+       * Stream text chunks.
+       *
+       * @param prompt - User prompt
+       * @param options - Optional configuration
+       * @returns Async generator yielding text chunks
+       */
+      stream(prompt, options) {
+        return stream(this.client, prompt, options);
+      }
+    };
+  }
+});
+
+// src/core/options.ts
+var ModelIdentifierParser;
+var init_options = __esm({
+  "src/core/options.ts"() {
+    "use strict";
+    ModelIdentifierParser = class {
+      constructor(defaultProvider = "openai") {
+        this.defaultProvider = defaultProvider;
+      }
+      parse(identifier) {
+        const trimmed = identifier.trim();
+        if (!trimmed) {
+          throw new Error("Model identifier cannot be empty");
+        }
+        const [maybeProvider, ...rest] = trimmed.split(":");
+        if (rest.length === 0) {
+          return { provider: this.defaultProvider, name: maybeProvider };
+        }
+        const provider = maybeProvider;
+        const name = rest.join(":");
+        if (!name) {
+          throw new Error("Model name cannot be empty");
+        }
+        return { provider, name };
+      }
+    };
+  }
+});
+
 // src/core/client.ts
 var client_exports = {};
 __export(client_exports, {
@@ -6020,12 +7015,20 @@ var init_client = __esm({
     init_builder();
     init_discovery();
     init_model_registry();
+    init_image();
+    init_speech();
+    init_text();
     init_options();
     init_quick_methods();
     LLMist = class _LLMist {
       parser;
+      defaultProvider;
       modelRegistry;
       adapters;
+      // Namespaces for different generation types
+      text;
+      image;
+      speech;
       constructor(...args) {
         let adapters = [];
         let defaultProvider;
@@ -6064,6 +7067,7 @@ var init_client = __esm({
           const priorityB = b.priority ?? 0;
           return priorityB - priorityA;
         });
+        this.defaultProvider = resolvedDefaultProvider;
         this.parser = new ModelIdentifierParser(resolvedDefaultProvider);
         this.modelRegistry = new ModelRegistry();
         for (const adapter of this.adapters) {
@@ -6072,6 +7076,9 @@ var init_client = __esm({
         if (customModels.length > 0) {
           this.modelRegistry.registerModels(customModels);
         }
+        this.text = new TextNamespace(this);
+        this.image = new ImageNamespace(this.adapters, this.defaultProvider);
+        this.speech = new SpeechNamespace(this.adapters, this.defaultProvider);
       }
       stream(options) {
         const descriptor = this.parser.parse(options.model);