@voicelayer/sdk 0.6.2 → 0.7.0

package/dist/runtime/text-session.js

@@ -14,6 +14,7 @@ import '@opentelemetry/sdk-logs';
 import '@opentelemetry/sdk-metrics';
 import '@opentelemetry/sdk-node';
 import '@opentelemetry/semantic-conventions';
+import { llm, DEFAULT_API_CONNECT_OPTIONS, intervalForRetry, APIStatusError, APITimeoutError, APIConnectionError } from '@livekit/agents';
 import http from 'http';
 import https from 'https';
 import { Readable } from 'stream';
@@ -44,35 +45,6 @@ var init_log = __esm({
   }
 });
 
-// src/runtime/graph/graph-model.ts
-function buildGraphModel(program) {
-  return {
-    entry: program.entry,
-    node: (id) => program.nodes[id],
-    out: (id) => program.nodes[id]?.out ?? [],
-    selectByPort: (id, port) => {
-      const edges = program.nodes[id]?.out ?? [];
-      const byHandle = edges.find((e) => e.sourceHandle === port);
-      if (byHandle) return byHandle.to;
-      const byLabel = edges.find((e) => e.label === port);
-      return byLabel ? byLabel.to : null;
-    },
-    askNodeForSlot: (slot) => {
-      const want = slot.trim();
-      for (const node of Object.values(program.nodes)) {
-        if (node.type !== "ask") continue;
-        const s = typeof node.config.slot === "string" ? node.config.slot : node.id;
-        if (s.trim() === want) return node.id;
-      }
-      return void 0;
-    }
-  };
-}
-var init_graph_model = __esm({
-  "src/runtime/graph/graph-model.ts"() {
-  }
-});
-
 // ../contracts/src/effect-stack.ts
 var EffectStack;
 var init_effect_stack = __esm({
@@ -1060,11 +1032,10 @@ var init_agent_config = __esm({
       projectId: z.string().min(1),
       // Human-readable label. No `agentType` enum on purpose.
       name: z.string().min(1).max(128),
-      // Soft override of the worker's baked-in prompt. Absent → call_start
-      // uses the SDK worker's predefined prompt (the source of truth for
-      // pre-defined agents like FNOL). Present → it overrides the worker's
-      // prompt at call_start as a snapshot decision; mid-call edits are not
-      // honoured. Per-call override at call_start time is also allowed.
+      // The agent's persona (the Behaviour page). For a FLOW agent the PUBLISHED value is the flow persona on every
+      // transport (flowPersonaOf — voice boot and text replies alike; absent → DEFAULT_FLOW_PERSONA), read at call start as
+      // a snapshot decision; mid-call edits are not honoured (burn-down G-46). A coded SDK agent's prompt is its code: this
+      // field doesn't reach it. A call plan may still override the prompt per call.
       systemPrompt: z.string().max(64e3).optional(),
       // Routing/decision layer (Voiceflow "Instructions"): plain-language guidance the
       // agent reads to decide WHEN to do things (vs systemPrompt = WHO it is). Injected
@@ -1945,12 +1916,143 @@ var init_call_result = __esm({
     });
   }
 });
+function supportedZones() {
+  if (!SUPPORTED_ZONES) {
+    const intl = Intl;
+    SUPPORTED_ZONES = new Set(intl.supportedValuesOf?.("timeZone") ?? []);
+  }
+  return SUPPORTED_ZONES;
+}
+function isIanaTimezone(tz) {
+  if (tz === "UTC" || supportedZones().has(tz)) return true;
+  if (!IANA_NAME.test(tz)) return false;
+  try {
+    new Intl.DateTimeFormat("en-US", { timeZone: tz });
+    return true;
+  } catch {
+    return false;
+  }
+}
+var BUDGET_SCOPE_KINDS, BudgetScopeKind, CREATABLE_BUDGET_SCOPE_KINDS, BUDGET_CHANNELS, BudgetScope, BudgetPeriodKind, BudgetEnforcement, BudgetInbound, BudgetOwner, DEFAULT_BUDGET_THRESHOLDS, BUDGET_MAX_USD, Thresholds, IANA_NAME, SUPPORTED_ZONES, Timezone, BudgetPeriodStatus, Budget, BudgetRefusalDetail, BillingNoticeKind, BillingNotice;
+var init_budgets = __esm({
+  "../contracts/src/budgets.ts"() {
+    BUDGET_SCOPE_KINDS = ["workspace", "agent", "api_key", "channel"];
+    BudgetScopeKind = z.enum(BUDGET_SCOPE_KINDS);
+    CREATABLE_BUDGET_SCOPE_KINDS = ["workspace", "api_key", "channel"];
+    BUDGET_CHANNELS = ["voice", "sms", "email", "chat", "discord"];
+    z.enum(BUDGET_CHANNELS);
+    BudgetScope = z.object({
+      kind: BudgetScopeKind,
+      // null for the workspace; the API key's id, or the channel name.
+      id: z.string().min(1).nullable()
+    });
+    BudgetPeriodKind = z.enum(["day", "month", "billing_period"]);
+    BudgetEnforcement = z.enum(["soft", "hard"]);
+    BudgetInbound = z.enum(["refuse", "answer"]);
+    BudgetOwner = z.enum(["customer", "operator"]);
+    DEFAULT_BUDGET_THRESHOLDS = [50, 80, 100];
+    BUDGET_MAX_USD = 1e6;
+    Thresholds = z.array(z.number().int().min(1).max(100)).max(5).refine((t) => new Set(t).size === t.length, "thresholds must be distinct").transform((t) => [...t].sort((a, b) => a - b));
+    IANA_NAME = /^[A-Za-z]+(?:\/[A-Za-z0-9_+-]+)+$/;
+    SUPPORTED_ZONES = null;
+    Timezone = z.string().min(1).max(64).refine(isIanaTimezone, "use an IANA time zone name, like America/New_York or UTC");
+    BudgetPeriodStatus = z.object({
+      periodStart: z.string(),
+      // When the budget resets.
+      periodEnd: z.string(),
+      // Charged usage this period.
+      settledUsd: z.string(),
+      // Reserved for calls in progress.
+      inProgressUsd: z.string(),
+      // settled + in progress — what the budget compares with its amount.
+      spentUsd: z.string(),
+      // spent ÷ amount, as a whole percent (may pass 100: calls in progress finish).
+      percent: z.number().int().min(0),
+      // A hard budget at its limit: new actions in its scope are refused until periodEnd.
+      reached: z.boolean()
+    });
+    Budget = z.object({
+      id: z.string(),
+      scope: BudgetScope,
+      period: BudgetPeriodKind,
+      timezone: z.string(),
+      amountUsd: z.string(),
+      enforcement: BudgetEnforcement,
+      thresholds: z.array(z.number().int()),
+      notifyEmail: z.boolean(),
+      notifyWebhook: z.boolean(),
+      // Operator budgets are VoiceLayer's own safety limits: shown to the customer, read-only.
+      owner: BudgetOwner,
+      inbound: BudgetInbound,
+      createdAt: z.string(),
+      current: BudgetPeriodStatus
+    });
+    z.object({ budgets: z.array(Budget) });
+    z.object({
+      scope: z.object({ kind: z.enum(CREATABLE_BUDGET_SCOPE_KINDS), id: z.string().min(1).max(200).nullable().optional() }),
+      period: BudgetPeriodKind,
+      timezone: Timezone.default("UTC"),
+      amountUsd: z.number().positive().max(BUDGET_MAX_USD),
+      enforcement: BudgetEnforcement,
+      thresholds: Thresholds.default([...DEFAULT_BUDGET_THRESHOLDS]),
+      notifyEmail: z.boolean().default(true),
+      notifyWebhook: z.boolean().default(true),
+      // Hard budgets only; a customer budget refuses incoming calls unless told to answer them (MON-9).
+      inbound: BudgetInbound.default("refuse")
+    }).superRefine((b, ctx) => {
+      const id = b.scope.id ?? null;
+      if (b.scope.kind === "workspace" && id !== null) ctx.addIssue({ code: "custom", path: ["scope", "id"], message: "a workspace budget names no scope id" });
+      if (b.scope.kind !== "workspace" && id === null) ctx.addIssue({ code: "custom", path: ["scope", "id"], message: "name the API key or channel" });
+      if (b.scope.kind === "channel" && id !== null && !BUDGET_CHANNELS.includes(id)) {
+        ctx.addIssue({ code: "custom", path: ["scope", "id"], message: `channel is one of ${BUDGET_CHANNELS.join(", ")}` });
+      }
+    });
+    z.object({
+      amountUsd: z.number().positive().max(BUDGET_MAX_USD),
+      enforcement: BudgetEnforcement,
+      thresholds: Thresholds,
+      notifyEmail: z.boolean(),
+      notifyWebhook: z.boolean(),
+      inbound: BudgetInbound
+    }).partial().refine((b) => Object.keys(b).length > 0, "nothing to change");
+    BudgetRefusalDetail = z.object({
+      budgetId: z.string(),
+      scope: BudgetScope,
+      period: BudgetPeriodKind,
+      resetsAt: z.string()
+    });
+    BillingNoticeKind = z.enum([
+      "balance_empty",
+      "credit_limit_reached",
+      "auto_topup_off",
+      "wallet_frozen",
+      "invoice_issued",
+      "invoice_overdue",
+      "workspace_paused",
+      "workspace_restored",
+      "budget_threshold",
+      "budget_reached"
+    ]);
+    BillingNotice = z.object({
+      id: z.string(),
+      kind: BillingNoticeKind,
+      // The same words as the email's subject and first paragraph.
+      title: z.string(),
+      body: z.string(),
+      // The budget a budget notice is about.
+      budgetId: z.string().nullable(),
+      createdAt: z.string()
+    });
+    z.object({ notices: z.array(BillingNotice) });
+  }
+});
 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"];
+    init_budgets();
+    WEBHOOK_EVENT_TYPES = ["call.started", "call.ended", "recording.ready", "billing.budget_threshold", "billing.budget_reached"];
     z.enum(WEBHOOK_EVENT_TYPES);
     CallWebhookDirection = z.enum(["inbound", "outbound", "web"]);
     CallWebhookOutcome = z.enum(["completed", "dropped", "failed", "no_answer", "other"]);
@@ -2009,6 +2111,19 @@ var init_webhook_events = __esm({
       recordingUrl: z.string().url(),
       status: z.enum(["starting", "active", "completed", "failed", "aborted"])
     });
+    z.object({
+      budgetId: z.string(),
+      scope: BudgetScope,
+      period: BudgetPeriodKind,
+      periodStart: z.string().datetime({ offset: true }),
+      periodEnd: z.string().datetime({ offset: true }),
+      amountUsd: z.string(),
+      spentUsd: z.string(),
+      inProgressUsd: z.string(),
+      // The threshold passed (budget_reached: 100).
+      thresholdPct: z.number().int().min(1).max(100),
+      enforcement: BudgetEnforcement
+    });
   }
 });
 var PhoneNumberStatus, PhoneNumberProvider, PhoneNumberCapabilities, PhoneNumberRecord;
