getpatter 0.5.0 → 0.5.2

package/dist/index.mjs

@@ -3,7 +3,7 @@ import {
 } from "./chunk-AFUYSNDH.mjs";
 import {
   startTunnel
-} from "./chunk-JO5C35FM.mjs";
+} from "./chunk-AKQFOFLG.mjs";
 import {
   CallMetricsAccumulator,
   DEFAULT_MIN_SENTENCE_LEN,
@@ -36,7 +36,7 @@ import {
   resample16kTo8k,
   resample24kTo16k,
   resample8kTo16k
-} from "./chunk-757NVN4L.mjs";
+} from "./chunk-7SDDK2AO.mjs";
 import {
   getLogger,
   setLogger
@@ -351,6 +351,8 @@ var Patter = class {
           "Unknown engine. Expected OpenAIRealtime or ElevenLabsConvAI instance."
         );
       }
+    } else if (!working.provider && (working.stt !== void 0 || working.tts !== void 0 || working.llm !== void 0)) {
+      working = { ...working, provider: "pipeline" };
     }
     if (working.provider) {
       const valid = ["openai_realtime", "elevenlabs_convai", "pipeline"];
@@ -358,6 +360,19 @@ var Patter = class {
         throw new Error(`provider must be one of: ${valid.join(", ")}. Got: '${working.provider}'`);
       }
     }
