@hiper2d/ai-agents 0.1.5 → 0.2.1

package/dist/index.js

@@ -44,10 +44,12 @@ __export(index_exports, {
   DeepSeekV2Agent: () => DeepSeekV2Agent,
   FUGU_REASONING_EFFORTS: () => FUGU_REASONING_EFFORTS,
   FuguAgent: () => FuguAgent,
+  GEMINI_AUDIO_TOKENS_PER_SECOND: () => GEMINI_AUDIO_TOKENS_PER_SECOND,
   GEMINI_REASONING_EFFORTS: () => GEMINI_REASONING_EFFORTS,
   GLM_REASONING_EFFORTS: () => GLM_REASONING_EFFORTS,
   GlmAgent: () => GlmAgent,
   GoogleAgent: () => GoogleAgent,
+  GoogleVoiceAgent: () => GoogleVoiceAgent,
   Gpt5Agent: () => Gpt5Agent,
   GrokAgent: () => GrokAgent,
   KimiAgent: () => KimiAgent,
@@ -65,23 +67,35 @@ __export(index_exports, {
   ModelRefusalError: () => ModelRefusalError,
   ModelUnavailableError: () => ModelUnavailableError,
   OPENAI_REASONING_EFFORTS: () => OPENAI_REASONING_EFFORTS,
+  OpenAiVoiceAgent: () => OpenAiVoiceAgent,
   QwenAgent: () => QwenAgent,
   REASONING_EFFORT_SCALE: () => REASONING_EFFORT_SCALE,
+  SUPPORTED_VOICE_PROVIDERS: () => SUPPORTED_VOICE_PROVIDERS,
   SupportedAiKeyNames: () => SupportedAiKeyNames,
   SupportedAiModels: () => SupportedAiModels,
+  VOICE_MODEL_CONSTANTS: () => VOICE_MODEL_CONSTANTS,
+  VOICE_MODEL_PRICING: () => VOICE_MODEL_PRICING,
+  VOICE_PROVIDER_API_KEY: () => VOICE_PROVIDER_API_KEY,
+  VoiceAgentFactory: () => VoiceAgentFactory,
   ZodSchemaConverter: () => ZodSchemaConverter,
+  buildGoogleTtsPrompt: () => buildGoogleTtsPrompt,
   calculateAnthropicCost: () => calculateAnthropicCost,
   calculateCost: () => calculateCost,
   calculateDeepSeekCost: () => calculateDeepSeekCost,
+  calculateGeminiSttCost: () => calculateGeminiSttCost,
+  calculateGeminiTtsCost: () => calculateGeminiTtsCost,
   calculateGoogleCost: () => calculateGoogleCost,
   calculateGrokCost: () => calculateGrokCost,
   calculateKimiCost: () => calculateKimiCost,
   calculateMistralCost: () => calculateMistralCost,
   calculateModelCost: () => calculateModelCost,
   calculateOpenAICost: () => calculateOpenAICost,
+  calculateOpenAiSttCost: () => calculateOpenAiSttCost,
+  calculateOpenAiTtsCost: () => calculateOpenAiTtsCost,
   clampReasoningEffort: () => clampReasoningEffort,
   cleanResponse: () => cleanResponse,
   createCatalog: () => createCatalog,
+  createVoiceAgent: () => createVoiceAgent,
   extractAnthropicTokenUsage: () => extractAnthropicTokenUsage,
   extractAnthropicTokenUsageFromResponse: () => extractTokenUsageFromResponse5,
   extractDeepSeekTokenUsage: () => extractDeepSeekTokenUsage,
@@ -99,6 +113,8 @@ __export(index_exports, {
   extractOpenAITokenUsageFromResponse: () => extractTokenUsageFromResponse,
   extractTokenUsage: () => extractTokenUsage,
   extractUsageAndCalculateCost: () => extractUsageAndCalculateCost,
+  generateGoogleTtsAudio: () => generateGoogleTtsAudio,
+  generateOpenAiTtsAudio: () => generateOpenAiTtsAudio,
   generateSchemaInstructions: () => generateSchemaInstructions,
   getModelConfigByApiName: () => getModelConfigByApiName,
   getModelDisplayName: () => getModelDisplayName,
@@ -115,6 +131,7 @@ __export(index_exports, {
   modelIsFast: () => modelIsFast,
   needsPromptBasedSchema: () => needsPromptBasedSchema,
   parseAndValidateLlmJson: () => parseAndValidateLlmJson,
+  pcmToWav: () => pcmToWav,
   safeValidateResponse: () => safeValidateResponse,
   setLlmLogger: () => setLlmLogger,
   stableHashHex: () => stableHashHex,
@@ -126,6 +143,8 @@ __export(index_exports, {
   toGeminiEffort: () => toGeminiEffort,
   toGlmEffort: () => toGlmEffort,
   toOpenAIEffort: () => toOpenAIEffort,
+  transcribeWithGemini: () => transcribeWithGemini,
+  transcribeWithOpenAi: () => transcribeWithOpenAi,
   validateResponse: () => validateResponse
 });
 module.exports = __toCommonJS(index_exports);
@@ -1750,6 +1769,263 @@ function extractTokenUsageFromResponse7(response) {
   return extractMistralTokenUsage(response);
 }
 
+// src/voice/voice-catalog.ts
+var VOICE_MODEL_CONSTANTS = {
+  OPENAI_TTS: "gpt-4o-mini-tts",
+  OPENAI_STT: "whisper-1",
+  // ai.google.dev/gemini-api/docs/speech-generation
+  GOOGLE_TTS: "gemini-3.1-flash-tts-preview",
+  // ai.google.dev/gemini-api/docs/transcribe — Interactions API only (see google-stt.ts)
+  GOOGLE_STT: "gemini-3.5-transcribe"
+};
+var SUPPORTED_VOICE_PROVIDERS = ["openai", "google"];
+var VOICE_PROVIDER_API_KEY = {
+  openai: API_KEY_CONSTANTS.OPENAI,
+  google: API_KEY_CONSTANTS.GOOGLE
+};
+var VOICE_MODEL_PRICING = {
+  [VOICE_MODEL_CONSTANTS.OPENAI_TTS]: { pricePerMillionCharacters: 15 },
+  [VOICE_MODEL_CONSTANTS.OPENAI_STT]: { pricePerMinute: 6e-3 },
+  // Measured 2026-09-05: ~32 audio tokens per second of speech, so a 15-second
+  // line is ~$0.01 — about 3-5x an OpenAI line of the same length.
+  [VOICE_MODEL_CONSTANTS.GOOGLE_TTS]: { textInputPricePerM: 1, audioOutputPricePerM: 20 },
+  // ~25 audio tokens per second in, ~175 text tokens per minute out: ≈ $0.005/min.
+  [VOICE_MODEL_CONSTANTS.GOOGLE_STT]: { audioInputPricePerM: 2, textOutputPricePerM: 12 }
+};
+
+// src/voice/voice-pricing.ts
+function roundUSD(value) {
+  return parseFloat((value || 0).toFixed(6));
+}
+function calculateOpenAiTtsCost(characterCount) {
+  const rate = VOICE_MODEL_PRICING[VOICE_MODEL_CONSTANTS.OPENAI_TTS]?.pricePerMillionCharacters ?? 0;
+  if (!characterCount || characterCount <= 0 || rate <= 0) return 0;
+  return roundUSD(characterCount / 1e6 * rate);
+}
+function calculateOpenAiSttCost(durationSeconds) {
+  const rate = VOICE_MODEL_PRICING[VOICE_MODEL_CONSTANTS.OPENAI_STT]?.pricePerMinute ?? 0;
+  if (!durationSeconds || durationSeconds <= 0 || rate <= 0) return 0;
+  return roundUSD(durationSeconds / 60 * rate);
+}
+function calculateGeminiTtsCost(usage) {
+  const pricing = VOICE_MODEL_PRICING[VOICE_MODEL_CONSTANTS.GOOGLE_TTS];
+  return tokenPairCost(usage, pricing?.textInputPricePerM ?? 0, pricing?.audioOutputPricePerM ?? 0);
+}
+function calculateGeminiSttCost(usage) {
+  const pricing = VOICE_MODEL_PRICING[VOICE_MODEL_CONSTANTS.GOOGLE_STT];
+  return tokenPairCost(usage, pricing?.audioInputPricePerM ?? 0, pricing?.textOutputPricePerM ?? 0);
+}
+function tokenPairCost(usage, inputRate, outputRate) {
+  const inputTokens = Math.max(0, usage.inputTokens || 0);
+  const outputTokens = Math.max(0, usage.outputTokens || 0);
+  return inputTokens / 1e6 * inputRate + outputTokens / 1e6 * outputRate;
+}
+
+// src/voice/openai-tts.ts
+var import_openai = require("openai");
+async function generateOpenAiTtsAudio(text, apiKey, options = {}) {
+  const client = new import_openai.OpenAI({ apiKey });
+  const speechOptions = {
+    model: VOICE_MODEL_CONSTANTS.OPENAI_TTS,
+    voice: options.voice || "alloy",
+    input: text,
+    speed: options.speed || 1,
+    response_format: options.format || "wav"
+  };
+  if (options.instructions) {
+    speechOptions.instructions = options.instructions;
+  }
+  const response = await client.audio.speech.create(speechOptions);
+  return await response.arrayBuffer();
+}
+
+// src/voice/openai-stt.ts
+var import_openai2 = require("openai");
+async function transcribeWithOpenAi(audioBuffer, apiKey, options = {}) {
+  const client = new import_openai2.OpenAI({ apiKey });
+  const audioFile = new File([new Uint8Array(audioBuffer)], options.fileName || "audio.webm", { type: options.mimeType || "audio/webm" });
+  const transcription = await client.audio.transcriptions.create({
+    file: audioFile,
+    model: VOICE_MODEL_CONSTANTS.OPENAI_STT,
+    language: options.language || "en",
+    prompt: options.prompt,
+    temperature: options.temperature || 0,
+    response_format: "verbose_json"
+  });
+  const explicitDuration = Number(transcription?.duration) || 0;
+  const segments = Array.isArray(transcription?.segments) ? transcription.segments : [];
+  const segmentsDuration = segments.reduce((max, segment) => {
+    const end = Number(segment?.end);
+    return end > max ? end : max;
+  }, 0);
+  const text = typeof transcription?.text === "string" ? transcription.text : segments.map((segment) => segment?.text || "").join(" ");
+  return { text: text.trim(), durationSeconds: explicitDuration || segmentsDuration };
+}
+
+// src/voice/openai-voice-agent.ts
+var OpenAiVoiceAgent = class {
+  constructor(apiKey) {
+    this.apiKey = apiKey;
+  }
+  apiKey;
+  provider = "openai";
+  ttsModel = VOICE_MODEL_CONSTANTS.OPENAI_TTS;
+  sttModel = VOICE_MODEL_CONSTANTS.OPENAI_STT;
+  async speak(request) {
+    const audio = await generateOpenAiTtsAudio(request.text, this.apiKey, {
+      voice: request.voice,
+      instructions: request.voiceStyle || void 0
+    });
+    const characters = request.text.length;
+    return { audio, costUSD: calculateOpenAiTtsCost(characters), usage: { characters } };
+  }
+  async transcribe(request) {
+    const { text, durationSeconds } = await transcribeWithOpenAi(request.audio, this.apiKey, {
+      language: request.language,
+      prompt: request.prompt,
+      fileName: request.fileName,
+      mimeType: request.mimeType
+    });
+    return { text, durationSeconds, costUSD: calculateOpenAiSttCost(durationSeconds), usage: { audioSeconds: durationSeconds } };
+  }
+};
+
+// src/voice/google-tts.ts
+var import_genai = require("@google/genai");
+var AUDIO_TOKENS_PER_SECOND = 32;
+var SAMPLE_RATE = 24e3;
+var PCM_BYTES_PER_SECOND = SAMPLE_RATE * 2;
+function buildGoogleTtsPrompt(text, voiceStyle) {
+  const style = voiceStyle?.trim().replace(/[:.!,;\s]+$/, "");
+  if (!style) return text;
+  const isShort = style.split(/\s+/).length <= 3 && !/[.!?,;]/.test(style);
+  return isShort ? `Say ${style}: ${text}` : `${style}:
+${text}`;
+}
+function pcmToWav(pcmData, sampleRate = SAMPLE_RATE) {
+  const numChannels = 1;
+  const bitsPerSample = 16;
+  const blockAlign = numChannels * (bitsPerSample / 8);
+  const byteRate = sampleRate * blockAlign;
+  const headerSize = 44;
+  const buffer = new ArrayBuffer(headerSize + pcmData.length);
+  const view = new DataView(buffer);
+  const writeString = (offset, str) => {
+    for (let i = 0; i < str.length; i++) view.setUint8(offset + i, str.charCodeAt(i));
+  };
+  writeString(0, "RIFF");
+  view.setUint32(4, 36 + pcmData.length, true);
+  writeString(8, "WAVE");
+  writeString(12, "fmt ");
+  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);
+  writeString(36, "data");
+  view.setUint32(40, pcmData.length, true);
+  new Uint8Array(buffer, headerSize).set(pcmData);
+  return buffer;
+}
+async function generateGoogleTtsAudio(text, apiKey, options) {
+  const client = new import_genai.GoogleGenAI({ apiKey });
+  const response = await client.models.generateContent({
+    model: VOICE_MODEL_CONSTANTS.GOOGLE_TTS,
+    contents: [{ parts: [{ text: buildGoogleTtsPrompt(text, options.voiceStyle) }] }],
+    config: {
+      responseModalities: ["AUDIO"],
+      speechConfig: { voiceConfig: { prebuiltVoiceConfig: { voiceName: options.voiceName } } }
+    }
+  });
+  const parts = response.candidates?.[0]?.content?.parts ?? [];
+  const audioPart = parts.find((part) => part.inlineData?.mimeType?.startsWith("audio/"));
+  if (!audioPart?.inlineData?.data) {
+    throw new Error("No audio data in Google TTS response");
+  }
+  const pcmData = new Uint8Array(Buffer.from(audioPart.inlineData.data, "base64"));
+  const usageMetadata = response.usageMetadata ?? {};
+  const inputTokens = usageMetadata.promptTokenCount ?? 0;
+  const reportedOutput = usageMetadata.candidatesTokenCount;
+  const outputTokens = reportedOutput && reportedOutput > 0 ? reportedOutput : Math.ceil(pcmData.length / PCM_BYTES_PER_SECOND * AUDIO_TOKENS_PER_SECOND);
+  return { audio: pcmToWav(pcmData), usage: { inputTokens, outputTokens } };
+}
+
+// src/voice/google-stt.ts
+var import_genai2 = require("@google/genai");
+var GEMINI_AUDIO_TOKENS_PER_SECOND = 25;
+async function transcribeWithGemini(audioBuffer, apiKey, options = {}) {
+  const client = new import_genai2.GoogleGenAI({ apiKey });
+  const interaction = await client.interactions.create({
+    model: VOICE_MODEL_CONSTANTS.GOOGLE_STT,
+    input: [{ type: "audio", data: Buffer.from(audioBuffer).toString("base64"), mime_type: options.mimeType || "audio/webm" }]
+  });
+  const text = typeof interaction?.output_text === "string" ? interaction.output_text.trim() : "";
+  const usage = interaction?.usage ?? {};
+  const byModality = (rows, modality) => (rows ?? []).filter((r) => r?.modality === modality).reduce((sum, r) => sum + (Number(r?.tokens) || 0), 0);
+  const inputTokens = byModality(usage.input_tokens_by_modality, "audio") || usage.total_input_tokens || 0;
+  const invocationOutput = (usage.model_invocation_token_counts ?? []).reduce((sum, inv) => sum + (inv?.candidates_tokens_details ?? []).reduce((s, d) => s + (Number(d?.tokens) || 0), 0), 0);
+  const outputTokens = usage.total_output_tokens || invocationOutput || Math.ceil(text.length / 4);
+  return { text, durationSeconds: inputTokens / GEMINI_AUDIO_TOKENS_PER_SECOND, usage: { inputTokens, outputTokens } };
+}
+
+// src/voice/google-voice-agent.ts
+var GoogleVoiceAgent = class {
+  constructor(apiKey) {
+    this.apiKey = apiKey;
+  }
+  apiKey;
+  provider = "google";
+  ttsModel = VOICE_MODEL_CONSTANTS.GOOGLE_TTS;
+  sttModel = VOICE_MODEL_CONSTANTS.GOOGLE_STT;
+  async speak(request) {
+    const { audio, usage } = await generateGoogleTtsAudio(request.text, this.apiKey, {
+      voiceName: request.voice,
+      voiceStyle: request.voiceStyle
+    });
+    return { audio, costUSD: calculateGeminiTtsCost(usage), usage };
+  }
+  async transcribe(request) {
+    const { text, durationSeconds, usage } = await transcribeWithGemini(request.audio, this.apiKey, { mimeType: request.mimeType });
+    return { text, durationSeconds, costUSD: calculateGeminiSttCost(usage), usage };
+  }
+};
+
+// src/voice/voice-agent-factory.ts
+var VoiceAgentFactory = class _VoiceAgentFactory {
+  /** Build an agent from a key already resolved by the caller. */
+  static createAgent(provider, apiKey) {
+    switch (provider) {
+      case "openai":
+        return new OpenAiVoiceAgent(apiKey);
+      case "google":
+        return new GoogleVoiceAgent(apiKey);
+      default:
+        throw new Error(`Unknown voice provider: ${provider}`);
+    }
+  }
+  /**
+   * Build an agent from a key map (the shape AgentFactory takes), reading the
+   * provider's key by its API_KEY_CONSTANTS name. Throws when the key is missing
+   * so the host can report a misconfiguration before any SDK is touched.
+   */
+  static createAgentFromKeys(provider, apiKeys) {
+    if (!SUPPORTED_VOICE_PROVIDERS.includes(provider)) {
+      throw new Error(`Unknown voice provider: ${provider}`);
+    }
+    const keyName = VOICE_PROVIDER_API_KEY[provider];
+    const apiKey = apiKeys[keyName];
+    if (!apiKey) {
+      throw new Error(`Missing API key ${keyName} for voice provider ${provider}`);
+    }
+    return _VoiceAgentFactory.createAgent(provider, apiKey);
+  }
+};
+function createVoiceAgent(provider, apiKey) {
+  return VoiceAgentFactory.createAgent(provider, apiKey);
+}
+
 // src/agents/abstract-agent.ts
 var AbstractAgent = class {
   name;
@@ -1896,10 +2172,15 @@ ${msg.content}` };
 };
 
 // src/agents/gpt-5-agent.ts
-var import_openai = __toESM(require("openai"));
+var import_openai3 = __toESM(require("openai"));
 var import_zod2 = require("openai/helpers/zod");
 var Gpt5Agent = class extends AbstractAgent {
   client;
+  // Routing hint for OpenAI's prefix cache (same scheme as the Mistral/Grok agents): one
+  // key per agent+instruction, so an agent's own calls group together instead of every
+  // agent that shares a static prefix hashing to the same route. Keys influence routing
+  // only; they do not guarantee a hit.
+  promptCacheKey;
   // Log message templates
   logTemplates = {
     error: (name, error) => `Error in ${name} agent: ${error}`
@@ -1912,7 +2193,9 @@ var Gpt5Agent = class extends AbstractAgent {
   };
   constructor(name, instruction, model, apiKey, temperature, enableThinking = false, agentLoggingConfig = DEFAULT_LOGGING_CONFIG.agents) {
     super(name, instruction, model, temperature, enableThinking, agentLoggingConfig);
-    this.client = new import_openai.default({
+    this.promptCacheKey = stableHashHex(`${name}
+${instruction}`);
+    this.client = new import_openai3.default({
       apiKey
     });
   }
@@ -1926,10 +2209,7 @@ var Gpt5Agent = class extends AbstractAgent {
     try {
       this.logAsking(messages);
       this.logMessages(messages);
-      const input = [
-        `System: ${this.instruction}`,
-        ...this.prepareMessages(messages).map((msg) => `${msg.role === "user" ? "User" : "Assistant"}: ${msg.content}`)
-      ].join("\n\n");
+      const input = this.prepareMessages(messages).map((msg) => `${msg.role === "user" ? "User" : "Assistant"}: ${msg.content}`).join("\n\n");
       const schemaToSend = zodSchema;
       let response;
       try {
@@ -1938,6 +2218,7 @@ var Gpt5Agent = class extends AbstractAgent {
           instructions: this.instruction,
           input,
           max_output_tokens: this.maxOutputTokens,
+          prompt_cache_key: this.promptCacheKey,
           text: {
             format: (0, import_zod2.zodTextFormat)(schemaToSend, "response_schema")
           }
@@ -2016,15 +2297,13 @@ var Gpt5Agent = class extends AbstractAgent {
     try {
       this.logAsking(messages);
       this.logMessages(messages);
-      const input = [
-        `System: ${this.instruction}`,
-        ...this.prepareMessages(messages).map((msg) => `${msg.role === "user" ? "User" : "Assistant"}: ${msg.content}`)
-      ].join("\n\n");
+      const input = this.prepareMessages(messages).map((msg) => `${msg.role === "user" ? "User" : "Assistant"}: ${msg.content}`).join("\n\n");
       const response = await this.client.responses.create({
         model: this.model,
         instructions: this.instruction,
         input,
-        max_output_tokens: this.maxOutputTokens
+        max_output_tokens: this.maxOutputTokens,
+        prompt_cache_key: this.promptCacheKey
       });
       const content = response.output_text;
       if (!content) {
@@ -2080,13 +2359,24 @@ var Gpt5Agent = class extends AbstractAgent {
 var import_sdk = require("@anthropic-ai/sdk");
 var ClaudeAgent = class extends AbstractAgent {
   client;
+  /**
+   * TTL for every breakpoint this agent places (system tiers and the message anchor).
+   * Anthropic bills a 5m write at 1.25x input, a 1h write at 2x, reads at 0.1x, and a read
+   * refreshes the timer on either TTL. Default '1h' because the main consumer runs at human
+   * pace: consecutive calls for one agent measured 12-78 minutes apart, so 5m entries
+   * expired before they were ever read (0-16% hit rate over 30 days, hits only on gaps
+   * under five minutes). Set '5m' for continuous traffic where every call lands inside the
+   * window; there the cheaper write wins. One knob for all breakpoints on purpose: Anthropic
+   * requires 1h entries to precede 5m ones, and a single TTL keeps that trivially true.
+   */
+  cacheTtl = "1h";
   // System-prompt breakpoints, one per cache tier (see CACHE_TIER_MARKER):
-  //   block 1 — shared static rules, byte-identical across all bots and games with the
-  //             same rule set, so one org-level entry serves everyone and ANY bot's call
-  //             refreshes its TTL;
-  //   block 2 — per-bot identity + game state + summaries, byte-stable from the start of
-  //             a game day through the end of its night (deaths/role knowledge/summaries
-  //             only change in startNewDay), so every call within a day reads it.
+  //   block 1 - shared static rules, byte-identical across all bots and games with the
+  //             same rule set. Caches are scoped per model, so one entry serves every bot
+  //             ON THAT MODEL (not the whole lobby), and any of their calls refreshes it;
+  //   block 2 - per-bot identity + game state + summaries, byte-stable between the game's
+  //             state writes (a lynch, the night resolution, the summary rewrite, the new
+  //             day), so every call inside one of those windows reads it.
   // GM prompts have no marker → single block, same behavior as before. Haiku 4.5 needs a
   // 4096-token cacheable prefix, so tiers below that silently no-op on Haiku — expected.
   // A getter, not a field: `maxOutputTokens` can be raised after construction, and a field
@@ -2094,7 +2384,7 @@ var ClaudeAgent = class extends AbstractAgent {
   get defaultParams() {
     return {
       max_tokens: this.maxOutputTokens,
-      system: this.instructionParts.map((part) => ({ type: "text", text: part, cache_control: { type: "ephemeral" } })),
+      system: this.instructionParts.map((part) => ({ type: "text", text: part, cache_control: { type: "ephemeral", ttl: this.cacheTtl } })),
       model: this.model
     };
   }
@@ -2199,14 +2489,14 @@ var ClaudeAgent = class extends AbstractAgent {
     const anchor = messages[messages.length - 2];
     if (typeof anchor.content === "string") {
       if (anchor.content.length > 0) {
-        anchor.content = [{ type: "text", text: anchor.content, cache_control: { type: "ephemeral" } }];
+        anchor.content = [{ type: "text", text: anchor.content, cache_control: { type: "ephemeral", ttl: this.cacheTtl } }];
       }
       return;
     }
     for (let i = anchor.content.length - 1; i >= 0; i--) {
       const block = anchor.content[i];
       if (block.type === "text" && block.text.length > 0) {
-        block.cache_control = { type: "ephemeral" };
+        block.cache_control = { type: "ephemeral", ttl: this.cacheTtl };
         return;
       }
     }
@@ -2444,7 +2734,7 @@ ${schemaDescription}`;
 };
 
 // src/agents/google-agent.ts
-var import_genai = require("@google/genai");
+var import_genai3 = require("@google/genai");
 var GoogleAgent = class extends AbstractAgent {
   client;
   defaultConfig = {
@@ -2463,7 +2753,7 @@ var GoogleAgent = class extends AbstractAgent {
   };
   constructor(name, instruction, model, apiKey, enableThinking = false, agentLoggingConfig = DEFAULT_LOGGING_CONFIG.agents) {
     super(name, instruction, model, 0.2, enableThinking, agentLoggingConfig);
-    this.client = new import_genai.GoogleGenAI({
+    this.client = new import_genai3.GoogleGenAI({
       apiKey
     });
   }
@@ -3024,7 +3314,7 @@ ${schemaDescription}`
 };
 
 // src/agents/deepseek-v2-agent.ts
-var import_openai2 = __toESM(require("openai"));
+var import_openai4 = __toESM(require("openai"));
 var DeepSeekV2Agent = class extends AbstractAgent {
   client;
   // Log message templates
@@ -3040,7 +3330,7 @@ var DeepSeekV2Agent = class extends AbstractAgent {
   };
   constructor(name, instruction, model, apiKey, temperature, enableThinking = false, agentLoggingConfig = DEFAULT_LOGGING_CONFIG.agents) {
     super(name, instruction, model, temperature, enableThinking, agentLoggingConfig);
-    this.client = new import_openai2.default({
+    this.client = new import_openai4.default({
       baseURL: "https://api.deepseek.com",
       apiKey
     });
@@ -3232,7 +3522,7 @@ ${schemaDescription}`
 };
 
 // src/agents/grok-agent.ts
-var import_openai3 = require("openai");
+var import_openai5 = require("openai");
 var GrokAgent = class extends AbstractAgent {
   client;
   // Log message templates
@@ -3249,7 +3539,7 @@ var GrokAgent = class extends AbstractAgent {
     super(name, instruction, model, temperature, enableThinking, agentLoggingConfig);
     const convId = stableHashHex(`${name}
 ${instruction}`);
-    this.client = new import_openai3.OpenAI({
+    this.client = new import_openai5.OpenAI({
       apiKey,
       baseURL: "https://api.x.ai/v1",
       timeout: 12e5,
@@ -3422,7 +3712,7 @@ ${input[0].content}`;
 };
 
 // src/agents/kimi-agent.ts
-var import_openai4 = require("openai");
+var import_openai6 = require("openai");
 var KimiAgent = class extends AbstractAgent {
   client;
   // kimi-k3 rejects any temperature other than 1, so we never send the field.
@@ -3449,7 +3739,7 @@ var KimiAgent = class extends AbstractAgent {
   };
   constructor(name, instruction, model, apiKey, temperature, enableThinking = false, agentLoggingConfig = DEFAULT_LOGGING_CONFIG.agents) {
     super(name, instruction, model, temperature, enableThinking, agentLoggingConfig);
-    this.client = new import_openai4.OpenAI({
+    this.client = new import_openai6.OpenAI({
       apiKey,
       baseURL: "https://api.moonshot.ai/v1"
     });
@@ -3640,7 +3930,7 @@ ${openAIMessages[0].content}`;
 };
 
 // src/agents/glm-agent.ts
-var import_openai5 = require("openai");
+var import_openai7 = require("openai");
 var GlmAgent = class extends AbstractAgent {
   client;
   // A getter, not a field: `maxOutputTokens` can be raised after construction, and a field
@@ -3666,7 +3956,7 @@ var GlmAgent = class extends AbstractAgent {
   };
   constructor(name, instruction, model, apiKey, temperature, enableThinking = false, agentLoggingConfig = DEFAULT_LOGGING_CONFIG.agents) {
     super(name, instruction, model, temperature, enableThinking, agentLoggingConfig);
-    this.client = new import_openai5.OpenAI({
+    this.client = new import_openai7.OpenAI({
       apiKey,
       baseURL: "https://api.z.ai/api/paas/v4/"
     });
@@ -3820,7 +4110,7 @@ ${openAIMessages[0].content}`;
 };
 
 // src/agents/fugu-agent.ts
-var import_openai6 = require("openai");
+var import_openai8 = require("openai");
 var FuguAgent = class extends AbstractAgent {
   client;
   // A getter, not a field: `maxOutputTokens` can be raised after construction, and a field
@@ -3844,7 +4134,7 @@ var FuguAgent = class extends AbstractAgent {
   };
   constructor(name, instruction, model, apiKey, enableThinking = false, agentLoggingConfig = DEFAULT_LOGGING_CONFIG.agents) {
     super(name, instruction, model, 1, enableThinking, agentLoggingConfig);
-    this.client = new import_openai6.OpenAI({
+    this.client = new import_openai8.OpenAI({
       apiKey,
       baseURL: "https://api.sakana.ai/v1",
       timeout: 12e5
@@ -4011,7 +4301,7 @@ ${schemaDescription}`;
 };
 
 // src/agents/qwen-agent.ts
-var import_openai7 = require("openai");
+var import_openai9 = require("openai");
 var QwenAgent = class extends AbstractAgent {
   client;
   // A getter, not a field: `maxOutputTokens` can be raised after construction, and a field
@@ -4036,7 +4326,7 @@ var QwenAgent = class extends AbstractAgent {
   };
   constructor(name, instruction, model, apiKey, temperature, enableThinking = false, agentLoggingConfig = DEFAULT_LOGGING_CONFIG.agents) {
     super(name, instruction, model, temperature, enableThinking, agentLoggingConfig);
-    this.client = new import_openai7.OpenAI({
+    this.client = new import_openai9.OpenAI({
       apiKey,
       baseURL: "https://dashscope-intl.aliyuncs.com/compatible-mode/v1"
     });
@@ -4211,7 +4501,7 @@ ${openAIMessages[0].content}`;
 };
 
 // src/agents/minimax-agent.ts
-var import_openai8 = require("openai");
+var import_openai10 = require("openai");
 var MiniMaxAgent = class extends AbstractAgent {
   client;
   // A getter, not a field: `maxOutputTokens` can be raised after construction, and a field
@@ -4236,7 +4526,7 @@ var MiniMaxAgent = class extends AbstractAgent {
   };
   constructor(name, instruction, model, apiKey, temperature, enableThinking = false, agentLoggingConfig = DEFAULT_LOGGING_CONFIG.agents) {
     super(name, instruction, model, temperature, enableThinking, agentLoggingConfig);
-    this.client = new import_openai8.OpenAI({
+    this.client = new import_openai10.OpenAI({
       apiKey,
       baseURL: "https://api.minimax.io/v1"
     });
@@ -4474,10 +4764,12 @@ var AgentFactory = class {
   DeepSeekV2Agent,
   FUGU_REASONING_EFFORTS,
   FuguAgent,
+  GEMINI_AUDIO_TOKENS_PER_SECOND,
   GEMINI_REASONING_EFFORTS,
   GLM_REASONING_EFFORTS,
   GlmAgent,
   GoogleAgent,
+  GoogleVoiceAgent,
   Gpt5Agent,
   GrokAgent,
   KimiAgent,
@@ -4495,23 +4787,35 @@ var AgentFactory = class {
   ModelRefusalError,
   ModelUnavailableError,
   OPENAI_REASONING_EFFORTS,
+  OpenAiVoiceAgent,
   QwenAgent,
   REASONING_EFFORT_SCALE,
+  SUPPORTED_VOICE_PROVIDERS,
   SupportedAiKeyNames,
   SupportedAiModels,
+  VOICE_MODEL_CONSTANTS,
+  VOICE_MODEL_PRICING,
+  VOICE_PROVIDER_API_KEY,
+  VoiceAgentFactory,
   ZodSchemaConverter,
+  buildGoogleTtsPrompt,
   calculateAnthropicCost,
   calculateCost,
   calculateDeepSeekCost,
+  calculateGeminiSttCost,
+  calculateGeminiTtsCost,
   calculateGoogleCost,
   calculateGrokCost,
   calculateKimiCost,
   calculateMistralCost,
   calculateModelCost,
   calculateOpenAICost,
+  calculateOpenAiSttCost,
+  calculateOpenAiTtsCost,
   clampReasoningEffort,
   cleanResponse,
   createCatalog,
+  createVoiceAgent,
   extractAnthropicTokenUsage,
   extractAnthropicTokenUsageFromResponse,
   extractDeepSeekTokenUsage,
@@ -4529,6 +4833,8 @@ var AgentFactory = class {
   extractOpenAITokenUsageFromResponse,
   extractTokenUsage,
   extractUsageAndCalculateCost,
+  generateGoogleTtsAudio,
+  generateOpenAiTtsAudio,
   generateSchemaInstructions,
   getModelConfigByApiName,
   getModelDisplayName,
@@ -4545,6 +4851,7 @@ var AgentFactory = class {
   modelIsFast,
   needsPromptBasedSchema,
   parseAndValidateLlmJson,
+  pcmToWav,
   safeValidateResponse,
   setLlmLogger,
   stableHashHex,
@@ -4556,6 +4863,8 @@ var AgentFactory = class {
   toGeminiEffort,
   toGlmEffort,
   toOpenAIEffort,
+  transcribeWithGemini,
+  transcribeWithOpenAi,
   validateResponse
 });
 //# sourceMappingURL=index.js.map