@voicelayer/sdk 0.6.2 → 0.6.3

package/dist/runtime/text-session.d.ts

@@ -1,4 +1,4 @@
-export { b1 as EmailResolver, b2 as FlowResolver, b3 as GraphResolvers, b4 as GraphTraceEvent, b5 as KnowledgeResolver, b6 as LiveTextConversation, b7 as LiveTurnResult, b8 as PlaybookLibraryEntry, b9 as PlaybookResolver, ba as RegistryToolsResolver, bb as RunLiveTextOptions, ag as RunTextSessionOptions, ah as RunTextTranscriptOptions, ay as TextSession, az as TextTranscriptResult, n as ToolExecutor, bc as dedupeConversationEmails, bd as denyPrivateNetwork, be as privateNetworkOptInHonoured, bf as runLiveTextConversation, aZ as runTextSession, a_ as runTextTranscript, bg as runWithOpenAIScope, bh as toPlaybookResolution } from '../text-session-B-T33y5P.js';
+export { b1 as EmailResolver, b2 as FlowResolver, b3 as GraphResolvers, b4 as GraphTraceEvent, b5 as KnowledgeResolver, b6 as LiveTextConversation, b7 as LiveTurnResult, b8 as PlaybookLibraryEntry, b9 as PlaybookResolver, ba as RegistryToolsResolver, bb as RunLiveTextOptions, ag as RunTextSessionOptions, ah as RunTextTranscriptOptions, ay as TextSession, az as TextTranscriptResult, n as ToolExecutor, bc as dedupeConversationEmails, bd as denyPrivateNetwork, be as privateNetworkOptInHonoured, bf as runLiveTextConversation, aZ as runTextSession, a_ as runTextTranscript, bg as runWithOpenAIScope, bh as toPlaybookResolution } from '../text-session-B928dhkB.js';
 import '@livekit/agents';
 import 'zod';
 import '../types-KqrAfY85.js';

package/dist/runtime/text-session.js

@@ -14,6 +14,7 @@ import '@opentelemetry/sdk-logs';
 import '@opentelemetry/sdk-metrics';
 import '@opentelemetry/sdk-node';
 import '@opentelemetry/semantic-conventions';
+import { llm, DEFAULT_API_CONNECT_OPTIONS, intervalForRetry, APIStatusError, APITimeoutError, APIConnectionError } from '@livekit/agents';
 import http from 'http';
 import https from 'https';
 import { Readable } from 'stream';
@@ -4076,32 +4077,116 @@ function acceptsReasoningEffort(model2) {
   const id = baseModelId(model2);
   return isReasoningModel(model2) && !/^o1-(mini|preview)/.test(id) && !/-chat(-|$)/.test(id);
 }
+function acceptsNoReasoningEffort(model2) {
+  if (!acceptsReasoningEffort(model2))
+    return false;
+  const id = baseModelId(model2);
+  if (/-pro\b/.test(id))
+    return false;
+  const gpt = /^gpt-(\d+)(?:\.(\d+))?/.exec(id);
+  if (!gpt)
+    return false;
+  const major = Number(gpt[1]);
+  const minor = gpt[2] !== void 0 ? Number(gpt[2]) : 0;
+  return major > 5 || major === 5 && minor >= 1;
+}
+function forgetLearnedReasoningEfforts() {
+  learnedEfforts.clear();
+}
+function chatReasoningEffort(model2, opts) {
+  const learned = learnedEfforts.get(learnedKey(model2, opts.tools === true));
+  if (learned !== void 0)
+    return learned === "omit" ? void 0 : learned;
+  if (!acceptsReasoningEffort(model2))
+    return void 0;
+  if (opts.tools === true && acceptsNoReasoningEffort(model2))
+    return "none";
+  return opts.requested;
+}
 function chatCompletionParams(model2, input) {
+  const effort = chatReasoningEffort(model2, {
+    ...input.tools !== void 0 ? { tools: input.tools } : {},
+    ...input.reasoningEffort !== void 0 ? { requested: input.reasoningEffort } : {}
+  });
   if (isReasoningModel(model2)) {
     return {
       ...input.maxTokens !== void 0 ? { max_completion_tokens: Math.max(input.maxTokens, REASONING_MIN_COMPLETION_TOKENS) } : {},
-      ...input.reasoningEffort !== void 0 && acceptsReasoningEffort(model2) ? { reasoning_effort: input.reasoningEffort } : {}
+      ...effort !== void 0 ? { reasoning_effort: effort } : {}
     };
   }
   return {
+    // only when a provider taught the process that this model (one we don't know as a reasoning model) takes an effort
+    ...effort !== void 0 ? { reasoning_effort: effort } : {},
     ...input.maxTokens !== void 0 ? { max_tokens: input.maxTokens } : {},
     ...input.temperature !== void 0 ? { temperature: input.temperature } : {},
     ...input.topP !== void 0 ? { top_p: input.topP } : {}
   };
 }