+    if (working.llm !== void 0) {
+      const llm = working.llm;
+      if (!llm || typeof llm.stream !== "function") {
+        throw new Error(
+          "`llm` must be an LLMProvider instance (e.g. new AnthropicLLM()). Got a value without a `.stream` method."
+        );
+      }
+      if (working.engine) {
+        getLogger().warn(
+          "agent({ engine, llm }): `llm` is ignored when `engine` is set \u2014 realtime/ConvAI engines run their own model. Remove `llm` or switch to pipeline mode (stt + tts + llm) to silence this warning."
+        );
+      }
+    }
     if (working.tools) {
       if (!Array.isArray(working.tools)) {
         throw new TypeError("tools must be an array");
@@ -400,8 +415,10 @@ var Patter = class {
     if (wantsCloudflared && webhookUrl) {
       throw new Error("Cannot use both tunnel: true and webhookUrl. Pick one.");
     }
+    const { showBanner } = await import("./banner-FLR2HE5Z.mjs");
+    showBanner();
     if (wantsCloudflared) {
-      const { startTunnel: startTunnel2 } = await import("./tunnel-BL7A7GXW.mjs");
+      const { startTunnel: startTunnel2 } = await import("./tunnel-O7ICMSTP.mjs");
       this.tunnelHandle = await startTunnel2(port);
       webhookUrl = this.tunnelHandle.hostname;
     }
@@ -452,7 +469,7 @@ var Patter = class {
     if (this.mode !== "local") {
       throw new Error("test() is only available in local mode");
     }
-    const { TestSession: TestSession2 } = await import("./test-mode-YFOL2HYH.mjs");
+    const { TestSession: TestSession2 } = await import("./test-mode-K2TTPRGE.mjs");
     const session = new TestSession2();
     await session.run({
       agent: opts.agent,
@@ -2274,7 +2291,8 @@ var ELEVENLABS_VOICE_ID_BY_NAME = {
   glinda: "z9fAnlkpzviPz146aGWa",
   giovanni: "zcAOhNBS3c14rBihAFp1",
   mimi: "zrHiDhphv9ZnVXBqCLjz",
-  alloy: "21m00Tcm4TlvDq8ikWAM"
+  sarah: "EXAVITQu4vr4xnSDxMaL",
+  alloy: "EXAVITQu4vr4xnSDxMaL"
 };
 var VOICE_ID_PATTERN = /^[A-Za-z0-9]{20}$/;
 function resolveVoiceId(voice) {
@@ -2283,7 +2301,7 @@ function resolveVoiceId(voice) {
   return ELEVENLABS_VOICE_ID_BY_NAME[voice.toLowerCase()] ?? voice;
 }
 var ElevenLabsTTS = class {
-  constructor(apiKey, voiceId = "21m00Tcm4TlvDq8ikWAM", modelId = "eleven_turbo_v2_5", outputFormat = "pcm_16000") {
+  constructor(apiKey, voiceId = "EXAVITQu4vr4xnSDxMaL", modelId = "eleven_turbo_v2_5", outputFormat = "pcm_16000") {
     this.apiKey = apiKey;
     this.modelId = modelId;
     this.outputFormat = outputFormat;
@@ -2354,7 +2372,7 @@ var TTS = class extends ElevenLabsTTS {
     }
     super(
       key,
-      opts.voiceId ?? "21m00Tcm4TlvDq8ikWAM",
+      opts.voiceId ?? "EXAVITQu4vr4xnSDxMaL",
       opts.modelId ?? "eleven_turbo_v2_5",
       opts.outputFormat ?? "pcm_16000"
     );
@@ -2850,6 +2868,616 @@ var TTS5 = class extends LMNTTTS {
   }
 };
 
+// src/llm/openai.ts
+var LLM = class extends OpenAILLMProvider {
+  constructor(opts = {}) {
+    const key = opts.apiKey ?? process.env.OPENAI_API_KEY;
+    if (!key) {
+      throw new Error(
+        "OpenAI LLM requires an apiKey. Pass { apiKey: 'sk-...' } or set OPENAI_API_KEY."
+      );
+    }
+    super(key, opts.model ?? "gpt-4o-mini");
+  }
+};
+
+// src/providers/anthropic-llm.ts
+var DEFAULT_ANTHROPIC_URL = "https://api.anthropic.com/v1/messages";
+var DEFAULT_ANTHROPIC_VERSION = "2023-06-01";
+var DEFAULT_MODEL = "claude-3-5-sonnet-20241022";
+var DEFAULT_MAX_TOKENS = 1024;
+var AnthropicLLMProvider = class {
+  apiKey;
+  model;
+  maxTokens;
+  temperature;
+  url;
+  anthropicVersion;
+  constructor(options) {
+    if (!options.apiKey) {
+      throw new Error(
+        "Anthropic API key is required. Pass it via { apiKey } or set the ANTHROPIC_API_KEY environment variable before constructing the provider."
+      );
+    }
+    this.apiKey = options.apiKey;
+    this.model = options.model ?? DEFAULT_MODEL;
+    this.maxTokens = options.maxTokens ?? DEFAULT_MAX_TOKENS;
+    this.temperature = options.temperature;
+    this.url = options.baseUrl ?? DEFAULT_ANTHROPIC_URL;
+    this.anthropicVersion = options.anthropicVersion ?? DEFAULT_ANTHROPIC_VERSION;
+  }
+  async *stream(messages, tools) {
+    const { system, messages: anthropicMessages } = toAnthropicMessages(messages);
+    const anthropicTools = tools ? toAnthropicTools(tools) : null;
+    const body = {
+      model: this.model,
+      messages: anthropicMessages,
+      max_tokens: this.maxTokens,
+      stream: true
+    };
+    if (system) body.system = system;
+    if (anthropicTools && anthropicTools.length > 0) body.tools = anthropicTools;
+    if (this.temperature !== void 0) body.temperature = this.temperature;
+    const response = await fetch(this.url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": this.apiKey,
+        "anthropic-version": this.anthropicVersion
+      },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(3e4)
+    });
+    if (!response.ok) {
+      const errText = await response.text();
+      getLogger().error(`Anthropic API error: ${response.status} ${errText}`);
+      return;
+    }
+    const reader = response.body?.getReader();
+    if (!reader) return;
+    const decoder = new TextDecoder();
+    let buffer = "";
+    const toolIndexByBlock = /* @__PURE__ */ new Map();
+    const toolIdByBlock = /* @__PURE__ */ new Map();
+    let nextIndex = 0;
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith("data: ")) continue;
+        const data = trimmed.slice(6);
+        if (!data || data === "[DONE]") continue;
+        let event;
+        try {
+          event = JSON.parse(data);
+        } catch {
+          continue;
+        }
+        if (event.type === "content_block_start" && event.content_block?.type === "tool_use") {
+          const blockIdx = event.index ?? 0;
+          const toolId = event.content_block.id ?? "";
+          const toolName = event.content_block.name ?? "";
+          const patterIndex = nextIndex++;
+          toolIndexByBlock.set(blockIdx, patterIndex);
+          toolIdByBlock.set(blockIdx, toolId);
+          yield {
+            type: "tool_call",
+            index: patterIndex,
+            id: toolId,
+            name: toolName,
+            arguments: ""
+          };
+          continue;
+        }
+        if (event.type === "content_block_delta") {
+          if (event.delta?.type === "text_delta" && event.delta.text) {
+            yield { type: "text", content: event.delta.text };
+            continue;
+          }
+          if (event.delta?.type === "input_json_delta" && event.delta.partial_json) {
+            const blockIdx = event.index ?? 0;
+            const patterIndex = toolIndexByBlock.get(blockIdx);
+            if (patterIndex !== void 0) {
+              yield {
+                type: "tool_call",
+                index: patterIndex,
+                id: toolIdByBlock.get(blockIdx),
+                arguments: event.delta.partial_json
+              };
+            }
+          }
+        }
+      }
+    }
+    yield { type: "done" };
+  }
+};
+function toAnthropicTools(tools) {
+  return tools.map((t) => {
+    const fn = t.function ?? t;
+    return {
+      name: String(fn.name ?? ""),
+      description: String(fn.description ?? ""),
+      input_schema: fn.parameters ?? { type: "object", properties: {} }
+    };
+  });
+}
+function toAnthropicMessages(messages) {
+  const systemParts = [];
+  const out = [];
+  for (const rawMsg of messages) {
+    const role = rawMsg.role;
+    if (role === "system") {
+      if (typeof rawMsg.content === "string" && rawMsg.content) {
+        systemParts.push(rawMsg.content);
+      }
+      continue;
+    }
+    if (role === "user") {
+      if (typeof rawMsg.content === "string") {
+        out.push({ role: "user", content: rawMsg.content });
+      } else if (rawMsg.content) {
+        out.push({ role: "user", content: rawMsg.content });
+      }
+      continue;
+    }
+    if (role === "assistant") {
+      const blocks = [];
+      if (typeof rawMsg.content === "string" && rawMsg.content) {
+        blocks.push({ type: "text", text: rawMsg.content });
+      }
+      for (const tc of rawMsg.tool_calls ?? []) {
+        let args = {};
+        try {
+          args = JSON.parse(tc.function?.arguments ?? "{}");
+        } catch {
+          args = {};
+        }
+        blocks.push({
+          type: "tool_use",
+          id: tc.id ?? "",
+          name: tc.function?.name ?? "",
+          input: args
+        });
+      }
+      if (blocks.length > 0) {
+        out.push({ role: "assistant", content: blocks });
+      }
+      continue;
+    }
+    if (role === "tool") {
+      const contentStr = typeof rawMsg.content === "string" ? rawMsg.content : JSON.stringify(rawMsg.content);
+      out.push({
+        role: "user",
+        content: [
+          {
+            type: "tool_result",
+            tool_use_id: rawMsg.tool_call_id ?? "",
+            content: contentStr
+          }
+        ]
+      });
+      continue;
+    }
+  }
+  return { system: systemParts.join("\n\n"), messages: out };
+}
+
+// src/llm/anthropic.ts
+var LLM2 = class extends AnthropicLLMProvider {
+  constructor(opts = {}) {
+    const key = opts.apiKey ?? process.env.ANTHROPIC_API_KEY;
+    if (!key) {
+      throw new Error(
+        "Anthropic LLM requires an apiKey. Pass { apiKey: 'sk-ant-...' } or set ANTHROPIC_API_KEY."
+      );
+    }
+    super({
+      apiKey: key,
+      model: opts.model,
+      maxTokens: opts.maxTokens,
+      temperature: opts.temperature,
+      baseUrl: opts.baseUrl,
+      anthropicVersion: opts.anthropicVersion
+    });
+  }
+};
+
+// src/providers/groq-llm.ts
+var GROQ_BASE_URL = "https://api.groq.com/openai/v1";
+var DEFAULT_MODEL2 = "llama-3.3-70b-versatile";
+var GroqLLMProvider = class {
+  apiKey;
+  model;
+  baseUrl;
+  constructor(options) {
+    if (!options.apiKey) {
+      throw new Error(
+        "Groq API key is required. Pass it via { apiKey } or read GROQ_API_KEY from the environment."
+      );
+    }
+    this.apiKey = options.apiKey;
+    this.model = options.model ?? DEFAULT_MODEL2;
+    this.baseUrl = options.baseUrl ?? GROQ_BASE_URL;
+  }
+  async *stream(messages, tools) {
+    const body = {
+      model: this.model,
+      messages,
+      stream: true
+    };
+    if (tools) body.tools = tools;
+    const response = await fetch(`${this.baseUrl}/chat/completions`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(3e4)
+    });
+    if (!response.ok) {
+      const errText = await response.text();
+      getLogger().error(`Groq API error: ${response.status} ${errText}`);
+      return;
+    }
+    yield* parseOpenAISseStream(response);
+  }
+};
+async function* parseOpenAISseStream(response) {
+  const reader = response.body?.getReader();
+  if (!reader) return;
+  const decoder = new TextDecoder();
+  let buffer = "";
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+    const lines = buffer.split("\n");
+    buffer = lines.pop() || "";
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed || !trimmed.startsWith("data: ")) continue;
+      const data = trimmed.slice(6);
+      if (data === "[DONE]") continue;
+      let chunk;
+      try {
+        chunk = JSON.parse(data);
+      } catch {
+        continue;
+      }
+      const delta = chunk.choices?.[0]?.delta;
+      if (!delta) continue;
+      if (delta.content) {
+        yield { type: "text", content: delta.content };
+      }
+      if (delta.tool_calls) {
+        for (const tc of delta.tool_calls) {
+          yield {
+            type: "tool_call",
+            index: tc.index,
+            id: tc.id,
+            name: tc.function?.name,
+            arguments: tc.function?.arguments
+          };
+        }
+      }
+    }
+  }
+}
+
+// src/llm/groq.ts
+var LLM3 = class extends GroqLLMProvider {
+  constructor(opts = {}) {
+    const key = opts.apiKey ?? process.env.GROQ_API_KEY;
+    if (!key) {
+      throw new Error(
+        "Groq LLM requires an apiKey. Pass { apiKey: 'gsk_...' } or set GROQ_API_KEY."
+      );
+    }
+    super({
+      apiKey: key,
+      model: opts.model,
+      baseUrl: opts.baseUrl
+    });
+  }
+};
+
+// src/providers/cerebras-llm.ts
+var CEREBRAS_BASE_URL = "https://api.cerebras.ai/v1";
+var DEFAULT_MODEL3 = "llama3.1-8b";
+var CerebrasLLMProvider = class {
+  apiKey;
+  model;
+  baseUrl;
+  gzipCompression;
+  constructor(options) {
+    if (!options.apiKey) {
+      throw new Error(
+        "Cerebras API key is required. Pass it via { apiKey } or read CEREBRAS_API_KEY from the environment."
+      );
+    }
+    this.apiKey = options.apiKey;
+    this.model = options.model ?? DEFAULT_MODEL3;
+    this.baseUrl = options.baseUrl ?? CEREBRAS_BASE_URL;
+    this.gzipCompression = options.gzipCompression ?? false;
+  }
+  async *stream(messages, tools) {
+    const body = {
+      model: this.model,
+      messages,
+      stream: true
+    };
+    if (tools) body.tools = tools;
+    const headers = {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${this.apiKey}`
+    };
+    let payload = JSON.stringify(body);
+    if (this.gzipCompression) {
+      const compressed = await gzipEncode(payload);
+      if (compressed) {
+        payload = compressed;
+        headers["Content-Encoding"] = "gzip";
+      }
+    }
+    const response = await fetch(`${this.baseUrl}/chat/completions`, {
+      method: "POST",
+      headers,
+      body: payload,
+      signal: AbortSignal.timeout(3e4)
+    });
+    if (!response.ok) {
+      const errText = await response.text();
+      getLogger().error(`Cerebras API error: ${response.status} ${errText}`);
+      return;
+    }
+    yield* parseOpenAISseStream(response);
+  }
+};
+async function gzipEncode(data) {
+  const CompressionCtor = globalThis.CompressionStream;
+  if (!CompressionCtor) return null;
+  const stream = new CompressionCtor("gzip");
+  const writer = stream.writable.getWriter();
+  const encoder = new TextEncoder();
+  await writer.write(encoder.encode(data));
+  await writer.close();
+  const chunks = [];
+  const reader = stream.readable.getReader();
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    if (value) chunks.push(value);
+  }
+  const total = chunks.reduce((n, c) => n + c.length, 0);
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const c of chunks) {
+    out.set(c, offset);
+    offset += c.length;
+  }
+  return out;
+}
+
+// src/llm/cerebras.ts
+var LLM4 = class extends CerebrasLLMProvider {
+  constructor(opts = {}) {
+    const key = opts.apiKey ?? process.env.CEREBRAS_API_KEY;
+    if (!key) {
+      throw new Error(
+        "Cerebras LLM requires an apiKey. Pass { apiKey: 'csk-...' } or set CEREBRAS_API_KEY."
+      );
+    }
+    super({
+      apiKey: key,
+      model: opts.model,
+      baseUrl: opts.baseUrl,
+      gzipCompression: opts.gzipCompression
+    });
+  }
+};
+
+// src/providers/google-llm.ts
+var DEFAULT_MODEL4 = "gemini-2.5-flash";
+var DEFAULT_BASE_URL3 = "https://generativelanguage.googleapis.com/v1beta";
+var GoogleLLMProvider = class {
+  apiKey;
+  model;
+  baseUrl;
+  temperature;
+  maxOutputTokens;
+  constructor(options) {
+    if (!options.apiKey) {
+      throw new Error(
+        "Google API key is required. Pass it via { apiKey } or read GOOGLE_API_KEY from the environment."
+      );
+    }
+    this.apiKey = options.apiKey;
+    this.model = options.model ?? DEFAULT_MODEL4;
+    this.baseUrl = options.baseUrl ?? DEFAULT_BASE_URL3;
+    this.temperature = options.temperature;
+    this.maxOutputTokens = options.maxOutputTokens;
+  }
+  async *stream(messages, tools) {
+    const { systemInstruction, contents } = toGeminiContents(messages);
+    const geminiTools = tools ? toGeminiTools(tools) : null;
+    const body = { contents };
+    if (systemInstruction) {
+      body.systemInstruction = { role: "system", parts: [{ text: systemInstruction }] };
+    }
+    if (geminiTools) body.tools = geminiTools;
+    const generationConfig = {};
+    if (this.temperature !== void 0) generationConfig.temperature = this.temperature;
+    if (this.maxOutputTokens !== void 0)
+      generationConfig.maxOutputTokens = this.maxOutputTokens;
+    if (Object.keys(generationConfig).length > 0) body.generationConfig = generationConfig;
+    const url = `${this.baseUrl}/models/${encodeURIComponent(this.model)}:streamGenerateContent?alt=sse&key=${encodeURIComponent(this.apiKey)}`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(3e4)
+    });
+    if (!response.ok) {
+      const errText = await response.text();
+      getLogger().error(`Gemini API error: ${response.status} ${errText}`);
+      return;
+    }
+    const reader = response.body?.getReader();
+    if (!reader) return;
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let nextIndex = 0;
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith("data: ")) continue;
+        const data = trimmed.slice(6);
+        if (!data) continue;
+        let payload;
+        try {
+          payload = JSON.parse(data);
+        } catch {
+          continue;
+        }
+        const candidate = payload.candidates?.[0];
+        const parts = candidate?.content?.parts ?? [];
+        for (const part of parts) {
+          if (part.functionCall) {
+            const args = part.functionCall.args ?? {};
+            const callId = part.functionCall.id ?? `gemini_call_${nextIndex}`;
+            yield {
+              type: "tool_call",
+              index: nextIndex,
+              id: callId,
+              name: part.functionCall.name ?? "",
+              arguments: JSON.stringify(args)
+            };
+            nextIndex++;
+            continue;
+          }
+          if (part.text) {
+            yield { type: "text", content: part.text };
+          }
+        }
+      }
+    }
+    yield { type: "done" };
+  }
+};
+function toGeminiTools(tools) {
+  const functionDeclarations = tools.map((t) => {
+    const fn = t.function ?? t;
+    return {
+      name: String(fn.name ?? ""),
+      description: String(fn.description ?? ""),
+      parameters: fn.parameters ?? { type: "object", properties: {} }
+    };
+  });
+  if (functionDeclarations.length === 0) return [];
+  return [{ functionDeclarations }];
+}
+function toGeminiContents(messages) {
+  const systemParts = [];
+  const contents = [];
+  for (const rawMsg of messages) {
+    const role = rawMsg.role;
+    if (role === "system") {
+      if (typeof rawMsg.content === "string" && rawMsg.content) {
+        systemParts.push(rawMsg.content);
+      }
+      continue;
+    }
+    if (role === "user") {
+      if (typeof rawMsg.content === "string" && rawMsg.content) {
+        contents.push({ role: "user", parts: [{ text: rawMsg.content }] });
+      }
+      continue;
+    }
+    if (role === "assistant") {
+      const parts = [];
+      if (typeof rawMsg.content === "string" && rawMsg.content) {
+        parts.push({ text: rawMsg.content });
+      }
+      for (const tc of rawMsg.tool_calls ?? []) {
+        let args = {};
+        try {
+          const parsed = JSON.parse(tc.function?.arguments ?? "{}");
+          if (parsed && typeof parsed === "object") args = parsed;
+        } catch {
+          args = {};
+        }
+        parts.push({
+          functionCall: {
+            name: tc.function?.name ?? "",
+            args,
+            id: tc.id
+          }
+        });
+      }
+      if (parts.length > 0) contents.push({ role: "model", parts });
+      continue;
+    }
+    if (role === "tool") {
+      const raw = rawMsg.content;
+      let response;
+      if (typeof raw === "string") {
+        try {
+          const parsed = JSON.parse(raw);
+          response = parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : { result: parsed };
+        } catch {
+          response = { result: raw };
+        }
+      } else {
+        response = raw ?? {};
+      }
+      contents.push({
+        role: "user",
+        parts: [
+          {
+            functionResponse: {
+              name: rawMsg.name ?? rawMsg.tool_call_id ?? "",
+              response,
+              id: rawMsg.tool_call_id
+            }
+          }
+        ]
+      });
+      continue;
+    }
+  }
+  return { systemInstruction: systemParts.join("\n\n"), contents };
+}
+
+// src/llm/google.ts
+var LLM5 = class extends GoogleLLMProvider {
+  constructor(opts = {}) {
+    const key = opts.apiKey ?? process.env.GEMINI_API_KEY ?? process.env.GOOGLE_API_KEY;
+    if (!key) {
+      throw new Error(
+        "Google LLM requires an apiKey. Pass { apiKey: 'AIza...' } or set GEMINI_API_KEY (or GOOGLE_API_KEY)."
+      );
+    }
+    super({
+      apiKey: key,
+      model: opts.model,
+      baseUrl: opts.baseUrl,
+      temperature: opts.temperature,
+      maxOutputTokens: opts.maxOutputTokens
+    });
+  }
+};
+
 // src/carriers/twilio.ts
 var Carrier = class {
   kind = "twilio";
@@ -3558,6 +4186,7 @@ function isAudioConfig(value) {
 }
 export {
   AllProvidersFailedError,
+  LLM2 as AnthropicLLM,
   STT5 as AssemblyAISTT,
   AuthenticationError,
   BackgroundAudioPlayer,
@@ -3565,6 +4194,7 @@ export {
   CallMetricsAccumulator,
   STT3 as CartesiaSTT,
   TTS3 as CartesiaTTS,
+  LLM4 as CerebrasLLM,
   ChatContext,
   CloudflareTunnel,
   DEFAULT_MIN_SENTENCE_LEN,
@@ -3578,11 +4208,14 @@ export {
   GEMINI_DEFAULT_INPUT_SR,
   GEMINI_DEFAULT_OUTPUT_SR,
   GeminiLiveAdapter,
+  LLM5 as GoogleLLM,
+  LLM3 as GroqLLM,
   Guardrail,
   IVRActivity,
   LLMLoop,
   TTS5 as LMNTTTS,
   MetricsStore,
+  LLM as OpenAILLM,
   OpenAILLMProvider,
   Realtime as OpenAIRealtime,
   OpenAIRealtimeAdapter,