@voicelayer/sdk 0.6.0 → 0.6.2

package/dist/index.js

@@ -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();
   }
 });
 
@@ -4675,10 +4686,86 @@ var init_dist = __esm({
     init_chat_params();
   }
 });
+function runWithModelMeter(listener, fn) {
+  return meterScope.run(listener, fn);
+}
+function requestedModel(body) {
+  const model2 = body?.model;
+  return typeof model2 === "string" && model2 ? model2 : void 0;
+}
+function safely(fn) {
+  try {
+    fn();
+  } catch (err) {
+    console.warn("[voicelayer] model meter listener failed", { err: err instanceof Error ? err.message : String(err) });
+  }
+}
+function metered(target, create, byok) {
+  return async (...args) => {
+    const listener = meterScope.getStore();
+    const startedAt = Date.now();
+    const model2 = requestedModel(args[0]);
+    if (listener) safely(() => listener.started());
+    let res;
+    try {
+      res = await Reflect.apply(create, target, args);
+      return res;
+    } finally {
+      if (listener) {
+        const usage = res?.usage;
+        const record = {
+          provider: "openai",
+          model: model2 ?? res?.model ?? "unknown",
+          ...usage ? { usage: { inputTokens: usage.prompt_tokens ?? 0, outputTokens: usage.completion_tokens ?? 0 } } : {},
+          ...byok !== void 0 ? { byok } : {},
+          startedAt,
+          endedAt: Date.now()
+        };
+        safely(() => listener.finished(record));
+      }
+    }
+  };
+}
+function meteredClient(client, byok) {
+  const hit = wrapped.get(client);
+  if (hit) return hit;
+  const chat = client.chat;
+  const embeddings = client.embeddings;
+  const completionsCreate = chat ? metered(chat.completions, chat.completions.create, byok) : void 0;
+  const embeddingsCreate = embeddings ? metered(embeddings, embeddings.create, byok) : void 0;
+  const completions = chat ? new Proxy(chat.completions, { get: (t, p, r) => p === "create" ? completionsCreate : Reflect.get(t, p, r) }) : void 0;
+  const chatProxy = chat ? new Proxy(chat, { get: (t, p, r) => p === "completions" ? completions : Reflect.get(t, p, r) }) : void 0;
+  const embeddingsProxy = embeddings ? new Proxy(embeddings, { get: (t, p, r) => p === "create" ? embeddingsCreate : Reflect.get(t, p, r) }) : void 0;
+  const proxy = new Proxy(client, {
+    get(target, prop, receiver) {
+      if (prop === "chat" && chatProxy) return chatProxy;
+      if (prop === "embeddings" && embeddingsProxy) return embeddingsProxy;
+      return Reflect.get(target, prop, receiver);
+    }
+  });
+  wrapped.set(client, proxy);
+  wrapped.set(proxy, proxy);
+  return proxy;
+}
+var meterScope, wrapped;
+var init_model_meter = __esm({
+  "src/runtime/model-meter.ts"() {
+    meterScope = new AsyncLocalStorage();
+    wrapped = /* @__PURE__ */ new WeakMap();
+  }
+});
 function configureDefaultOpenAI(cred) {
   credential = cred;
   cached = null;
 }