@@ -2083,10 +2198,154 @@ var init_project_limits = __esm({
 });
 
 // ../contracts/src/flow-ports.ts
-var INCOMPLETE_PORT_ID;
+var INCOMPLETE_PORT_ID, UNFILLED_PORT_ID, MISSING_PORT_ID;
 var init_flow_ports = __esm({
   "../contracts/src/flow-ports.ts"() {
     INCOMPLETE_PORT_ID = "incomplete";
+    UNFILLED_PORT_ID = "unfilled";
+    MISSING_PORT_ID = "missing";
+  }
+});
+
+// ../contracts/src/flow-persona.ts
+var init_flow_persona = __esm({
+  "../contracts/src/flow-persona.ts"() {
+  }
+});
+
+// ../contracts/src/question-text.ts
+function lastSentences(line) {
+  const text = line.trim();
+  if (!text) return [];
+  const sentences = [];
+  let last = 0;
+  for (const m of text.matchAll(SENTENCE_END)) {
+    const end = (m.index ?? 0) + m[0].length;
+    sentences.push(text.slice(last, end));
+    last = end;
+  }
+  if (last < text.length) sentences.push(text.slice(last));
+  return sentences.slice(-2);
+}
+function isQuestion(line) {
+  return lastSentences(line).some((s) => QUESTION_MARK.test(s));
+}
+var QUESTION_MARK, SENTENCE_END;
+var init_question_text = __esm({
+  "../contracts/src/question-text.ts"() {
+    QUESTION_MARK = /[?？؟]/;
+    SENTENCE_END = /[.!?…。！？؟]+["'”’)\]]*\s*/g;
+  }
+});
+
+// ../contracts/src/flow-ask-lines.ts
+function norm(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+function fnv1a64(text) {
+  let hash = FNV_OFFSET;
+  for (const byte of new TextEncoder().encode(text)) {
+    hash ^= BigInt(byte);
+    hash = BigInt.asUintN(64, hash * FNV_PRIME);
+  }
+  return hash.toString(16).padStart(16, "0");
+}
+function askLinesBasis(input) {
+  const canonical = JSON.stringify([
+    ["persona", norm(input.persona)],
+    ["routing", norm(input.routing)],
+    ["language", norm(input.language).toLowerCase()],
+    ["ask", norm(input.ask)],
+    ["instructions", norm(input.instructions)]
+  ]);
+  return fnv1a64(canonical);
+}
+function isEnglishLanguage(language) {
+  return norm(language).toLowerCase().startsWith("en");
+}
+function readAskGeneratedLines(value) {
+  if (!value || typeof value !== "object") return null;
+  const v = value;
+  if (typeof v.basis !== "string" || !v.basis) return null;
+  const reasks = Array.isArray(v.reasks) ? v.reasks.filter((x) => typeof x === "string" && x.trim() !== "") : [];
+  return {
+    reasks,
+    basis: v.basis,
+    ...typeof v.skipOffer === "string" && v.skipOffer.trim() ? { skipOffer: v.skipOffer } : {},
+    ...typeof v.voicedAsk === "string" && v.voicedAsk.trim() ? { voicedAsk: v.voicedAsk } : {}
+  };
+}
+function authorReasksOf(value) {
+  return Array.isArray(value) ? value.filter((x) => typeof x === "string" && x.trim() !== "").map((x) => x.trim().slice(0, ASK_LINE_MAX_CHARS)).slice(0, ASK_REASKS_MAX) : [];
+}
+function defaultAskText(slot, nodeId) {
+  const authored = slot === nodeId ? "" : slot.trim();
+  const label = authored.replace(/[_-]+/g, " ");
+  return label ? `Could you tell me your ${label}?` : "Could you tell me a bit more about what you need?";
+}
+var ASK_LINE_MAX_CHARS, ASK_REASKS_MAX, FNV_OFFSET, FNV_PRIME, DEFAULT_ASK_EXHAUSTED_MESSAGE;
+var init_flow_ask_lines = __esm({
+  "../contracts/src/flow-ask-lines.ts"() {
+    init_question_text();
+    ASK_LINE_MAX_CHARS = 300;
+    ASK_REASKS_MAX = 3;
+    FNV_OFFSET = BigInt("0xcbf29ce484222325");
+    FNV_PRIME = BigInt("0x100000001b3");
+    DEFAULT_ASK_EXHAUSTED_MESSAGE = "I wasn't able to get everything we need on this call, so let me have someone follow up with you. Thanks for your time.";
+  }
+});
+
+// ../contracts/src/flow-required-inputs.ts
+function templateFieldRefs(text) {
+  if (typeof text !== "string" || text.indexOf("{{") === -1) return [];
+  const out = [];
+  for (const m of text.matchAll(TOKEN)) {
+    const expr = (m[1] ?? "").trim();
+    const name = expr.startsWith("slots.") ? expr.slice("slots.".length).trim() : expr;
+    if (name && !out.includes(name)) out.push(name);
+  }
+  return out;
+}
+function stepInputNames(type, config) {
+  const out = [];
+  const add = (names) => {
+    for (const n of names) if (!out.includes(n)) out.push(n);
+  };
+  if (type === "email") {
+    for (const key of EMAIL_TEMPLATE_KEYS) add(templateFieldRefs(config[key]));
+    return out;
+  }
+  if (type === "tool") {
+    if (typeof config.toolRef === "string" && config.toolRef.trim()) return out;
+    if (config.input && typeof config.input === "object") add(Object.keys(config.input));
+    if (config.headers && typeof config.headers === "object") {
+      for (const v of Object.values(config.headers)) add(templateFieldRefs(v));
+    }
+  }
+  return out;
+}
+function requiredInputsFor(type, config, isRequired) {
+  return stepInputNames(type, config).filter((n) => isRequired(n));
+}
+function requiredFieldNamesOf(nodes) {
+  const out = /* @__PURE__ */ new Set();
+  for (const node of nodes) {
+    const config = node.config;
+    if (node.type === "ask" && config.required !== false) {
+      out.add((typeof config.slot === "string" && config.slot.trim() ? config.slot : node.id).trim());
+    }
+    if ((node.type === "playbook" || node.type === "gate") && Array.isArray(config.requiredFields)) {
+      for (const f of config.requiredFields) if (typeof f === "string" && f.trim()) out.add(f.trim());
+    }
+  }
+  return out;
+}
+var EMAIL_TEMPLATE_KEYS, TOKEN;
+var init_flow_required_inputs = __esm({
+  "../contracts/src/flow-required-inputs.ts"() {
+    init_flow_ports();
+    EMAIL_TEMPLATE_KEYS = ["to", "subject", "body", "from", "replyTo", "fromName"];
+    TOKEN = /\{\{\s*([^}]+?)\s*\}\}/g;
   }
 });
 
@@ -2107,6 +2366,9 @@ var init_flow_compile = __esm({
   "../contracts/src/flow-compile.ts"() {
     init_flow_enrichment();
     init_flow_edges();
+    init_flow_ports();
+    init_flow_ask_lines();
+    init_flow_required_inputs();
   }
 });
 
@@ -2294,6 +2556,8 @@ var init_flow_validate = __esm({
     init_flow_ports();
     init_flow_edges();
     init_flow_compile_check();
+    init_flow_required_inputs();
+    init_flow_ask_lines();
     init_secret_headers();
     init_network_address();
     init_dispatch_metadata();
@@ -3819,6 +4083,7 @@ var init_monitoring = __esm({
 var WalletRefusalCode, WalletMode, WalletInvoiceStatus, WalletInvoice, WalletEntryKind, WalletEntry, TOPUP_MIN_USD, TOPUP_MAX_USD;
 var init_wallet = __esm({
   "../contracts/src/wallet.ts"() {
+    init_budgets();
     WalletRefusalCode = z.enum([
       // Prepaid balance (or an invoiced credit limit) cannot cover the action.
       "insufficient_balance",
@@ -3828,14 +4093,18 @@ var init_wallet = __esm({
       // still answered. Paying the invoice restores the workspace.
       "account_suspended",
       // The action's reservation already closed (e.g. a call ended or expired) — it cannot be re-admitted.
-      "hold_closed"
+      "hold_closed",
+      // A hard budget (docs/specs/monetization LLD §8a) would be passed: new actions in its scope wait for its reset.
+      "budget_exceeded"
     ]);
     z.object({
       error: WalletRefusalCode,
       code: WalletRefusalCode,
       availableUsd: z.string(),
       needUsd: z.string(),
-      message: z.string()
+      message: z.string(),
+      // budget_exceeded only: which budget, and when it resets.
+      budget: BudgetRefusalDetail.optional()
     });
     WalletMode = z.enum(["prepaid", "invoiced"]);
     z.object({
@@ -3876,7 +4145,7 @@ var init_wallet = __esm({
       payUrl: z.string().nullable()
     });
     z.object({ invoices: z.array(WalletInvoice) });
-    WalletEntryKind = z.enum(["grant", "topup", "usage", "refund", "refund_reversal", "dispute", "dispute_reinstated", "adjustment", "invoice_payment"]);
+    WalletEntryKind = z.enum(["grant", "topup", "usage", "usage_correction", "refund", "refund_reversal", "dispute", "dispute_reinstated", "adjustment", "invoice_payment"]);
     WalletEntry = z.object({
       id: z.string(),
       kind: WalletEntryKind,
@@ -3920,6 +4189,81 @@ var init_pipeline_keys = __esm({
     });
   }
 });
+var METERING_SCHEMA_VERSION, METER_IDS, MeterId, KEY_OWNERS, READING_SOURCES, SUBJECT_KINDS, SubjectKind, MeteringSubject, DimValue, IdentityDims, Attributes, SERIES_PATTERN, SeriesName, Quantity, MeterReadingInput;
+var init_metering = __esm({
+  "../contracts/src/metering.ts"() {
+    METERING_SCHEMA_VERSION = 2;
+    METER_IDS = [
+      // A model's prompt tokens as the provider counts them (cached ones included); `cached_input_tokens` is the cached
+      // subset and `reasoning_tokens` the reasoning subset of `output_tokens`. Rating prices the totals until it prices the
+      // subsets on their own (monetization MON-14).
+      "llm.input_tokens",
+      "llm.cached_input_tokens",
+      "llm.output_tokens",
+      "llm.reasoning_tokens",
+      "embedding.input_tokens",
+      "realtime.audio_input_tokens",
+      "realtime.audio_output_tokens",
+      "realtime.text_input_tokens",
+      "realtime.cached_input_tokens",
+      "realtime.text_output_tokens",
+      "stt.billed_seconds",
+      "tts.characters",
+      "call.connected_seconds",
+      "telephony.carrier_seconds",
+      "media.participant_seconds",
+      "media.sip_seconds",
+      "recording.seconds",
+      "storage.byte_days",
+      "message.segments",
+      "email.messages",
+      // One per billable text action — a text turn, or a single model action the API takes for a workspace (a QA review,
+      // an evaluation, a planner call, a knowledge ingest): the per-message fee's basis.
+      "text.turns",
+      // Informational: number rental is a recurring fee on charge_cycles (🔒 B-21).
+      "number.held_days",
+      "provider_fee.micros"
+    ];
+    MeterId = z.enum(METER_IDS);
+    KEY_OWNERS = ["platform", "workspace_key", "workspace_plan", "workspace_brain", "self_hosted"];
+    z.enum(KEY_OWNERS);
+    READING_SOURCES = ["server_observed", "platform_wire", "platform_estimate", "customer_report"];
+    z.enum(READING_SOURCES);
+    SUBJECT_KINDS = ["call", "turn", "job", "message", "email", "number"];
+    SubjectKind = z.enum(SUBJECT_KINDS);
+    MeteringSubject = z.object({ kind: SubjectKind, id: z.string().min(1).max(200) });
+    DimValue = z.string().max(200).nullable();
+    IdentityDims = z.record(z.string(), DimValue);
+    Attributes = z.object({
+      served_model: z.string().max(200).nullable(),
+      channel: z.string().max(64).nullable(),
+      direction: z.string().max(32).nullable(),
+      leg_kind: z.string().max(64).nullable(),
+      country: z.string().max(8).nullable(),
+      worker_owner: z.enum(["platform", "self_hosted", "unknown"]).nullable()
+    });
+    SERIES_PATTERN = /^(req|ws|srv):[A-Za-z0-9._:-]{1,60}$/;
+    SeriesName = z.string().max(64).regex(SERIES_PATTERN);
+    Quantity = z.string().regex(/^\d{1,14}(\.\d{1,6})?$/);
+    MeterReadingInput = z.object({
+      schemaVersion: z.literal(METERING_SCHEMA_VERSION),
+      subject: MeteringSubject,
+      meter: MeterId,
+      identity: IdentityDims,
+      series: SeriesName,
+      quantity: Quantity,
+      final: z.boolean(),
+      void: z.literal(true).optional(),
+      // The pre-send input estimate of a request that may never answer (LLD §4.1). A client never names a source: the
+      // server derives it from the principal (§4.4), and this flag is the one thing only the producer knows. Honoured
+      // only from the call's own worker token; it ranks below the request's wire count, which supersedes it.
+      estimate: z.literal(true).optional(),
+      occurredAt: z.string().datetime({ offset: true }),
+      attributes: Attributes.partial().optional()
+    }).strict();
+    z.object({ readings: z.array(MeterReadingInput).min(1).max(200) }).strict();
+  }
+});
 
 // ../contracts/src/index.ts
 var init_src = __esm({
@@ -3956,6 +4300,10 @@ var init_src = __esm({
     init_flow();
     init_flow_program();
     init_flow_ports();
+    init_flow_persona();
+    init_flow_ask_lines();
+    init_flow_required_inputs();
+    init_question_text();
     init_flow_validate();
     init_flow_builtins();
     init_compliance();
@@ -3984,16 +4332,73 @@ var init_src = __esm({
     init_channel_connector();
     init_monitoring();
     init_wallet();
+    init_budgets();
     init_network_address();
     init_dispatch_metadata();
     init_pipeline_keys();
+    init_metering();
+  }
+});
+
+// src/runtime/graph/graph-model.ts
+function buildGraphModel(program) {
+  return {
+    // the program's completion gate is the compiler's own subset of these (a gate's fields, else the required asks') —
+    // read too, so a program carries one answer however it was produced
+    requiredFields: /* @__PURE__ */ new Set([
+      ...requiredFieldNamesOf(Object.values(program.nodes)),
+      ...program.completionGate.requiredFields.map((f) => f.trim())
+    ]),
+    entry: program.entry,
+    node: (id) => program.nodes[id],
+    out: (id) => program.nodes[id]?.out ?? [],
+    selectByPort: (id, port) => {
+      const edges = program.nodes[id]?.out ?? [];
+      const byHandle = edges.find((e) => e.sourceHandle === port);
+      if (byHandle) return byHandle.to;
+      const byLabel = edges.find((e) => e.label === port);
+      return byLabel ? byLabel.to : null;
+    },
+    askNodeForSlot: (slot) => {
+      const want = slot.trim();
+      for (const node of Object.values(program.nodes)) {
+        if (node.type !== "ask") continue;
+        const s = typeof node.config.slot === "string" ? node.config.slot : node.id;
+        if (s.trim() === want) return node.id;
+      }
+      return void 0;
+    }
+  };
+}
+var init_graph_model = __esm({
+  "src/runtime/graph/graph-model.ts"() {
+    init_src();
+  }
+});
+
+// src/runtime/graph/reask-templates.ts
+function templateReasks(ask) {
+  const q = ask.trim();
+  return [`${NOT_CAUGHT} ${q}`, `Let me ask that another way \u2014 ${q}`, `Just so I get it right: ${q}`];
+}
+function notCaught(line) {
+  return `${NOT_CAUGHT} ${line.trim()}`;
+}
+function skipOfferTemplate(label) {
+  const what = label.trim() ? `your ${label.trim()}` : "that detail";
+  return `No problem if you don't have ${what} handy \u2014 shall we skip it for now?`;
+}
+var NOT_CAUGHT;
+var init_reask_templates = __esm({
+  "src/runtime/graph/reask-templates.ts"() {
+    NOT_CAUGHT = "Sorry, I didn't catch that.";
   }
 });
 
 // src/runtime/graph/interpolate.ts
 function interpolate(template, scope2) {
   if (!template || template.indexOf("{{") === -1) return template;
-  return template.replace(TOKEN, (_match, expr) => {
+  return template.replace(TOKEN2, (_match, expr) => {
     const value = resolvePath(scope2, expr.trim());
     return value === void 0 || value === null ? "" : String(value);
   });
@@ -4018,10 +4423,10 @@ function hasSlot(slots, name) {
   const v = resolvePath(slots, name.trim());
   return v !== void 0 && v !== null && v !== "";
 }
-var TOKEN;
+var TOKEN2;
 var init_interpolate = __esm({
   "src/runtime/graph/interpolate.ts"() {
-    TOKEN = /\{\{\s*([^}]+?)\s*\}\}/g;
+    TOKEN2 = /\{\{\s*([^}]+?)\s*\}\}/g;
   }
 });
 
@@ -4076,32 +4481,116 @@ function acceptsReasoningEffort(model2) {
   const id = baseModelId(model2);
   return isReasoningModel(model2) && !/^o1-(mini|preview)/.test(id) && !/-chat(-|$)/.test(id);
 }
+function acceptsNoReasoningEffort(model2) {
+  if (!acceptsReasoningEffort(model2))
+    return false;
+  const id = baseModelId(model2);
+  if (/-pro\b/.test(id))
+    return false;
+  const gpt = /^gpt-(\d+)(?:\.(\d+))?/.exec(id);
+  if (!gpt)
+    return false;
+  const major = Number(gpt[1]);
+  const minor = gpt[2] !== void 0 ? Number(gpt[2]) : 0;
+  return major > 5 || major === 5 && minor >= 1;
+}
+function forgetLearnedReasoningEfforts() {
+  learnedEfforts.clear();
+}
+function chatReasoningEffort(model2, opts) {
+  const learned = learnedEfforts.get(learnedKey(model2, opts.tools === true));
+  if (learned !== void 0)
+    return learned === "omit" ? void 0 : learned;
+  if (!acceptsReasoningEffort(model2))
+    return void 0;
+  if (opts.tools === true && acceptsNoReasoningEffort(model2))
+    return "none";
+  return opts.requested;
+}
 function chatCompletionParams(model2, input) {
+  const effort = chatReasoningEffort(model2, {
+    ...input.tools !== void 0 ? { tools: input.tools } : {},
+    ...input.reasoningEffort !== void 0 ? { requested: input.reasoningEffort } : {}
+  });
   if (isReasoningModel(model2)) {
     return {
       ...input.maxTokens !== void 0 ? { max_completion_tokens: Math.max(input.maxTokens, REASONING_MIN_COMPLETION_TOKENS) } : {},
-      ...input.reasoningEffort !== void 0 && acceptsReasoningEffort(model2) ? { reasoning_effort: input.reasoningEffort } : {}
+      ...effort !== void 0 ? { reasoning_effort: effort } : {}
     };
   }
   return {
+    // only when a provider taught the process that this model (one we don't know as a reasoning model) takes an effort
+    ...effort !== void 0 ? { reasoning_effort: effort } : {},
     ...input.maxTokens !== void 0 ? { max_tokens: input.maxTokens } : {},
     ...input.temperature !== void 0 ? { temperature: input.temperature } : {},
     ...input.topP !== void 0 ? { top_p: input.topP } : {}
   };
 }
-function modelRejectionOf(err) {
+function acceptsSamplingParams(model2) {
+  return !isReasoningModel(model2);
+}
+function providerErrorOf(err) {
+  if (err === null || typeof err !== "object")
+    return null;
   const e = err;
-  const status = typeof e?.status === "number" ? e.status : null;
-  if (status !== 400 && status !== 403 && status !== 404)
+  const body = e["body"] !== null && typeof e["body"] === "object" ? e["body"] : {};
+  const pick = (k) => e[k] !== void 0 && e[k] !== null ? e[k] : body[k];
+  const statusRaw = typeof e["status"] === "number" ? e["status"] : e["statusCode"];
+  const status = typeof statusRaw === "number" && statusRaw > 0 ? statusRaw : null;
+  const code = pick("code");
+  const type = pick("type");
+  const param = pick("param");
+  const message = typeof body["message"] === "string" ? body["message"] : typeof e["message"] === "string" ? e["message"] : "";
+  return {
+    status,
+    code: typeof code === "string" ? code : typeof type === "string" ? type : "",
+    param: typeof param === "string" ? param : null,
+    message
+  };
+}
+function reasoningEffortRejectionOf(err) {
+  const f = providerErrorOf(err);
+  if (!f || f.status !== 400)
     return null;
-  const code = typeof e?.code === "string" ? e.code : typeof e?.type === "string" ? e.type : "";
-  const param = typeof e?.param === "string" ? e.param : null;
-  const rejected = REJECTION_CODES.has(code) || param !== null && MODEL_PARAMS.has(param);
+  if (f.param !== "reasoning_effort" && !/reasoning[_ ]effort/i.test(f.message))
+    return null;
+  return { status: f.status, message: f.message, suggestsNone: /reasoning[_ ]effort[^.]*\bnone\b/i.test(f.message) };
+}
+function learnReasoningEffort(model2, shape, err) {
+  const rejection = reasoningEffortRejectionOf(err);
+  if (!rejection)
+    return false;
+  const next = shape.sent !== "none" && (rejection.suggestsNone || shape.sent === void 0) ? "none" : "omit";
+  if ((next === "omit" ? void 0 : next) === shape.sent)
+    return false;
+  learnedEfforts.set(learnedKey(model2, shape.tools), next);
+  return true;
+}
+async function withReasoningEffortRetry(shape, call) {
+  const sent = chatReasoningEffort(shape.model, {
+    tools: shape.tools,
+    ...shape.requested !== void 0 ? { requested: shape.requested } : {}
+  });
+  try {
+    return await call();
+  } catch (err) {
+    if (!learnReasoningEffort(shape.model, { tools: shape.tools, sent }, err))
+      throw err;
+    return call();
+  }
+}
+function modelRejectionOf(err) {
+  const f = providerErrorOf(err);
+  const status = f?.status ?? null;
+  if (!f || status === null || status !== 400 && status !== 403 && status !== 404)
+    return null;
+  const { code, param } = f;
+  const rejected = REJECTION_CODES.has(code) || param !== null && MODEL_PARAMS.has(param) || reasoningEffortRejectionOf(err) !== null;
   if (!rejected)
     return null;
   if (status === 403 && code !== "model_not_found")
     return null;
-  return { status, code: code || "invalid_request_error", message: typeof e?.message === "string" ? e.message : "" };
+  return { status, code: code || "invalid_request_error", message: f.message };
 }
 async function withModelFallback(opts) {
   const fallbackModel = opts.fallbackModel ?? PLATFORM_DEFAULT_CHAT_MODEL;
@@ -4122,11 +4611,13 @@ async function withModelFallback(opts) {
     return opts.call(fallbackModel);
   }
 }
-var PLATFORM_DEFAULT_CHAT_MODEL, REASONING_MIN_COMPLETION_TOKENS, REJECTION_CODES, MODEL_PARAMS, MODEL_REJECTION_TTL_MS, ModelRejectionCache;
+var PLATFORM_DEFAULT_CHAT_MODEL, REASONING_MIN_COMPLETION_TOKENS, learnedEfforts, learnedKey, REJECTION_CODES, MODEL_PARAMS, MODEL_REJECTION_TTL_MS, ModelRejectionCache;
 var init_chat_params = __esm({
   "../llm-client/dist/chat-params.js"() {
     PLATFORM_DEFAULT_CHAT_MODEL = "gpt-4o-mini";
     REASONING_MIN_COMPLETION_TOKENS = 2048;
+    learnedEfforts = /* @__PURE__ */ new Map();
+    learnedKey = (model2, tools) => `${baseModelId(model2)}|${tools ? "tools" : "plain"}`;
     REJECTION_CODES = /* @__PURE__ */ new Set(["unsupported_parameter", "unsupported_value", "model_not_found"]);
     MODEL_PARAMS = /* @__PURE__ */ new Set(["model", "max_tokens", "max_completion_tokens", "temperature", "top_p", "reasoning_effort"]);
     MODEL_REJECTION_TTL_MS = 5 * 60 * 1e3;
@@ -4154,6 +4645,30 @@ var init_chat_params = __esm({
     };
   }
 });
+
+// ../llm-client/dist/index.js
+var dist_exports = {};
+__export(dist_exports, {
+  MODEL_REJECTION_TTL_MS: () => MODEL_REJECTION_TTL_MS,
+  ModelRejectionCache: () => ModelRejectionCache,
+  PLATFORM_DEFAULT_CHAT_MODEL: () => PLATFORM_DEFAULT_CHAT_MODEL,
+  REASONING_MIN_COMPLETION_TOKENS: () => REASONING_MIN_COMPLETION_TOKENS,
+  acceptsNoReasoningEffort: () => acceptsNoReasoningEffort,
+  acceptsReasoningEffort: () => acceptsReasoningEffort,
+  acceptsSamplingParams: () => acceptsSamplingParams,
+  chatCompletionParams: () => chatCompletionParams,
+  chatReasoningEffort: () => chatReasoningEffort,
+  createChatClient: () => createChatClient,
+  forgetLearnedReasoningEfforts: () => forgetLearnedReasoningEfforts,
+  hasChatKey: () => hasChatKey,
+  isReasoningModel: () => isReasoningModel,
+  learnReasoningEffort: () => learnReasoningEffort,
+  modelRejectionOf: () => modelRejectionOf,
+  providerErrorOf: () => providerErrorOf,
+  reasoningEffortRejectionOf: () => reasoningEffortRejectionOf,
+  withModelFallback: () => withModelFallback,
+  withReasoningEffortRetry: () => withReasoningEffortRetry
+});
 function createChatClient(config = {}) {
   return new OpenAI({
     ...config.apiKey ? { apiKey: config.apiKey } : {},
@@ -4161,6 +4676,9 @@ function createChatClient(config = {}) {
     ...config.timeoutMs ? { timeout: config.timeoutMs } : {}
   });
 }
+function hasChatKey(config = {}) {
+  return Boolean(config.apiKey || process.env["OPENAI_API_KEY"]);
+}
 var init_dist = __esm({
   "../llm-client/dist/index.js"() {
     init_chat_params();
@@ -4300,6 +4818,340 @@ var init_wrap = __esm({
   "src/providers/wrap.ts"() {
   }
 });
+var init_start = __esm({
+  "../observability/dist/start.js"() {
+  }
+});
+
+// ../observability/dist/attributes.js
+var ATTR;
+var init_attributes = __esm({
+  "../observability/dist/attributes.js"() {
+    ATTR = {
+      projectId: "vl.project_id",
+      callId: "vl.call_id",
+      campaignId: "vl.campaign_id",
+      room: "vl.room",
+      agentId: "vl.agent_id",
+      phoneNumberId: "vl.phone_number_id",
+      bindingId: "vl.binding_id",
+      source: "vl.source",
+      kind: "vl.kind"
+    };
+  }
+});
+function getCurrentCallContext() {
+  return callContextStore.getStore();
+}
+var callContextStore;
+var init_call_context = __esm({
+  "../observability/dist/call-context.js"() {
+    init_attributes();
+    callContextStore = new AsyncLocalStorage();
+  }
+});
+var init_trace_propagation = __esm({
+  "../observability/dist/trace-propagation.js"() {
+  }
+});
+function meter() {
+  return metrics.getMeter(METER_NAME, METER_VERSION);
+}
+function modelFallbacks() {
+  return _modelFallbacks ??= meter().createCounter("vl.llm.model_fallback", {
+    description: "Model calls the provider rejected that fell back to the platform default model",
+    unit: "{fallbacks}"
+  });
+}
+function recordModelFallback(args) {
+  const out = {
+    "vl.model": args.model,
+    "vl.fallback_model": args.fallbackModel,
+    "vl.error_code": args.code
+  };
+  if (args.projectId)
+    out[ATTR.projectId] = args.projectId;
+  if (args.agentId)
+    out[ATTR.agentId] = args.agentId;
+  if (args.surface)
+    out["vl.surface"] = args.surface;
+  modelFallbacks().add(1, out);
+}
+var METER_NAME, METER_VERSION, _modelFallbacks;
+var init_metrics = __esm({
+  "../observability/dist/metrics.js"() {
+    init_attributes();
+    METER_NAME = "voicelayer";
+    METER_VERSION = "0.1.0";
+    _modelFallbacks = null;
+  }
+});
+var init_latency_span = __esm({
+  "../observability/dist/latency-span.js"() {
+    init_attributes();
+  }
+});
+
+// ../observability/dist/index.js
+var init_dist2 = __esm({
+  "../observability/dist/index.js"() {
+    init_start();
+    init_call_context();
+    init_trace_propagation();
+    init_attributes();
+    init_metrics();
+    init_latency_span();
+  }
+});
+
+// src/providers/resilient-llm.ts
+var resilient_llm_exports = {};
+__export(resilient_llm_exports, {
+  LLM_APOLOGY: () => LLM_APOLOGY,
+  ResilientLLM: () => ResilientLLM,
+  isResilientLLM: () => isResilientLLM
+});
+function isResilientLLM(value) {
+  return typeof value === "object" && value !== null && value[RESILIENT] === true;
+}
+function transient(error) {
+  if (error instanceof APIStatusError) {
+    const s = error.statusCode;
+    return s === 408 || s === 429 || s < 0 || s >= 500;
+  }
+  return error instanceof APITimeoutError || error instanceof APIConnectionError;
+}
+var LLM_APOLOGY, RESILIENT, ResilientLLM, sameModel, ServedLLM, ResilientLLMStream;
+var init_resilient_llm = __esm({
+  "src/providers/resilient-llm.ts"() {
+    init_dist();
+    init_dist2();
+    LLM_APOLOGY = "Sorry, I'm having trouble right now. Could you give me a moment and say that again?";
+    RESILIENT = /* @__PURE__ */ Symbol.for("voicelayer.resilientLLM");
+    ResilientLLM = class extends llm.LLM {
+      [RESILIENT] = true;
+      #opts;
+      #fallback = null;
+      #listeners = /* @__PURE__ */ new Set();
+      /** Models the provider rejected on this call (a call's pipeline is built per call): later turns go straight to the fallback. */
+      rejections = new ModelRejectionCache();
+      constructor(opts) {
+        super();
+        this.#opts = opts;
+      }
+      label() {
+        return this.#opts.primary.label();
+      }
+      get model() {
+        return this.#opts.primary.model;
+      }
+      get provider() {
+        return this.#opts.primary.provider;
+      }
+      get apology() {
+        return this.#opts.apology ?? LLM_APOLOGY;
+      }
+      get reasoningParams() {
+        return this.#opts.reasoningParams === true;
+      }
+      /** The fallback LLM, built on first need; null when there is none or it is the agent's own model. */
+      fallbackLLM() {
+        if (!this.#opts.fallback) return null;
+        this.#fallback ??= this.#opts.fallback();
+        return sameModel(this.#fallback.model, this.model) ? null : this.#fallback;
+      }
+      /** Hear about every recovery (and every apology). Returns the unsubscribe. */
+      onIncident(listener) {
+        this.#listeners.add(listener);
+        return () => this.#listeners.delete(listener);
+      }
+      /** @internal */
+      report(incident) {
+        const log = incident.kind === "apology" ? console.error : console.warn;
+        log(`[voicelayer] llm ${incident.kind.replace(/_/g, " ")}`, incident);
+        if (incident.kind === "model_fallback") {
+          const call = getCurrentCallContext();
+          recordModelFallback({
+            model: incident.model,
+            fallbackModel: incident.fallbackModel,
+            code: incident.code,
+            surface: "voice",
+            ...call?.projectId ? { projectId: call.projectId } : {},
+            ...call?.agentId ? { agentId: call.agentId } : {}
+          });
+        }
+        for (const listener of this.#listeners) {
+          try {
+            listener(incident);
+          } catch {
+          }
+        }
+      }
+      chat(args) {
+        return new ResilientLLMStream(this, args);
+      }
+      prewarm() {
+        this.#opts.primary.prewarm();
+      }
+      async aclose() {
+        await Promise.all([this.#opts.primary.aclose(), this.#fallback?.aclose()]);
+      }
+      /** @internal */
+      get primary() {
+        return this.#opts.primary;
+      }
+    };
+    sameModel = (a, b) => a.trim().toLowerCase() === b.trim().toLowerCase();
+    ServedLLM = class extends llm.LLM {
+      constructor(owner, served) {
+        super();
+        this.owner = owner;
+        this.served = served;
+      }
+      owner;
+      served;
+      label() {
+        return this.owner.label();
+      }
+      get model() {
+        return this.served();
+      }
+      get provider() {
+        return this.owner.provider;
+      }
+      chat(args) {
+        return this.owner.chat(args);
+      }
+      emit(event, ...args) {
+        return this.owner.emit(event, ...args);
+      }
+    };
+    ResilientLLMStream = class extends llm.LLMStream {
+      #owner;
+      #args;
+      #conn;
+      /** The model answering this stream — what its metrics report. */
+      #served;
+      #current = null;
+      constructor(owner, args) {
+        const conn = args.connOptions ?? DEFAULT_API_CONNECT_OPTIONS;
+        const served = { model: owner.model };
+        super(new ServedLLM(owner, () => served.model), {
+          chatCtx: args.chatCtx,
+          ...args.toolCtx ? { toolCtx: args.toolCtx } : {},
+          connOptions: { ...conn, maxRetry: 0 }
+        });
+        this.#owner = owner;
+        this.#args = args;
+        this.#conn = conn;
+        this.#served = served;
+        this.abortController.signal.addEventListener("abort", () => this.#current?.close());
+      }
+      get #hasTools() {
+        return this.#args.toolCtx !== void 0 && Object.keys(this.#args.toolCtx).length > 0;
+      }
+      #extraKwargs(model2) {
+        const base = this.#args.extraKwargs;
+        if (!this.#owner.reasoningParams) return base;
+        const effort = chatReasoningEffort(model2, { tools: this.#hasTools });
+        if (effort === void 0) {
+          if (!base || !("reasoning_effort" in base)) return base;
+          const { reasoning_effort: _dropped, ...rest } = base;
+          return rest;
+        }
+        return { ...base, reasoning_effort: effort };
+      }
+      /** One request on `target`, forwarding its chunks. Its failure is the inner LLM's 'error' event. */
+      async #attempt(target) {
+        let failure = null;
+        const onError = (ev) => {
+          failure ??= ev.error;
+        };
+        target.on("error", onError);
+        let started = false;
+        try {
+          const extraKwargs = this.#extraKwargs(target.model);
+          const stream = target.chat({
+            ...this.#args,
+            connOptions: { ...this.#conn, maxRetry: 0 },
+            ...extraKwargs !== void 0 ? { extraKwargs } : {}
+          });
+          this.#current = stream;
+          for await (const chunk of stream) {
+            if (this.abortController.signal.aborted) break;
+            started = true;
+            this.queue.put(chunk);
+          }
+        } catch (err) {
+          failure ??= err instanceof Error ? err : new Error(String(err));
+        } finally {
+          target.off("error", onError);
+          this.#current = null;
+        }
+        return failure ? { ok: false, error: failure, started } : { ok: true };
+      }
+      /** Run `target` until it answers, or a failure that retrying it won't fix. */
+      async #run(target) {
+        let effortRetried = false;
+        for (let retries = 0; ; ) {
+          const sent = this.#owner.reasoningParams ? chatReasoningEffort(target.model, { tools: this.#hasTools }) : void 0;
+          const result = await this.#attempt(target);
+          if (result.ok || result.started || this.abortController.signal.aborted) return result;
+          if (this.#owner.reasoningParams && !effortRetried && learnReasoningEffort(target.model, { tools: this.#hasTools, sent }, result.error)) {
+            effortRetried = true;
+            this.#owner.report({
+              kind: "reasoning_effort_adapted",
+              model: target.model,
+              message: providerErrorOf(result.error)?.message ?? result.error.message
+            });
+            continue;
+          }
+          if (!transient(result.error) || retries >= this.#conn.maxRetry) return result;
+          const wait = intervalForRetry(this.#conn, retries);
+          retries += 1;
+          if (wait > 0) await new Promise((r) => setTimeout(r, wait));
+          if (this.abortController.signal.aborted) return result;
+        }
+      }
+      async run() {
+        const owner = this.#owner;
+        const model2 = owner.model;
+        const fallback = owner.fallbackLLM();
+        const known = fallback ? owner.rejections.get(model2) : null;
+        let failure;
+        if (known && fallback) {
+          owner.report({ kind: "model_fallback", model: model2, fallbackModel: fallback.model, code: known.code, message: known.message, cached: true });
+          failure = new Error(known.message);
+        } else {
+          const first = await this.#run(owner.primary);
+          if (first.ok || first.started || this.abortController.signal.aborted) return;
+          failure = first.error;
+          const rejection = modelRejectionOf(first.error);
+          if (rejection) owner.rejections.set(model2, rejection);
+          if (fallback) {
+            const f = providerErrorOf(first.error);
+            owner.report({
+              kind: "model_fallback",
+              model: model2,
+              fallbackModel: fallback.model,
+              code: rejection?.code ?? (f?.status ? String(f.status) : "error"),
+              message: f?.message || first.error.message,
+              cached: false
+            });
+          }
+        }
+        if (fallback) {
+          this.#served.model = fallback.model;
+          const second = await this.#run(fallback);
+          if (second.ok || second.started || this.abortController.signal.aborted) return;
+          failure = second.error;
+        }
+        owner.report({ kind: "apology", model: this.#served.model, message: providerErrorOf(failure)?.message || failure.message });
+        this.queue.put({ id: `vl-apology-${Date.now()}`, delta: { role: "assistant", content: owner.apology } });
+      }
+    };
+  }
+});
 
 // src/providers/index.ts
 async function importOptional(spec, hint) {
@@ -4346,9 +5198,13 @@ var init_providers2 = __esm({
       llm(options = {}) {
         return async () => {
           const oa = await importOptional("@voicelayer/agents-plugin-openai", "openai.llm");
-          return new oa.LLM(
-            withCreds({ model: options.model ?? "gpt-4o-mini" }, options)
-          );
+          const { ResilientLLM: ResilientLLM2 } = await Promise.resolve().then(() => (init_resilient_llm(), resilient_llm_exports));
+          const { PLATFORM_DEFAULT_CHAT_MODEL: PLATFORM_DEFAULT_CHAT_MODEL2 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
+          return new ResilientLLM2({
+            primary: new oa.LLM(withCreds({ model: options.model ?? "gpt-4o-mini" }, options)),
+            fallback: () => new oa.LLM(withCreds({ model: PLATFORM_DEFAULT_CHAT_MODEL2 }, options)),
+            reasoningParams: true
+          });
         };
       },
       tts(options = {}) {
@@ -4424,9 +5280,10 @@ var init_providers2 = __esm({
       llm(options = {}) {
         return async () => {
           const g = await importOptional("@voicelayer/agents-plugin-google", "google.llm");
-          return new g.LLM(
-            withCreds({ model: options.model ?? "gemini-3.8-flash" }, options)
-          );
+          const { ResilientLLM: ResilientLLM2 } = await Promise.resolve().then(() => (init_resilient_llm(), resilient_llm_exports));
+          return new ResilientLLM2({
+            primary: new g.LLM(withCreds({ model: options.model ?? "gemini-3.8-flash" }, options))
+          });
         };
       },
       realtime(options = {}) {
@@ -4528,91 +5385,6 @@ var init_llm = __esm({
     init_registry();
   }
 });
-var init_start = __esm({
-  "../observability/dist/start.js"() {
-  }
-});
-
-// ../observability/dist/attributes.js
-var ATTR;
-var init_attributes = __esm({
-  "../observability/dist/attributes.js"() {
-    ATTR = {
-      projectId: "vl.project_id",
-      callId: "vl.call_id",
-      campaignId: "vl.campaign_id",
-      room: "vl.room",
-      agentId: "vl.agent_id",
-      phoneNumberId: "vl.phone_number_id",
-      bindingId: "vl.binding_id",
-      source: "vl.source",
-      kind: "vl.kind"
-    };
-  }
-});
-function getCurrentCallContext() {
-  return callContextStore.getStore();
-}
-var callContextStore;
-var init_call_context = __esm({
-  "../observability/dist/call-context.js"() {
-    init_attributes();
-    callContextStore = new AsyncLocalStorage();
-  }
-});
-var init_trace_propagation = __esm({
-  "../observability/dist/trace-propagation.js"() {
-  }
-});
-function meter() {
-  return metrics.getMeter(METER_NAME, METER_VERSION);
-}
-function modelFallbacks() {
-  return _modelFallbacks ??= meter().createCounter("vl.llm.model_fallback", {
-    description: "Model calls the provider rejected that fell back to the platform default model",
-    unit: "{fallbacks}"
-  });
-}
-function recordModelFallback(args) {
-  const out = {
-    "vl.model": args.model,
-    "vl.fallback_model": args.fallbackModel,
-    "vl.error_code": args.code
-  };
-  if (args.projectId)
-    out[ATTR.projectId] = args.projectId;
-  if (args.agentId)
-    out[ATTR.agentId] = args.agentId;
-  if (args.surface)
-    out["vl.surface"] = args.surface;
-  modelFallbacks().add(1, out);
-}
-var METER_NAME, METER_VERSION, _modelFallbacks;
-var init_metrics = __esm({
-  "../observability/dist/metrics.js"() {
-    init_attributes();
-    METER_NAME = "voicelayer";
-    METER_VERSION = "0.1.0";
-    _modelFallbacks = null;
-  }
-});
-var init_latency_span = __esm({
-  "../observability/dist/latency-span.js"() {
-    init_attributes();
-  }
-});
-
-// ../observability/dist/index.js
-var init_dist2 = __esm({
-  "../observability/dist/index.js"() {
-    init_start();
-    init_call_context();
-    init_trace_propagation();
-    init_attributes();
-    init_metrics();
-    init_latency_span();
-  }
-});
 
 // src/runtime/helper-models.ts
 function rejectionsFor(client) {
@@ -4852,7 +5624,9 @@ function evaluateDeterministic(atom, ctx) {
     if (result === void 0) return false;
     if (!path || path === "ok") {
       const ok = result.ok === true || result.kind === "ok";
-      return op === "!=" ? !ok : ok;
+      const want = (rawVal ?? "").trim().toLowerCase();
+      const eq2 = want === "" ? ok : String(ok) === want;
+      return op === "!=" ? !eq2 : eq2;
     }
     const actual = resolvePath(result, path);
     if (!op) return actual !== void 0 && actual !== null && actual !== "";
@@ -5047,28 +5821,12 @@ var init_conditions = __esm({
 });
 
 // src/runtime/graph/turn-text.ts
-function lastSentences(line) {
-  const text = line.trim();
-  if (!text) return [];
-  const sentences = [];
-  let last = 0;
-  for (const m of text.matchAll(SENTENCE_END)) {
-    const end = (m.index ?? 0) + m[0].length;
-    sentences.push(text.slice(last, end));
-    last = end;
-  }
-  if (last < text.length) sentences.push(text.slice(last));
-  return sentences.slice(-2);
-}
-function isQuestion(line) {
-  return lastSentences(line).some((s) => QUESTION_MARK.test(s));
-}
 function wordsOf(field) {
   return field.toLowerCase().split(/[^a-z0-9]+/).filter(Boolean);
 }
 function asksFor(line, fields) {
   if (!line) return false;
-  const questions = lastSentences(line).filter((s) => QUESTION_MARK.test(s)).map((s) => s.toLowerCase().replace(/^[\s"'“(]*(?:and|so|ok|okay|great|thanks|sure|alright|now)[,\s]+/, "").trim());
+  const questions = lastSentences(line).filter((s) => QUESTION_MARK2.test(s)).map((s) => s.toLowerCase().replace(/^[\s"'“(]*(?:and|so|ok|okay|great|thanks|sure|alright|now)[,\s]+/, "").trim());
   return questions.some((q) => {
     if (YES_NO.test(q) && !POLITE_REQUEST.test(q)) return false;
     const words = new Set(q.match(/[a-z0-9]+/g) ?? []);
@@ -5078,11 +5836,11 @@ function asksFor(line, fields) {
     });
   });
 }
-var QUESTION_MARK, SENTENCE_END, POLITE_REQUEST, YES_NO;
+var QUESTION_MARK2, POLITE_REQUEST, YES_NO;
 var init_turn_text = __esm({
   "src/runtime/graph/turn-text.ts"() {
-    QUESTION_MARK = /[?？؟]/;
-    SENTENCE_END = /[.!?…。！？؟]+["'”’)\]]*\s*/g;
+    init_src();
+    QUESTION_MARK2 = /[?？؟]/;
     POLITE_REQUEST = /^(?:(?:could|can|would|will) you (?:please )?(?:tell|give|share|say|spell|repeat|read|provide|confirm|let me know)|(?:could|can|may) (?:i|we) (?:please )?(?:get|have|take|grab))\b/;
     YES_NO = /^(?:would|do|does|did|is|are|was|were|can|could|shall|should|will|have|has|had|may|might|am)\b/;
   }
@@ -5645,7 +6403,8 @@ async function nextTurn(deps, state, reprompt, opts) {
       ...opts?.deferCapture ? { deferCapture: true } : {},
       ...opts?.number ? { number: opts.number } : {},
       ...opts?.fields?.length ? { fields: opts.fields } : {},
-      ...opts?.answering && opts.answering.fields.length > 0 ? { answering: opts.answering } : {}
+      ...opts?.answering && opts.answering.fields.length > 0 ? { answering: opts.answering } : {},
+      ...opts?.captureAfterRead ? { captureAfterRead: true } : {}
     });
     if (evt.kind === "hangup") return { result: { kind: "end" } };
     if (evt.kind === "control") return { result: evt.result };
@@ -5672,7 +6431,7 @@ async function nextTurn(deps, state, reprompt, opts) {
     state.lastNotInContext = evt.notInContext;
     state.lastAgentText = evt.agentText;
     state.lastDtmf = void 0;
-    return { text: evt.text };
+    return { text: evt.text, ...evt.capture ? { capture: evt.capture } : {} };
   }
 }
 function detectYesNo(text) {
@@ -5682,6 +6441,58 @@ function detectYesNo(text) {
   if (no && !yes) return "no";
   return null;
 }
+function renderLine(template, state, deps) {
+  return { spoken: interpolate(template, scopeFor(state, deps)), model: interpolate(template, modelScopeFor(state, deps)) };
+}
+function askLinesFor(node, state, deps, askText, label, rephrase) {
+  const render = (line) => renderLine(line, state, deps);
+  const ctx = deps.askContext;
+  const english = isEnglishLanguage(ctx?.language);
+  const generated = readAskGeneratedLines(node.config.generated);
+  const current = generated !== null && ctx !== void 0 && generated.basis === askLinesBasis({
+    persona: ctx.persona,
+    routing: ctx.routing ?? null,
+    language: ctx.language ?? null,
+    ask: str(node.config.ask),
+    instructions: str(node.config.instructions)
+  });
+  if (generated && !current) deps.events.note("ask.reask_lines_stale", { node: node.id });
+  const usable = current && rephrase !== "never" ? generated : null;
+  const author = authorReasksOf(node.config.reasks).map(render);
+  const pool = author.length ? author : usable && usable.reasks.length ? usable.reasks.map(render) : english ? templateReasks(askText.spoken).map((spoken, i) => ({ spoken, model: templateReasks(askText.model)[i] })) : rephrase === "never" ? [askText] : [];
+  const offerTemplate = english ? skipOfferTemplate(label) : void 0;
+  const skipOffer = usable?.skipOffer ? render(usable.skipOffer) : offerTemplate ? { spoken: offerTemplate, model: offerTemplate } : void 0;
+  const voicedAsk = rephrase === "all" && usable?.voicedAsk ? render(usable.voicedAsk) : void 0;
+  return { pool, ...skipOffer ? { skipOffer } : {}, ...voicedAsk ? { voicedAsk } : {} };
+}
+function skipOfferVerdict(text, dtmf) {
+  if (dtmf === "1") return "yes";
+  if (dtmf === "2") return "no";
+  if (!text.trim()) return null;
+  if (KEEP_ASKING.test(text)) return "no";
+  if (SKIP_INTENT.test(text)) return OFFERS_IT.test(text) ? null : "yes";
+  return detectYesNo(text);
+}
+async function readYesNo(t, state, deps) {
+  const words = skipOfferVerdict(t.text, t.dtmf);
+  if (words) return words;
+  if (!t.text.trim()) return null;
+  return await resolveBranch(
+    [
+      { id: "yes", label: "The caller agrees to skip it for now." },
+      { id: "no", label: "The caller does not want to skip it \u2014 they will give it." }
+    ],
+    evalCtxOf(state, deps)
+  );
+}
+function briefingScope(template, state, deps) {
+  const scope2 = scopeFor(state, deps);
+  const data = deps.processRt.getData();
+  const notProvided = templateFieldRefs(template).filter((f) => isRequiredField(deps, f) && !hasSlot(data, f));
+  if (notProvided.length === 0) return scope2;
+  const filled = Object.fromEntries(notProvided.map((f) => [f, "not provided"]));
+  return { ...scope2, ...filled, slots: { ...scope2.slots, ...filled } };
+}
 function formatCollected(deps) {
   return Object.entries(deps.processRt.getData()).filter(([, v]) => v !== void 0 && v !== null && v !== "").map(([k, v]) => `${k.trim()}: ${String(forModel(deps, k, v))}`).join("\n");
 }
@@ -5735,6 +6546,27 @@ function positiveMs(raw, fallback) {
   const n = Number(raw);
   return Number.isFinite(n) && n > 0 ? n : fallback;
 }
+function isRequiredField(deps, name) {
+  return deps.model.requiredFields.has(name.trim());
+}
+function requiredInputsOf(node, state, deps) {
+  const baked = node.config.requiredInputs;
+  if (Array.isArray(baked)) return baked.filter((x) => typeof x === "string");
+  const cached2 = state.derivedInputs?.get(node.id);
+  if (cached2) return cached2;
+  const derived = requiredInputsFor(node.type, node.config, (f) => isRequiredField(deps, f));
+  (state.derivedInputs ??= /* @__PURE__ */ new Map()).set(node.id, derived);
+  return derived;
+}
+function blockOnMissingInputs(node, state, deps, inputs, tool) {
+  const data = deps.processRt.getData();
+  const missing = inputs.filter((f) => !hasSlot(data, f)).map((f) => f.trim());
+  if (missing.length === 0) return null;
+  deps.events.note("step.missing_inputs", { node: node.id, missing });
+  state.nodeResults[node.id] = { ok: false, error: "missing_required", missing };
+  if (tool) state.toolResults[node.id] = { ok: false, status: 0, data: { kind: "blocked", reason: "missing_required", missing } };
+  return deps.model.selectByPort(node.id, MISSING_PORT_ID) !== null ? { kind: "take", port: MISSING_PORT_ID } : routeByPort(node, deps, "fail");
+}
 function routeByPort(node, deps, port) {
   return deps.model.selectByPort(node.id, port) !== null ? { kind: "take", port } : { kind: "advance" };
 }
@@ -5746,11 +6578,15 @@ function menuDigitOf(b) {
 function menuLabelOf(label) {
   return label.replace(/^\s*[0-9*#]\s*[-—–:.]*\s*/, "").trim() || label.trim();
 }
-var ASK_MAX_CLARIFY, COLLECT_MAX_STALLED_TURNS, LLM_MAX_TURNS, HUB_MAX_TURNS, NO_INPUT_MS, sayExecutor, YES_WORDS, NO_WORDS, confirmExecutor, askExecutor, gateExecutor, endExecutor, handoffExecutor, OPENING_SILENCE_MS, llmExecutor, toolExecutor, ragExecutor, codeExecutor, decisionExecutor, MENU_MAX_INPUTS, menuExecutor, classifyExecutor, routerExecutor, playbookExecutor, setExecutor, MAX_SUBFLOW_DEPTH, subflowExecutor, EmailStepTimeout, EMAIL_SEND_TIMEOUT_MS, emailExecutor, passthroughExecutor, EXECUTORS;
+async function speakLine(text, deps) {
+  await speak(text, deps);
+}
+var ASK_MAX_CLARIFY, COLLECT_MAX_STALLED_TURNS, LLM_MAX_TURNS, HUB_MAX_TURNS, NO_INPUT_MS, sayExecutor, YES_WORDS, NO_WORDS, confirmExecutor, legacyAskExecutor, ASK_POLICIES, askExecutor, KEEP_ASKING, SKIP_INTENT, OFFERS_IT, gateExecutor, endExecutor, handoffExecutor, OPENING_SILENCE_MS, llmExecutor, toolExecutor, ragExecutor, codeExecutor, decisionExecutor, MENU_MAX_INPUTS, menuExecutor, classifyExecutor, routerExecutor, playbookExecutor, setExecutor, MAX_SUBFLOW_DEPTH, subflowExecutor, EmailStepTimeout, EMAIL_SEND_TIMEOUT_MS, emailExecutor, passthroughExecutor, EXECUTORS;
 var init_executors = __esm({
   "src/runtime/graph/executors.ts"() {
     init_log();
     init_src();
+    init_reask_templates();
     init_interpolate();
     init_builtins();
     init_conditions();
@@ -5772,9 +6608,11 @@ var init_executors = __esm({
     NO_WORDS = /\b(no|nope|nah|wrong|incorrect|negative|not right|that'?s not|change|actually)\b/i;
     confirmExecutor = async (node, state, deps) => {
       const text = interpolate(str(node.config.text), scopeFor(state, deps));
-      await speak(text || "Is that correct?", deps);
+      const line = text || "Is that correct?";
+      await speak(line, deps);
+      const reprompt = isEnglishLanguage(deps.askContext?.language) ? notCaught(line) : line;
       for (let attempt = 0; attempt < 2; attempt++) {
-        const t = await nextTurn(deps, state, text || "Is that correct?");
+        const t = await nextTurn(deps, state, reprompt);
         if ("result" in t) return t.result;
         let verdict = null;
         if (t.dtmf === "1") verdict = "yes";
@@ -5802,7 +6640,7 @@ var init_executors = __esm({
       deps.events.note("confirm.unresolved", { node: node.id });
       return { kind: "advance" };
     };
-    askExecutor = async (node, state, deps) => {
+    legacyAskExecutor = async (node, state, deps) => {
       const slot = str(node.config.slot) || node.id;
       const authoredSlot = slot === node.id ? "" : slot.trim();
       const label = authoredSlot.replace(/[_-]+/g, " ");
@@ -5843,6 +6681,165 @@ var init_executors = __esm({
       deps.events.note("ask.unfilled", { slot: slot.trim() });
       return { kind: "advance" };
     };
+    ASK_POLICIES = /* @__PURE__ */ new Set(["offer_skip", "fallback", "end"]);
+    askExecutor = async (node, state, deps) => {
+      const cfg = node.config;
+      if (typeof cfg.maxAttempts !== "number") return legacyAskExecutor(node, state, deps);
+      const slot = str(cfg.slot) || node.id;
+      const field = slot.trim();
+      const label = (slot === node.id ? "" : field).replace(/[_-]+/g, " ");
+      const required = cfg.required !== false;
+      const maxAttempts = Math.min(6, Math.max(1, Math.round(cfg.maxAttempts)));
+      const policy = ASK_POLICIES.has(str(cfg.onExhausted)) ? str(cfg.onExhausted) : "offer_skip";
+      const rephrase = cfg.rephrase === "all" || cfg.rephrase === "never" ? cfg.rephrase : "reasks";
+      const unfilledWired = deps.model.selectByPort(node.id, UNFILLED_PORT_ID) !== null;
+      const captured = () => hasSlot(deps.processRt.getData(), slot);
+      const exitNext = { kind: "advance" };
+      if (captured()) {
+        deps.events.note("ask.skipped", { slot: field, reason: "already known" });
+        return exitNext;
+      }
+      const askText = renderLine(str(cfg.ask) || defaultAskText(slot, node.id), state, deps);
+      const lines = askLinesFor(node, state, deps, askText, label, rephrase);
+      const closing = () => interpolate(str(cfg.exhaustedMessage) || DEFAULT_ASK_EXHAUSTED_MESSAGE, scopeFor(state, deps));
+      const giveUp = async () => {
+        state.closingLine = closing();
+        if (unfilledWired) return { kind: "take", port: UNFILLED_PORT_ID };
+        await speak(state.closingLine, deps);
+        return { kind: "end" };
+      };
+      let lastLine = askText;
+      let rotation = 0;
+      const nextLine = () => {
+        const pool = lines.pool;
+        if (pool.length === 0) return askText;
+        let line = pool[rotation++ % pool.length];
+        if (line.spoken === lastLine.spoken && pool.length > 1) line = pool[rotation++ % pool.length];
+        return line;
+      };
+      const sayLine = async (line) => {
+        lastLine = line;
+        await speak(line.spoken, deps);
+      };
+      const kind = cfg.type === "phone" || cfg.type === "number" ? cfg.type : void 0;
+      const turnOpts = (since) => ({
+        fields: [slot],
+        // the ask's question is about its slot by definition: every turn here answers it (a free-text slot takes the turn)
+        answering: { fields: answerable(deps, [slot]), step: node.id, since },
+        ...kind ? { number: { field: slot, kind } } : {}
+      });
+      let askedAt = Date.now();
+      if (required && state.skipped?.[field]) {
+        const revisits = (state.skipRevisits?.[field] ?? 0) + 1;
+        state.skipRevisits = { ...state.skipRevisits, [field]: revisits };
+        if (revisits >= 2) {
+          deps.events.note("ask.revisit_exhausted", { slot: field });
+          return giveUp();
+        }
+        deps.events.note("ask.revisit", { slot: field });
+        await sayLine(askText);
+        const t = await nextTurn(deps, state, () => sayLine(nextLine()), turnOpts(askedAt));
+        if ("result" in t) return t.result;
+        if (captured()) {
+          deps.events.note("ask.captured", { slot: field });
+          return exitNext;
+        }
+        deps.events.note("ask.revisit_unfilled", { slot: field });
+        return giveUp();
+      }
+      const clarify = async (question) => {
+        const endOn = lines.pool.length > 0 ? nextLine() : null;
+        const what = label || "the detail just asked about";
+        const parts = [
+          `You are collecting "${what}" from the caller. They haven't given a clear, valid value yet.`,
+          question ? "The caller asked a question: answer it briefly and honestly first." : "Acknowledge what they said in a few words.",
+          // the model-safe copies only: caller-given values fenced and tokenised, never raw (§B.9)
+          endOn ? `Then ask for just that again, ending on this question: "${endOn.model}"` : "Then briefly ask again for just that.",
+          `Don't repeat this line word for word: "${lastLine.model}"`
+        ];
+        const instructions = interpolate(str(cfg.instructions), modelScopeFor(state, deps));
+        if (instructions) parts.push(`About this question (from the flow's author): ${instructions}`);
+        if (endOn) lastLine = endOn;
+        await withHistory(deps, historyPolicyOf(node), () => genReply(deps, parts.join("\n")));
+      };
+      const round = async (attempts) => {
+        let tries = 0;
+        for (let turn = 1; ; turn++) {
+          const t = await nextTurn(deps, state, () => sayLine(nextLine()), turnOpts(askedAt));
+          if ("result" in t) return t.result;
+          if (captured()) return "captured";
+          const text = t.text.trim();
+          const filler = isFiller(text);
+          const question = !filler && isQuestion(text);
+          if (!question) tries += 1;
+          if (tries >= attempts) return "exhausted";
+          if (turn >= 2 * attempts) {
+            deps.events.note("ask.turn_cap", { slot: field, turns: turn });
+            return "exhausted";
+          }
+          deps.events.note("ask.clarify", { slot: field, turn, kind: filler ? "filler" : question ? "question" : "answer" });
+          if (filler && lines.pool.length > 0 || rephrase === "never") await sayLine(nextLine());
+          else await clarify(question);
+        }
+      };
+      await sayLine(lines.voicedAsk ?? askText);
+      let outcome = await round(maxAttempts);
+      if (outcome === "captured") {
+        deps.events.note("ask.captured", { slot: field });
+        return exitNext;
+      }
+      if (outcome !== "exhausted") return outcome;
+      if (!required) {
+        deps.events.note("ask.unfilled", { slot: field });
+        return exitNext;
+      }
+      deps.events.note("ask.exhausted", { slot: field, policy });
+      if (policy === "end" || policy === "fallback") return giveUp();
+      const offer = lines.skipOffer;
+      if (!offer) return giveUp();
+      state.closingLine = closing();
+      const skip = (reason) => {
+        state.skipped = { ...state.skipped, [field]: reason };
+        deps.events.note("ask.skipped_by_caller", { slot: field, reason });
+        return unfilledWired ? { kind: "take", port: UNFILLED_PORT_ID } : exitNext;
+      };
+      let unclear = 0;
+      await sayLine(offer);
+      for (; ; ) {
+        const t = await nextTurn(deps, state, offer.spoken, { fields: [slot], captureAfterRead: true });
+        if ("result" in t) return t.result;
+        const verdict = await readYesNo(t, state, deps);
+        if (verdict === "yes") {
+          await t.capture?.({ exclude: [slot] });
+          return skip("caller");
+        }
+        if (verdict === "no") {
+          await t.capture?.({ exclude: [slot] });
+          deps.events.note("ask.skip_declined", { slot: field });
+          askedAt = Date.now();
+          await sayLine(nextLine());
+          outcome = await round(maxAttempts);
+          if (outcome === "captured") {
+            deps.events.note("ask.captured", { slot: field });
+            return exitNext;
+          }
+          if (outcome !== "exhausted") return outcome;
+          deps.events.note("ask.exhausted", { slot: field, policy, round: 2 });
+          return giveUp();
+        }
+        await t.capture?.();
+        if (captured()) {
+          deps.events.note("ask.captured", { slot: field });
+          return exitNext;
+        }
+        unclear += 1;
+        if (unclear >= 2) return skip("unclear");
+        await sayLine(offer);
+      }
+    };
+    KEEP_ASKING = /\b(?:don'?t|do not|not|never|no need to)(?:\s+\w+){0,3}\s+skip\b|\bi(?:'ve| have)(?: got)? it\b/i;
+    SKIP_INTENT = /\b(?:skip|don'?t have|do not have|haven'?t got|move on|pass on (?:it|that|this))\b/i;
+    OFFERS_IT = /\b(?:give|here|hold on|let me|it'?s|my number)\b/i;
     gateExecutor = async (node, _state, deps) => {
       const required = Array.isArray(node.config.requiredFields) ? node.config.requiredFields.filter((x) => typeof x === "string") : [];
       const data = deps.processRt.getData();
@@ -5865,7 +6862,7 @@ var init_executors = __esm({
       }
       const reason = str(cfg.reason) || `flow:${node.id}`;
       const mode = cfg.mode === "warm" || cfg.mode === "cold" ? cfg.mode : void 0;
-      const briefing = str(cfg.briefing) ? interpolate(str(cfg.briefing), scopeFor(state, deps)) : void 0;
+      const briefing = str(cfg.briefing) ? interpolate(str(cfg.briefing), briefingScope(str(cfg.briefing), state, deps)) : void 0;
       deps.events.note("handoff.start", { node: node.id, to: target, ...mode ? { mode } : {} });
       try {
         await deps.ctx.handoff(target, {
@@ -5969,9 +6966,17 @@ ${collected}`);
       const toolRef = str(cfg.toolRef);
       const registry = deps.resolvers?.registryTools;
       if (toolRef && registry) {
-        deps.events.note("tool.invoked", { node: node.id, name: toolRef, ref: true });
         try {
           const spec = (await registry.catalog()).find((t) => t.name === toolRef);
+          const blocked2 = blockOnMissingInputs(
+            node,
+            state,
+            deps,
+            Object.keys(spec?.input ?? {}).filter((f) => isRequiredField(deps, f)),
+            true
+          );
+          if (blocked2) return blocked2;
+          deps.events.note("tool.invoked", { node: node.id, name: toolRef, ref: true });
           const slots2 = deps.processRt.getData();
           const bag2 = {};
           for (const field of Object.keys(spec?.input ?? {})) {
@@ -6004,6 +7009,8 @@ ${collected}`);
         deps.events.note("tool.unavailable", { node: node.id, name: toolRef });
         return routeByOutcome();
       }
+      const blocked = blockOnMissingInputs(node, state, deps, requiredInputsOf(node, state, deps), true);
+      if (blocked) return blocked;
       const url = str(cfg.url);
       if (!url) {
         state.toolResults[node.id] = { ok: false, status: 0, data: null };
@@ -6229,7 +7236,7 @@ ${collected}`);
             deps.events.note("menu.selected", { node: node.id, choice });
             return { kind: "take", port: choice };
           }
-          await speak(prompt, deps);
+          await speak(isEnglishLanguage(deps.askContext?.language) && prompt ? notCaught(prompt) : prompt, deps);
         }
       }
       deps.events.note("menu.unmatched", { node: node.id });
@@ -6502,7 +7509,7 @@ ${collected}`);
         }
         await speak(
           interpolate(
-            str(cfg.incompleteMessage) || "I wasn't able to get everything we need on this call, so let me have someone follow up with you. Thanks for your time.",
+            str(cfg.incompleteMessage) || DEFAULT_ASK_EXHAUSTED_MESSAGE,
             scopeFor(state, deps)
           ),
           deps
@@ -6558,6 +7565,7 @@ ${collected}`);
         ...deps.resolvers ? { resolvers: deps.resolvers } : {},
         ...deps.live ? { live: deps.live } : {},
         ...deps.security ? { security: deps.security } : {},
+        ...deps.askContext ? { askContext: deps.askContext } : {},
         depth: depth + 1
       });
       deps.events.note("subflow.exit", { node: node.id, ref, outcome: outcome.kind });
@@ -6570,6 +7578,8 @@ ${collected}`);
     EMAIL_SEND_TIMEOUT_MS = 1e4;
     emailExecutor = async (node, state, deps) => {
       const cfg = node.config;
+      const blocked = blockOnMissingInputs(node, state, deps, requiredInputsOf(node, state, deps), false);
+      if (blocked) return blocked;
       const scope2 = scopeFor(state, deps);
       const render = (key) => interpolate(str(cfg[key]), scope2).trim();
       const to = render("to");
@@ -6679,6 +7689,12 @@ async function selectNext(model2, from, result, state, deps) {
     ...state.lastDtmf !== void 0 ? { lastDtmf: state.lastDtmf } : {}
   });
 }
+async function closeAtLoopGuard(state, deps) {
+  try {
+    await speakLine(state.closingLine ?? DEFAULT_ASK_EXHAUSTED_MESSAGE, { ctx: deps.ctx, ...deps.realtime ? { realtime: true } : {} });
+  } catch {
+  }
+}
 async function runFlowGraph(program, deps) {
   const model2 = buildGraphModel(program);
   const maxNodeVisits = deps.maxNodeVisits ?? DEFAULT_MAX_NODE_VISITS;
@@ -6691,6 +7707,7 @@ async function runFlowGraph(program, deps) {
   while (cursor !== null) {
     if (++steps > maxSteps) {
       deps.events.note("flow.loop_guard_tripped", { reason: "max_steps", steps });
+      await closeAtLoopGuard(state, deps);
       break;
     }
     const node = model2.node(cursor);
@@ -6703,6 +7720,7 @@ async function runFlowGraph(program, deps) {
     const visitCap = node.config.hub === true ? HUB_MAX_NODE_VISITS : maxNodeVisits;
     if (visit > visitCap) {
       deps.events.note("flow.loop_guard_tripped", { reason: "max_node_visits", nodeId: cursor });
+      await closeAtLoopGuard(state, deps);
       break;
     }
     state.cursor = cursor;
@@ -6723,7 +7741,8 @@ async function runFlowGraph(program, deps) {
         ...deps.depth !== void 0 ? { depth: deps.depth } : {},
         ...deps.busy ? { busy: deps.busy } : {},
         ...deps.live ? { live: deps.live } : {},
-        ...deps.security ? { security: deps.security } : {}
+        ...deps.security ? { security: deps.security } : {},
+        ...deps.askContext ? { askContext: deps.askContext } : {}
       });
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
@@ -6756,6 +7775,7 @@ var init_interpreter = __esm({
     init_log();
     init_graph_model();
     init_executors();
+    init_src();
     init_conditions();
     DEFAULT_MAX_NODE_VISITS = 25;
     DEFAULT_MAX_STEPS = 200;
@@ -7145,6 +8165,13 @@ function createUtteranceStream(session, processRt, ctx, rails, prewarm, wantsDtm
           ...number ? { numberField: number.field } : {},
           ...answer ? { answering: answer.field } : {}
         };
+        if (opts?.captureAfterRead) {
+          const text = raw.text;
+          return {
+            ...turn,
+            capture: (o) => capture(text, false, { ...step, ...o?.exclude?.length ? { exclude: o.exclude } : {} }, answer)
+          };
+        }
         if (opts?.deferCapture) {
           const run = capture(raw.text, true, step, answer).then(() => {
             if (pending === run) pending = null;
@@ -7318,7 +8345,8 @@ var NOT_SENT = /* @__PURE__ */ new Set([
   "email_provider_error",
   "email_send_failed",
   "insufficient_balance",
-  "spend_cap_exceeded"
+  // a hard budget refused it (the key's monthly budget replaced the old per-key spend cap — monetization MON2)
+  "budget_exceeded"
 ]);
 function dedupeConversationEmails(resolver) {
   const sends = /* @__PURE__ */ new Map();
@@ -7401,7 +8429,8 @@ async function runFlowProgram(program, ctx, opts) {
       ...opts.resolvers ? { resolvers: opts.resolvers } : {},
       ...opts.busy ? { busy: opts.busy } : {},
       ...opts.live ? { live: opts.live } : {},
-      ...security ? { security } : {}
+      ...security ? { security } : {},
+      ...opts.askContext ? { askContext: opts.askContext } : {}
     });
     graphLog("outcome", outcome);
     return outcome;
@@ -7888,14 +8917,15 @@ function createProcessRuntime(def) {
           console.error("[process] onField threw", err);
         }
       };
-      const answering = opts?.answering;
+      const excluded = (name) => opts?.exclude?.some((f) => f.trim() === name.trim()) === true;
+      const answering = opts?.answering !== void 0 && !excluded(opts.answering) ? opts.answering : void 0;
       const answerField = answering !== void 0 ? def.collect[answering] : void 0;
       const answerWasOpen = answering !== void 0 && !callerGave.has(answering);
       const status = primitive.getFieldStatus();
       const captured = (name) => status.find((f) => f.name === name)?.captured === true;
       const stepFields = opts?.stepFields;
       const named = (name) => stepFields?.some((f) => f.trim() === name.trim()) === true;
-      const spoken = Object.entries(def.collect).filter(([, f]) => f.fromCaller !== false);
+      const spoken = Object.entries(def.collect).filter(([name, f]) => f.fromCaller !== false && !excluded(name));
       const open = (name) => !captured(name) || named(name) && !callerGave.has(name);
       const remaining = spoken.filter(([name]) => open(name) && (!completed || stepFields === void 0 || named(name)));
       const correctable = spoken.filter(([name]) => captured(name) && named(name) && callerGave.has(name));
@@ -8433,13 +9463,13 @@ function createTextSessionAdapter(transport) {
   };
   function setState(next) {
     const raw = String(next);
-    const norm = normalizeState(raw);
+    const norm2 = normalizeState(raw);
     const oldState = currentState;
     const rawOld = currentRaw;
-    currentState = norm;
+    currentState = norm2;
     currentRaw = raw;
-    fire("state", { oldState, newState: norm, rawOldState: rawOld, rawNewState: raw });
-    if (NON_BUSY_STATES.has(norm)) releaseIdleWaiters("idle");
+    fire("state", { oldState, newState: norm2, rawOldState: rawOld, rawNewState: raw });
+    if (NON_BUSY_STATES.has(norm2)) releaseIdleWaiters("idle");
   }
   function push(text, opts) {
     if (closed || text.length === 0) return;
@@ -8560,7 +9590,8 @@ function runTextSession(opts) {
     events,
     ...opts.maxSteps !== void 0 ? { maxSteps: opts.maxSteps } : {},
     ...opts.onAwaitInput ? { onAwaitInput: opts.onAwaitInput } : {},
-    ...opts.resolvers ? { resolvers: opts.resolvers } : {}
+    ...opts.resolvers ? { resolvers: opts.resolvers } : {},
+    ...opts.askContext ? { askContext: opts.askContext } : {}
   });
   return {
     sendUserMessage: (text) => {