-function modelRejectionOf(err) {
+function acceptsSamplingParams(model2) {
+  return !isReasoningModel(model2);
+}
+function providerErrorOf(err) {
+  if (err === null || typeof err !== "object")
+    return null;
   const e = err;
-  const status = typeof e?.status === "number" ? e.status : null;
-  if (status !== 400 && status !== 403 && status !== 404)
+  const body = e["body"] !== null && typeof e["body"] === "object" ? e["body"] : {};
+  const pick = (k) => e[k] !== void 0 && e[k] !== null ? e[k] : body[k];
+  const statusRaw = typeof e["status"] === "number" ? e["status"] : e["statusCode"];
+  const status = typeof statusRaw === "number" && statusRaw > 0 ? statusRaw : null;
+  const code = pick("code");
+  const type = pick("type");
+  const param = pick("param");
+  const message = typeof body["message"] === "string" ? body["message"] : typeof e["message"] === "string" ? e["message"] : "";
+  return {
+    status,
+    code: typeof code === "string" ? code : typeof type === "string" ? type : "",
+    param: typeof param === "string" ? param : null,
+    message
+  };
+}
+function reasoningEffortRejectionOf(err) {
+  const f = providerErrorOf(err);
+  if (!f || f.status !== 400)
     return null;
-  const code = typeof e?.code === "string" ? e.code : typeof e?.type === "string" ? e.type : "";
-  const param = typeof e?.param === "string" ? e.param : null;
-  const rejected = REJECTION_CODES.has(code) || param !== null && MODEL_PARAMS.has(param);
+  if (f.param !== "reasoning_effort" && !/reasoning[_ ]effort/i.test(f.message))
+    return null;
+  return { status: f.status, message: f.message, suggestsNone: /reasoning[_ ]effort[^.]*\bnone\b/i.test(f.message) };
+}
+function learnReasoningEffort(model2, shape, err) {
+  const rejection = reasoningEffortRejectionOf(err);
+  if (!rejection)
+    return false;
+  const next = shape.sent !== "none" && (rejection.suggestsNone || shape.sent === void 0) ? "none" : "omit";
+  if ((next === "omit" ? void 0 : next) === shape.sent)
+    return false;
+  learnedEfforts.set(learnedKey(model2, shape.tools), next);
+  return true;
+}
+async function withReasoningEffortRetry(shape, call) {
+  const sent = chatReasoningEffort(shape.model, {
+    tools: shape.tools,
+    ...shape.requested !== void 0 ? { requested: shape.requested } : {}
+  });
+  try {
+    return await call();
+  } catch (err) {
+    if (!learnReasoningEffort(shape.model, { tools: shape.tools, sent }, err))
+      throw err;
+    return call();
+  }
+}
+function modelRejectionOf(err) {
+  const f = providerErrorOf(err);
+  const status = f?.status ?? null;
+  if (!f || status === null || status !== 400 && status !== 403 && status !== 404)
+    return null;
+  const { code, param } = f;
+  const rejected = REJECTION_CODES.has(code) || param !== null && MODEL_PARAMS.has(param) || reasoningEffortRejectionOf(err) !== null;
   if (!rejected)
     return null;
   if (status === 403 && code !== "model_not_found")
     return null;
-  return { status, code: code || "invalid_request_error", message: typeof e?.message === "string" ? e.message : "" };
+  return { status, code: code || "invalid_request_error", message: f.message };
 }
 async function withModelFallback(opts) {
   const fallbackModel = opts.fallbackModel ?? PLATFORM_DEFAULT_CHAT_MODEL;
@@ -4122,11 +4207,13 @@ async function withModelFallback(opts) {
     return opts.call(fallbackModel);
   }
 }
-var PLATFORM_DEFAULT_CHAT_MODEL, REASONING_MIN_COMPLETION_TOKENS, REJECTION_CODES, MODEL_PARAMS, MODEL_REJECTION_TTL_MS, ModelRejectionCache;
+var PLATFORM_DEFAULT_CHAT_MODEL, REASONING_MIN_COMPLETION_TOKENS, learnedEfforts, learnedKey, REJECTION_CODES, MODEL_PARAMS, MODEL_REJECTION_TTL_MS, ModelRejectionCache;
 var init_chat_params = __esm({
   "../llm-client/dist/chat-params.js"() {
     PLATFORM_DEFAULT_CHAT_MODEL = "gpt-4o-mini";
     REASONING_MIN_COMPLETION_TOKENS = 2048;
+    learnedEfforts = /* @__PURE__ */ new Map();
+    learnedKey = (model2, tools) => `${baseModelId(model2)}|${tools ? "tools" : "plain"}`;
     REJECTION_CODES = /* @__PURE__ */ new Set(["unsupported_parameter", "unsupported_value", "model_not_found"]);
     MODEL_PARAMS = /* @__PURE__ */ new Set(["model", "max_tokens", "max_completion_tokens", "temperature", "top_p", "reasoning_effort"]);
     MODEL_REJECTION_TTL_MS = 5 * 60 * 1e3;
@@ -4154,6 +4241,30 @@ var init_chat_params = __esm({
     };
   }
 });
+
+// ../llm-client/dist/index.js
+var dist_exports = {};
+__export(dist_exports, {
+  MODEL_REJECTION_TTL_MS: () => MODEL_REJECTION_TTL_MS,
+  ModelRejectionCache: () => ModelRejectionCache,
+  PLATFORM_DEFAULT_CHAT_MODEL: () => PLATFORM_DEFAULT_CHAT_MODEL,
+  REASONING_MIN_COMPLETION_TOKENS: () => REASONING_MIN_COMPLETION_TOKENS,
+  acceptsNoReasoningEffort: () => acceptsNoReasoningEffort,
+  acceptsReasoningEffort: () => acceptsReasoningEffort,
+  acceptsSamplingParams: () => acceptsSamplingParams,
+  chatCompletionParams: () => chatCompletionParams,
+  chatReasoningEffort: () => chatReasoningEffort,
+  createChatClient: () => createChatClient,
+  forgetLearnedReasoningEfforts: () => forgetLearnedReasoningEfforts,
+  hasChatKey: () => hasChatKey,
+  isReasoningModel: () => isReasoningModel,
+  learnReasoningEffort: () => learnReasoningEffort,
+  modelRejectionOf: () => modelRejectionOf,
+  providerErrorOf: () => providerErrorOf,
+  reasoningEffortRejectionOf: () => reasoningEffortRejectionOf,
+  withModelFallback: () => withModelFallback,
+  withReasoningEffortRetry: () => withReasoningEffortRetry
+});
 function createChatClient(config = {}) {
   return new OpenAI({
     ...config.apiKey ? { apiKey: config.apiKey } : {},
@@ -4161,6 +4272,9 @@ function createChatClient(config = {}) {
     ...config.timeoutMs ? { timeout: config.timeoutMs } : {}
   });
 }
+function hasChatKey(config = {}) {
+  return Boolean(config.apiKey || process.env["OPENAI_API_KEY"]);
+}
 var init_dist = __esm({
   "../llm-client/dist/index.js"() {
     init_chat_params();
@@ -4300,6 +4414,340 @@ var init_wrap = __esm({
   "src/providers/wrap.ts"() {
   }
 });
+var init_start = __esm({
+  "../observability/dist/start.js"() {
+  }
+});
+
+// ../observability/dist/attributes.js
+var ATTR;
+var init_attributes = __esm({
+  "../observability/dist/attributes.js"() {
+    ATTR = {
+      projectId: "vl.project_id",
+      callId: "vl.call_id",
+      campaignId: "vl.campaign_id",
+      room: "vl.room",
+      agentId: "vl.agent_id",
+      phoneNumberId: "vl.phone_number_id",
+      bindingId: "vl.binding_id",
+      source: "vl.source",
+      kind: "vl.kind"
+    };
+  }
+});
+function getCurrentCallContext() {
+  return callContextStore.getStore();
+}
+var callContextStore;
+var init_call_context = __esm({
+  "../observability/dist/call-context.js"() {
+    init_attributes();
+    callContextStore = new AsyncLocalStorage();
+  }
+});
+var init_trace_propagation = __esm({
+  "../observability/dist/trace-propagation.js"() {
+  }
+});
+function meter() {
+  return metrics.getMeter(METER_NAME, METER_VERSION);
+}
+function modelFallbacks() {
+  return _modelFallbacks ??= meter().createCounter("vl.llm.model_fallback", {
+    description: "Model calls the provider rejected that fell back to the platform default model",
+    unit: "{fallbacks}"
+  });
+}
+function recordModelFallback(args) {
+  const out = {
+    "vl.model": args.model,
+    "vl.fallback_model": args.fallbackModel,
+    "vl.error_code": args.code
+  };
+  if (args.projectId)
+    out[ATTR.projectId] = args.projectId;
+  if (args.agentId)
+    out[ATTR.agentId] = args.agentId;
+  if (args.surface)
+    out["vl.surface"] = args.surface;
+  modelFallbacks().add(1, out);
+}
+var METER_NAME, METER_VERSION, _modelFallbacks;
+var init_metrics = __esm({
+  "../observability/dist/metrics.js"() {
+    init_attributes();
+    METER_NAME = "voicelayer";
+    METER_VERSION = "0.1.0";
+    _modelFallbacks = null;
+  }
+});
+var init_latency_span = __esm({
+  "../observability/dist/latency-span.js"() {
+    init_attributes();
+  }
+});
+
+// ../observability/dist/index.js
+var init_dist2 = __esm({
+  "../observability/dist/index.js"() {
+    init_start();
+    init_call_context();
+    init_trace_propagation();
+    init_attributes();
+    init_metrics();
+    init_latency_span();
+  }
+});
+
+// src/providers/resilient-llm.ts
+var resilient_llm_exports = {};
+__export(resilient_llm_exports, {
+  LLM_APOLOGY: () => LLM_APOLOGY,
+  ResilientLLM: () => ResilientLLM,
+  isResilientLLM: () => isResilientLLM
+});
+function isResilientLLM(value) {
+  return typeof value === "object" && value !== null && value[RESILIENT] === true;
+}
+function transient(error) {
+  if (error instanceof APIStatusError) {
+    const s = error.statusCode;
+    return s === 408 || s === 429 || s < 0 || s >= 500;
+  }
+  return error instanceof APITimeoutError || error instanceof APIConnectionError;
+}
+var LLM_APOLOGY, RESILIENT, ResilientLLM, sameModel, ServedLLM, ResilientLLMStream;
+var init_resilient_llm = __esm({
+  "src/providers/resilient-llm.ts"() {
+    init_dist();
+    init_dist2();
+    LLM_APOLOGY = "Sorry, I'm having trouble right now. Could you give me a moment and say that again?";
+    RESILIENT = /* @__PURE__ */ Symbol.for("voicelayer.resilientLLM");
+    ResilientLLM = class extends llm.LLM {
+      [RESILIENT] = true;
+      #opts;
+      #fallback = null;
+      #listeners = /* @__PURE__ */ new Set();
+      /** Models the provider rejected on this call (a call's pipeline is built per call): later turns go straight to the fallback. */
+      rejections = new ModelRejectionCache();
+      constructor(opts) {
+        super();
+        this.#opts = opts;
+      }
+      label() {
+        return this.#opts.primary.label();
+      }
+      get model() {
+        return this.#opts.primary.model;
+      }
+      get provider() {
+        return this.#opts.primary.provider;
+      }
+      get apology() {
+        return this.#opts.apology ?? LLM_APOLOGY;
+      }
+      get reasoningParams() {
+        return this.#opts.reasoningParams === true;
+      }
+      /** The fallback LLM, built on first need; null when there is none or it is the agent's own model. */
+      fallbackLLM() {
+        if (!this.#opts.fallback) return null;
+        this.#fallback ??= this.#opts.fallback();
+        return sameModel(this.#fallback.model, this.model) ? null : this.#fallback;
+      }
+      /** Hear about every recovery (and every apology). Returns the unsubscribe. */
+      onIncident(listener) {
+        this.#listeners.add(listener);
+        return () => this.#listeners.delete(listener);
+      }
+      /** @internal */
+      report(incident) {
+        const log = incident.kind === "apology" ? console.error : console.warn;
+        log(`[voicelayer] llm ${incident.kind.replace(/_/g, " ")}`, incident);
+        if (incident.kind === "model_fallback") {
+          const call = getCurrentCallContext();
+          recordModelFallback({
+            model: incident.model,
+            fallbackModel: incident.fallbackModel,
+            code: incident.code,
+            surface: "voice",
+            ...call?.projectId ? { projectId: call.projectId } : {},
+            ...call?.agentId ? { agentId: call.agentId } : {}
+          });
+        }
+        for (const listener of this.#listeners) {
+          try {
+            listener(incident);
+          } catch {
+          }
+        }
+      }
+      chat(args) {
+        return new ResilientLLMStream(this, args);
+      }
+      prewarm() {
+        this.#opts.primary.prewarm();
+      }
+      async aclose() {
+        await Promise.all([this.#opts.primary.aclose(), this.#fallback?.aclose()]);
+      }
+      /** @internal */
+      get primary() {
+        return this.#opts.primary;
+      }
+    };
+    sameModel = (a, b) => a.trim().toLowerCase() === b.trim().toLowerCase();
+    ServedLLM = class extends llm.LLM {
+      constructor(owner, served) {
+        super();
+        this.owner = owner;
+        this.served = served;
+      }
+      owner;
+      served;
+      label() {
+        return this.owner.label();
+      }
+      get model() {
+        return this.served();
+      }
+      get provider() {
+        return this.owner.provider;
+      }
+      chat(args) {
+        return this.owner.chat(args);
+      }
+      emit(event, ...args) {
+        return this.owner.emit(event, ...args);
+      }
+    };
+    ResilientLLMStream = class extends llm.LLMStream {
+      #owner;
+      #args;
+      #conn;
+      /** The model answering this stream — what its metrics report. */
+      #served;
+      #current = null;
+      constructor(owner, args) {
+        const conn = args.connOptions ?? DEFAULT_API_CONNECT_OPTIONS;
+        const served = { model: owner.model };
+        super(new ServedLLM(owner, () => served.model), {
+          chatCtx: args.chatCtx,
+          ...args.toolCtx ? { toolCtx: args.toolCtx } : {},
+          connOptions: { ...conn, maxRetry: 0 }
+        });
+        this.#owner = owner;
+        this.#args = args;
+        this.#conn = conn;
+        this.#served = served;
+        this.abortController.signal.addEventListener("abort", () => this.#current?.close());
+      }
+      get #hasTools() {
+        return this.#args.toolCtx !== void 0 && Object.keys(this.#args.toolCtx).length > 0;
+      }
+      #extraKwargs(model2) {
+        const base = this.#args.extraKwargs;
+        if (!this.#owner.reasoningParams) return base;
+        const effort = chatReasoningEffort(model2, { tools: this.#hasTools });
+        if (effort === void 0) {
+          if (!base || !("reasoning_effort" in base)) return base;
+          const { reasoning_effort: _dropped, ...rest } = base;
+          return rest;
+        }
+        return { ...base, reasoning_effort: effort };
+      }
+      /** One request on `target`, forwarding its chunks. Its failure is the inner LLM's 'error' event. */
+      async #attempt(target) {
+        let failure = null;
+        const onError = (ev) => {
+          failure ??= ev.error;
+        };
+        target.on("error", onError);
+        let started = false;
+        try {
+          const extraKwargs = this.#extraKwargs(target.model);
+          const stream = target.chat({
+            ...this.#args,
+            connOptions: { ...this.#conn, maxRetry: 0 },
+            ...extraKwargs !== void 0 ? { extraKwargs } : {}
+          });
+          this.#current = stream;
+          for await (const chunk of stream) {
+            if (this.abortController.signal.aborted) break;
+            started = true;
+            this.queue.put(chunk);
+          }
+        } catch (err) {
+          failure ??= err instanceof Error ? err : new Error(String(err));
+        } finally {
+          target.off("error", onError);
+          this.#current = null;
+        }
+        return failure ? { ok: false, error: failure, started } : { ok: true };
+      }
+      /** Run `target` until it answers, or a failure that retrying it won't fix. */
+      async #run(target) {
+        let effortRetried = false;
+        for (let retries = 0; ; ) {
+          const sent = this.#owner.reasoningParams ? chatReasoningEffort(target.model, { tools: this.#hasTools }) : void 0;
+          const result = await this.#attempt(target);
+          if (result.ok || result.started || this.abortController.signal.aborted) return result;
+          if (this.#owner.reasoningParams && !effortRetried && learnReasoningEffort(target.model, { tools: this.#hasTools, sent }, result.error)) {
+            effortRetried = true;
+            this.#owner.report({
+              kind: "reasoning_effort_adapted",
+              model: target.model,
+              message: providerErrorOf(result.error)?.message ?? result.error.message
+            });
+            continue;
+          }
+          if (!transient(result.error) || retries >= this.#conn.maxRetry) return result;
+          const wait = intervalForRetry(this.#conn, retries);
+          retries += 1;
+          if (wait > 0) await new Promise((r) => setTimeout(r, wait));
+          if (this.abortController.signal.aborted) return result;
+        }
+      }
+      async run() {
+        const owner = this.#owner;
+        const model2 = owner.model;
+        const fallback = owner.fallbackLLM();
+        const known = fallback ? owner.rejections.get(model2) : null;
+        let failure;
+        if (known && fallback) {
+          owner.report({ kind: "model_fallback", model: model2, fallbackModel: fallback.model, code: known.code, message: known.message, cached: true });
+          failure = new Error(known.message);
+        } else {
+          const first = await this.#run(owner.primary);
+          if (first.ok || first.started || this.abortController.signal.aborted) return;
+          failure = first.error;
+          const rejection = modelRejectionOf(first.error);
+          if (rejection) owner.rejections.set(model2, rejection);
+          if (fallback) {
+            const f = providerErrorOf(first.error);
+            owner.report({
+              kind: "model_fallback",
+              model: model2,
+              fallbackModel: fallback.model,
+              code: rejection?.code ?? (f?.status ? String(f.status) : "error"),
+              message: f?.message || first.error.message,
+              cached: false
+            });
+          }
+        }
+        if (fallback) {
+          this.#served.model = fallback.model;
+          const second = await this.#run(fallback);
+          if (second.ok || second.started || this.abortController.signal.aborted) return;
+          failure = second.error;
+        }
+        owner.report({ kind: "apology", model: this.#served.model, message: providerErrorOf(failure)?.message || failure.message });
+        this.queue.put({ id: `vl-apology-${Date.now()}`, delta: { role: "assistant", content: owner.apology } });
+      }
+    };
+  }
+});
 
 // src/providers/index.ts
 async function importOptional(spec, hint) {
@@ -4346,9 +4794,13 @@ var init_providers2 = __esm({
       llm(options = {}) {
         return async () => {
           const oa = await importOptional("@voicelayer/agents-plugin-openai", "openai.llm");
-          return new oa.LLM(
-            withCreds({ model: options.model ?? "gpt-4o-mini" }, options)
-          );
+          const { ResilientLLM: ResilientLLM2 } = await Promise.resolve().then(() => (init_resilient_llm(), resilient_llm_exports));
+          const { PLATFORM_DEFAULT_CHAT_MODEL: PLATFORM_DEFAULT_CHAT_MODEL2 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
+          return new ResilientLLM2({
+            primary: new oa.LLM(withCreds({ model: options.model ?? "gpt-4o-mini" }, options)),
+            fallback: () => new oa.LLM(withCreds({ model: PLATFORM_DEFAULT_CHAT_MODEL2 }, options)),
+            reasoningParams: true
+          });
         };
       },
       tts(options = {}) {
@@ -4424,9 +4876,10 @@ var init_providers2 = __esm({
       llm(options = {}) {
         return async () => {
           const g = await importOptional("@voicelayer/agents-plugin-google", "google.llm");
-          return new g.LLM(
-            withCreds({ model: options.model ?? "gemini-3.8-flash" }, options)
-          );
+          const { ResilientLLM: ResilientLLM2 } = await Promise.resolve().then(() => (init_resilient_llm(), resilient_llm_exports));
+          return new ResilientLLM2({
+            primary: new g.LLM(withCreds({ model: options.model ?? "gemini-3.8-flash" }, options))
+          });
         };
       },
       realtime(options = {}) {
@@ -4528,91 +4981,6 @@ var init_llm = __esm({
     init_registry();
   }
 });
-var init_start = __esm({
-  "../observability/dist/start.js"() {
-  }
-});
-
-// ../observability/dist/attributes.js
-var ATTR;
-var init_attributes = __esm({
-  "../observability/dist/attributes.js"() {
-    ATTR = {
-      projectId: "vl.project_id",
-      callId: "vl.call_id",
-      campaignId: "vl.campaign_id",
-      room: "vl.room",
-      agentId: "vl.agent_id",
-      phoneNumberId: "vl.phone_number_id",
-      bindingId: "vl.binding_id",
-      source: "vl.source",
-      kind: "vl.kind"
-    };
-  }
-});
-function getCurrentCallContext() {
-  return callContextStore.getStore();
-}
-var callContextStore;
-var init_call_context = __esm({
-  "../observability/dist/call-context.js"() {
-    init_attributes();
-    callContextStore = new AsyncLocalStorage();
-  }
-});
-var init_trace_propagation = __esm({
-  "../observability/dist/trace-propagation.js"() {
-  }
-});
-function meter() {
-  return metrics.getMeter(METER_NAME, METER_VERSION);
-}
-function modelFallbacks() {
-  return _modelFallbacks ??= meter().createCounter("vl.llm.model_fallback", {
-    description: "Model calls the provider rejected that fell back to the platform default model",
-    unit: "{fallbacks}"
-  });
-}
-function recordModelFallback(args) {
-  const out = {
-    "vl.model": args.model,
-    "vl.fallback_model": args.fallbackModel,
-    "vl.error_code": args.code
-  };
-  if (args.projectId)
-    out[ATTR.projectId] = args.projectId;
-  if (args.agentId)
-    out[ATTR.agentId] = args.agentId;
-  if (args.surface)
-    out["vl.surface"] = args.surface;
-  modelFallbacks().add(1, out);
-}
-var METER_NAME, METER_VERSION, _modelFallbacks;
-var init_metrics = __esm({
-  "../observability/dist/metrics.js"() {
-    init_attributes();
-    METER_NAME = "voicelayer";
-    METER_VERSION = "0.1.0";
-    _modelFallbacks = null;
-  }
-});
-var init_latency_span = __esm({
-  "../observability/dist/latency-span.js"() {
-    init_attributes();
-  }
-});
-
-// ../observability/dist/index.js
-var init_dist2 = __esm({
-  "../observability/dist/index.js"() {
-    init_start();
-    init_call_context();
-    init_trace_propagation();
-    init_attributes();
-    init_metrics();
-    init_latency_span();
-  }
-});
 
 // src/runtime/helper-models.ts
 function rejectionsFor(client) {