@voicelayer/sdk 0.6.1 → 0.6.3

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';
@@ -693,7 +694,7 @@ var init_consultation = __esm({
     });
   }
 });
-var CallEventKind, OP_CALL_EVENT_KIND, OpCallEventKind, commandId, SayCommand, HangupCommand, DtmfCommand, InstructCommand, InjectContextCommand;
+var CallEventKind, OP_CALL_EVENT_KIND, OpCallEventKind, LatencyMs, commandId, SayCommand, HangupCommand, DtmfCommand, InstructCommand, InjectContextCommand;
 var init_call_events = __esm({
   "../contracts/src/call-events.ts"() {
     init_consultation();
@@ -719,7 +720,9 @@ var init_call_events = __esm({
       "dtmf.sent",
       // A host's runtime intervention (burn-down G-6): call_say / call_send_guidance / call_inject_context / call_instruct,
       // with masked args and the API key — written by the API only, never through the worker's /events endpoint.
-      "mcp.interaction"
+      "mcp.interaction",
+      // One per caller turn the agent answered (burn-down G-44): where that turn's wait went — see TurnLatencyPayload.
+      "turn.latency"
     ]);
     OP_CALL_EVENT_KIND = /^(tool|handoff|lookup|record|notify|engine)\.[a-z0-9_]{1,48}(\.[a-z0-9_]{1,48})?$/;
     OpCallEventKind = z.string().regex(OP_CALL_EVENT_KIND);
@@ -746,6 +749,17 @@ var init_call_events = __esm({
       code: z.number().int().min(0).max(15),
       participantId: z.string().optional()
     });
+    LatencyMs = z.number().int().min(0).max(6e5).nullable();
+    z.object({
+      turn: z.number().int().min(1),
+      atMs: z.number().int().min(0),
+      endpointingMs: LatencyMs,
+      sttMs: LatencyMs,
+      llmMs: LatencyMs,
+      ttsMs: LatencyMs,
+      endToEndMs: LatencyMs,
+      realtime: z.boolean().optional()
+    });
     z.object({
       totalUsd: z.string(),
       breakdown: z.object({
@@ -862,9 +876,65 @@ var init_text_turns = __esm({
     ]);
   }
 });
+var PLATFORM_MAX_CALL_MINUTES, Message, CallerRateLimit, CallLimits, CallerChannel, CallDurationLimits;
+var init_call_limits = __esm({
+  "../contracts/src/call-limits.ts"() {
+    PLATFORM_MAX_CALL_MINUTES = 240;
+    Message = z.string().trim().min(1).max(300);
+    CallerRateLimit = z.object({
+      enabled: z.boolean().optional(),
+      perTenMinutes: z.number().int().min(1).max(100).optional(),
+      perDay: z.number().int().min(1).max(1e3).optional(),
+      withheldPerTenMinutes: z.number().int().min(1).max(100).optional(),
+      withheldPerDay: z.number().int().min(1).max(1e3).optional()
+    });
+    CallLimits = z.object({
+      /** The agent's own ceiling in minutes; clamped to the workspace's plan ceiling. Absent ⇒ DEFAULT_MAX_CALL_MINUTES. */
+      maxDurationMinutes: z.number().int().min(1).max(PLATFORM_MAX_CALL_MINUTES).optional(),
+      /** Seconds before the limit the wrap-up line is spoken; 0 ⇒ no warning. */
+      wrapUpWarningSeconds: z.number().int().min(0).max(300).optional(),
+      wrapUpMessage: Message.optional(),
+      goodbyeMessage: Message.optional(),
+      callerRateLimit: CallerRateLimit.optional(),
+      rateLimitedMessage: Message.optional()
+    });
+    CallerChannel = z.enum(["phone", "web"]);
+    z.object({
+      roomName: z.string().min(1).max(256),
+      /** From the dispatch metadata: lets the API admit (gate) a room whose call row doesn't exist yet. */
+      agentId: z.string().max(128).optional(),
+      phoneNumberId: z.string().max(128).optional(),
+      caller: z.object({
+        channel: CallerChannel,
+        /** The caller's number as the carrier presented it; null / absent / not E.164 ⇒ the withheld bucket. */
+        number: z.string().max(64).nullable().optional()
+      })
+    });
+    CallDurationLimits = z.object({
+      /** The agent's own ceiling (already clamped to the plan), or null when it set none. */
+      agentMaxSeconds: z.number().int().min(1).nullable(),
+      /** The plan ceiling — the platform bound no call outlives. */
+      ceilingSeconds: z.number().int().min(1),
+      wrapUpWarningSeconds: z.number().int().min(0),
+      wrapUpMessage: z.string(),
+      goodbyeMessage: z.string()
+    });
+    z.discriminatedUnion("admitted", [
+      z.object({ admitted: z.literal(true), limits: CallDurationLimits }),
+      z.object({
+        admitted: z.literal(false),
+        /** 'rate_limited:caller' | 'inbound_refused:<code>' — already recorded as the call's end reason. */
+        endReason: z.string(),
+        /** The fixed line to speak before hanging up. */
+        message: z.string()
+      })
+    ]);
+  }
+});
 var VoiceConfig, ModelConfig, SttConfig, RealtimeConfig, PipelineMode, ToolBinding, ProcessFieldType, ProcessFieldSpec, ProcessCompleteWhen, ProcessBackendAckSpec, ProcessSpec, TriggerConditionSpec, TriggerActionSpec, TriggerSpec, RequiredInfoField, AgentConfig;
 var init_agent_config = __esm({
   "../contracts/src/agent-config.ts"() {
+    init_call_limits();
     init_consultation();
     VoiceConfig = z.object({
       // Finite, vetted list — platform-level enum.
@@ -1028,6 +1098,9 @@ var init_agent_config = __esm({
       // LLM slot through the connector instead of a first-party model. Null/absent →
       // first-party pipeline (unchanged default). See docs/specs/voice-brain-connector.
       brainConnectorId: z.string().uuid().nullable().optional(),
+      // Per-agent call bounds: caller rate limit, max duration and their spoken lines (burn-down G-41, G-43). Absent ⇒
+      // every default (call-limits.ts) — the rate limit is ON by default.
+      callLimits: CallLimits.optional(),
       // Provenance: 'sdk' (hand-coded defineAgent worker), 'flow' (canvas deploy),
       // 'playbook' (agent-mode deploy), or 'connector' (brain-connector agent).
       // DERIVED from the linked agents row's deploy tags (flowId / playbookId /
@@ -1341,6 +1414,7 @@ var init_agent_versions = __esm({
   "../contracts/src/agent-versions.ts"() {
     init_agent_config();
     init_agents();
+    init_call_limits();
     init_consultation();
     z.object({
       systemPrompt: z.string().max(64e3),
@@ -1355,6 +1429,8 @@ var init_agent_versions = __esm({
       consultation: ConsultationPolicy,
       tags: z.array(z.string().max(64)).max(32).nullable(),
       brainConnectorId: z.string().uuid().nullable(),
+      // Versions published before call limits existed carry none: read as null (every default).
+      callLimits: CallLimits.nullable().default(null),
       flowVersion: z.number().int().nullable(),
       processSchema: ProcessSchemaDTO.nullable()
     });
@@ -1390,6 +1466,7 @@ var init_agent_versions = __esm({
       "language",
       "tools",
       "brainConnectorId",
+      "callLimits",
       "consultation",
       "tags",
       "flowVersion",
@@ -1531,6 +1608,9 @@ var init_model_catalog = __esm({
     CostEstimateBilledPerMinute = z.object({
       platformFee: z.number().nonnegative(),
       providerPassthrough: z.number().nonnegative(),
+      // The flat own-key fee per minute (burn-down B-26); 0 when every provider runs on the platform's keys. Optional
+      // only for responses from an API older than the fee.
+      ownKeyFee: z.number().nonnegative().optional(),
       telephony: z.number().nonnegative(),
       allIn: z.number().nonnegative()
     });
@@ -1760,9 +1840,46 @@ var init_call_review = __esm({
     });
   }
 });
+var CAPTURED_FIELDS_MAX, CAPTURED_STRING_MAX_CHARS, CAPTURED_ARRAY_MAX_ITEMS, CapturedFieldValue, CapturedField, StructuredOutputs;
+var init_call_outcome = __esm({
+  "../contracts/src/call-outcome.ts"() {
+    init_agent_config();
+    CAPTURED_FIELDS_MAX = 200;
+    CAPTURED_STRING_MAX_CHARS = 8e3;
+    CAPTURED_ARRAY_MAX_ITEMS = 100;
+    CapturedFieldValue = z.union([
+      z.string().max(CAPTURED_STRING_MAX_CHARS),
+      z.number().finite(),
+      z.boolean(),
+      z.array(z.string().max(CAPTURED_STRING_MAX_CHARS)).max(CAPTURED_ARRAY_MAX_ITEMS),
+      z.null()
+    ]);
+    CapturedField = z.object({
+      name: z.string().min(1).max(64),
+      type: ProcessFieldType,
+      required: z.boolean(),
+      // false ⇒ the call never captured it; `value` is then null
+      filled: z.boolean(),
+      value: CapturedFieldValue
+    });
+    StructuredOutputs = z.record(CapturedFieldValue);
+    z.object({
+      // Every declared field, in declaration order; empty when the agent declares none.
+      fields: z.array(CapturedField).max(CAPTURED_FIELDS_MAX)
+    }).superRefine((body, ctx) => {
+      const seen = /* @__PURE__ */ new Set();
+      for (const f of body.fields) {
+        if (seen.has(f.name)) ctx.addIssue({ code: z.ZodIssueCode.custom, message: `duplicate field ${f.name}` });
+        seen.add(f.name);
+        if (!f.filled && f.value !== null) ctx.addIssue({ code: z.ZodIssueCode.custom, message: `${f.name}: an unfilled field has no value` });
+      }
+    });
+  }
+});
 var TranscriptTurn, ConsultationAudit, ToolCallAudit, McpInteractionAudit;
 var init_call_result = __esm({
   "../contracts/src/call-result.ts"() {
+    init_call_outcome();
     TranscriptTurn = z.object({
       speaker: z.enum(["caller", "agent"]),
       text: z.string(),
@@ -1811,9 +1928,13 @@ var init_call_result = __esm({
       startedAt: z.string().datetime(),
       endedAt: z.string().datetime(),
       durationMs: z.number().int().min(0),
+      // Final segments only, in call order.
       transcript: z.array(TranscriptTurn),
-      // Whatever the agent's process-schema captured. No prescribed shape.
-      structuredOutputs: z.record(z.unknown()).optional(),
+      // The filled fields of the agent's process / flow, keyed by name (burn-down G-20). Absent when the agent declares no
+      // fields, or its worker never reported them.
+      structuredOutputs: StructuredOutputs.optional(),
+      // Every declared field with what the call captured and whether it was filled — the same list `call.ended` carries.
+      fields: z.array(CapturedField).optional(),
       recordingUrl: z.string().url().optional(),
       cost: z.object({
         totalUsd: z.string(),
@@ -1825,9 +1946,11 @@ var init_call_result = __esm({
     });
   }
 });
-var WEBHOOK_EVENT_TYPES, CallWebhookDirection, CallWebhookOutcome, CallWebhookAttributes, Party;
+var WEBHOOK_EVENT_TYPES, CallWebhookDirection, CallWebhookOutcome, CallWebhookAttributes, Party, CALL_ENDED_PAYLOAD_VERSION, CallEndedTranscript;
 var init_webhook_events = __esm({
   "../contracts/src/webhook-events.ts"() {
+    init_call_result();
+    init_call_outcome();
     WEBHOOK_EVENT_TYPES = ["call.started", "call.ended", "recording.ready"];
     z.enum(WEBHOOK_EVENT_TYPES);
     CallWebhookDirection = z.enum(["inbound", "outbound", "web"]);
@@ -1845,7 +1968,18 @@ var init_webhook_events = __esm({
       // set, it is the same value `call.ended` carries; `call.ended` always has one.
       direction: CallWebhookDirection.nullable()
     });
+    CALL_ENDED_PAYLOAD_VERSION = 2;
+    CallEndedTranscript = z.object({
+      // Final segments only (what was said, never an interim STT guess), in call order. Empty when `truncated`.
+      turns: z.array(TranscriptTurn),
+      // How many final turns the call has — the length of `turns` unless truncated.
+      turnCount: z.number().int().min(0),
+      truncated: z.boolean(),
+      // Where the whole transcript is: GET /v1/calls/:callId/result (its `transcript`). Always set.
+      fetchPath: z.string().regex(/^\/v1\/calls\/[0-9a-f-]{36}\/result$/)
+    });
     z.object({
+      version: z.literal(CALL_ENDED_PAYLOAD_VERSION),
       callId: z.string().uuid(),
       durationMs: z.number().int().min(0),
       endedAt: z.string().datetime(),
@@ -1856,7 +1990,20 @@ var init_webhook_events = __esm({
       toE164: Party,
       direction: CallWebhookDirection,
       outcome: CallWebhookOutcome,
-      attributes: CallWebhookAttributes
+      attributes: CallWebhookAttributes,
+      // Every field the agent declared (its process, or a flow's slots), in declaration order, with what the call captured
+      // and whether it was filled. Empty when the agent declares none.
+      fields: z.array(CapturedField),
+      // The filled fields as one object keyed by name (as GET /v1/calls/:id/result returns them). Absent when the agent
+      // declares no fields.
+      structuredOutputs: StructuredOutputs.optional(),
+      transcript: CallEndedTranscript,
+      // true: the agent's worker confirmed its last transcript segment and captured field had landed before this payload
+      // was built. false: built without that word (a worker that crashed or runs an SDK before 0.6.2, or one that didn't
+      // answer within the hold) — the transcript and fields are what had arrived; GET /v1/calls/:id/result has any later.
+      finalized: z.boolean(),
+      // true: the payload would have passed CALL_ENDED_PAYLOAD_MAX_BYTES, so values were left out (see the cap) — fetch them.
+      valuesOmitted: z.boolean()
     });
     z.object({
       callId: z.string().uuid(),
@@ -2432,166 +2579,6 @@ var init_telephony = __esm({
     });
   }
 });
-var SHORTENER_HOSTS, PLACEHOLDER_HOSTS, PublicUrl, A2pBusinessType, A2pBusinessInfo, A2pOptInType, A2pUseCase, A2pMessagingProfile, A2pState;
-var init_a2p = __esm({
-  "../contracts/src/a2p.ts"() {
-    SHORTENER_HOSTS = [
-      "bit.ly",
-      "tinyurl.com",
-      "t.co",
-      "goo.gl",
-      "ow.ly",
-      "is.gd",
-      "buff.ly",
-      "rebrand.ly",
-      "cutt.ly",
-      "shorturl.at",
-      "tiny.cc"
-    ];
-    PLACEHOLDER_HOSTS = ["acme.com", "example.com", "example.org", "test.com", "localhost"];
-    PublicUrl = z.string().url().refine((v) => v.startsWith("https://"), "must be https").refine((v) => {
-      try {
-        const host = new URL(v).hostname.toLowerCase().replace(/^www\./, "");
-        return !SHORTENER_HOSTS.includes(host);
-      } catch {
-        return false;
-      }
-    }, "public URL shorteners are rejected by carriers \u2014 use your own domain").refine((v) => {
-      try {
-        const host = new URL(v).hostname.toLowerCase().replace(/^www\./, "");
-        return !PLACEHOLDER_HOSTS.some((p) => host === p || host.endsWith(`.${p}`));
-      } catch {
-        return false;
-      }
-    }, "placeholder domain \u2014 reviewers will follow this link and reject the campaign");
-    A2pBusinessType = z.enum([
-      "Sole Proprietorship",
-      "Partnership",
-      "Corporation",
-      "Co-operative",
-      "Limited Liability Corporation",
-      "Non-profit Corporation"
-    ]);
-    A2pBusinessInfo = z.object({
-      legalName: z.string().trim().min(2).max(200),
-      /** EIN (US) or equivalent registration number. */
-      registrationNumber: z.string().trim().min(4).max(50),
-      businessType: A2pBusinessType,
-      /** Publicly reachable production site — not staging, not a 404. */
-      website: PublicUrl,
-      industry: z.string().trim().min(2).max(60),
-      address: z.object({
-        street: z.string().trim().min(2).max(200),
-        city: z.string().trim().min(1).max(100),
-        region: z.string().trim().min(1).max(100),
-        postalCode: z.string().trim().min(2).max(20),
-        isoCountry: z.string().trim().length(2)
-      }),
-      authorizedRep: z.object({
-        firstName: z.string().trim().min(1).max(100),
-        lastName: z.string().trim().min(1).max(100),
-        email: z.string().trim().email(),
-        phone: z.string().trim().regex(/^\+[1-9]\d{6,14}$/, "must be E.164"),
-        jobTitle: z.string().trim().min(2).max(100)
-      })
-    });
-    A2pOptInType = z.enum(["WEB_FORM", "PAPER_FORM", "VERBAL", "VIA_TEXT", "MOBILE_QR_CODE"]);
-    A2pUseCase = z.enum([
-      "MIXED",
-      "CUSTOMER_CARE",
-      "MARKETING",
-      "ACCOUNT_NOTIFICATION",
-      "2FA",
-      "DELIVERY_NOTIFICATION",
-      "HIGHER_EDUCATION",
-      "POLLING_VOTING",
-      "PUBLIC_SERVICE_ANNOUNCEMENT",
-      "LOW_VOLUME"
-    ]);
-    A2pMessagingProfile = z.object({
-      useCase: A2pUseCase,
-      /** Specific, not generic. "We send texts" gets rejected; describe the actual
-       *  messages and when they are sent. */
-      description: z.string().trim().min(40).max(4096),
-      /**
-       * The single most-rejected field. Must describe HOW people opt in, state the
-       * message frequency, include the "message and data rates may apply"
-       * disclosure, and link to publicly reachable evidence. Twilio's API bounds it
-       * to 40–2049 characters.
-       */
-      messageFlow: z.string().trim().min(40).max(2049),
-      optInType: A2pOptInType,
-      /** Publicly accessible screenshots/pages showing the opt-in. Reviewers open
-       *  these; anything behind a login fails. */
-      optInEvidenceUrls: z.array(PublicUrl).min(1).max(5),
-      /** Real messages the customer will send. Must reflect the declared use case
-       *  and carry opt-out language. */
-      messageSamples: z.array(z.string().trim().min(10).max(1024)).min(2).max(5),
-      privacyPolicyUrl: PublicUrl,
-      termsAndConditionsUrl: PublicUrl,
-      hasEmbeddedLinks: z.boolean().default(false),
-      hasEmbeddedPhone: z.boolean().default(false)
-    });
-    z.object({
-      business: A2pBusinessInfo,
-      messaging: A2pMessagingProfile,
-      /** Register against Twilio's mock endpoints — exercises the full pipeline
-       *  with no fees and no real carrier submission. Used in CI and staging. */
-      mock: z.boolean().default(false)
-    }).superRefine((v, ctx) => {
-      const flow = v.messaging.messageFlow.toLowerCase();
-      if (!/(msg|message)\s*(&|and)\s*data rates/.test(flow)) {
-        ctx.addIssue({
-          code: z.ZodIssueCode.custom,
-          path: ["messaging", "messageFlow"],
-          message: 'must include a "Message and data rates may apply" disclosure \u2014 carriers reject without it'
-        });
-      }
-      if (!/\d/.test(flow) || !/(msg|message|text)/.test(flow)) {
-        ctx.addIssue({
-          code: z.ZodIssueCode.custom,
-          path: ["messaging", "messageFlow"],
-          message: 'must state message frequency, e.g. "Up to 4 msgs/month"'
-        });
-      }
-      const hasOptOut = v.messaging.messageSamples.some((s) => /stop/i.test(s));
-      if (!hasOptOut) {
-        ctx.addIssue({
-          code: z.ZodIssueCode.custom,
-          path: ["messaging", "messageSamples"],
-          message: 'at least one sample must include opt-out language (e.g. "Reply STOP to opt out")'
-        });
-      }
-    });
-    A2pState = z.enum([
-      "none",
-      "profile_pending",
-      "profile_approved",
-      "profile_failed",
-      "brand_pending",
-      "brand_approved",
-      "brand_failed",
-      "campaign_pending",
-      "messaging_ready",
-      "campaign_failed"
-    ]);
-    z.object({
-      state: A2pState,
-      customerProfileSid: z.string().nullable(),
-      trustProductSid: z.string().nullable(),
-      brandSid: z.string().nullable(),
-      messagingServiceSid: z.string().nullable(),
-      campaignSid: z.string().nullable(),
-      mock: z.boolean(),
-      /** Carrier/Twilio rejection details, surfaced verbatim so the customer can
-       *  fix the specific field rather than guess. */
-      failures: z.array(z.object({ code: z.number().nullable(), field: z.string().nullable(), message: z.string() })).default([]),
-      /** Plain-language next step for the dashboard. */
-      nextAction: z.string().nullable(),
-      updatedAt: z.string().nullable()
-    });
-  }
-});
 var ConnectorMode, ConnectorStatus, ConnectorNormalize;
 var init_connector = __esm({
   "../contracts/src/connector.ts"() {
@@ -2706,7 +2693,7 @@ var init_connector_stream = __esm({
     ]);
   }
 });
-var FLOW_BOOT_FAILURES;
+var FLOW_BOOT_FAILURES, AGENT_END_REASONS;
 var init_call_end_reason = __esm({
   "../contracts/src/call-end-reason.ts"() {
     FLOW_BOOT_FAILURES = [
@@ -2717,9 +2704,11 @@ var init_call_end_reason = __esm({
       "worker_identity_refused",
       "provider_unavailable"
     ];
-    z.enum(
-      FLOW_BOOT_FAILURES.map((cause) => `flow_boot:${cause}`)
-    );
+    AGENT_END_REASONS = [
+      "max_duration",
+      ...FLOW_BOOT_FAILURES.map((cause) => `flow_boot:${cause}`)
+    ];
+    z.enum(AGENT_END_REASONS);
   }
 });
 var EnvironmentSpec;
@@ -3915,6 +3904,23 @@ var init_wallet = __esm({
     });
   }
 });
+var PipelineSlotKey;
+var init_pipeline_keys = __esm({
+  "../contracts/src/pipeline-keys.ts"() {
+    PipelineSlotKey = z.object({
+      /** The provider as the slot reports it (LiveKit's label: `openai`, `api.openai.com`, `Deepgram`, …). */
+      provider: z.string().min(1).max(200),
+      /** true = the workspace's own key built it; false = the platform's. */
+      byok: z.boolean()
+    });
+    z.object({
+      llm: PipelineSlotKey.optional(),
+      stt: PipelineSlotKey.optional(),
+      tts: PipelineSlotKey.optional(),
+      realtime: PipelineSlotKey.optional()
+    });
+  }
+});
 
 // ../contracts/src/index.ts
 var init_src = __esm({
@@ -3944,6 +3950,7 @@ var init_src = __esm({
     init_tests();
     init_call_review();
     init_call_result();
+    init_call_outcome();
     init_webhook_events();
     init_numbers();
     init_project_limits();
@@ -3959,12 +3966,12 @@ var init_src = __esm({
     init_connection();
     init_secret_headers();
     init_telephony();
-    init_a2p();
     init_connector();
     init_connector_stream();
     init_flow_compile();
     init_flow_compile_check();
     init_call_end_reason();
+    init_call_limits();
     init_flow_enrichment();
     init_environments();
     init_variables();
@@ -3980,6 +3987,7 @@ var init_src = __esm({
     init_wallet();
     init_network_address();
     init_dispatch_metadata();
+    init_pipeline_keys();
   }
 });
 
@@ -4069,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;
@@ -4115,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;
@@ -4147,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 } : {},
@@ -4154,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();
@@ -4293,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) {
@@ -4339,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 = {}) {
@@ -4417,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 = {}) {
@@ -4521,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) {