@voicelayer/sdk 0.6.1 → 0.6.3

package/dist/index.js

@@ -14,11 +14,11 @@ import { LoggerProvider, BatchLogRecordProcessor } from '@opentelemetry/sdk-logs
 import { PeriodicExportingMetricReader } from '@opentelemetry/sdk-metrics';
 import { NodeSDK } from '@opentelemetry/sdk-node';
 import { ATTR_SERVICE_VERSION, ATTR_SERVICE_NAME } from '@opentelemetry/semantic-conventions';
+import { llm, DEFAULT_API_CONNECT_OPTIONS, intervalForRetry, voice as voice$1, APIStatusError, APITimeoutError, APIConnectionError } from '@livekit/agents';
 import http from 'http';
 import https from 'https';
 import { Readable } from 'stream';
 import { lookup } from 'dns/promises';
-import { voice as voice$1, llm } from '@livekit/agents';
 import { getQuickJS, shouldInterruptAfterDeadline } from 'quickjs-emscripten';
 import { randomUUID, createHash } from 'crypto';
 import { setup, createActor } from 'xstate';
@@ -750,7 +750,7 @@ var init_consultation = __esm({
     });
   }
 });
-var CALL_CONTROL_PUBSUB_CHANNEL, CALL_CONTROL_ACK_CHANNEL, CALL_CONTROL_READY_KEY, CallEventKind, OP_CALL_EVENT_KIND, OpCallEventKind, commandId, SayCommand, HangupCommand, DtmfCommand, InstructCommand, InjectContextCommand, CallControlCommand;
+var CALL_CONTROL_PUBSUB_CHANNEL, CALL_CONTROL_ACK_CHANNEL, CALL_CONTROL_READY_KEY, CallEventKind, OP_CALL_EVENT_KIND, OpCallEventKind, LatencyMs, TURN_LATENCY_MAX_PER_CALL, commandId, SayCommand, HangupCommand, DtmfCommand, InstructCommand, InjectContextCommand, CallControlCommand;
 var init_call_events = __esm({
   "../contracts/src/call-events.ts"() {
     init_consultation();
@@ -779,7 +779,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);
@@ -806,6 +808,18 @@ 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();
+    TURN_LATENCY_MAX_PER_CALL = 500;
+    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({
@@ -924,9 +938,68 @@ var init_text_turns = __esm({
     ]);
   }
 });
+var PLATFORM_MAX_CALL_MINUTES, SIP_LEG_MAX_CALL_DURATION_SECONDS, INBOUND_REFUSED_MESSAGE, Message, CallerRateLimit, CallLimits, CallerChannel, CallDurationLimits, INBOUND_REFUSED_END_REASON_PREFIX, CallAdmissionResponse;
+var init_call_limits = __esm({
+  "../contracts/src/call-limits.ts"() {
+    PLATFORM_MAX_CALL_MINUTES = 240;
+    SIP_LEG_MAX_CALL_DURATION_SECONDS = (PLATFORM_MAX_CALL_MINUTES + 15) * 60;
+    INBOUND_REFUSED_MESSAGE = "Sorry, we can't take your call right now. Please try again later. Goodbye.";
+    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()
+    });
+    INBOUND_REFUSED_END_REASON_PREFIX = "inbound_refused:";
+    CallAdmissionResponse = 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.
@@ -1090,6 +1163,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 /
@@ -1445,6 +1521,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),
@@ -1459,6 +1536,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()
     });
@@ -1494,6 +1573,7 @@ var init_agent_versions = __esm({
       "language",
       "tools",
       "brainConnectorId",
+      "callLimits",
       "consultation",
       "tags",
       "flowVersion",
@@ -1635,6 +1715,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()
     });
@@ -1900,9 +1983,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(),
@@ -1951,9 +2071,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(),
@@ -1965,9 +2089,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"]);
@@ -1985,7 +2111,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(),
@@ -1996,7 +2133,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(),
@@ -2942,166 +3092,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"() {
@@ -3218,7 +3208,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 = [
@@ -3229,9 +3219,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;
@@ -4427,6 +4419,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({
@@ -4456,6 +4465,7 @@ var init_src = __esm({
     init_tests();
     init_call_review();
     init_call_result();
+    init_call_outcome();
     init_webhook_events();
     init_numbers();
     init_project_limits();
@@ -4471,12 +4481,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();
@@ -4492,6 +4502,7 @@ var init_src = __esm({
     init_wallet();
     init_network_address();
     init_dispatch_metadata();
+    init_pipeline_keys();
   }
 });
 
@@ -4585,32 +4596,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;
+  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 = 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);
+  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;
@@ -4631,11 +4726,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;
@@ -4663,6 +4760,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 } : {},
@@ -4670,6 +4791,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();
@@ -5128,505 +5252,206 @@ var init_wrap = __esm({
   "src/providers/wrap.ts"() {
   }
 });
-
-// src/providers/index.ts
-async function importOptional(spec, hint) {
-  try {
-    return await import(spec);
-  } catch {
-    throw new Error(`${hint}: "${spec}" is not installed. Add it with: pnpm add ${spec}`);
+function metricExportIntervalMs() {
+  const raw = Number(process.env.OTEL_METRIC_EXPORT_INTERVAL);
+  return Number.isFinite(raw) && raw > 0 ? raw : DEFAULT_METRIC_EXPORT_INTERVAL_MS;
+}
+function start(opts) {
+  if (started)
+    return;
+  started = true;
+  if (opts.debug) {
+    diag.setLogger(new DiagConsoleLogger(), DiagLogLevel.INFO);
+  }
+  const authKey = process.env.VOICELAYER_TELEMETRY_KEY || process.env.VOICELAYER_API_KEY;
+  if (!authKey) {
+    return;
+  }
+  if (!process.env.OTEL_EXPORTER_OTLP_ENDPOINT) {
+    process.env.OTEL_EXPORTER_OTLP_ENDPOINT = DEFAULT_OTLP_ENDPOINT;
+  }
+  process.env.OTEL_EXPORTER_OTLP_HEADERS = `Authorization=Bearer ${authKey}`;
+  const resource = resourceFromAttributes({
+    [ATTR_SERVICE_NAME]: opts.service,
+    ...opts.version ? { [ATTR_SERVICE_VERSION]: opts.version } : {}
+  });
+  loggerProvider = new LoggerProvider({
+    resource,
+    processors: [new BatchLogRecordProcessor(new OTLPLogExporter())]
+  });
+  logs.setGlobalLoggerProvider(loggerProvider);
+  metricReader = new PeriodicExportingMetricReader({
+    exportIntervalMillis: metricExportIntervalMs(),
+    // DELTA temporality: each export carries only the increment since the
+    // previous one. The read side (apps/api openobserve-repository) totals a
+    // metric with SUM(value) over the query window, which is correct only for
+    // deltas. The OTLP exporter defaults to CUMULATIVE — it re-reports the
+    // running total every export, so SUM double-counts every call that lives
+    // longer than one export interval (inflating LLM/TTS/STT usage + cost).
+    // Setting DELTA makes the existing SUM reads correct without touching them.
+    exporter: new OTLPMetricExporter({
+      temporalityPreference: AggregationTemporalityPreference.DELTA
+    })
+  });
+  sdk = new NodeSDK({
+    resource,
+    traceExporter: new OTLPTraceExporter(),
+    metricReader,
+    instrumentations: [
+      getNodeAutoInstrumentations({
+        // fs instrumentation is extremely noisy and rarely useful for app traces.
+        "@opentelemetry/instrumentation-fs": { enabled: false }
+      })
+    ]
+  });
+  sdk.start();
+  const shutdown = async () => {
+    try {
+      await sdk?.shutdown();
+      await loggerProvider?.shutdown();
+    } catch {
+    }
+  };
+  process.once("SIGTERM", () => void shutdown().then(() => process.exit(0)));
+  process.once("SIGINT", () => void shutdown().then(() => process.exit(0)));
+}
+async function flushTelemetry() {
+  const flushes = [];
+  if (metricReader)
+    flushes.push(metricReader.forceFlush());
+  if (loggerProvider)
+    flushes.push(loggerProvider.forceFlush());
+  const proxied = trace.getTracerProvider();
+  const tracerProvider = proxied.getDelegate?.() ?? proxied;
+  if (typeof tracerProvider.forceFlush === "function") {
+    flushes.push(tracerProvider.forceFlush());
   }
+  await Promise.allSettled(flushes);
 }
-function withCreds(opts, creds2) {
-  if (creds2?.apiKey) opts["apiKey"] = creds2.apiKey;
-  if (creds2?.baseURL) opts["baseURL"] = creds2.baseURL;
-  return opts;
+function getLogger(name) {
+  return logs.getLogger(name);
 }
-var deepgram, openai, anthropic, cartesia, elevenlabs, assemblyai, google, silero, livekitTurn, connector;
-var init_providers2 = __esm({
-  "src/providers/index.ts"() {
-    init_ssrf();
-    init_transport_callback();
-    init_connector_llm();
-    init_wrap();
-    deepgram = {
-      stt(options = {}) {
-        return async () => {
-          const dg = await importOptional("@voicelayer/agents-plugin-deepgram", "deepgram.stt");
-          return new dg.STT(
-            withCreds(
-              { model: options.model ?? "nova-3", language: options.language ?? "en-US" },
-              options
-            )
-          );
-        };
-      },
-      tts(options = {}) {
-        return async () => {
-          const dg = await importOptional("@voicelayer/agents-plugin-deepgram", "deepgram.tts");
-          return new dg.TTS(
-            withCreds({ model: options.model ?? "aura-2-harmonia-en" }, options)
-          );
-        };
-      }
-    };
-    openai = {
-      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)
-          );
-        };
-      },
-      tts(options = {}) {
-        return async () => {
-          const oa = await importOptional("@voicelayer/agents-plugin-openai", "openai.tts");
-          const opts = { model: options.model ?? "tts-1" };
-          if (options.voice) opts["voice"] = options.voice;
-          if (options.instructions) opts["instructions"] = options.instructions;
-          return new oa.TTS(withCreds(opts, options));
-        };
-      },
-      // Speech-to-speech via the OpenAI Realtime API. Returns a RealtimeProvider
-      // that the SDK uses in place of the stt/llm/tts pipeline.
-      realtime(options = {}) {
-        return async () => {
-          const oa = await importOptional("@voicelayer/agents-plugin-openai", "openai.realtime");
-          const opts = {};
-          if (options.model) opts["model"] = options.model;
-          if (options.voice) opts["voice"] = options.voice;
-          return new oa.realtime.RealtimeModel(withCreds(opts, options));
-        };
-      }
-    };
-    anthropic = {
-      llm(options = {}) {
-        return async () => {
-          const an = await importOptional("@livekit/agents-plugin-anthropic", "anthropic.llm");
-          return new an.LLM(
-            withCreds({ model: options.model ?? "claude-sonnet-5-5" }, options)
-          );
-        };
-      }
-    };
-    cartesia = {
-      tts(options = {}) {
-        return async () => {
-          const ct = await importOptional("@voicelayer/agents-plugin-cartesia", "cartesia.tts");
-          return new ct.TTS(options);
-        };
-      },
-      stt(options = {}) {
-        return async () => {
-          const ct = await importOptional("@voicelayer/agents-plugin-cartesia", "cartesia.stt");
-          const opts = {};
-          if (options.model) opts["model"] = options.model;
-          if (options.language) opts["language"] = options.language;
-          return new ct.STT(withCreds(opts, options));
-        };
-      }
-    };
-    elevenlabs = {
-      tts(options = {}) {
-        return async () => {
-          const el = await importOptional("@voicelayer/agents-plugin-elevenlabs", "elevenlabs.tts");
-          const opts = {};
-          if (options.voice) opts["voiceId"] = options.voice;
-          if (options.model) opts["model"] = options.model;
-          return new el.TTS(withCreds(opts, options));
-        };
-      }
-    };
-    assemblyai = {
-      stt(options = {}) {
-        return async () => {
-          const aai = await importOptional("@voicelayer/agents-plugin-assemblyai", "assemblyai.stt");
-          const opts = {};
-          if (options.language) opts["language"] = options.language;
-          return new aai.STT(withCreds(opts, options));
-        };
-      }
-    };
-    google = {
-      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)
-          );
-        };
-      },
-      realtime(options = {}) {
-        return async () => {
-          const g = await importOptional("@voicelayer/agents-plugin-google", "google.realtime");
-          const opts = {};
-          if (options.model) opts["model"] = options.model;
-          if (options.voice) opts["voice"] = options.voice;
-          return new g.beta.realtime.RealtimeModel(withCreds(opts, options));
-        };
-      }
-    };
-    silero = {
-      vad() {
-        return async () => {
-          const sil = await importOptional("@voicelayer/agents-plugin-silero", "silero.vad");
-          return await sil.VAD.load();
-        };
-      }
-    };
-    livekitTurn = {
-      english() {
-        return async () => {
-          const lk = await importOptional("@voicelayer/agents-plugin-livekit", "livekitTurn.english");
-          return new lk.turnDetector.EnglishModel();
-        };
-      },
-      multilingual() {
-        return async () => {
-          const lk = await importOptional("@voicelayer/agents-plugin-livekit", "livekitTurn.multilingual");
-          return new lk.turnDetector.MultilingualModel();
-        };
-      }
-    };
-    connector = {
-      llm(config = {}) {
-        return async (call) => {
-          if (config.url) {
-            await assertPublicHttpsUrl(
-              config.url,
-              config.allowHosts ? { allowHosts: config.allowHosts } : {}
-            );
-            return openai.llm({
-              ...config.model ? { model: config.model } : {},
-              ...config.apiKey ? { apiKey: config.apiKey } : {},
-              baseURL: config.url
-            })(call);
-          }
-          const transport = config.transport ?? (config.onQuery ? callbackTransport(config.onQuery) : void 0);
-          if (!transport) {
-            throw new Error("connector.llm requires one of: url, onQuery, or transport");
-          }
-          const projectId = typeof call.metadata["projectId"] === "string" ? call.metadata["projectId"] : void 0;
-          const llmOptions = {
-            ...config.model ? { model: config.model } : {},
-            ...config.temperature !== void 0 ? { temperature: config.temperature } : {},
-            ...config.fallbackText ? { fallbackText: config.fallbackText } : {},
-            ...call.callId ? { callId: call.callId } : {},
-            ...projectId ? { projectId } : {}
-          };
-          return await createConnectorLLM(transport, llmOptions);
-        };
-      }
+var DEFAULT_OTLP_ENDPOINT, DEFAULT_METRIC_EXPORT_INTERVAL_MS, started, sdk, loggerProvider, metricReader;
+var init_start = __esm({
+  "../observability/dist/start.js"() {
+    DEFAULT_OTLP_ENDPOINT = "https://otel.vlayers.ai/v1/otlp";
+    DEFAULT_METRIC_EXPORT_INTERVAL_MS = 15e3;
+    started = false;
+    sdk = null;
+    loggerProvider = null;
+    metricReader = null;
+  }
+});
+
+// ../observability/dist/attributes.js
+function callContextToAttributes(ctx) {
+  const out = {};
+  if (ctx.projectId)
+    out[ATTR.projectId] = ctx.projectId;
+  if (ctx.callId)
+    out[ATTR.callId] = ctx.callId;
+  if (ctx.campaignId)
+    out[ATTR.campaignId] = ctx.campaignId;
+  if (ctx.room)
+    out[ATTR.room] = ctx.room;
+  if (ctx.agentId)
+    out[ATTR.agentId] = ctx.agentId;
+  if (ctx.phoneNumberId)
+    out[ATTR.phoneNumberId] = ctx.phoneNumberId;
+  if (ctx.bindingId)
+    out[ATTR.bindingId] = ctx.bindingId;
+  return out;
+}
+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"
     };
   }
 });