+function configureHelperCallCredential(source) {
+  callCredentialSource = source;
+  cached = null;
+}
+function helperKeyIsCustomers() {
+  if (credential) return true;
+  return callCredentialSource !== "worker-token";
+}
 function defaultOpenAIOptions() {
   if (!credential) return {};
   return {
@@ -4686,27 +4773,31 @@ function defaultOpenAIOptions() {
     ...credential.baseURL ? { baseURL: credential.baseURL } : {}
   };
 }
-function internalChatClient(opts) {
+function internalChatClient() {
   const cred = defaultOpenAIOptions();
   return createChatClient({
     ...cred.apiKey ? { apiKey: cred.apiKey } : {},
-    ...cred.baseURL ? { baseURL: cred.baseURL } : {},
-    ...opts?.timeoutMs ? { timeoutMs: opts.timeoutMs } : {}
+    ...cred.baseURL ? { baseURL: cred.baseURL } : {}
   });
 }
 function defaultOpenAI() {
-  return scope.getStore() ?? (cached ??= internalChatClient());
+  const scoped = scope.getStore();
+  if (scoped) return meteredClient(scoped);
+  if (!cached) cached = meteredClient(internalChatClient(), helperKeyIsCustomers());
+  return cached;
 }
 function hasOpenAiKey() {
   return scope.getStore() !== void 0 || credential !== null || Boolean(process.env["OPENAI_API_KEY"]);
 }
-var credential, cached, scope;
+var credential, cached, scope, callCredentialSource;
 var init_openai_default = __esm({
   "src/runtime/openai-default.ts"() {
     init_dist();
+    init_model_meter();
     credential = null;
     cached = null;
     scope = new AsyncLocalStorage();
+    callCredentialSource = null;
   }
 });
 function ipv4Parts(ip) {
@@ -5743,7 +5834,9 @@ var init_metrics = __esm({
   }
 });
 function recordTurnLatencySpan(args) {
-  if (!Number.isFinite(args.latencyMs) || args.latencyMs <= 0)
+  if (!Number.isFinite(args.latencyMs) || args.latencyMs < 0)
+    return;
+  if (args.latencyMs === 0 && !args.allowZero)
     return;
   const attributes = {
     [ATTR.projectId]: args.projectId,
@@ -9137,19 +9230,22 @@ function parseArgs(raw) {
 }
 function defaultComplete() {
   if (!hasOpenAiKey()) return null;
-  const client = internalChatClient({ timeoutMs: RUNNER_TIMEOUT_MS });
   return async ({ model: model2, temperature, messages, tools }) => {
+    const client = defaultOpenAI();
     const res = await withHelperModelFallback({
       client,
       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 } : {}
-      }),
+      call: (m) => client.chat.completions.create(
+        {
+          model: m,
+          ...chatCompletionParams(m, { ...temperature !== void 0 ? { temperature } : {}, reasoningEffort: "low" }),
+          messages,
+          ...tools.length ? { tools } : {}
+        },
+        { timeout: RUNNER_TIMEOUT_MS }
+      ),
       warn: graphWarn
     });
     const msg = res.choices[0]?.message;
@@ -11899,6 +11995,9 @@ var MemoryClient = class {
     );
   }
 };
+
+// src/calls.ts
+init_src();
 var CallSchema = z.object({
   id: z.string(),
   projectId: z.string(),
@@ -11957,6 +12056,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({
@@ -11995,13 +12095,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(
       {
@@ -12035,11 +12150,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,
@@ -12050,6 +12166,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(
       {
@@ -13219,6 +13351,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) {
@@ -13232,17 +13396,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
@@ -15428,6 +15595,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) {
@@ -15576,7 +15746,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 };
     }
@@ -16100,16 +16272,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));
   }
 }
@@ -16308,7 +16480,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;
@@ -16955,8 +17127,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,
@@ -16968,6 +17150,13 @@ function makeNoopHandle(callId) {
     publishDtmf() {
     },
     async recordEndReason() {
+    },
+    publishTurnLatency() {
+    },
+    track(write) {
+      return write;
+    },
+    async finalize() {
     }
   };
 }
@@ -16980,6 +17169,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,
@@ -16989,13 +17188,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
@@ -17003,12 +17202,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 {
@@ -17028,7 +17258,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,
@@ -17053,7 +17283,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 {
@@ -17123,7 +17356,7 @@ function initialLegs(call, roomName) {
       startedAt
     }
   ];
-  if (destination) {
+  if (destination && call.metadata["direction"] !== "outbound") {
     legs.unshift({
       legKey: "primary-inbound",
       kind: "sip-inbound",
@@ -17143,26 +17376,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();
-  addLlm(provider, model2, inputTokens, outputTokens) {
-    const key = `${provider}:${model2}`;
-    const entry2 = this.llm.get(key) ?? { provider, model: model2, inputTokens: 0, outputTokens: 0 };
+  addLlm(provider, model2, inputTokens, outputTokens, byok) {
+    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;
@@ -17215,10 +17451,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) => {
@@ -17260,7 +17499,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,
@@ -17269,9 +17509,14 @@ function dispatch(metrics2, ctx) {
         inputTokens: m.promptTokens,
         outputTokens: m.completionTokens
       });
-      if (typeof m.ttftMs === "number" && m.ttftMs >= 0) {
+      if (ctx.modelClock) {
+        const startAt = m.timestamp - Math.max(0, m.durationMs);
+        const waitedMs = typeof m.ttftMs === "number" && m.ttftMs >= 0 ? m.ttftMs : Math.max(0, m.durationMs);
+        ctx.modelClock.noteReplyModelTime({ startAt, endAt: startAt + waitedMs });
+      } 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;
     }
@@ -17279,7 +17524,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,
@@ -17289,6 +17534,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;
     }
@@ -17296,7 +17542,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,
@@ -17319,6 +17570,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({
@@ -17340,6 +17592,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": {
@@ -17372,14 +17629,15 @@ function createTelemetrySink(accumulator = new UsageAccumulator()) {
             sample.provider,
             sample.model ?? "unknown",
             sample.inputTokens ?? 0,
-            sample.outputTokens ?? 0
+            sample.outputTokens ?? 0,
+            sample.byok
           );
           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;
       }
     },
@@ -17392,84 +17650,467 @@ function createTelemetrySink(accumulator = new UsageAccumulator()) {
   };
 }
 
-// src/runtime/vad-tap.ts
-function tapVad(vad, opts) {
-  const listeners = /* @__PURE__ */ new Set();
-  const now = opts.now ?? Date.now;
-  const target = vad;
-  if (!target || typeof target.stream !== "function") {
-    return { onSpeechEnd: () => () => {
-    } };
-  }
-  const originalStream = target.stream.bind(target);
-  target.stream = () => {
-    const stream = originalStream();
-    const originalNext = stream.next.bind(stream);
-    stream.next = async () => {
-      const result = await originalNext();
-      try {
-        const event = result.value;
-        if (!result.done && event && event.type === opts.endOfSpeechType) {
-          const silenceMs = numberOr(event.silenceDuration, 0);
-          const inferenceMs = numberOr(event.inferenceDuration, 0);
-          const sample = {
-            speechEndAt: now() - silenceMs - inferenceMs,
-            silenceMs,
-            inferenceMs
-          };
-          for (const listener of [...listeners]) listener(sample);
-        }
-      } catch (err) {
-        console.warn("[agent] vad tap failed", err);
-      }
-      return result;
-    };
-    return stream;
+// src/runtime/call-model-usage.ts
+init_dist2();
+var MAX_UNTAGGED = 32;
+function createCallModelMeter(usage) {
+  let base = null;
+  let clock;
+  let untagged = [];
+  let inFlight = 0;
+  let idle = [];
+  const otel = (t) => {
+    if (base) recordLlmUsage({ ...base, ...t });
+    else if (untagged.length < MAX_UNTAGGED) untagged.push(t);
   };
   return {
-    onSpeechEnd(listener) {
-      listeners.add(listener);
-      return () => listeners.delete(listener);
+    listener: {
+      started() {
+        inFlight += 1;
+      },
+      finished(call) {
+        inFlight = Math.max(0, inFlight - 1);
+        try {
+          const tokens = call.usage;
+          if (tokens && tokens.inputTokens + tokens.outputTokens > 0) {
+            usage.record({
+              kind: "llm",
+              provider: call.provider,
+              model: call.model,
+              inputTokens: tokens.inputTokens,
+              outputTokens: tokens.outputTokens,
+              ...call.byok !== void 0 ? { byok: call.byok } : {}
+            });
+            otel({ provider: call.provider, model: call.model, inputTokens: tokens.inputTokens, outputTokens: tokens.outputTokens });
+          }
+          clock?.noteModelTime({ startAt: call.startedAt, endAt: call.endedAt });
+        } finally {
+          if (inFlight === 0 && idle.length > 0) {
+            const waiting = idle;
+            idle = [];
+            for (const resolve of waiting) resolve();
+          }
+        }
+      }
+    },
+    bind(b, c) {
+      base = b;
+      clock = c;
+      const early = untagged;
+      untagged = [];
+      for (const t of early) recordLlmUsage({ ...b, ...t });
+    },
+    drain(timeoutMs) {
+      if (inFlight === 0) return Promise.resolve();
+      return new Promise((resolve) => {
+        const timer = setTimeout(done, timeoutMs);
+        timer.unref?.();
+        function done() {
+          clearTimeout(timer);
+          idle = idle.filter((r) => r !== done);
+          resolve();
+        }
+        idle.push(done);
+      });
     }
   };
 }
-function numberOr(value, fallback) {
-  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
-}
-function resolveAgentModulePath(moduleUrl) {
-  if (moduleUrl.startsWith("file://")) {
-    return fileURLToPath(moduleUrl);
+var HANGUP_DRAIN_MS = 3e3;
+async function reportUsageAtClose(opts) {
+  try {
+    await opts.meter.drain(opts.drainMs ?? HANGUP_DRAIN_MS);
+    if (opts.usage.isEmpty()) return;
+    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) });
   }
-  return moduleUrl;
 }
-
-// src/agent.ts
-init_dist2();
-init_src();
-
-// src/runtime/plan-merge.ts
-function applyPlanToConfig(base, plan) {
-  const draft = plan.draftConfig;
-  let prompt = base.prompt;
-  if (typeof draft.systemPrompt === "string" && draft.systemPrompt.length > 0) {
-    prompt = draft.systemPrompt;
-  } else if (plan.objective) {
-    prompt = plan.objective;
-  }
-  const routingInstructions = typeof draft.routingInstructions === "string" && draft.routingInstructions.length > 0 ? draft.routingInstructions : base.routingInstructions;
-  let models = base.models;
-  if (draft.language || draft.model || draft.voice) {
-    const baseModels = base.models ?? {};
-    const next = {
-      ...baseModels
-    };
-    if (draft.language && next.language === void 0) {
-      next.language = draft.language;
+var MAX_INTERVALS_PER_TURN = 64;
+var REPLY_METRICS_WAIT_MS = 1500;
+function modelTimeWithin(intervals, from, to) {
+  const clipped = intervals.map((i) => ({ startAt: Math.max(i.startAt, from), endAt: Math.min(i.endAt, to) })).filter((i) => i.endAt > i.startAt).sort((a, b) => a.startAt - b.startAt);
+  let total = 0;
+  let runStart = -Infinity;
+  let runEnd = -Infinity;
+  for (const i of clipped) {
+    if (i.startAt > runEnd) {
+      if (runEnd > runStart) total += runEnd - runStart;
+      runStart = i.startAt;
+      runEnd = i.endAt;
+    } else if (i.endAt > runEnd) {
+      runEnd = i.endAt;
+    }
+  }
+  if (runEnd > runStart) total += runEnd - runStart;
+  return total;
+}
+var newTurn = () => ({ windowStart: 0, windowEnd: 0, intervals: [], modelReply: false, repliesPending: 0 });
+function attachTurnModelClock(session, events, ctx, deps = {}) {
+  const now = deps.now ?? Date.now;
+  const replyWaitMs = deps.replyWaitMs ?? REPLY_METRICS_WAIT_MS;
+  const base = { projectId: ctx.projectId, callId: ctx.callId, ...ctx.campaignId ? { campaignId: ctx.campaignId } : {} };
+  let phase = "idle";
+  let turn = newTurn();
+  let parked = null;
+  let outsidePending = 0;
+  let abandonedPending = 0;
+  let spokeWhileDeciding = false;
+  const safely2 = (fn) => {
+    try {
+      fn();
+    } catch (err) {
+      console.warn("[agent] turn model time record failed", { err: err instanceof Error ? err.message : String(err) });
     }
-    if (draft.model && typeof baseModels.llm !== "object") {
-      next.llm = `${draft.model.provider}/${draft.model.model}`;
+  };
+  const record = (t) => {
+    if (t.repliesPending > 0) return;
+    const latencyMs = modelTimeWithin(t.intervals, t.windowStart, t.windowEnd);
+    if (t.modelReply && latencyMs <= 0) return;
+    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 = () => {
+    if (!parked) return;
+    clearTimeout(parked.timer);
+    const t = parked.turn;
+    parked = null;
+    abandonedPending += t.repliesPending;
+    record(t);
+  };
+  const flush = () => {
+    if (phase === "answered") {
+      if (turn.repliesPending > 0) {
+        releaseParked();
+        const t = turn;
+        const timer = setTimeout(releaseParked, replyWaitMs);
+        timer.unref?.();
+        parked = { turn: t, timer };
+      } else {
+        record(turn);
+      }
+    } else {
+      abandonedPending += turn.repliesPending;
     }
-    if (draft.voice && typeof baseModels.tts !== "object") {
+    phase = "idle";
+    turn = newTurn();
+    spokeWhileDeciding = false;
+  };
+  const at = (event) => {
+    const t = event?.createdAt;
+    return typeof t === "number" ? t : now();
+  };
+  session.on(events.userStateChanged, (event) => {
+    if (event?.newState !== "speaking") return;
+    if (phase === "deciding") {
+      spokeWhileDeciding = true;
+      return;
+    }
+    flush();
+    phase = "listening";
+  });
+  session.on(events.userInputTranscribed, (event) => {
+    if (!event?.isFinal) return;
+    if (phase === "deciding" && spokeWhileDeciding) {
+      turn = { ...newTurn(), modelReply: turn.modelReply, repliesPending: turn.repliesPending, windowStart: at(event) };
+      spokeWhileDeciding = false;
+      return;
+    }
+    if (phase !== "idle" && phase !== "listening") return;
+    turn.windowStart = at(event);
+    phase = "deciding";
+  });
+  session.on(events.agentStateChanged, (event) => {
+    if (event?.newState !== "speaking" || phase !== "deciding") return;
+    turn.windowEnd = Math.max(turn.windowStart, at(event));
+    phase = "answered";
+    spokeWhileDeciding = false;
+  });
+  session.on(events.speechCreated, (event) => {
+    if (event?.source === "say") return;
+    if (phase === "deciding") {
+      turn.modelReply = true;
+      turn.repliesPending += 1;
+    } else if (phase === "answered") {
+      turn.repliesPending += 1;
+    } else {
+      outsidePending += 1;
+    }
+  });
+  const push = (t, interval) => {
+    if (t.intervals.length < MAX_INTERVALS_PER_TURN) t.intervals.push(interval);
+  };
+  return {
+    noteModelTime(interval) {
+      push(turn, interval);
+    },
+    noteReplyModelTime(interval) {
+      if (parked && parked.turn.repliesPending > 0) {
+        push(parked.turn, interval);
+        parked.turn.repliesPending -= 1;
+        if (parked.turn.repliesPending === 0) releaseParked();
+        return;
+      }
+      const inTurn = phase === "deciding" || phase === "answered";
+      if (abandonedPending > 0 && inTurn && interval.startAt < turn.windowStart) {
+        abandonedPending -= 1;
+        return;
+      }
+      if (inTurn && turn.repliesPending > 0) {
+        push(turn, interval);
+        turn.repliesPending -= 1;
+        return;
+      }
+      if (abandonedPending > 0) {
+        abandonedPending -= 1;
+        return;
+      }
+      if (outsidePending > 0 || phase === "idle" || phase === "listening") {
+        outsidePending = Math.max(0, outsidePending - 1);
+        const ttftMs = interval.endAt - interval.startAt;
+        if (ttftMs > 0) {
+          safely2(() => {
+            recordTurnLatency({ ...base, firstTokenMs: ttftMs });
+            recordTurnLatencySpan({ ...base, stage: "llm", latencyMs: ttftMs });
+          });
+        }
+        return;
+      }
+      push(turn, interval);
+    },
+    close() {
+      flush();
+    }
+  };
+}
+
+// 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();
+
+// src/runtime/vad-tap.ts
+function tapVad(vad, opts) {
+  const listeners = /* @__PURE__ */ new Set();
+  const now = opts.now ?? Date.now;
+  const target = vad;
+  if (!target || typeof target.stream !== "function") {
+    return { onSpeechEnd: () => () => {
+    } };
+  }
+  const originalStream = target.stream.bind(target);
+  target.stream = () => {
+    const stream = originalStream();
+    const originalNext = stream.next.bind(stream);
+    stream.next = async () => {
+      const result = await originalNext();
+      try {
+        const event = result.value;
+        if (!result.done && event && event.type === opts.endOfSpeechType) {
+          const silenceMs = numberOr(event.silenceDuration, 0);
+          const inferenceMs = numberOr(event.inferenceDuration, 0);
+          const sample = {
+            speechEndAt: now() - silenceMs - inferenceMs,
+            silenceMs,
+            inferenceMs
+          };
+          for (const listener of [...listeners]) listener(sample);
+        }
+      } catch (err) {
+        console.warn("[agent] vad tap failed", err);
+      }
+      return result;
+    };
+    return stream;
+  };
+  return {
+    onSpeechEnd(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    }
+  };
+}
+function numberOr(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function resolveAgentModulePath(moduleUrl) {
+  if (moduleUrl.startsWith("file://")) {
+    return fileURLToPath(moduleUrl);
+  }
+  return moduleUrl;
+}
+
+// src/agent.ts
+init_dist2();
+init_src();
+
+// src/runtime/plan-merge.ts
+function applyPlanToConfig(base, plan) {
+  const draft = plan.draftConfig;
+  let prompt = base.prompt;
+  if (typeof draft.systemPrompt === "string" && draft.systemPrompt.length > 0) {
+    prompt = draft.systemPrompt;
+  } else if (plan.objective) {
+    prompt = plan.objective;
+  }
+  const routingInstructions = typeof draft.routingInstructions === "string" && draft.routingInstructions.length > 0 ? draft.routingInstructions : base.routingInstructions;
+  let models = base.models;
+  if (draft.language || draft.model || draft.voice) {
+    const baseModels = base.models ?? {};
+    const next = {
+      ...baseModels
+    };
+    if (draft.language && next.language === void 0) {
+      next.language = draft.language;
+    }
+    if (draft.model && typeof baseModels.llm !== "object") {
+      next.llm = `${draft.model.provider}/${draft.model.model}`;
+    }
+    if (draft.voice && typeof baseModels.tts !== "object") {
       next.tts = `${draft.voice.provider}/${draft.voice.voiceId}`;
     }
     models = next;
@@ -17591,6 +18232,230 @@ function actionSpecToAction(spec) {
   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) });
+    }
+    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;
+      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();
+    }
+  };
+}
+
+// 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 {
+      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]);
+    }
+  }
+}
+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({
   question: z.string().min(1).max(2e3),
@@ -18141,7 +19006,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;
@@ -18150,11 +19015,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
@@ -18174,150 +19039,6 @@ 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_helper_models();
 var FLOW_HANGUP_GRACE_MS = Number(process.env["VL_FLOW_HANGUP_GRACE_MS"] ?? "1200");
@@ -18417,6 +19138,8 @@ var Agent = class {
     const agentId = typeof md["agentId"] === "string" ? md["agentId"] : void 0;
     const room = job.room.name ?? void 0;
     registerTelemetryFlush(job);
+    const usageSink = createTelemetrySink();
+    const modelMeter = createCallModelMeter(usageSink);
     try {
       return await withCallContext(
         {
@@ -18427,14 +19150,16 @@ var Agent = class {
           ...agentId ? { agentId } : {},
           ...room ? { room } : {}
         },
-        () => this.runCallSpan(job)
+        // Every model call the SDK makes on its own during the call (judge, extractor, agent loop, embeddings) reports
+        // into the call's usage and latency — the meter follows all the async work the call starts (burn-down G-40).
+        () => runWithModelMeter(modelMeter.listener, () => this.runCallSpan(job, usageSink, modelMeter))
       );
     } finally {
       await flushTelemetry().catch(() => {
       });
     }
   }
-  async runCallSpan(job) {
+  async runCallSpan(job, usageSink, modelMeter) {
     const { AutoSubscribe, voice: voice3, VADEventType } = await import('@livekit/agents');
     const Events = voice3.AgentSessionEventTypes;
     await job.connect(void 0, AutoSubscribe.SUBSCRIBE_ALL);
@@ -18460,6 +19185,7 @@ var Agent = class {
     const identity = admission.resolution;
     const sdkClient = identity.kind === "ok" ? identity.identity.client : null;
     const callCredential = identity.kind === "ok" ? identity.identity.credential : null;
+    configureHelperCallCredential(callCredential?.source ?? null);
     const identityRefused = identity.kind === "refused" && (!!this.config.flowRuntime || identity.reason === "no_project_in_dispatch");
     if (identity.kind === "refused" && !identityRefused) {
       console.warn("[agent] running with no workspace credential (worker-token exchange failed)", { reason: identity.reason });
@@ -18627,6 +19353,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;
@@ -18639,9 +19366,10 @@ 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(() => {
       });
     };
     const graphEvents = graphMode ? withOpEventFanout(createGraphEvents(processRt), emitOpEvent) : null;
@@ -18668,8 +19396,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 };
@@ -18801,7 +19544,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 {
@@ -18814,6 +19558,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,
@@ -18852,6 +19607,7 @@ ${callIntent}`
       }
     });
     const session = adapter.raw.session;
+    lineRef.say = (text) => adapter.say(text, { allowInterruptions: false });
     sessionRef.current = session;
     const handoffRt = createHandoffRuntime(effectiveConfig.handoff, {
       session,
@@ -19082,12 +19838,13 @@ ${callIntent}`
         }
       }
     };
-    const usageSink = createTelemetrySink();
     const callEffects = new EffectStack({
       onDisposeError: (err) => console.warn("[agent] call-effect dispose failed", {
         err: err instanceof Error ? err.message : String(err)
       })
     });
+    let usageReported = Promise.resolve();
+    let finalized = Promise.resolve();
     session.once(Events.Close, () => {
       sessionClosed = true;
       endCallController.dispose();
@@ -19099,12 +19856,14 @@ ${callIntent}`
         void offboardParticipant(remaining.id);
       }
       const outcome = callEndOutcome(startedAt);
-      if (sdkClient && !usageSink.isEmpty()) {
-        void sdkClient.calls.reportUsage(callSync.callId, usageSink.report(outcome.durationMs)).catch((err) => {
-          console.warn("[agent] usage report failed", {
-            callId: callSync.callId,
-            err: err instanceof Error ? err.message : String(err)
-          });
+      if (sdkClient) {
+        const calls = sdkClient.calls;
+        usageReported = reportUsageAtClose({
+          meter: modelMeter,
+          usage: usageSink,
+          durationMs: outcome.durationMs,
+          send: (report, signal) => calls.reportUsage(callSync.callId, report, { signal }),
+          warn: (message, meta) => console.warn(message, { callId: callSync.callId, ...meta })
         });
       }
       void audioExperience.onCallEnd(audioCtx, outcome);
@@ -19243,9 +20002,40 @@ ${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,
+      {
+        userStateChanged: Events.UserStateChanged,
+        userInputTranscribed: Events.UserInputTranscribed,
+        agentStateChanged: Events.AgentStateChanged,
+        speechCreated: Events.SpeechCreated
+      },
+      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
+      usage: usageSink,
+      keyOwner,
+      turns: turnLatency,
+      ...modelClock ? { modelClock } : {}
     });
     if (graphMode) {
       attachEndpointingProbe(
@@ -19254,7 +20044,7 @@ ${callIntent}`
           userStateChanged: Events.UserStateChanged,
           userInputTranscribed: Events.UserInputTranscribed
         },
-        metricsCtx,
+        { ...metricsCtx, turns: turnLatency },
         { vad: vadTap }
       );
     }
@@ -19317,11 +20107,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) {
@@ -19329,7 +20119,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) {
@@ -19420,6 +20216,8 @@ ${callIntent}`
         }
       }
       await waitForSessionClose;
+      await usageReported;
+      await finalized;
     } catch (err) {
       console.error("[agent] runJob failed", {
         room: job.room.name ?? null,
@@ -19529,7 +20327,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) {
@@ -19604,7 +20402,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) {
@@ -19612,7 +20409,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) {