-
-// src/providers/registry.ts
-function entry(id, bits) {
-  const identity = providerIdentity(id);
-  if (!identity) throw new Error(`PROVIDER_REGISTRY: no provider identity in contracts for '${id}'`);
-  return { name: identity.id, capabilities: identity.capabilities, ...bits };
+async function withCallContext(opts, fn) {
+  const tracer = trace.getTracer(TRACER_NAME);
+  const ctx = {
+    ...opts.projectId ? { projectId: opts.projectId } : {},
+    ...opts.callId ? { callId: opts.callId } : {},
+    ...opts.room ? { room: opts.room } : {},
+    ...opts.agentId ? { agentId: opts.agentId } : {},
+    ...opts.phoneNumberId ? { phoneNumberId: opts.phoneNumberId } : {},
+    ...opts.bindingId ? { bindingId: opts.bindingId } : {}
+  };
+  return callContextStore.run(ctx, () => tracer.startActiveSpan(opts.kind, async (span) => {
+    span.setAttributes(callContextToAttributes(opts));
+    span.setAttribute(ATTR.kind, opts.kind);
+    if (opts.source)
+      span.setAttribute(ATTR.source, opts.source);
+    if (opts.attributes)
+      span.setAttributes(opts.attributes);
+    try {
+      return await fn(span);
+    } catch (err) {
+      span.recordException(err);
+      span.setStatus({ code: SpanStatusCode.ERROR, message: err.message });
+      throw err;
+    } finally {
+      span.end();
+    }
+  }));
 }
-function providerEntry(name) {
-  if (!name) return void 0;
-  return PROVIDER_REGISTRY[PROVIDER_ALIASES[name] ?? name];
+function getCurrentCallContext() {
+  return callContextStore.getStore();
 }
-function resolveStt(name, o) {
-  return (providerEntry(name)?.stt ?? PROVIDER_REGISTRY["deepgram"].stt)(o);
+var TRACER_NAME, callContextStore;
+var init_call_context = __esm({
+  "../observability/dist/call-context.js"() {
+    init_attributes();
+    TRACER_NAME = "@voicelayer/observability";
+    callContextStore = new AsyncLocalStorage();
+  }
+});
+var init_trace_propagation = __esm({
+  "../observability/dist/trace-propagation.js"() {
+  }
+});
+function meter() {
+  return metrics.getMeter(METER_NAME, METER_VERSION);
 }
-function resolveTts(name, o) {
-  return (providerEntry(name)?.tts ?? PROVIDER_REGISTRY["deepgram"].tts)(o);
+function attrs(a) {
+  const out = {
+    [ATTR.projectId]: a.projectId,
+    [ATTR.callId]: a.callId,
+    "vl.provider": a.provider
+  };
+  if (a.campaignId)
+    out[ATTR.campaignId] = a.campaignId;
+  if (a.model)
+    out["vl.model"] = a.model;
+  return out;
 }
-function resolveLlm(name, o) {
-  return (providerEntry(name)?.llm ?? PROVIDER_REGISTRY["openai"].llm)(withCurrentModel(name, o));
+function llmInputTokens() {
+  return _llmInputTokens ??= meter().createCounter(USAGE_METRIC_NAMES.llmInputTokens, {
+    description: "Input tokens consumed by an LLM call",
+    unit: "{tokens}"
+  });
 }
-function resolveRealtime(name, o) {
-  return (providerEntry(name)?.realtime ?? PROVIDER_REGISTRY["openai"].realtime)(withCurrentModel(name, o));
+function llmOutputTokens() {
+  return _llmOutputTokens ??= meter().createCounter(USAGE_METRIC_NAMES.llmOutputTokens, {
+    description: "Output tokens produced by an LLM call",
+    unit: "{tokens}"
+  });
 }
-function withCurrentModel(name, o) {
-  if (!name || !o.model) return o;
-  const current = currentModelFor(name, o.model);
-  if (!current.retired) return o;
-  console.warn("[agent] the configured model is retired; running its replacement", {
-    provider: name,
-    model: current.retired,
-    replacement: current.model
-  });
-  return { ...o, model: current.model };
-}
-var model, lang, voice, creds, PROVIDER_REGISTRY;
-var init_registry = __esm({
-  "src/providers/registry.ts"() {
-    init_providers2();
-    init_src();
-    model = (o) => o.model ? { model: o.model } : {};
-    lang = (o) => o.language ? { language: o.language } : {};
-    voice = (o) => o.voice ? { voice: o.voice } : {};
-    creds = (o) => o.creds ?? {};
-    PROVIDER_REGISTRY = {
-      deepgram: entry("deepgram", {
-        failureClass: "vendor-api",
-        engines: ["livekit"],
-        stt: (o) => deepgram.stt({ ...model(o), ...lang(o), ...creds(o) }),
-        // Deepgram folds the voice into the model id (aura-2-<name>-en): wire config
-        // passes a voice, code config passes a model — both land as `model`.
-        tts: (o) => {
-          const m = o.voice ?? o.model;
-          return deepgram.tts({ ...m ? { model: m } : {}, ...creds(o) });
-        }
-      }),
-      openai: entry("openai", {
-        failureClass: "vendor-api",
-        engines: ["livekit", "text"],
-        llm: (o) => openai.llm({ ...model(o), ...creds(o) }),
-        tts: (o) => openai.tts({ ...voice(o), ...model(o), ...creds(o) }),
-        realtime: (o) => openai.realtime({ ...model(o), ...voice(o), ...creds(o) })
-      }),
-      anthropic: entry("anthropic", {
-        failureClass: "vendor-api",
-        engines: ["livekit", "text"],
-        llm: (o) => anthropic.llm({ ...model(o), ...creds(o) })
-      }),
-      google: entry("google", {
-        failureClass: "vendor-api",
-        engines: ["livekit", "text"],
-        llm: (o) => google.llm({ ...model(o), ...creds(o) }),
-        realtime: (o) => google.realtime({ ...model(o), ...voice(o), ...creds(o) })
-      }),
-      cartesia: entry("cartesia", {
-        failureClass: "vendor-api",
-        engines: ["livekit"],
-        stt: (o) => cartesia.stt({ ...model(o), ...lang(o), ...creds(o) }),
-        tts: (o) => cartesia.tts({ ...voice(o), ...model(o), ...creds(o) })
-      }),
-      elevenlabs: entry("elevenlabs", {
-        failureClass: "vendor-api",
-        engines: ["livekit"],
-        tts: (o) => elevenlabs.tts({ ...voice(o), ...model(o), ...creds(o) })
-      }),
-      assemblyai: entry("assemblyai", {
-        failureClass: "vendor-api",
-        engines: ["livekit"],
-        stt: (o) => assemblyai.stt({ ...lang(o), ...creds(o) })
-        // no model knob
-      }),
-      silero: entry("silero", {
-        failureClass: "local",
-        engines: ["livekit"],
-        vad: () => silero.vad()
-      })
-    };
-  }
-});
-
-// src/providers/llm.ts
-var init_llm = __esm({
-  "src/providers/llm.ts"() {
-    init_openai_default();
-    init_registry();
-  }
-});
-function metricExportIntervalMs() {
-  const raw = Number(process.env.OTEL_METRIC_EXPORT_INTERVAL);
-  return Number.isFinite(raw) && raw > 0 ? raw : DEFAULT_METRIC_EXPORT_INTERVAL_MS;
-}
-function start(opts) {
-  if (started)
-    return;
-  started = true;
-  if (opts.debug) {
-    diag.setLogger(new DiagConsoleLogger(), DiagLogLevel.INFO);
-  }
-  const authKey = process.env.VOICELAYER_TELEMETRY_KEY || process.env.VOICELAYER_API_KEY;
-  if (!authKey) {
-    return;
-  }
-  if (!process.env.OTEL_EXPORTER_OTLP_ENDPOINT) {
-    process.env.OTEL_EXPORTER_OTLP_ENDPOINT = DEFAULT_OTLP_ENDPOINT;
-  }
-  process.env.OTEL_EXPORTER_OTLP_HEADERS = `Authorization=Bearer ${authKey}`;
-  const resource = resourceFromAttributes({
-    [ATTR_SERVICE_NAME]: opts.service,
-    ...opts.version ? { [ATTR_SERVICE_VERSION]: opts.version } : {}
-  });
-  loggerProvider = new LoggerProvider({
-    resource,
-    processors: [new BatchLogRecordProcessor(new OTLPLogExporter())]
-  });
-  logs.setGlobalLoggerProvider(loggerProvider);
-  metricReader = new PeriodicExportingMetricReader({
-    exportIntervalMillis: metricExportIntervalMs(),
-    // DELTA temporality: each export carries only the increment since the
-    // previous one. The read side (apps/api openobserve-repository) totals a
-    // metric with SUM(value) over the query window, which is correct only for
-    // deltas. The OTLP exporter defaults to CUMULATIVE — it re-reports the
-    // running total every export, so SUM double-counts every call that lives
-    // longer than one export interval (inflating LLM/TTS/STT usage + cost).
-    // Setting DELTA makes the existing SUM reads correct without touching them.
-    exporter: new OTLPMetricExporter({
-      temporalityPreference: AggregationTemporalityPreference.DELTA
-    })
-  });
-  sdk = new NodeSDK({
-    resource,
-    traceExporter: new OTLPTraceExporter(),
-    metricReader,
-    instrumentations: [
-      getNodeAutoInstrumentations({
-        // fs instrumentation is extremely noisy and rarely useful for app traces.
-        "@opentelemetry/instrumentation-fs": { enabled: false }
-      })
-    ]
-  });
-  sdk.start();
-  const shutdown = async () => {
-    try {
-      await sdk?.shutdown();
-      await loggerProvider?.shutdown();
-    } catch {
-    }
-  };
-  process.once("SIGTERM", () => void shutdown().then(() => process.exit(0)));
-  process.once("SIGINT", () => void shutdown().then(() => process.exit(0)));
-}
-async function flushTelemetry() {
-  const flushes = [];
-  if (metricReader)
-    flushes.push(metricReader.forceFlush());
-  if (loggerProvider)
-    flushes.push(loggerProvider.forceFlush());
-  const proxied = trace.getTracerProvider();
-  const tracerProvider = proxied.getDelegate?.() ?? proxied;
-  if (typeof tracerProvider.forceFlush === "function") {
-    flushes.push(tracerProvider.forceFlush());
-  }
-  await Promise.allSettled(flushes);
-}
-function getLogger(name) {
-  return logs.getLogger(name);
-}
-var DEFAULT_OTLP_ENDPOINT, DEFAULT_METRIC_EXPORT_INTERVAL_MS, started, sdk, loggerProvider, metricReader;
-var init_start = __esm({
-  "../observability/dist/start.js"() {
-    DEFAULT_OTLP_ENDPOINT = "https://otel.vlayers.ai/v1/otlp";
-    DEFAULT_METRIC_EXPORT_INTERVAL_MS = 15e3;
-    started = false;
-    sdk = null;
-    loggerProvider = null;
-    metricReader = null;
-  }
-});
-
-// ../observability/dist/attributes.js
-function callContextToAttributes(ctx) {
-  const out = {};
-  if (ctx.projectId)
-    out[ATTR.projectId] = ctx.projectId;
-  if (ctx.callId)
-    out[ATTR.callId] = ctx.callId;
-  if (ctx.campaignId)
-    out[ATTR.campaignId] = ctx.campaignId;
-  if (ctx.room)
-    out[ATTR.room] = ctx.room;
-  if (ctx.agentId)
-    out[ATTR.agentId] = ctx.agentId;
-  if (ctx.phoneNumberId)
-    out[ATTR.phoneNumberId] = ctx.phoneNumberId;
-  if (ctx.bindingId)
-    out[ATTR.bindingId] = ctx.bindingId;
-  return out;
-}
-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"
-    };
-  }
-});
-async function withCallContext(opts, fn) {
-  const tracer = trace.getTracer(TRACER_NAME);
-  const ctx = {
-    ...opts.projectId ? { projectId: opts.projectId } : {},
-    ...opts.callId ? { callId: opts.callId } : {},
-    ...opts.room ? { room: opts.room } : {},
-    ...opts.agentId ? { agentId: opts.agentId } : {},
-    ...opts.phoneNumberId ? { phoneNumberId: opts.phoneNumberId } : {},
-    ...opts.bindingId ? { bindingId: opts.bindingId } : {}
-  };
-  return callContextStore.run(ctx, () => tracer.startActiveSpan(opts.kind, async (span) => {
-    span.setAttributes(callContextToAttributes(opts));
-    span.setAttribute(ATTR.kind, opts.kind);
-    if (opts.source)
-      span.setAttribute(ATTR.source, opts.source);
-    if (opts.attributes)
-      span.setAttributes(opts.attributes);
-    try {
-      return await fn(span);
-    } catch (err) {
-      span.recordException(err);
-      span.setStatus({ code: SpanStatusCode.ERROR, message: err.message });
-      throw err;
-    } finally {
-      span.end();
-    }
-  }));
-}
-function getCurrentCallContext() {
-  return callContextStore.getStore();
-}
-var TRACER_NAME, callContextStore;
-var init_call_context = __esm({
-  "../observability/dist/call-context.js"() {
-    init_attributes();
-    TRACER_NAME = "@voicelayer/observability";
-    callContextStore = new AsyncLocalStorage();
-  }
-});
-var init_trace_propagation = __esm({
-  "../observability/dist/trace-propagation.js"() {
-  }
-});
-function meter() {
-  return metrics.getMeter(METER_NAME, METER_VERSION);
-}
-function attrs(a) {
-  const out = {
-    [ATTR.projectId]: a.projectId,
-    [ATTR.callId]: a.callId,
-    "vl.provider": a.provider
-  };
-  if (a.campaignId)
-    out[ATTR.campaignId] = a.campaignId;
-  if (a.model)
-    out["vl.model"] = a.model;
-  return out;
-}
-function llmInputTokens() {
-  return _llmInputTokens ??= meter().createCounter(USAGE_METRIC_NAMES.llmInputTokens, {
-    description: "Input tokens consumed by an LLM call",
-    unit: "{tokens}"
-  });
-}
-function llmOutputTokens() {
-  return _llmOutputTokens ??= meter().createCounter(USAGE_METRIC_NAMES.llmOutputTokens, {
-    description: "Output tokens produced by an LLM call",
-    unit: "{tokens}"
-  });
-}
-function ttsChars() {
-  return _ttsChars ??= meter().createCounter(USAGE_METRIC_NAMES.ttsChars, {
-    description: "Characters synthesized by TTS",
-    unit: "{chars}"
+function ttsChars() {
+  return _ttsChars ??= meter().createCounter(USAGE_METRIC_NAMES.ttsChars, {
+    description: "Characters synthesized by TTS",
+    unit: "{chars}"
   });
 }
 function sttSeconds() {
@@ -5850,15 +5675,568 @@ var init_latency_span = __esm({
   }
 });
 
-// ../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();
+// ../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 failure2 = null;
+        const onError = (ev) => {
+          failure2 ??= ev.error;
+        };
+        target.on("error", onError);
+        let started2 = 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;
+            started2 = true;
+            this.queue.put(chunk);
+          }
+        } catch (err) {
+          failure2 ??= err instanceof Error ? err : new Error(String(err));
+        } finally {
+          target.off("error", onError);
+          this.#current = null;
+        }
+        return failure2 ? { ok: false, error: failure2, started: started2 } : { 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 failure2;
+        if (known && fallback) {
+          owner.report({ kind: "model_fallback", model: model2, fallbackModel: fallback.model, code: known.code, message: known.message, cached: true });
+          failure2 = new Error(known.message);
+        } else {
+          const first = await this.#run(owner.primary);
+          if (first.ok || first.started || this.abortController.signal.aborted) return;
+          failure2 = 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;
+          failure2 = second.error;
+        }
+        owner.report({ kind: "apology", model: this.#served.model, message: providerErrorOf(failure2)?.message || failure2.message });
+        this.queue.put({ id: `vl-apology-${Date.now()}`, delta: { role: "assistant", content: owner.apology } });
+      }
+    };
+  }
+});
+
+// src/providers/index.ts
+async function importOptional(spec, hint) {
+  try {
+    return await import(spec);
+  } catch {
+    throw new Error(`${hint}: "${spec}" is not installed. Add it with: pnpm add ${spec}`);
+  }
+}
+function withCreds(opts, creds2) {
+  if (creds2?.apiKey) opts["apiKey"] = creds2.apiKey;
+  if (creds2?.baseURL) opts["baseURL"] = creds2.baseURL;
+  return opts;
+}
+var deepgram, openai, anthropic, cartesia, elevenlabs, assemblyai, google, silero, livekitTurn, connector;
+var init_providers2 = __esm({
+  "src/providers/index.ts"() {
+    init_ssrf();
+    init_transport_callback();
+    init_connector_llm();
+    init_wrap();
+    deepgram = {
+      stt(options = {}) {
+        return async () => {
+          const dg = await importOptional("@voicelayer/agents-plugin-deepgram", "deepgram.stt");
+          return new dg.STT(
+            withCreds(
+              { model: options.model ?? "nova-3", language: options.language ?? "en-US" },
+              options
+            )
+          );
+        };
+      },
+      tts(options = {}) {
+        return async () => {
+          const dg = await importOptional("@voicelayer/agents-plugin-deepgram", "deepgram.tts");
+          return new dg.TTS(
+            withCreds({ model: options.model ?? "aura-2-harmonia-en" }, options)
+          );
+        };
+      }
+    };
+    openai = {
+      llm(options = {}) {
+        return async () => {
+          const oa = await importOptional("@voicelayer/agents-plugin-openai", "openai.llm");
+          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 = {}) {
+        return async () => {
+          const oa = await importOptional("@voicelayer/agents-plugin-openai", "openai.tts");
+          const opts = { model: options.model ?? "tts-1" };
+          if (options.voice) opts["voice"] = options.voice;
+          if (options.instructions) opts["instructions"] = options.instructions;
+          return new oa.TTS(withCreds(opts, options));
+        };
+      },
+      // Speech-to-speech via the OpenAI Realtime API. Returns a RealtimeProvider
+      // that the SDK uses in place of the stt/llm/tts pipeline.
+      realtime(options = {}) {
+        return async () => {
+          const oa = await importOptional("@voicelayer/agents-plugin-openai", "openai.realtime");
+          const opts = {};
+          if (options.model) opts["model"] = options.model;
+          if (options.voice) opts["voice"] = options.voice;
+          return new oa.realtime.RealtimeModel(withCreds(opts, options));
+        };
+      }
+    };
+    anthropic = {
+      llm(options = {}) {
+        return async () => {
+          const an = await importOptional("@livekit/agents-plugin-anthropic", "anthropic.llm");
+          return new an.LLM(
+            withCreds({ model: options.model ?? "claude-sonnet-5-5" }, options)
+          );
+        };
+      }
+    };
+    cartesia = {
+      tts(options = {}) {
+        return async () => {
+          const ct = await importOptional("@voicelayer/agents-plugin-cartesia", "cartesia.tts");
+          return new ct.TTS(options);
+        };
+      },
+      stt(options = {}) {
+        return async () => {
+          const ct = await importOptional("@voicelayer/agents-plugin-cartesia", "cartesia.stt");
+          const opts = {};
+          if (options.model) opts["model"] = options.model;
+          if (options.language) opts["language"] = options.language;
+          return new ct.STT(withCreds(opts, options));
+        };
+      }
+    };
+    elevenlabs = {
+      tts(options = {}) {
+        return async () => {
+          const el = await importOptional("@voicelayer/agents-plugin-elevenlabs", "elevenlabs.tts");
+          const opts = {};
+          if (options.voice) opts["voiceId"] = options.voice;
+          if (options.model) opts["model"] = options.model;
+          return new el.TTS(withCreds(opts, options));
+        };
+      }
+    };
+    assemblyai = {
+      stt(options = {}) {
+        return async () => {
+          const aai = await importOptional("@voicelayer/agents-plugin-assemblyai", "assemblyai.stt");
+          const opts = {};
+          if (options.language) opts["language"] = options.language;
+          return new aai.STT(withCreds(opts, options));
+        };
+      }
+    };
+    google = {
+      llm(options = {}) {
+        return async () => {
+          const g = await importOptional("@voicelayer/agents-plugin-google", "google.llm");
+          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 = {}) {
+        return async () => {
+          const g = await importOptional("@voicelayer/agents-plugin-google", "google.realtime");
+          const opts = {};
+          if (options.model) opts["model"] = options.model;
+          if (options.voice) opts["voice"] = options.voice;
+          return new g.beta.realtime.RealtimeModel(withCreds(opts, options));
+        };
+      }
+    };
+    silero = {
+      vad() {
+        return async () => {
+          const sil = await importOptional("@voicelayer/agents-plugin-silero", "silero.vad");
+          return await sil.VAD.load();
+        };
+      }
+    };
+    livekitTurn = {
+      english() {
+        return async () => {
+          const lk = await importOptional("@voicelayer/agents-plugin-livekit", "livekitTurn.english");
+          return new lk.turnDetector.EnglishModel();
+        };
+      },
+      multilingual() {
+        return async () => {
+          const lk = await importOptional("@voicelayer/agents-plugin-livekit", "livekitTurn.multilingual");
+          return new lk.turnDetector.MultilingualModel();
+        };
+      }
+    };
+    connector = {
+      llm(config = {}) {
+        return async (call) => {
+          if (config.url) {
+            await assertPublicHttpsUrl(
+              config.url,
+              config.allowHosts ? { allowHosts: config.allowHosts } : {}
+            );
+            return openai.llm({
+              ...config.model ? { model: config.model } : {},
+              ...config.apiKey ? { apiKey: config.apiKey } : {},
+              baseURL: config.url
+            })(call);
+          }
+          const transport = config.transport ?? (config.onQuery ? callbackTransport(config.onQuery) : void 0);
+          if (!transport) {
+            throw new Error("connector.llm requires one of: url, onQuery, or transport");
+          }
+          const projectId = typeof call.metadata["projectId"] === "string" ? call.metadata["projectId"] : void 0;
+          const llmOptions = {
+            ...config.model ? { model: config.model } : {},
+            ...config.temperature !== void 0 ? { temperature: config.temperature } : {},
+            ...config.fallbackText ? { fallbackText: config.fallbackText } : {},
+            ...call.callId ? { callId: call.callId } : {},
+            ...projectId ? { projectId } : {}
+          };
+          return await createConnectorLLM(transport, llmOptions);
+        };
+      }
+    };
+  }
+});
+
+// src/providers/registry.ts
+function entry(id, bits) {
+  const identity = providerIdentity(id);
+  if (!identity) throw new Error(`PROVIDER_REGISTRY: no provider identity in contracts for '${id}'`);
+  return { name: identity.id, capabilities: identity.capabilities, ...bits };
+}
+function providerEntry(name) {
+  if (!name) return void 0;
+  return PROVIDER_REGISTRY[PROVIDER_ALIASES[name] ?? name];
+}
+function resolveStt(name, o) {
+  return (providerEntry(name)?.stt ?? PROVIDER_REGISTRY["deepgram"].stt)(o);
+}
+function resolveTts(name, o) {
+  return (providerEntry(name)?.tts ?? PROVIDER_REGISTRY["deepgram"].tts)(o);
+}
+function resolveLlm(name, o) {
+  return (providerEntry(name)?.llm ?? PROVIDER_REGISTRY["openai"].llm)(withCurrentModel(name, o));
+}
+function resolveRealtime(name, o) {
+  return (providerEntry(name)?.realtime ?? PROVIDER_REGISTRY["openai"].realtime)(withCurrentModel(name, o));
+}
+function withCurrentModel(name, o) {
+  if (!name || !o.model) return o;
+  const current = currentModelFor(name, o.model);
+  if (!current.retired) return o;
+  console.warn("[agent] the configured model is retired; running its replacement", {
+    provider: name,
+    model: current.retired,
+    replacement: current.model
+  });
+  return { ...o, model: current.model };
+}
+var model, lang, voice, creds, PROVIDER_REGISTRY;
+var init_registry = __esm({
+  "src/providers/registry.ts"() {
+    init_providers2();
+    init_src();
+    model = (o) => o.model ? { model: o.model } : {};
+    lang = (o) => o.language ? { language: o.language } : {};
+    voice = (o) => o.voice ? { voice: o.voice } : {};
+    creds = (o) => o.creds ?? {};
+    PROVIDER_REGISTRY = {
+      deepgram: entry("deepgram", {
+        failureClass: "vendor-api",
+        engines: ["livekit"],
+        stt: (o) => deepgram.stt({ ...model(o), ...lang(o), ...creds(o) }),
+        // Deepgram folds the voice into the model id (aura-2-<name>-en): wire config
+        // passes a voice, code config passes a model — both land as `model`.
+        tts: (o) => {
+          const m = o.voice ?? o.model;
+          return deepgram.tts({ ...m ? { model: m } : {}, ...creds(o) });
+        }
+      }),
+      openai: entry("openai", {
+        failureClass: "vendor-api",
+        engines: ["livekit", "text"],
+        llm: (o) => openai.llm({ ...model(o), ...creds(o) }),
+        tts: (o) => openai.tts({ ...voice(o), ...model(o), ...creds(o) }),
+        realtime: (o) => openai.realtime({ ...model(o), ...voice(o), ...creds(o) })
+      }),
+      anthropic: entry("anthropic", {
+        failureClass: "vendor-api",
+        engines: ["livekit", "text"],
+        llm: (o) => anthropic.llm({ ...model(o), ...creds(o) })
+      }),
+      google: entry("google", {
+        failureClass: "vendor-api",
+        engines: ["livekit", "text"],
+        llm: (o) => google.llm({ ...model(o), ...creds(o) }),
+        realtime: (o) => google.realtime({ ...model(o), ...voice(o), ...creds(o) })
+      }),
+      cartesia: entry("cartesia", {
+        failureClass: "vendor-api",
+        engines: ["livekit"],
+        stt: (o) => cartesia.stt({ ...model(o), ...lang(o), ...creds(o) }),
+        tts: (o) => cartesia.tts({ ...voice(o), ...model(o), ...creds(o) })
+      }),
+      elevenlabs: entry("elevenlabs", {
+        failureClass: "vendor-api",
+        engines: ["livekit"],
+        tts: (o) => elevenlabs.tts({ ...voice(o), ...model(o), ...creds(o) })
+      }),
+      assemblyai: entry("assemblyai", {
+        failureClass: "vendor-api",
+        engines: ["livekit"],
+        stt: (o) => assemblyai.stt({ ...lang(o), ...creds(o) })
+        // no model knob
+      }),
+      silero: entry("silero", {
+        failureClass: "local",
+        engines: ["livekit"],
+        vad: () => silero.vad()
+      })
+    };
+  }
+});
+
+// src/providers/llm.ts
+var init_llm = __esm({
+  "src/providers/llm.ts"() {
+    init_openai_default();
+    init_registry();
   }
 });
 
@@ -9226,14 +9604,23 @@ function defaultComplete() {
       model: model2,
       fallbackModel: RUNNER_MODEL,
       helper: "agent runner",
-      call: (m) => client.chat.completions.create(
-        {
-          model: m,
-          ...chatCompletionParams(m, { ...temperature !== void 0 ? { temperature } : {}, reasoningEffort: "low" }),
-          messages,
-          ...tools.length ? { tools } : {}
-        },
-        { timeout: RUNNER_TIMEOUT_MS }
+      // With tools, a model that takes effort 'none' gets 'none' (OpenAI refuses tools at any other effort on chat
+      // completions for GPT-5.2 and later), and a reasoning_effort 400 is learned and retried once (burn-down G-45).
+      call: (m) => withReasoningEffortRetry(
+        { model: m, tools: tools.length > 0, requested: "low" },
+        () => client.chat.completions.create(
+          {
+            model: m,
+            ...chatCompletionParams(m, {
+              ...temperature !== void 0 ? { temperature } : {},
+              reasoningEffort: "low",
+              tools: tools.length > 0
+            }),
+            messages,
+            ...tools.length ? { tools } : {}
+          },
+          { timeout: RUNNER_TIMEOUT_MS }
+        )
       ),
       warn: graphWarn
     });
@@ -11984,6 +12371,9 @@ var MemoryClient = class {
     );
   }
 };
+
+// src/calls.ts
+init_src();
 var CallSchema = z.object({
   id: z.string(),
   projectId: z.string(),
@@ -12042,6 +12432,7 @@ z.object({
 });
 var CallStateSyncResponse = z.object({ ok: z.literal(true) }).or(z.object({}).passthrough());
 var DtmfEventResponse = z.object({ accepted: z.literal(true) }).or(z.object({}).passthrough());
+var CallFinalizeResponse = z.object({ ok: z.boolean() }).or(z.object({}).passthrough());
 var UsageReportResponse = z.object({ recorded: z.boolean() }).or(z.object({}).passthrough());
 var CallEventEnvelopeResponse = z.object({
   event: z.object({
@@ -12080,13 +12471,28 @@ var CallsClient = class {
           ...input.attributes !== void 0 ? { attributes: input.attributes } : {},
           ...input.participants !== void 0 ? { participants: input.participants } : {},
           ...input.legs !== void 0 ? { legs: input.legs } : {},
-          ...input.startedAt !== void 0 ? { startedAt: input.startedAt } : {}
+          ...input.startedAt !== void 0 ? { startedAt: input.startedAt } : {},
+          ...input.pipelineKeys !== void 0 ? { pipelineKeys: input.pipelineKeys } : {},
+          ...input.finalizes !== void 0 ? { finalizes: input.finalizes } : {}
         }
       },
       CallByRoomResponse
     );
     return call;
   }
+  /**
+   * The call's admission (burn-down G-41/G-42/G-43), asked once right after the caller joins and before the agent
+   * speaks: admitted with its duration limits, or refused with the end reason the platform recorded and the line to
+   * speak before hanging up. Throws on a transport / server error — the runtime retries, then refuses (fail closed).
+   */
+  async admit(input) {
+    return this.transport.request(
+      // The runtime owns the retries (bounded, then a polite refusal): a server error comes straight back, and one
+      // attempt never holds a caller longer than 2.5 s.
+      { method: "POST", path: "/v1/calls/admission", body: input, noRetryStatuses: [500, 502, 503, 504], signal: AbortSignal.timeout(2500) },
+      CallAdmissionResponse
+    );
+  }
   async syncState(callId, input) {
     await this.transport.request(
       {
@@ -12120,11 +12526,12 @@ var CallsClient = class {
   }
   // One-shot cascade usage report at session close — the platform prices it
   // into the call's bill (voice_components). Idempotent server-side.
-  async reportUsage(callId, report) {
+  async reportUsage(callId, report, opts = {}) {
     await this.transport.request(
       {
         method: "POST",
         path: `/v1/calls/${encodeURIComponent(callId)}/usage-report`,
+        ...opts.signal ? { signal: opts.signal } : {},
         body: {
           durationMs: report.durationMs,
           llm: report.llm,
@@ -12135,6 +12542,22 @@ var CallsClient = class {
       UsageReportResponse
     );
   }
+  /**
+   * The worker's last word on a call (burn-down G-20): what the call captured — every declared field — sent at the
+   * session's close after the worker's other writes for the call have landed. The API keeps the fields on the call
+   * and releases the call's held `call.ended` webhook. Idempotent.
+   */
+  async finalize(callId, input, opts = {}) {
+    await this.transport.request(
+      {
+        method: "POST",
+        path: `/v1/calls/${encodeURIComponent(callId)}/finalize`,
+        ...opts.signal ? { signal: opts.signal } : {},
+        body: { fields: input.fields }
+      },
+      CallFinalizeResponse
+    );
+  }
   async appendDtmfEvent(callId, input) {
     await this.transport.request(
       {
@@ -12850,7 +13273,7 @@ async function resolvePipeline(cfg, call, preloadedVad) {
     () => language.startsWith("en") ? livekitTurn.english() : livekitTurn.multilingual(),
     () => language.startsWith("en") ? livekitTurn.english() : livekitTurn.multilingual()
   ) : null;
-  const [stt, llm3, tts, vad] = await Promise.all([
+  const [stt, llm4, tts, vad] = await Promise.all([
     sttFactory2(call),
     llmFactory2(call),
     ttsFactory2(call),
@@ -12866,7 +13289,7 @@ async function resolvePipeline(cfg, call, preloadedVad) {
       });
     }
   }
-  return { stt, llm: llm3, tts, vad, turnDetector };
+  return { stt, llm: llm4, tts, vad, turnDetector };
 }
 var DEFAULT_REQUIRED_ENV = [
   "LIVEKIT_URL",
@@ -13304,6 +13727,38 @@ function buildRedisBrainPubSub(redisUrl) {
 // src/runtime/pipeline-from-config.ts
 init_providers2();
 init_registry();
+
+// src/runtime/pipeline-key-owner.ts
+var vaultKeyed = /* @__PURE__ */ new WeakSet();
+var isObject = (v) => v !== null && (typeof v === "object" || typeof v === "function");
+function vaultKeyedFactory(factory) {
+  return async (call) => {
+    const provider = await factory(call);
+    if (isObject(provider)) vaultKeyed.add(provider);
+    return provider;
+  };
+}
+function builtWithVaultKey(provider) {
+  return isObject(provider) && vaultKeyed.has(provider);
+}
+function providerLabel(provider) {
+  const label = isObject(provider) ? provider.provider : void 0;
+  return typeof label === "string" && label.length > 0 ? label : "unknown";
+}
+function pipelineKeys(pipeline, envKeyIsCustomers) {
+  const slot = (provider) => ({
+    provider: providerLabel(provider),
+    byok: builtWithVaultKey(provider) || envKeyIsCustomers
+  });
+  return {
+    ...pipeline.llm != null ? { llm: slot(pipeline.llm) } : {},
+    ...pipeline.stt != null ? { stt: slot(pipeline.stt) } : {},
+    ...pipeline.tts != null ? { tts: slot(pipeline.tts) } : {},
+    ...pipeline.realtime != null ? { realtime: slot(pipeline.realtime) } : {}
+  };
+}
+
+// src/runtime/pipeline-from-config.ts
 function modelsFromWireConfig(p, creds2) {
   const language = p.language ?? "en-US";
   if (p.mode === "realtime" && p.realtime) {
@@ -13317,17 +13772,20 @@ function modelsFromWireConfig(p, creds2) {
     out.tts = ttsFactory(p.voice.provider, p.voice.voiceId, p.voice.model, creds2?.[p.voice.provider]);
   return out;
 }
+function owned(factory, creds2) {
+  return creds2 ? vaultKeyedFactory(factory) : factory;
+}
 function realtimeFactory(r, creds2) {
-  return resolveRealtime(r.provider, { model: r.model, ...r.voice ? { voice: r.voice } : {}, ...creds2 ? { creds: creds2 } : {} });
+  return owned(resolveRealtime(r.provider, { model: r.model, ...r.voice ? { voice: r.voice } : {}, ...creds2 ? { creds: creds2 } : {} }), creds2);
 }
 function llmFactory(provider, model2, creds2) {
-  return resolveLlm(provider, { model: model2, ...creds2 ? { creds: creds2 } : {} });
+  return owned(resolveLlm(provider, { model: model2, ...creds2 ? { creds: creds2 } : {} }), creds2);
 }
 function sttFactory(provider, model2, language, creds2) {
-  return resolveStt(provider, { ...model2 ? { model: model2 } : {}, language, ...creds2 ? { creds: creds2 } : {} });
+  return owned(resolveStt(provider, { ...model2 ? { model: model2 } : {}, language, ...creds2 ? { creds: creds2 } : {} }), creds2);
 }
 function ttsFactory(provider, voiceId, model2, creds2) {
-  return resolveTts(provider, { voice: voiceId, ...model2 ? { model: model2 } : {}, ...creds2 ? { creds: creds2 } : {} });
+  return owned(resolveTts(provider, { voice: voiceId, ...model2 ? { model: model2 } : {}, ...creds2 ? { creds: creds2 } : {} }), creds2);
 }
 
 // src/agent.ts
@@ -15513,6 +15971,9 @@ function extractText2(msg) {
   const trimmed = txt.trim();
   return trimmed.length === 0 ? null : trimmed;
 }
+
+// src/runtime/handoff.ts
+init_src();
 function createHandoffRuntime(config, deps) {
   return {
     async handoff(to, opts) {
@@ -15661,7 +16122,9 @@ function buildDefaultSipOps(trunkOverride, fromNumber) {
         participantIdentity: identity,
         playDialtone: false,
         waitUntilAnswered: true,
-        ...fromNumber ? { fromNumber } : {}
+        ...fromNumber ? { fromNumber } : {},
+        // LiveKit's own ceiling on the transfer leg (burn-down G-43): it can't outlive the platform's longest call.
+        maxCallDuration: SIP_LEG_MAX_CALL_DURATION_SECONDS
       });
       return { identity };
     }
@@ -16185,16 +16648,16 @@ async function exchangeWorkerToken(input) {
   const internalToken = process.env["INTERNAL_SERVICE_TOKEN"];
   if (!apiUrl || !internalToken) return null;
   const delays = input.retryDelaysMs ?? EXCHANGE_RETRY_DELAYS_MS;
-  const deadline = Date.now() + (input.budgetMs ?? EXCHANGE_BUDGET_MS);
+  const deadline2 = Date.now() + (input.budgetMs ?? EXCHANGE_BUDGET_MS);
   for (let attempt = 0; ; attempt++) {
-    const left = deadline - Date.now();
+    const left = deadline2 - Date.now();
     if (left <= 0) return null;
     const r = await exchangeOnce(input, apiUrl, internalToken, Math.min(input.attemptTimeoutMs ?? EXCHANGE_ATTEMPT_TIMEOUT_MS, left));
     if ("token" in r) return r.token;
     if ("stale" in r) throw new StaleRouteError(r.stale);
     const base = delays[attempt];
     const wait = base === void 0 ? void 0 : Math.max(base, "retryAfterMs" in r && r.retryAfterMs !== void 0 ? r.retryAfterMs : 0);
-    if (r.final || wait === void 0 || Date.now() + wait >= deadline) return null;
+    if (r.final || wait === void 0 || Date.now() + wait >= deadline2) return null;
     await new Promise((resolve) => setTimeout(resolve, wait));
   }
 }
@@ -16330,7 +16793,7 @@ async function answerTextTurn(deps) {
   const { turn, config } = deps;
   const agentId = turn.agentId;
   const now = deps.now ?? Date.now;
-  const { voice: voice3, llm: llm3, initializeLogger, loggerOptions } = await import('@livekit/agents');
+  const { voice: voice3, llm: llm4, initializeLogger, loggerOptions } = await import('@livekit/agents');
   if (loggerOptions() === void 0) initializeLogger({ pretty: false, level: "warn" });
   let effective = config;
   let pipeline = null;
@@ -16372,7 +16835,7 @@ async function answerTextTurn(deps) {
     getCtx
   });
   const instructions = processRt.augmentPrompt(composeSystemPrompt(effective.prompt, effective.routingInstructions));
-  const chatCtx = llm3.ChatContext.empty();
+  const chatCtx = llm4.ChatContext.empty();
   let skipReply = false;
   for (const h of turn.history) {
     if (h.role === "user" && security && security.inputGuard.check(h.content).action === "block") {
@@ -16393,7 +16856,7 @@ async function answerTextTurn(deps) {
   );
   const brain = pipeline?.brain === "bound";
   const label = pipeline?.llm ?? { provider: "openai", model: model2.model };
-  const byok = pipeline ? pipeline.byokProviders.includes(label.provider) : false;
+  const byok = builtWithVaultKey(model2);
   const usage = brain ? [{ provider: "brain", model: model2.model || "brain", inputTokens: 0, outputTokens: 0, byok: true }] : [];
   const onMetrics = (m) => {
     if (brain) return;
@@ -17040,8 +17503,18 @@ function guardIsActive(opts) {
   return false;
 }
 
+// src/runtime/close-deadline.ts
+var CLOSE_REQUEST_TIMEOUT_MS = 5e3;
+function deadline(ms) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(new Error(`timed out after ${ms} ms`)), ms);
+  timer.unref?.();
+  return { signal: controller.signal, clear: () => clearTimeout(timer) };
+}
+
 // src/runtime/call-sync.ts
 var END_REASON_WAIT_MS = 2e3;
+var FINALIZE_WRITES_WAIT_MS = 3e3;
 function makeNoopHandle(callId) {
   return {
     callId,
@@ -17053,6 +17526,13 @@ function makeNoopHandle(callId) {
     publishDtmf() {
     },
     async recordEndReason() {
+    },
+    publishTurnLatency() {
+    },
+    track(write) {
+      return write;
+    },
+    async finalize() {
     }
   };
 }
@@ -17065,6 +17545,16 @@ async function createCallSyncHandle(init) {
     });
     return makeNoopHandle(init.call.callId);
   }
+  const inFlight = /* @__PURE__ */ new Set();
+  const track = (write) => {
+    const settled = write.then(
+      () => void 0,
+      () => void 0
+    );
+    inFlight.add(settled);
+    void settled.then(() => inFlight.delete(settled));
+    return write;
+  };
   return {
     callId,
     resolved: true,
@@ -17074,13 +17564,13 @@ async function createCallSyncHandle(init) {
         startMs,
         (input.endAt ?? input.at).getTime() - init.call.startedAt.getTime()
       );
-      void init.client.calls.appendTranscriptSegment(callId, {
+      void track(init.client.calls.appendTranscriptSegment(callId, {
         speaker: input.speaker,
         text: input.text,
         startMs,
         endMs,
         final: input.final
-      }).catch((err) => {
+      })).catch((err) => {
         console.warn("[sdk.call-sync] segment publish failed", {
           speaker: input.speaker,
           err: err instanceof Error ? err.message : err
@@ -17088,12 +17578,43 @@ async function createCallSyncHandle(init) {
       });
     },
     syncState(input) {
-      void init.client.calls.syncState(callId, input).catch((err) => {
+      void track(init.client.calls.syncState(callId, input)).catch((err) => {
         console.warn("[sdk.call-sync] state sync failed", {
           err: err instanceof Error ? err.message : err
         });
       });
     },
+    publishTurnLatency(payload) {
+      void track(init.client.calls.appendEvent(callId, { kind: "turn.latency", payload: { ...payload } })).catch((err) => {
+        console.warn("[sdk.call-sync] turn latency publish failed", {
+          turn: payload.turn,
+          err: err instanceof Error ? err.message : err
+        });
+      });
+    },
+    track,
+    async finalize(fields) {
+      let timer;
+      try {
+        await Promise.race([
+          Promise.all([...inFlight]),
+          new Promise((resolve) => {
+            timer = setTimeout(resolve, FINALIZE_WRITES_WAIT_MS);
+          })
+        ]);
+        clearTimeout(timer);
+        const limit = deadline(CLOSE_REQUEST_TIMEOUT_MS);
+        try {
+          await init.client.calls.finalize(callId, { fields: [...fields] }, { signal: limit.signal });
+        } finally {
+          limit.clear();
+        }
+      } catch (err) {
+        console.warn("[sdk.call-sync] finalize failed", { err: err instanceof Error ? err.message : err });
+      } finally {
+        clearTimeout(timer);
+      }
+    },
     async recordEndReason(reason) {
       let timer;
       try {
@@ -17113,7 +17634,7 @@ async function createCallSyncHandle(init) {
       }
     },
     publishDtmf(input) {
-      void init.client.calls.appendDtmfEvent(callId, input).catch((err) => {
+      void track(init.client.calls.appendDtmfEvent(callId, input)).catch((err) => {
         console.warn("[sdk.call-sync] dtmf publish failed", {
           direction: input.direction,
           digit: input.digit,
@@ -17138,7 +17659,10 @@ async function resolveCallIdWithRetry(init) {
         attributes: initialAttributes(init.call),
         participants: initialParticipants(init.call),
         legs: initialLegs(init.call, init.roomName),
-        startedAt: init.call.startedAt.toISOString()
+        startedAt: init.call.startedAt.toISOString(),
+        ...init.pipelineKeys ? { pipelineKeys: init.pipelineKeys } : {},
+        // this worker sends POST /v1/calls/:id/finalize at the close: the API holds call.ended for it (G-20)
+        finalizes: true
       });
       return summary.id;
     } catch {
@@ -17208,7 +17732,7 @@ function initialLegs(call, roomName) {
       startedAt
     }
   ];
-  if (destination) {
+  if (destination && call.metadata["direction"] !== "outbound") {
     legs.unshift({
       legKey: "primary-inbound",
       kind: "sip-inbound",
@@ -17228,28 +17752,29 @@ function looksLikeSipParticipant(value) {
 
 // src/runtime/metrics-bridge.ts
 init_dist2();
+var payerKey = (byok) => byok === void 0 ? "" : byok ? "byok" : "platform";
 var UsageAccumulator = class {
   llm = /* @__PURE__ */ new Map();
   tts = /* @__PURE__ */ new Map();
   stt = /* @__PURE__ */ new Map();
-  // `byok` keeps a line whose payer is known (the SDK's helper calls) apart from LiveKit's own line on the same model,
-  // which the API prices by the workspace's vault keys.
   addLlm(provider, model2, inputTokens, outputTokens, byok) {
-    const key = `${provider}:${model2}:${byok === void 0 ? "" : byok ? "byok" : "platform"}`;
+    const key = `${provider}:${model2}:${payerKey(byok)}`;
     const entry2 = this.llm.get(key) ?? { provider, model: model2, inputTokens: 0, outputTokens: 0, ...byok !== void 0 ? { byok } : {} };
     entry2.inputTokens += Math.max(0, inputTokens || 0);
     entry2.outputTokens += Math.max(0, outputTokens || 0);
     this.llm.set(key, entry2);
   }
-  addTts(provider, chars) {
-    const entry2 = this.tts.get(provider) ?? { provider, chars: 0 };
+  addTts(provider, chars, byok) {
+    const key = `${provider}:${payerKey(byok)}`;
+    const entry2 = this.tts.get(key) ?? { provider, chars: 0, ...byok !== void 0 ? { byok } : {} };
     entry2.chars += Math.max(0, chars || 0);
-    this.tts.set(provider, entry2);
+    this.tts.set(key, entry2);
   }
-  addStt(provider, seconds) {
-    const entry2 = this.stt.get(provider) ?? { provider, seconds: 0 };
+  addStt(provider, seconds, byok) {
+    const key = `${provider}:${payerKey(byok)}`;
+    const entry2 = this.stt.get(key) ?? { provider, seconds: 0, ...byok !== void 0 ? { byok } : {} };
     entry2.seconds += Math.max(0, seconds || 0);
-    this.stt.set(provider, entry2);
+    this.stt.set(key, entry2);
   }
   isEmpty() {
     return this.llm.size === 0 && this.tts.size === 0 && this.stt.size === 0;
@@ -17302,10 +17827,13 @@ function attachEndpointingProbe(session, events, ctx, deps) {
     });
     recordTurnLatencySpan({ ...base, stage: "endpointing", latencyMs: delayMs });
     recordTurnLatencySpan({ ...base, stage: "stt", latencyMs: delayMs });
+    ctx.turns?.note({ stage: "endpointing", latencyMs: delayMs });
+    ctx.turns?.note({ stage: "stt", latencyMs: delayMs });
   };
   deps.vad.onSpeechEnd((sample) => {
     if (!armed) return;
     speechEndAt = sample.speechEndAt;
+    ctx.turns?.noteSpeechEnd(sample.speechEndAt);
     tryEmit();
   });
   session.on(events.userStateChanged, (event) => {
@@ -17347,7 +17875,8 @@ function dispatch(metrics2, ctx) {
         provider,
         ...model2 ? { model: model2 } : {},
         inputTokens: m.promptTokens,
-        outputTokens: m.completionTokens
+        outputTokens: m.completionTokens,
+        ...ctx.keyOwner?.llm ? { byok: ctx.keyOwner.llm.byok } : {}
       });
       recordLlmUsage({
         ...base,
@@ -17363,6 +17892,7 @@ function dispatch(metrics2, ctx) {
       } else if (typeof m.ttftMs === "number" && m.ttftMs >= 0) {
         recordTurnLatency({ ...base, firstTokenMs: m.ttftMs });
         recordTurnLatencySpan({ ...base, stage: "llm", latencyMs: m.ttftMs });
+        ctx.turns?.note({ stage: "llm", latencyMs: m.ttftMs, startedAt: m.timestamp - Math.max(0, m.durationMs) });
       }
       break;
     }
@@ -17370,7 +17900,7 @@ function dispatch(metrics2, ctx) {
       const m = metrics2;
       const provider = m.metadata?.modelProvider ?? "unknown";
       const model2 = m.metadata?.modelName;
-      ctx.usage?.record({ kind: "tts", provider, chars: m.charactersCount });
+      ctx.usage?.record({ kind: "tts", provider, chars: m.charactersCount, ...ctx.keyOwner?.tts ? { byok: ctx.keyOwner.tts.byok } : {} });
       recordTtsUsage({
         ...base,
         provider,
@@ -17380,6 +17910,7 @@ function dispatch(metrics2, ctx) {
       if (typeof m.ttfbMs === "number" && m.ttfbMs >= 0) {
         recordTurnLatency({ ...base, ttsStartMs: m.ttfbMs });
         recordTurnLatencySpan({ ...base, stage: "tts", latencyMs: m.ttfbMs });
+        ctx.turns?.note({ stage: "tts", latencyMs: m.ttfbMs, startedAt: m.timestamp - Math.max(0, m.durationMs) });
       }
       break;
     }
@@ -17387,7 +17918,12 @@ function dispatch(metrics2, ctx) {
       const m = metrics2;
       const provider = m.metadata?.modelProvider ?? "unknown";
       const model2 = m.metadata?.modelName;
-      ctx.usage?.record({ kind: "stt", provider, seconds: (m.audioDurationMs ?? 0) / 1e3 });
+      ctx.usage?.record({
+        kind: "stt",
+        provider,
+        seconds: (m.audioDurationMs ?? 0) / 1e3,
+        ...ctx.keyOwner?.stt ? { byok: ctx.keyOwner.stt.byok } : {}
+      });
       recordSttUsage({
         ...base,
         provider,
@@ -17410,6 +17946,7 @@ function dispatch(metrics2, ctx) {
       if (typeof m.ttftMs === "number" && m.ttftMs >= 0) {
         recordTurnLatency({ ...base, firstTokenMs: m.ttftMs });
         recordTurnLatencySpan({ ...base, stage: "llm", latencyMs: m.ttftMs, realtime: true });
+        ctx.turns?.note({ stage: "llm", latencyMs: m.ttftMs, startedAt: m.timestamp, realtime: true });
       }
       if (typeof m.sessionDurationMs === "number" && m.sessionDurationMs > 0) {
         recordRealtimeSessionDuration({
@@ -17431,6 +17968,11 @@ function dispatch(metrics2, ctx) {
       });
       recordTurnLatencySpan({ ...base, stage: "endpointing", latencyMs: m.endOfUtteranceDelayMs });
       recordTurnLatencySpan({ ...base, stage: "stt", latencyMs: m.transcriptionDelayMs });
+      if (ctx.turns) {
+        if (m.endOfUtteranceDelayMs > 0) ctx.turns.note({ stage: "endpointing", latencyMs: m.endOfUtteranceDelayMs });
+        if (m.transcriptionDelayMs > 0) ctx.turns.note({ stage: "stt", latencyMs: m.transcriptionDelayMs });
+        if (m.lastSpeakingTimeMs > 0) ctx.turns.noteSpeechEnd(m.lastSpeakingTimeMs);
+      }
       break;
     }
     case "interruption_metrics": {
@@ -17468,10 +18010,10 @@ function createTelemetrySink(accumulator = new UsageAccumulator()) {
           );
           break;
         case "tts":
-          accumulator.addTts(sample.provider, sample.chars ?? 0);
+          accumulator.addTts(sample.provider, sample.chars ?? 0, sample.byok);
           break;
         case "stt":
-          accumulator.addStt(sample.provider, sample.seconds ?? 0);
+          accumulator.addStt(sample.provider, sample.seconds ?? 0, sample.byok);
           break;
       }
     },
@@ -17554,7 +18096,12 @@ async function reportUsageAtClose(opts) {
   try {
     await opts.meter.drain(opts.drainMs ?? HANGUP_DRAIN_MS);
     if (opts.usage.isEmpty()) return;
-    await opts.send(opts.usage.report(opts.durationMs));
+    const limit = deadline(CLOSE_REQUEST_TIMEOUT_MS);
+    try {
+      await opts.send(opts.usage.report(opts.durationMs), limit.signal);
+    } finally {
+      limit.clear();
+    }
   } catch (err) {
     opts.warn?.("[agent] usage report failed", { err: err instanceof Error ? err.message : String(err) });
   }
@@ -17603,6 +18150,7 @@ function attachTurnModelClock(session, events, ctx, deps = {}) {
     safely2(() => {
       recordTurnLatencySpan({ ...base, stage: "llm", latencyMs, allowZero: true });
       if (latencyMs > 0) recordTurnLatency({ ...base, firstTokenMs: latencyMs });
+      deps.turns?.note({ stage: "llm", latencyMs, replyAt: t.windowEnd });
     });
   };
   const releaseParked = () => {
@@ -17719,6 +18267,145 @@ function attachTurnModelClock(session, events, ctx, deps = {}) {
   };
 }
 
+// src/runtime/turn-latency.ts
+init_src();
+var MAX_TURN_LATENCY_EVENTS = TURN_LATENCY_MAX_PER_CALL;
+var MAX_STAGE_MS = 6e5;
+var noStages = () => ({ endpointingMs: null, sttMs: null, llmMs: null, ttsMs: null, realtime: false });
+function attachTurnLatencyRecorder(session, events, deps) {
+  const now = deps.now ?? Date.now;
+  const maxTurns = deps.maxTurns ?? MAX_TURN_LATENCY_EVENTS;
+  let waiting = null;
+  let open = null;
+  let turns = 0;
+  let lastReplyAt = -Infinity;
+  let lastSpeechEndAt = null;
+  let closed = false;
+  const ms = (v) => v === null || !Number.isFinite(v) || v < 0 || v > MAX_STAGE_MS ? null : Math.round(v);
+  const emit = (t) => {
+    const endpointingMs = ms(t.endpointingMs);
+    const llmMs = ms(t.llmMs);
+    const ttsMs = ms(t.ttsMs);
+    const measured = t.speechEndAt !== null ? ms(t.replyAt - t.speechEndAt) : null;
+    const summed = endpointingMs !== null && llmMs !== null && ttsMs !== null ? ms(endpointingMs + llmMs + ttsMs) : null;
+    try {
+      deps.emit({
+        turn: t.index,
+        atMs: Math.max(0, Math.round(t.replyAt - deps.callStartedAt)),
+        endpointingMs,
+        sttMs: ms(t.sttMs),
+        llmMs,
+        ttsMs,
+        endToEndMs: t.realtime ? llmMs : measured ?? summed,
+        ...t.realtime ? { realtime: true } : {}
+      });
+    } catch (err) {
+      console.warn("[agent] turn latency emit failed", { err: err instanceof Error ? err.message : String(err) });
+    }
+  };
+  const at = (event) => {
+    const t = event?.createdAt;
+    return typeof t === "number" ? t : now();
+  };
+  const targetFor = (s) => {
+    if (waiting && (s.startedAt === void 0 || s.startedAt >= waiting.firstFinalAt)) return waiting;
+    return open;
+  };
+  if (!deps.realtime) {
+    session.on(events.userInputTranscribed, (event) => {
+      if (closed || !event?.isFinal) return;
+      waiting ??= { ...noStages(), firstFinalAt: at(event) };
+    });
+    session.on(events.agentStateChanged, (event) => {
+      if (closed || event?.newState !== "speaking" || !waiting) return;
+      const replyAt = at(event);
+      if (open) emit(open);
+      open = null;
+      if (turns >= maxTurns) {
+        waiting = null;
+        return;
+      }
+      turns += 1;
+      const speechEndAt = lastSpeechEndAt !== null && lastSpeechEndAt > lastReplyAt && lastSpeechEndAt <= replyAt ? lastSpeechEndAt : null;
+      const { firstFinalAt: _first, ...stages } = waiting;
+      open = { ...stages, index: turns, replyAt, speechEndAt };
+      waiting = null;
+      lastReplyAt = replyAt;
+    });
+  }
+  return {
+    note(s) {
+      if (closed || !Number.isFinite(s.latencyMs) || s.latencyMs < 0) return;
+      if (deps.realtime) {
+        if (s.stage !== "llm" || turns >= maxTurns) return;
+        turns += 1;
+        emit({ ...noStages(), llmMs: s.latencyMs, realtime: true, index: turns, replyAt: (s.startedAt ?? now()) + s.latencyMs, speechEndAt: null });
+        return;
+      }
+      switch (s.stage) {
+        case "endpointing":
+        case "stt": {
+          const key = s.stage === "endpointing" ? "endpointingMs" : "sttMs";
+          if (waiting) waiting[key] = s.latencyMs;
+          else if (open && open[key] === null) open[key] = s.latencyMs;
+          return;
+        }
+        case "llm": {
+          if (s.replyAt !== void 0) {
+            if (open && open.replyAt === s.replyAt) open.llmMs = (open.llmMs ?? 0) + s.latencyMs;
+            return;
+          }
+          const t = targetFor(s);
+          if (t) t.llmMs = (t.llmMs ?? 0) + s.latencyMs;
+          return;
+        }
+        case "tts": {
+          const t = targetFor(s);
+          if (t && t.ttsMs === null) t.ttsMs = s.latencyMs;
+          return;
+        }
+      }
+    },
+    noteSpeechEnd(at2) {
+      if (Number.isFinite(at2) && at2 > 0) lastSpeechEndAt = at2;
+    },
+    close() {
+      if (closed) return;
+      closed = true;
+      if (open) emit(open);
+      open = null;
+      waiting = null;
+    }
+  };
+}
+
+// src/runtime/call-outcome.ts
+init_src();
+var cut = (s) => s.length > CAPTURED_STRING_MAX_CHARS ? s.slice(0, CAPTURED_STRING_MAX_CHARS) : s;
+function wireValue(value) {
+  if (value === void 0 || value === null) return null;
+  if (typeof value === "string") return value.trim().length === 0 ? null : cut(value);
+  if (typeof value === "number") return Number.isFinite(value) ? value : null;
+  if (typeof value === "boolean") return value;
+  if (value instanceof Date) return Number.isNaN(value.getTime()) ? null : value.toISOString();
+  if (Array.isArray(value)) {
+    const items = value.filter((v) => v !== void 0 && v !== null).map((v) => cut(typeof v === "string" ? v : JSON.stringify(v))).slice(0, CAPTURED_ARRAY_MAX_ITEMS);
+    return items.length === 0 ? null : items;
+  }
+  try {
+    return cut(JSON.stringify(value));
+  } catch {
+    return null;
+  }
+}
+function capturedFields(def, data) {
+  if (!def) return [];
+  return Object.entries(def.collect).filter(([name]) => name.length > 0 && name.length <= 64).slice(0, CAPTURED_FIELDS_MAX).map(([name, field]) => {
+    const value = wireValue(data[name]);
+    return { name, type: field.type, required: field.required === true, filled: value !== null, value };
+  });
+}
+
 // src/agent.ts
 init_model_meter();
 
@@ -17884,42 +18571,266 @@ function fieldSpecToField(spec) {
   if (spec.required !== void 0) field.required = spec.required;
   if (spec.pattern !== void 0) {
     try {
-      field.pattern = new RegExp(spec.pattern);
-    } catch {
+      field.pattern = new RegExp(spec.pattern);
+    } catch {
+    }
+  }
+  if (spec.min !== void 0) field.min = spec.min;
+  if (spec.max !== void 0) field.max = spec.max;
+  if (spec.enum !== void 0) field.enum = spec.enum;
+  if (spec.ask !== void 0) field.ask = spec.ask;
+  if (spec.extract !== void 0) field.extract = spec.extract;
+  return field;
+}
+function triggerSpecToDefinition(spec) {
+  const condition = conditionSpecToCondition(spec.on);
+  const action = actionSpecToAction(spec.then);
+  if (!condition || !action) return void 0;
+  return {
+    on: condition,
+    then: action,
+    ...spec.onlyWhile ? { onlyWhile: spec.onlyWhile } : {}
+  };
+}
+function conditionSpecToCondition(spec) {
+  if (spec.kind === "regex") {
+    try {
+      return new RegExp(spec.pattern, spec.flags);
+    } catch {
+      return void 0;
+    }
+  }
+  return `signal:${spec.name}`;
+}
+function actionSpecToAction(spec) {
+  if (spec.kind === "handoff") return "handoff";
+  if (spec.kind === "endCall") return "endCall";
+  if (spec.kind === "say") return { say: spec.text };
+  return void 0;
+}
+
+// src/runtime/call-admission.ts
+init_src();
+
+// src/end-call.ts
+var defaultClock = {
+  now: () => Date.now(),
+  setTimeout: (fn, ms) => setTimeout(fn, ms),
+  clearTimeout: (h) => clearTimeout(h)
+};
+var HOST_HANGUP_HOOK_LIMIT_MS = 2e3;
+var GUARANTEE_RETRY_MS = 1500;
+var GOODBYE_LIMIT_MS = 1e4;
+var DEFAULT_MAX_CALL_DURATION_MS = 36e5;
+function createEndCallController(deps) {
+  const clock = deps.clock ?? defaultClock;
+  const log = deps.log ?? (() => {
+  });
+  let ended = false;
+  let idleTimer = null;
+  let durationTimer = null;
+  let warnTimer = null;
+  const clearIdle = () => {
+    if (idleTimer !== null) {
+      clock.clearTimeout(idleTimer);
+      idleTimer = null;
+    }
+  };
+  const clearDuration = () => {
+    if (durationTimer !== null) {
+      clock.clearTimeout(durationTimer);
+      durationTimer = null;
+    }
+    if (warnTimer !== null) {
+      clock.clearTimeout(warnTimer);
+      warnTimer = null;
+    }
+  };
+  const sleep2 = (ms) => new Promise((resolve) => {
+    clock.setTimeout(resolve, ms);
+  });
+  const guarantee = async (teardown = deps.runTeardown) => {
+    if (deps.guaranteeMs === false) return;
+    const deadline2 = clock.now() + deps.guaranteeMs;
+    while (!deps.isEnded() && clock.now() < deadline2) {
+      await sleep2(Math.min(GUARANTEE_RETRY_MS, Math.max(0, deadline2 - clock.now())));
+      if (deps.isEnded()) return;
+      log("[agent] end-call teardown not confirmed; retrying", { teardown: deps.teardown });
+      try {
+        await teardown();
+      } catch (err) {
+        log("[agent] end-call retry teardown threw", { err: String(err) });
+      }
+    }
+  };
+  let hostHangup = null;
+  const hostHangUp = (reason) => {
+    if (deps.isEnded()) return Promise.resolve();
+    hostHangup ??= (async () => {
+      ended = true;
+      clearIdle();
+      clearDuration();
+      const info = { ...reason !== void 0 ? { reason } : {}, trigger: "host", teardown: "room" };
+      deps.emit?.(info);
+      log("[agent] hang up (host)", { reason });
+      if (deps.onEnd) {
+        let limit;
+        await Promise.race([
+          Promise.resolve().then(() => deps.onEnd(info)).catch((err) => log("[agent] endCall.onEnd threw on a host hangup", { err: String(err) })),
+          new Promise((resolve) => {
+            limit = clock.setTimeout(resolve, HOST_HANGUP_HOOK_LIMIT_MS);
+          })
+        ]).finally(() => clock.clearTimeout(limit));
+      }
+      const teardown = deps.runRoomTeardown ?? deps.runTeardown;
+      try {
+        await teardown();
+      } catch (err) {
+        log("[agent] host hangup teardown threw", { err: String(err) });
+      }
+      await guarantee(teardown);
+      if (!deps.isEnded()) hostHangup = null;
+    })();
+    return hostHangup;
+  };
+  const hangUp = async (opts) => {
+    if (opts?.trigger === "host") return hostHangUp(opts.reason);
+    if (ended) return;
+    ended = true;
+    clearIdle();
+    clearDuration();
+    const info = {
+      ...opts?.reason !== void 0 ? { reason: opts.reason } : {},
+      trigger: opts?.trigger ?? "user",
+      teardown: deps.teardown
+    };
+    deps.emit?.(info);
+    log("[agent] hang up", { trigger: info.trigger, teardown: info.teardown });
+    let suppress = false;
+    if (deps.onEnd) {
+      try {
+        suppress = await deps.onEnd(info) === false;
+      } catch (err) {
+        log("[agent] endCall.onEnd threw; running default teardown", { err: String(err) });
+      }
+    }
+    if (suppress) {
+      log("[agent] endCall.onEnd suppressed default teardown", { trigger: info.trigger });
+      return;
+    }
+    try {
+      await deps.runTeardown();
+    } catch (err) {
+      log("[agent] end-call teardown threw", { err: String(err) });
     }
-  }
-  if (spec.min !== void 0) field.min = spec.min;
-  if (spec.max !== void 0) field.max = spec.max;
-  if (spec.enum !== void 0) field.enum = spec.enum;
-  if (spec.ask !== void 0) field.ask = spec.ask;
-  if (spec.extract !== void 0) field.extract = spec.extract;
-  return field;
-}
-function triggerSpecToDefinition(spec) {
-  const condition = conditionSpecToCondition(spec.on);
-  const action = actionSpecToAction(spec.then);
-  if (!condition || !action) return void 0;
+    await guarantee();
+  };
   return {
-    on: condition,
-    then: action,
-    ...spec.onlyWhile ? { onlyWhile: spec.onlyWhile } : {}
+    hangUp,
+    armIdle() {
+      if (ended || deps.idleHangupMs === false) return;
+      clearIdle();
+      idleTimer = clock.setTimeout(() => {
+        idleTimer = null;
+        void hangUp({ trigger: "idle", reason: "no activity on the line" });
+      }, deps.idleHangupMs);
+    },
+    cancelIdle() {
+      clearIdle();
+    },
+    armDuration() {
+      if (ended || deps.maxCallDurationMs === false) return;
+      clearDuration();
+      const durationMs = deps.maxCallDurationMs ?? DEFAULT_MAX_CALL_DURATION_MS;
+      const wrapUp = deps.wrapUp;
+      if (wrapUp && wrapUp.warnBeforeMs > 0 && durationMs > wrapUp.warnBeforeMs) {
+        warnTimer = clock.setTimeout(() => {
+          warnTimer = null;
+          if (ended) return;
+          try {
+            void Promise.resolve(wrapUp.warn()).catch((err) => log("[agent] wrap-up line failed", { err: String(err) }));
+          } catch (err) {
+            log("[agent] wrap-up line failed", { err: String(err) });
+          }
+        }, durationMs - wrapUp.warnBeforeMs);
+      }
+      durationTimer = clock.setTimeout(() => {
+        durationTimer = null;
+        void (async () => {
+          if (wrapUp && !ended) {
+            let limit;
+            await Promise.race([
+              wrapUp.goodbye().catch((err) => log("[agent] goodbye line failed", { err: String(err) })),
+              new Promise((resolve) => {
+                limit = clock.setTimeout(resolve, GOODBYE_LIMIT_MS);
+              })
+            ]).finally(() => clock.clearTimeout(limit));
+          }
+          await hangUp({
+            trigger: "max_duration",
+            reason: `call exceeded the ${durationMs}ms duration ceiling`
+          });
+        })();
+      }, durationMs);
+    },
+    noteEngineClosed() {
+      if (ended) return;
+      log("[agent] realtime engine closed; guaranteeing teardown");
+      void hangUp({ trigger: "engine-closed", reason: "realtime engine closed" });
+    },
+    dispose() {
+      clearIdle();
+      clearDuration();
+    }
   };
 }
-function conditionSpecToCondition(spec) {
-  if (spec.kind === "regex") {
+
+// src/runtime/call-admission.ts
+var CALL_ADMISSION_RETRY_DELAYS_MS = [300, 1e3];
+var ADMISSION_UNAVAILABLE_END_REASON = `${INBOUND_REFUSED_END_REASON_PREFIX}gate_unavailable`;
+function notAVerdict(err) {
+  if (err instanceof VoiceLayerAuthError || err instanceof VoiceLayerValidationError) return true;
+  return err instanceof VoiceLayerHttpError && err.status >= 400 && err.status < 500 && err.status !== 408 && err.status !== 429;
+}
+async function requestCallAdmission(admit, req, opts = {}) {
+  if (!admit) return { kind: "admitted", limits: null };
+  const delays = opts.delaysMs ?? CALL_ADMISSION_RETRY_DELAYS_MS;
+  const sleep2 = opts.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+  const log = opts.log ?? ((msg, attrs2) => console.warn(msg, attrs2 ?? {}));
+  for (let attempt = 1; ; attempt++) {
     try {
-      return new RegExp(spec.pattern, spec.flags);
-    } catch {
-      return void 0;
+      const res = await admit(req);
+      return res.admitted ? { kind: "admitted", limits: res.limits } : { kind: "refused", endReason: res.endReason, message: res.message };
+    } catch (err) {
+      if (notAVerdict(err)) {
+        if (opts.platformWorker) {
+          log("[agent] call admission refused for this room on a platform worker; refusing the call (fail closed)", { err: String(err) });
+          return { kind: "refused", endReason: ADMISSION_UNAVAILABLE_END_REASON, message: INBOUND_REFUSED_MESSAGE };
+        }
+        log("[agent] call admission unavailable for this room; running on the agent settings", { err: String(err) });
+        return { kind: "admitted", limits: null };
+      }
+      if (attempt > delays.length) {
+        log("[agent] call admission failed after retries; refusing the call (fail closed)", { err: String(err), attempts: attempt });
+        return { kind: "refused", endReason: ADMISSION_UNAVAILABLE_END_REASON, message: INBOUND_REFUSED_MESSAGE };
+      }
+      await sleep2(delays[attempt - 1]);
     }
   }
-  return `signal:${spec.name}`;
 }
-function actionSpecToAction(spec) {
-  if (spec.kind === "handoff") return "handoff";
-  if (spec.kind === "endCall") return "endCall";
-  if (spec.kind === "say") return { say: spec.text };
-  return void 0;
+function effectiveMaxCallDurationMs(code, limits) {
+  if (!limits) return code === void 0 ? DEFAULT_MAX_CALL_DURATION_MS : code;
+  const ceiling = limits.ceilingSeconds * 1e3;
+  const base = limits.agentMaxSeconds !== null ? limits.agentMaxSeconds * 1e3 : code === void 0 ? DEFAULT_MAX_CALL_DURATION_MS : code;
+  return base === false ? ceiling : Math.min(base, ceiling);
+}
+async function playAdmissionRefusal(verdict, deps) {
+  try {
+    await deps.say(verdict.message, { allowInterruptions: false });
+  } catch (err) {
+    (deps.log ?? ((m, a) => console.warn(m, a ?? {})))("[agent] admission refusal line failed to play", { err: String(err) });
+  }
+  await deps.hangUp(verdict.endReason);
 }
 init_src();
 var AskHostInput = z.object({
@@ -18471,7 +19382,7 @@ function asText(value) {
 function masked(value) {
   return maskPii(asText(value).slice(0, READ_CAP));
 }
-var cut = (text, cap) => text.length > cap ? `${text.slice(0, cap)}\u2026` : text;
+var cut2 = (text, cap) => text.length > cap ? `${text.slice(0, cap)}\u2026` : text;
 function toolAuditPayload(r) {
   const args = masked(r.params);
   const result = r.ok ? masked(r.result) : void 0;
@@ -18480,11 +19391,11 @@ function toolAuditPayload(r) {
     const payload = {
       invocationId: r.invocationId,
       toolName: r.toolName,
-      args: cut(args, cap),
-      ...result !== void 0 ? { result: cut(result, cap) } : {},
+      args: cut2(args, cap),
+      ...result !== void 0 ? { result: cut2(result, cap) } : {},
       ok: r.ok,
       blocked: r.blocked,
-      ...error !== void 0 ? { errorMessage: cut(error, Math.min(cap, 300)) } : {},
+      ...error !== void 0 ? { errorMessage: cut2(error, Math.min(cap, 300)) } : {},
       startedAt: r.startedAt.toISOString(),
       durationMs: r.durationMs,
       // the tool got the caller's values in place of the call's PII tokens (G-33): how many and where — never a value
@@ -18504,151 +19415,8 @@ function toolAuditObserver(emit) {
   };
 }
 
-// src/end-call.ts
-var defaultClock = {
-  now: () => Date.now(),
-  setTimeout: (fn, ms) => setTimeout(fn, ms),
-  clearTimeout: (h) => clearTimeout(h)
-};
-var HOST_HANGUP_HOOK_LIMIT_MS = 2e3;
-var GUARANTEE_RETRY_MS = 1500;
-var DEFAULT_MAX_CALL_DURATION_MS = 36e5;
-function createEndCallController(deps) {
-  const clock = deps.clock ?? defaultClock;
-  const log = deps.log ?? (() => {
-  });
-  let ended = false;
-  let idleTimer = null;
-  let durationTimer = null;
-  const clearIdle = () => {
-    if (idleTimer !== null) {
-      clock.clearTimeout(idleTimer);
-      idleTimer = null;
-    }
-  };
-  const clearDuration = () => {
-    if (durationTimer !== null) {
-      clock.clearTimeout(durationTimer);
-      durationTimer = null;
-    }
-  };
-  const sleep2 = (ms) => new Promise((resolve) => {
-    clock.setTimeout(resolve, ms);
-  });
-  const guarantee = async (teardown = deps.runTeardown) => {
-    if (deps.guaranteeMs === false) return;
-    const deadline = clock.now() + deps.guaranteeMs;
-    while (!deps.isEnded() && clock.now() < deadline) {
-      await sleep2(Math.min(GUARANTEE_RETRY_MS, Math.max(0, deadline - clock.now())));
-      if (deps.isEnded()) return;
-      log("[agent] end-call teardown not confirmed; retrying", { teardown: deps.teardown });
-      try {
-        await teardown();
-      } catch (err) {
-        log("[agent] end-call retry teardown threw", { err: String(err) });
-      }
-    }
-  };
-  let hostHangup = null;
-  const hostHangUp = (reason) => {
-    if (deps.isEnded()) return Promise.resolve();
-    hostHangup ??= (async () => {
-      ended = true;
-      clearIdle();
-      clearDuration();
-      const info = { ...reason !== void 0 ? { reason } : {}, trigger: "host", teardown: "room" };
-      deps.emit?.(info);
-      log("[agent] hang up (host)", { reason });
-      if (deps.onEnd) {
-        let limit;
-        await Promise.race([
-          Promise.resolve().then(() => deps.onEnd(info)).catch((err) => log("[agent] endCall.onEnd threw on a host hangup", { err: String(err) })),
-          new Promise((resolve) => {
-            limit = clock.setTimeout(resolve, HOST_HANGUP_HOOK_LIMIT_MS);
-          })
-        ]).finally(() => clock.clearTimeout(limit));
-      }
-      const teardown = deps.runRoomTeardown ?? deps.runTeardown;
-      try {
-        await teardown();
-      } catch (err) {
-        log("[agent] host hangup teardown threw", { err: String(err) });
-      }
-      await guarantee(teardown);
-      if (!deps.isEnded()) hostHangup = null;
-    })();
-    return hostHangup;
-  };
-  const hangUp = async (opts) => {
-    if (opts?.trigger === "host") return hostHangUp(opts.reason);
-    if (ended) return;
-    ended = true;
-    clearIdle();
-    clearDuration();
-    const info = {
-      ...opts?.reason !== void 0 ? { reason: opts.reason } : {},
-      trigger: opts?.trigger ?? "user",
-      teardown: deps.teardown
-    };
-    deps.emit?.(info);
-    log("[agent] hang up", { trigger: info.trigger, teardown: info.teardown });
-    let suppress = false;
-    if (deps.onEnd) {
-      try {
-        suppress = await deps.onEnd(info) === false;
-      } catch (err) {
-        log("[agent] endCall.onEnd threw; running default teardown", { err: String(err) });
-      }
-    }
-    if (suppress) {
-      log("[agent] endCall.onEnd suppressed default teardown", { trigger: info.trigger });
-      return;
-    }
-    try {
-      await deps.runTeardown();
-    } catch (err) {
-      log("[agent] end-call teardown threw", { err: String(err) });
-    }
-    await guarantee();
-  };
-  return {
-    hangUp,
-    armIdle() {
-      if (ended || deps.idleHangupMs === false) return;
-      clearIdle();
-      idleTimer = clock.setTimeout(() => {
-        idleTimer = null;
-        void hangUp({ trigger: "idle", reason: "no activity on the line" });
-      }, deps.idleHangupMs);
-    },
-    cancelIdle() {
-      clearIdle();
-    },
-    armDuration() {
-      if (ended || deps.maxCallDurationMs === false) return;
-      clearDuration();
-      const durationMs = deps.maxCallDurationMs ?? DEFAULT_MAX_CALL_DURATION_MS;
-      durationTimer = clock.setTimeout(() => {
-        durationTimer = null;
-        void hangUp({
-          trigger: "max_duration",
-          reason: `call exceeded the ${durationMs}ms duration ceiling`
-        });
-      }, durationMs);
-    },
-    noteEngineClosed() {
-      if (ended) return;
-      log("[agent] realtime engine closed; guaranteeing teardown");
-      void hangUp({ trigger: "engine-closed", reason: "realtime engine closed" });
-    },
-    dispose() {
-      clearIdle();
-      clearDuration();
-    }
-  };
-}
-
 // src/agent.ts
+init_resilient_llm();
 init_helper_models();
 var FLOW_HANGUP_GRACE_MS = Number(process.env["VL_FLOW_HANGUP_GRACE_MS"] ?? "1200");
 function isLiveKitChildProcess() {
@@ -18962,6 +19730,7 @@ var Agent = class {
     const built = await resolveCallPipeline(effectiveConfig.models ?? {}, callInfo, job.proc.userData.vad);
     const pipeline = built.pipeline;
     if (built.failure && !flowBootFailure) flowBootFailure = built.failure;
+    const keyOwner = pipelineKeys(pipeline, callCredential?.source !== "worker-token");
     const vadTap = tapVad(pipeline.vad, { endOfSpeechType: VADEventType.END_OF_SPEECH });
     const usingRealtime = pipeline.realtime != null;
     let runtimeLlm = usingRealtime ? pipeline.realtime : pipeline.llm;
@@ -18974,11 +19743,15 @@ var Agent = class {
     seedCallPrefill(processRt, dispatchMdEarly);
     await seedProjectVariables(processRt, callCredential);
     let opEventCallId = null;
+    let trackWrite = (write) => write;
     const emitOpEvent = (kind, payload) => {
       if (!sdkClient || !opEventCallId) return;
-      void sdkClient.calls.appendEvent(opEventCallId, { kind, payload }).catch(() => {
+      void trackWrite(sdkClient.calls.appendEvent(opEventCallId, { kind, payload })).catch(() => {
       });
     };
+    if (isResilientLLM(pipeline.llm)) {
+      pipeline.llm.onIncident((incident) => emitOpEvent(`engine.llm.${incident.kind}`, { ...incident }));
+    }
     const graphEvents = graphMode ? withOpEventFanout(createGraphEvents(processRt), emitOpEvent) : null;
     const isOutbound = stringValue(dispatchMdEarly["direction"]) === "outbound";
     const perCallAmd = stringValue(dispatchMdEarly["amd"]);
@@ -19003,8 +19776,23 @@ var Agent = class {
     const callSync = await createCallSyncHandle({
       client: sdkClient,
       roomName: job.room.name ?? `room-${job.job?.id ?? "unknown"}`,
-      call: callInfo
+      call: callInfo,
+      pipelineKeys: keyOwner
     });
+    trackWrite = callSync.track;
+    const callerIsPhone = isSipParticipant2(participant);
+    const callAdmission = await requestCallAdmission(
+      sdkClient ? (req) => sdkClient.calls.admit(req) : null,
+      {
+        roomName: job.room.name ?? `room-${job.job?.id ?? "unknown"}`,
+        ...stringValue(callInfo.metadata["agentId"]) ? { agentId: stringValue(callInfo.metadata["agentId"]) } : {},
+        ...stringValue(callInfo.metadata["phoneNumberId"]) ? { phoneNumberId: stringValue(callInfo.metadata["phoneNumberId"]) } : {},
+        caller: { channel: callerIsPhone ? "phone" : "web", number: callerIsPhone ? callInfo.callerId : null }
+      },
+      // our pool's per-call worker token: no "no verdict" — a missing row is a refusal, never an unbilled call
+      { platformWorker: callCredential?.source === "worker-token" }
+    );
+    const admissionLimits = callAdmission.kind === "admitted" ? callAdmission.limits : null;
     const transcriptLines = [];
     const transcript = createTranscriptHandle(() => transcriptLines);
     const ctxRef = { current: null };
@@ -19136,7 +19924,8 @@ ${callIntent}`
     const endCallTeardown = endCallPolicy.teardown ?? "room";
     const endCallGuaranteeMs = endCallPolicy.guaranteeMs === void 0 ? 4e3 : endCallPolicy.guaranteeMs;
     const endCallIdleMs = endCallPolicy.idleHangupMs === void 0 ? 2e4 : endCallPolicy.idleHangupMs;
-    const endCallMaxDurationMs = endCallPolicy.maxCallDurationMs === void 0 ? DEFAULT_MAX_CALL_DURATION_MS : endCallPolicy.maxCallDurationMs;
+    const endCallMaxDurationMs = effectiveMaxCallDurationMs(endCallPolicy.maxCallDurationMs, admissionLimits);
+    const lineRef = { say: null };
     const endCallRoomName = job.room.name ?? `room-${job.job?.id ?? "unknown"}`;
     const localDisconnect = async () => {
       try {
@@ -19149,6 +19938,17 @@ ${callIntent}`
       guaranteeMs: endCallGuaranteeMs,
       idleHangupMs: endCallIdleMs,
       maxCallDurationMs: endCallMaxDurationMs,
+      ...admissionLimits ? {
+        wrapUp: {
+          warnBeforeMs: admissionLimits.wrapUpWarningSeconds * 1e3,
+          warn: () => lineRef.say?.(admissionLimits.wrapUpMessage),
+          goodbye: async () => {
+            const reported = callSync.recordEndReason("max_duration");
+            await lineRef.say?.(admissionLimits.goodbyeMessage);
+            await reported;
+          }
+        }
+      } : {},
       // 'room' deletes the whole LK room (drops the SIP/PSTN leg → carrier BYE);
       // 'agent' only disconnects the agent participant.
       runTeardown: endCallTeardown === "room" ? () => endRoomBestEffort(endCallRoomName, localDisconnect) : localDisconnect,
@@ -19187,6 +19987,7 @@ ${callIntent}`
       }
     });
     const session = adapter.raw.session;
+    lineRef.say = (text) => adapter.say(text, { allowInterruptions: false });
     sessionRef.current = session;
     const handoffRt = createHandoffRuntime(effectiveConfig.handoff, {
       session,
@@ -19423,6 +20224,7 @@ ${callIntent}`
       })
     });
     let usageReported = Promise.resolve();
+    let finalized = Promise.resolve();
     session.once(Events.Close, () => {
       sessionClosed = true;
       endCallController.dispose();
@@ -19440,7 +20242,7 @@ ${callIntent}`
           meter: modelMeter,
           usage: usageSink,
           durationMs: outcome.durationMs,
-          send: (report) => calls.reportUsage(callSync.callId, report),
+          send: (report, signal) => calls.reportUsage(callSync.callId, report, { signal }),
           warn: (message, meta) => console.warn(message, { callId: callSync.callId, ...meta })
         });
       }
@@ -19580,6 +20382,11 @@ ${callIntent}`
       callId: callSync.callId,
       ...callCampaignId ? { campaignId: callCampaignId } : {}
     };
+    const turnLatency = attachTurnLatencyRecorder(
+      session,
+      { userInputTranscribed: Events.UserInputTranscribed, agentStateChanged: Events.AgentStateChanged },
+      { callStartedAt: callInfo.startedAt.getTime(), emit: (payload) => callSync.publishTurnLatency(payload), realtime: usingRealtime }
+    );
     const modelClock = graphMode && !usingRealtime ? attachTurnModelClock(
       session,
       {
@@ -19588,13 +20395,26 @@ ${callIntent}`
         agentStateChanged: Events.AgentStateChanged,
         speechCreated: Events.SpeechCreated
       },
-      metricsCtx
+      metricsCtx,
+      { turns: turnLatency }
     ) : void 0;
     if (modelClock) session.once(Events.Close, () => modelClock.close());
+    session.once(Events.Close, () => {
+      turnLatency.close();
+      finalized = (async () => {
+        await modelMeter.drain(HANGUP_DRAIN_MS);
+        await new Promise((resolve) => setImmediate(resolve));
+        await callSync.finalize(capturedFields(effectiveConfig.process, processRt.getData()));
+      })().catch((err) => {
+        console.warn("[agent] finalize failed", { callId: callSync.callId, err: err instanceof Error ? err.message : String(err) });
+      });
+    });
     modelMeter.bind(metricsCtx, modelClock);
     attachMetricsBridge(session, Events.MetricsCollected, {
       ...metricsCtx,
       usage: usageSink,
+      keyOwner,
+      turns: turnLatency,
       ...modelClock ? { modelClock } : {}
     });
     if (graphMode) {
@@ -19604,7 +20424,7 @@ ${callIntent}`
           userStateChanged: Events.UserStateChanged,
           userInputTranscribed: Events.UserInputTranscribed
         },
-        metricsCtx,
+        { ...metricsCtx, turns: turnLatency },
         { vad: vadTap }
       );
     }
@@ -19667,11 +20487,11 @@ ${callIntent}`
         room: job.room.name ?? null,
         participant: participant.identity
       });
-      endCallController.armDuration();
+      if (callAdmission.kind !== "refused") endCallController.armDuration();
       {
         const announceMd = parseJobMetadata(job.job?.metadata);
         const announcement = stringValue(announceMd["recordingAnnouncement"]);
-        if (announcement) {
+        if (announcement && callAdmission.kind !== "refused") {
           try {
             await adapter.say(announcement, { allowInterruptions: false });
           } catch (err) {
@@ -19679,7 +20499,13 @@ ${callIntent}`
           }
         }
       }
-      if (puppetOwnsOpening(this.config.puppetMode, flowBootFailure)) {
+      if (callAdmission.kind === "refused") {
+        console.warn("[agent] call refused at admission", { room: job.room.name ?? null, endReason: callAdmission.endReason });
+        await playAdmissionRefusal(callAdmission, {
+          say: (text, opts) => adapter.say(text, opts),
+          hangUp: (reason) => endCallController.hangUp({ trigger: "admission", reason })
+        });
+      } else if (puppetOwnsOpening(this.config.puppetMode, flowBootFailure)) {
         const dispatchMd = parseJobMetadata(job.job?.metadata);
         const initialDirective = stringValue(dispatchMd["initialDirective"]);
         if (initialDirective) {
@@ -19771,6 +20597,7 @@ ${callIntent}`
       }
       await waitForSessionClose;
       await usageReported;
+      await finalized;
     } catch (err) {
       console.error("[agent] runJob failed", {
         room: job.room.name ?? null,
@@ -19880,7 +20707,7 @@ function sharedBrainPubSub() {
 async function applyStoredPipeline(client, agentId, base, codeMode) {
   try {
     const stored = await client.agents.getConfig(agentId);
-    if (!stored) return { config: base, brain: "none", byokProviders: [] };
+    if (!stored) return { config: base, brain: "none" };
     const mode = codeMode ?? stored.mode;
     const providers = /* @__PURE__ */ new Set();
     if (mode === "realtime" && stored.realtime) {
@@ -19955,7 +20782,6 @@ async function applyStoredPipeline(client, agentId, base, codeMode) {
         models: { ...base.models ?? {}, ...mapped, ...brainLlm ? { llm: brainLlm } : {} }
       },
       brain: brainLlm ? "bound" : brainConnectorId && mode !== "realtime" ? "unreachable" : "none",
-      byokProviders: Object.keys(creds2),
       ...mode !== "realtime" && stored.model ? { llm: { provider: stored.model.provider, model: stored.model.model } } : {}
     };
   } catch (err) {
@@ -19963,7 +20789,7 @@ async function applyStoredPipeline(client, agentId, base, codeMode) {
       agentId,
       err: err instanceof Error ? err.message : String(err)
     });
-    return { config: base, brain: "unknown", byokProviders: [] };
+    return { config: base, brain: "unknown" };
   }
 }
 function firstString(...values) {