@voicelayer/sdk 0.1.8 → 0.1.10

package/dist/runtime/text-session.js

@@ -1,8 +1,8 @@
 import { z } from 'zod';
 import OpenAI from 'openai';
 import 'quickjs-emscripten';
-import { setup } from 'xstate';
-import 'crypto';
+import { setup, createActor } from 'xstate';
+import { randomUUID } from 'crypto';
 
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -42,8 +42,46 @@ var init_graph_model = __esm({
   "src/runtime/graph/graph-model.ts"() {
   }
 });
+
+// ../contracts/src/primitive.ts
+var BasePrimitive;
 var init_primitive = __esm({
   "../contracts/src/primitive.ts"() {
+    BasePrimitive = class {
+      async onError(err, _ctx) {
+        return {
+          kind: "fail",
+          userMessage: "I ran into an issue on my end. Let me transfer you to a teammate."
+        };
+      }
+      async healthCheck() {
+        return { healthy: true, lastCheckedAt: /* @__PURE__ */ new Date() };
+      }
+      getMetrics() {
+        return {
+          callsInFlight: 0,
+          p50LatencyMs: 0,
+          p90LatencyMs: 0,
+          p99LatencyMs: 0,
+          errorRate: 0
+        };
+      }
+      validateInput(_input) {
+        return { ok: true };
+      }
+      validateOutput(_output) {
+        return { ok: true };
+      }
+      // The event bus is injected by the orchestrator at boot time. These
+      // methods are intentionally stubs — see packages/event-bus for the real
+      // implementation.
+      emit(_event) {
+      }
+      subscribe(_type, _handler) {
+        return () => {
+        };
+      }
+    };
   }
 });
 
@@ -64,8 +102,13 @@ var init_errors = __esm({
   "../contracts/src/errors.ts"() {
   }
 });
+
+// ../contracts/src/ids.ts
+var PrimitiveId, SemanticVersion;
 var init_ids = __esm({
   "../contracts/src/ids.ts"() {
+    PrimitiveId = (s) => s;
+    SemanticVersion = (s) => s;
   }
 });
 var FlowKind, FlowStatus, FlowNodeType, FlowNodePosition, FlowNode, FlowEdge, FlowGraph;
@@ -2621,7 +2664,7 @@ var init_executors = __esm({
       const authoredSlot = slot === node.id ? "" : slot.trim();
       const label = authoredSlot.replace(/[_-]+/g, " ");
       if (hasSlot(deps.processRt.getData(), slot)) {
-        console.log("[graph] ask: slot already known, skipping", { slot: slot.trim() });
+        deps.events.note("ask.skipped", { slot: slot.trim(), reason: "already known" });
         return { kind: "advance" };
       }
       const askText = interpolate(
@@ -2635,10 +2678,10 @@ var init_executors = __esm({
         state.lastUtterance = t.text;
         state.lastDtmf = t.dtmf;
         if (hasSlot(deps.processRt.getData(), slot)) {
-          console.log("[graph] ask: captured", { slot: slot.trim() });
+          deps.events.note("ask.captured", { slot: slot.trim() });
           return { kind: "advance" };
         }
-        console.log("[graph] ask: clarify", { slot: slot.trim(), turn });
+        deps.events.note("ask.clarify", { slot: slot.trim(), turn });
         await withHistory(
           deps,
           historyPolicyOf(node),
@@ -2739,11 +2782,18 @@ ${collected}`);
         if (ok && cfg.outputAs && typeof cfg.outputAs === "object") {
           for (const [slot, path] of Object.entries(cfg.outputAs)) {
             if (typeof path !== "string" || !path.trim()) continue;
-            const value = resolvePath(result, path.trim());
-            if (value !== void 0 && value !== null) {
-              deps.processRt.captureField(slot, value);
-              deps.events.note("tool.output_captured", { node: node.id, slot });
+            const raw = resolvePath(result, path.trim());
+            if (raw === void 0 || raw === null) {
+              deps.events.note("tool.output_missing", { node: node.id, slot, path });
+              continue;
             }
+            const value = typeof raw === "string" ? raw : typeof raw === "number" || typeof raw === "boolean" || typeof raw === "bigint" ? String(raw) : JSON.stringify(raw);
+            const captured = deps.processRt.captureField(slot, value);
+            deps.events.note(captured ? "tool.output_captured" : "tool.output_rejected", {
+              node: node.id,
+              slot,
+              ...captured ? {} : { reason: "slot not declared or value not coercible" }
+            });
           }
         }
         return routeByPort(node, deps, ok ? "ok" : "fail");
@@ -3252,13 +3302,19 @@ ${collected}`);
     setExecutor = async (node, state, deps) => {
       const assignments = Array.isArray(node.config.assignments) ? node.config.assignments : [];
       let applied = 0;
+      const rejected = [];
       for (const a of assignments) {
         if (!a || typeof a.name !== "string" || !a.name.trim()) continue;
+        const name = a.name.trim();
         const value = interpolate(typeof a.value === "string" ? a.value : "", scopeFor(state, deps));
-        deps.processRt.captureField(a.name.trim(), value);
-        applied += 1;
+        if (deps.processRt.captureField(name, value)) applied += 1;
+        else rejected.push(name);
       }
-      deps.events.note("set.applied", { node: node.id, count: applied });
+      deps.events.note("set.applied", {
+        node: node.id,
+        count: applied,
+        ...rejected.length ? { rejected } : {}
+      });
       return { kind: "advance" };
     };
     MAX_SUBFLOW_DEPTH = 3;
@@ -3716,7 +3772,54 @@ init_openai_default();
 // ../primitives/process-schema/src/index.ts
 init_src();
 var PROCESS_LIFECYCLE_MAX_EVENTS = 100;
-setup({
+function isZodSchema(v) {
+  return typeof v === "object" && v !== null && "_def" in v && "parse" in v;
+}
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object") return false;
+  return Object.getPrototypeOf(value) === Object.prototype;
+}
+function compileFieldValidator(field) {
+  if (isZodSchema(field.validation)) return field.validation;
+  return legacySpecToZod(isPlainObject(field.validation) ? field.validation : {});
+}
+function legacySpecToZod(spec) {
+  switch (spec.type) {
+    case "number": {
+      let s = z.number();
+      if (spec.min !== void 0) s = s.min(spec.min);
+      if (spec.max !== void 0) s = s.max(spec.max);
+      return narrowEnum(s, spec.enum);
+    }
+    case "boolean":
+      return narrowEnum(z.boolean(), spec.enum);
+    case "datetime":
+      return z.string().datetime();
+    case "array": {
+      let s = z.array(z.unknown());
+      if (spec.min !== void 0) s = s.min(spec.min);
+      if (spec.max !== void 0) s = s.max(spec.max);
+      return s;
+    }
+    case "object":
+      return z.record(z.string(), z.unknown());
+    case "string":
+    default: {
+      let s = z.string();
+      if (spec.min !== void 0) s = s.min(spec.min);
+      if (spec.max !== void 0) s = s.max(spec.max);
+      if (spec.pattern !== void 0) s = s.regex(new RegExp(spec.pattern));
+      return narrowEnum(s, spec.enum);
+    }
+  }
+}
+function narrowEnum(base, enumValues) {
+  if (!enumValues || enumValues.length === 0) return base;
+  return base.refine((v) => enumValues.some((c) => Object.is(c, v)), {
+    message: "value not in enum"
+  });
+}
+var machine = setup({
   types: {},
   guards: {
     allRequiredCaptured: ({ context }) => context.requiredFields.every((n) => context.fieldsCaptured.has(n)),
@@ -3811,10 +3914,277 @@ setup({
     }
   }
 });
+var ProcessSchemaPrimitive = class extends BasePrimitive {
+  primitiveId = PrimitiveId("process-schema");
+  version = SemanticVersion("0.2.0");
+  schema = null;
+  compiledFields = /* @__PURE__ */ new Map();
+  actor;
+  lastSnapshot = null;
+  lastBlockedReason;
+  constructor() {
+    super();
+    this.actor = createActor(machine);
+    this.actor.start();
+  }
+  async loadSchema(schema) {
+    const seen = /* @__PURE__ */ new Set();
+    const compiled = /* @__PURE__ */ new Map();
+    for (const field of schema.fields) {
+      if (seen.has(field.name)) throw new Error(`duplicate process field: ${field.name}`);
+      seen.add(field.name);
+      compiled.set(field.name, { ...field, validator: compileFieldValidator(field) });
+    }
+    for (const required of schema.completionGate.requiredFields) {
+      if (!seen.has(required)) {
+        throw new Error(`completion gate references unknown field: ${required}`);
+      }
+    }
+    this.schema = schema;
+    this.compiledFields = compiled;
+    this.lastBlockedReason = void 0;
+    this.actor.send({
+      type: "LOAD",
+      requiredFields: schema.completionGate.requiredFields,
+      requiresAck: schema.completionGate.backendAck !== void 0
+    });
+  }
+  async onCallStart(_ctx) {
+    if (this.schema === null) return;
+    this.lastBlockedReason = void 0;
+    this.actor.send({
+      type: "LOAD",
+      requiredFields: this.schema.completionGate.requiredFields,
+      requiresAck: this.schema.completionGate.backendAck !== void 0
+    });
+  }
+  async onCallEnd(_ctx, outcome) {
+    if (this.schema === null) return;
+    this.lastSnapshot = this.exportSnapshot();
+    if (outcome.processCompleted) {
+      this.actor.send({ type: "COMPLETE" });
+    } else {
+      const gate = this.canCallEnd();
+      if (!gate.ok) this.lastBlockedReason = gate.reason;
+    }
+  }
+  getCurrentState() {
+    const snap = this.actor.getSnapshot();
+    const ctx = snap.context;
+    const blockedReason = this.computeBlockedReason(snap);
+    return {
+      currentNode: this.currentNodeName(snap),
+      fieldsCaptured: new Map(ctx.fieldsCaptured),
+      backendAckReceived: ctx.backendAckReceived,
+      ...blockedReason === void 0 ? {} : { blockedReason },
+      ...ctx.backendAckReceivedAt === void 0 ? {} : { backendAckReceivedAt: ctx.backendAckReceivedAt }
+    };
+  }
+  getFieldStatus() {
+    if (this.schema === null) return [];
+    const ctx = this.actor.getSnapshot().context;
+    return this.schema.fields.map((field) => {
+      const captured = ctx.fieldsCaptured.has(field.name);
+      const value = ctx.fieldsCaptured.get(field.name);
+      const validator = this.compiledFields.get(field.name)?.validator;
+      const valid = captured && validator ? validator.safeParse(value).success : !captured;
+      return { name: field.name, captured, value, required: field.required, valid };
+    });
+  }
+  getCompletionPercentage() {
+    if (this.schema === null) return 0;
+    const requiredCount = this.schema.completionGate.requiredFields.length;
+    const requiresAck = this.schema.completionGate.backendAck !== void 0;
+    const denom = requiredCount + (requiresAck ? 1 : 0);
+    if (denom === 0) return 100;
+    const ctx = this.actor.getSnapshot().context;
+    const capturedRequired = this.schema.completionGate.requiredFields.filter(
+      (n) => ctx.fieldsCaptured.has(n)
+    ).length;
+    const ackCount = ctx.backendAckReceived ? 1 : 0;
+    return Math.round((capturedRequired + ackCount) / denom * 100);
+  }
+  canCallEnd() {
+    if (this.schema === null) return { ok: false, reason: "schema_not_loaded", missingFields: [] };
+    const ctx = this.actor.getSnapshot().context;
+    const missingFields = this.schema.completionGate.requiredFields.filter(
+      (n) => !ctx.fieldsCaptured.has(n)
+    );
+    if (missingFields.length > 0) {
+      return {
+        ok: false,
+        reason: `${missingFields.length} required field(s) missing`,
+        missingFields
+      };
+    }
+    if (this.schema.completionGate.backendAck !== void 0 && !ctx.backendAckReceived) {
+      return { ok: false, reason: "backend acknowledgement pending", missingFields: [] };
+    }
+    return { ok: true };
+  }
+  captureField(f) {
+    if (this.schema === null) return { ok: false, reason: "schema_not_loaded" };
+    const field = this.compiledFields.get(f.name);
+    if (field === void 0) return { ok: false, reason: `unknown field: ${f.name}` };
+    const parsed = field.validator.safeParse(f.value);
+    if (!parsed.success) {
+      const reason = parsed.error.issues[0]?.message ?? "invalid value";
+      this.lastBlockedReason = `${f.name}: ${reason}`;
+      return { ok: false, reason };
+    }
+    const before = this.actor.getSnapshot().context.fieldsCaptured.get(f.name);
+    const clonedValue = structuredClone(parsed.data);
+    this.actor.send({ type: "CAPTURE", name: f.name, value: clonedValue });
+    this.lastBlockedReason = void 0;
+    return { ok: true, advanced: !Object.is(before, parsed.data) };
+  }
+  recordBackendAck(receivedAt = /* @__PURE__ */ new Date()) {
+    this.actor.send({ type: "ACK", receivedAt });
+  }
+  exportSnapshot() {
+    const ctx = this.actor.getSnapshot().context;
+    return {
+      schemaId: this.schema?.id ?? "unloaded",
+      currentNode: this.currentNodeName(this.actor.getSnapshot()),
+      fieldsCaptured: Object.fromEntries(ctx.fieldsCaptured),
+      backendAckReceived: ctx.backendAckReceived,
+      ...ctx.backendAckReceivedAt === void 0 ? {} : { backendAckReceivedAt: new Date(ctx.backendAckReceivedAt) },
+      // Defensive copy — callers shouldn't be able to mutate the live array.
+      lifecycle: ctx.lifecycle.slice()
+    };
+  }
+  /**
+   * Record a side-channel lifecycle event. Does not advance the state machine.
+   * Triggers the snapshot subscription so the dashboard sees the event in
+   * real time alongside any state transitions.
+   */
+  emitLifecycle(event) {
+    this.actor.send({ type: "EMIT_LIFECYCLE", event });
+  }
+  hydrateSnapshot(snapshot) {
+    if (this.schema === null) {
+      throw new Error("cannot hydrate process state before schema is loaded");
+    }
+    if (snapshot.schemaId !== this.schema.id) {
+      throw new Error(`snapshot schema mismatch: ${snapshot.schemaId} !== ${this.schema.id}`);
+    }
+    this.actor.send({
+      type: "LOAD",
+      requiredFields: this.schema.completionGate.requiredFields,
+      requiresAck: this.schema.completionGate.backendAck !== void 0
+    });
+    for (const [name, value] of Object.entries(snapshot.fieldsCaptured)) {
+      this.actor.send({ type: "CAPTURE", name, value });
+    }
+    if (snapshot.backendAckReceived) {
+      this.actor.send({ type: "ACK", receivedAt: snapshot.backendAckReceivedAt ?? /* @__PURE__ */ new Date() });
+    }
+    for (const ev of snapshot.lifecycle) {
+      this.actor.send({ type: "EMIT_LIFECYCLE", event: ev });
+    }
+    this.lastSnapshot = snapshot;
+  }
+  getLastSnapshot() {
+    return this.lastSnapshot;
+  }
+  /** @internal — for XState devtools / Stately Inspector. */
+  getActor() {
+    return this.actor;
+  }
+  /**
+   * Fire-and-forget subscription to state-machine transitions. Listener receives
+   * a fresh `ProcessSnapshot` on every actor transition (capture, ack, gate).
+   *
+   * Hot-path contract: the listener is invoked synchronously inside the actor
+   * subscription; callers MUST NOT await any I/O inside it. For external fan-out
+   * (BullMQ, SSE), enqueue work without awaiting — `queue.add(...).catch(noop)`.
+   *
+   * Returns an unsubscribe function.
+   */
+  onSnapshot(listener) {
+    const sub = this.actor.subscribe(() => {
+      try {
+        listener(this.exportSnapshot());
+      } catch (err) {
+        console.error("[process-schema] subscriber threw", err);
+      }
+    });
+    return () => sub.unsubscribe();
+  }
+  // ── helpers ────────────────────────────────────────────────────────────────
+  currentNodeName(snap) {
+    const value = snap.value;
+    return typeof value === "string" ? value : Object.keys(value)[0] ?? "unloaded";
+  }
+  computeBlockedReason(snap) {
+    if (this.schema === null) return "schema_not_loaded";
+    if (this.lastBlockedReason !== void 0) return this.lastBlockedReason;
+    const ctx = snap.context;
+    const missing = this.schema.completionGate.requiredFields.filter((n) => !ctx.fieldsCaptured.has(n));
+    if (missing.length > 0) return `${missing.length} required field(s) missing`;
+    if (this.schema.completionGate.backendAck !== void 0 && !ctx.backendAckReceived) {
+      return "backend acknowledgement pending";
+    }
+    return void 0;
+  }
+};
+var DEFAULT_SCHEMA_ID = "process";
+function buildProcessSchema(def, schemaId = DEFAULT_SCHEMA_ID) {
+  const fields = Object.entries(def.collect).map(([name, field]) => ({
+    name,
+    required: field.required === true,
+    validation: fieldToZod(field)
+  }));
+  const requiredFields = Object.entries(def.collect).filter(([, f]) => f.required === true).map(([n]) => n);
+  const gate = {
+    requiredFields,
+    ...def.backendAck ? {
+      backendAck: {
+        url: def.backendAck.url,
+        timeoutMs: def.backendAck.timeoutMs ?? 3e4
+      }
+    } : {}
+  };
+  return { id: schemaId, fields, completionGate: gate };
+}
+function fieldToZod(field) {
+  switch (field.type) {
+    case "string":
+    case "email":
+    case "phone": {
+      let s = z.string();
+      if (field.type === "email") s = s.email();
+      if (field.pattern) s = s.regex(field.pattern);
+      if (field.min !== void 0) s = s.min(field.min);
+      if (field.max !== void 0) s = s.max(field.max);
+      return narrowEnum2(s, field.enum);
+    }
+    case "string[]": {
+      let arr = z.array(z.string());
+      if (field.min !== void 0) arr = arr.min(field.min);
+      if (field.max !== void 0) arr = arr.max(field.max);
+      return arr;
+    }
+    case "number": {
+      let n = z.number();
+      if (field.min !== void 0) n = n.min(field.min);
+      if (field.max !== void 0) n = n.max(field.max);
+      return n;
+    }
+    case "boolean":
+      return z.boolean();
+    case "datetime":
+      return z.union([z.date(), z.string().datetime()]);
+  }
+}
+function narrowEnum2(base, enumValues) {
+  if (!enumValues || enumValues.length === 0) return base;
+  return base.refine((v) => enumValues.includes(v), { message: "value not in enum" });
+}
 
 // src/runtime/process.ts
 function createProcessRuntime(def) {
-  {
+  if (!def) {
     return {
       augmentPrompt: (p) => p,
       ingest: async () => {
@@ -3830,6 +4200,278 @@ function createProcessRuntime(def) {
       }
     };
   }
+  const primitive = new ProcessSchemaPrimitive();
+  const schema = buildProcessSchema(def);
+  void primitive.loadSchema(schema);
+  let completed = false;
+  const getOpenAi = () => defaultOpenAI();
+  return {
+    augmentPrompt(basePrompt) {
+      const lines = Object.entries(def.collect).map(([name, field]) => {
+        const parts = [`type=${field.type}`];
+        if (field.required) parts.push("required");
+        if (field.enum) parts.push(`one of: ${field.enum.join("|")}`);
+        const ask = field.ask ?? `the ${name}`;
+        return `- ${name} (${parts.join(", ")}) \u2014 ask: "${ask}"`;
+      });
+      return [
+        basePrompt,
+        "",
+        "You are collecting the following structured information from the caller:",
+        ...lines,
+        "",
+        "Ask for ONE missing field at a time. Acknowledge captured values. Do not invent values."
+      ].join("\n");
+    },
+    async ingest(utterance, ctx) {
+      if (completed) return;
+      const status = primitive.getFieldStatus();
+      const remaining = Object.entries(def.collect).filter(([name]) => {
+        const s = status.find((f) => f.name === name);
+        return !s || !s.captured;
+      });
+      if (remaining.length > 0) {
+        let extractions;
+        try {
+          extractions = await extractFields(getOpenAi(), utterance, remaining);
+        } catch (err) {
+          console.warn("[process] extractor failed", err);
+          return;
+        }
+        for (const { name, value } of extractions) {
+          const field = def.collect[name];
+          if (!field) continue;
+          const coerced = coerce(value, field);
+          if (coerced === INVALID) {
+            console.debug("[process] rejected capture (coerce failed)", { name, value });
+            continue;
+          }
+          const result = primitive.captureField({ name, value: coerced });
+          if (!result.ok) {
+            console.debug("[process] primitive rejected capture", { name, reason: result.reason });
+            continue;
+          }
+          if (def.onField) {
+            try {
+              await def.onField(
+                name,
+                coerced,
+                ctx
+              );
+            } catch (err) {
+              console.error("[process] onField threw", err);
+            }
+          }
+        }
+      }
+      await maybeComplete(def, primitive, ctx, () => {
+        completed = true;
+      });
+    },
+    getData() {
+      const out = {};
+      for (const f of primitive.getFieldStatus()) {
+        if (f.captured) out[f.name] = f.value;
+      }
+      return out;
+    },
+    isComplete() {
+      return completed;
+    },
+    captureField(name, value) {
+      const field = def.collect[name];
+      if (!field) return false;
+      const coerced = coerce(value, field);
+      if (coerced === INVALID) return false;
+      const result = primitive.captureField({ name, value: coerced });
+      return result.ok;
+    },
+    recordEvent({ kind, source, data }) {
+      primitive.emitLifecycle({
+        id: randomUUID(),
+        at: (/* @__PURE__ */ new Date()).toISOString(),
+        kind,
+        source: source ?? "agent",
+        data: data ?? {}
+      });
+    },
+    getSnapshot() {
+      return primitive.exportSnapshot();
+    },
+    getSchema() {
+      return schema;
+    },
+    subscribe(listener) {
+      return primitive.onSnapshot(listener);
+    }
+  };
+}
+var INVALID = /* @__PURE__ */ Symbol("invalid");
+function coerce(value, field) {
+  switch (field.type) {
+    case "string":
+    case "email":
+    case "phone":
+      return typeof value === "string" ? value : INVALID;
+    case "string[]":
+      if (Array.isArray(value) && value.every((v) => typeof v === "string")) return value;
+      if (typeof value === "string") return [value];
+      return INVALID;
+    case "number": {
+      if (typeof value === "number" && Number.isFinite(value)) return value;
+      if (typeof value === "string" && value.trim() !== "") {
+        const n = Number(value);
+        if (Number.isFinite(n)) return n;
+      }
+      return INVALID;
+    }
+    case "boolean":
+      if (typeof value === "boolean") return value;
+      if (typeof value === "string") {
+        const v = value.toLowerCase();
+        if (["true", "yes", "y"].includes(v)) return true;
+        if (["false", "no", "n"].includes(v)) return false;
+      }
+      return INVALID;
+    case "datetime":
+      if (value instanceof Date) return value;
+      if (typeof value === "string") {
+        const d = new Date(value);
+        if (!Number.isNaN(d.getTime())) return d;
+      }
+      return INVALID;
+  }
+}
+async function maybeComplete(def, primitive, ctx, markComplete) {
+  const data = {};
+  for (const f of primitive.getFieldStatus()) if (f.captured) data[f.name] = f.value;
+  const strategyOk = await checkStrategy(def, data, ctx);
+  if (!strategyOk) return;
+  const missingRequired = primitive.getFieldStatus().filter((f) => f.required && !f.captured);
+  if (missingRequired.length > 0) return;
+  if (def.backendAck && !primitive.exportSnapshot().backendAckReceived) {
+    try {
+      const res = await fetchWithTimeout(
+        def.backendAck.url,
+        {
+          method: "POST",
+          headers: { "content-type": "application/json", ...def.backendAck.headers ?? {} },
+          body: JSON.stringify(data)
+        },
+        def.backendAck.timeoutMs ?? 3e4
+      );
+      if (!res.ok) {
+        console.warn("[process] backend ACK non-2xx; not completing", res.status);
+        return;
+      }
+      primitive.recordBackendAck(/* @__PURE__ */ new Date());
+    } catch (err) {
+      console.warn("[process] backend ACK failed; not completing", err);
+      return;
+    }
+  }
+  const finalGate = primitive.canCallEnd();
+  if (!finalGate.ok) return;
+  markComplete();
+  if (def.onComplete) {
+    try {
+      await def.onComplete(data, ctx);
+    } catch (err) {
+      console.error("[process] onComplete threw", err);
+    }
+  }
+}
+async function checkStrategy(def, data, ctx) {
+  const strategy = def.completeWhen ?? "all-required-captured";
+  if (strategy === "all-required-captured") {
+    return Object.entries(def.collect).every(([name, f]) => !f.required || data[name] !== void 0);
+  }
+  if (strategy === "all-captured") {
+    return Object.keys(def.collect).every((name) => data[name] !== void 0);
+  }
+  if (typeof strategy === "object" && "custom" in strategy) {
+    return Promise.resolve(strategy.custom(data, ctx));
+  }
+  return false;
+}
+async function fetchWithTimeout(url, init, timeoutMs) {
+  const ctrl = new AbortController();
+  const t = setTimeout(() => ctrl.abort(), timeoutMs);
+  try {
+    return await fetch(url, { ...init, signal: ctrl.signal });
+  } finally {
+    clearTimeout(t);
+  }
+}
+async function extractFields(client, utterance, remaining) {
+  const fieldLines = remaining.map(([name, f]) => {
+    const parts = [`type=${f.type}`];
+    if (f.pattern) parts.push(`pattern=${f.pattern.source}`);
+    if (f.enum) parts.push(`enum=${JSON.stringify(f.enum)}`);
+    if (f.extract) parts.push(`hint=${f.extract}`);
+    return `- ${name} (${parts.join(", ")})${f.required ? " [required]" : ""}`;
+  });
+  const prompt = [
+    "Schema fields still to capture:",
+    ...fieldLines,
+    "",
+    `Only emit values for: ${remaining.map(([n]) => n).join(", ")}`,
+    "",
+    `Latest caller utterance:
+"""
+${utterance}
+"""`,
+    "",
+    'Respond as JSON: {"fields": [{"name": "<field>", "value": <value>}, ...]}.',
+    "Omit any field you are not confident about. Empty array if nothing to extract.",
+    "For datetime fields use ISO 8601. For arrays return arrays. For booleans return true/false."
+  ].join("\n");
+  const ctrl = new AbortController();
+  const timer = setTimeout(() => ctrl.abort(), 4e3);
+  try {
+    const completion = await client.chat.completions.create(
+      {
+        model: process.env["VOICELAYER_EXTRACTOR_MODEL"] ?? "gpt-4o-mini",
+        response_format: { type: "json_object" },
+        temperature: 0,
+        messages: [
+          {
+            role: "system",
+            content: "You extract structured fields from a single caller utterance for a voice agent. Only emit fields you are confident about based on the utterance. Never invent values."
+          },
+          { role: "user", content: prompt }
+        ]
+      },
+      { signal: ctrl.signal }
+    );
+    const raw = completion.choices[0]?.message?.content ?? "{}";
+    return parseExtractorResponse(raw, new Set(remaining.map(([n]) => n)));
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function parseExtractorResponse(raw, allowed) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return [];
+  }
+  if (!parsed || typeof parsed !== "object") return [];
+  const fields = parsed.fields;
+  if (!Array.isArray(fields)) return [];
+  const out = [];
+  for (const item of fields) {
+    if (!item || typeof item !== "object") continue;
+    const rawName = item.name;
+    const value = item.value;
+    if (typeof rawName !== "string") continue;
+    const name = allowed.has(rawName) ? rawName : [...allowed].find((a) => a.trim() === rawName.trim());
+    if (name === void 0) continue;
+    if (value === null || value === void 0) continue;
+    out.push({ name, value });
+  }
+  return out;
 }
 
 // src/runtime/session-adapter.ts
@@ -4075,6 +4717,29 @@ function createTextSessionAdapter(transport) {
   return { adapter, push, setState, close };
 }
 
+// src/flow-runtime.ts
+init_define_tool();
+function processSchemaToDefinition(schema) {
+  const required = new Set(schema.completionGate.requiredFields);
+  const collect = {};
+  for (const f of schema.fields) {
+    collect[f.name] = {
+      type: f.type,
+      required: required.has(f.name) || f.required,
+      ...f.ask !== void 0 ? { ask: f.ask } : {},
+      ...f.pattern !== void 0 ? { pattern: new RegExp(f.pattern) } : {},
+      ...f.min !== void 0 ? { min: f.min } : {},
+      ...f.max !== void 0 ? { max: f.max } : {},
+      ...f.enum !== void 0 ? { enum: f.enum } : {}
+    };
+  }
+  return {
+    collect,
+    completeWhen: "all-required-captured",
+    ...schema.completionGate.backendAck !== void 0 ? { backendAck: schema.completionGate.backendAck } : {}
+  };
+}
+
 // src/runtime/text-session.ts
 function buildTextContext(adapter, call, processRt) {
   return {
@@ -4092,12 +4757,24 @@ function buildTextContext(adapter, call, processRt) {
     get process() {
       return { data: processRt.getData(), complete: processRt.isComplete() };
     },
+    // Voice-only actions, stubbed so a flow containing them can still be dry-run
+    // over text. Without these the handoff node threw "deps.ctx.handoff is not
+    // a function" mid-trace (seen in the builder's dry run); the graph now
+    // reaches its handoff outcome cleanly and the trace says why nothing dialed.
+    handoff: async (to) => {
+      processRt.recordEvent({
+        kind: "handoff.simulated",
+        data: { to, reason: "text dry run \u2014 no telephony leg to transfer" }
+      });
+    },
+    endCall: async () => {
+    },
     // Voice-only escape hatch is absent on text; left undefined.
     livekit: { session: {}, job: {} }
   };
 }
 function runTextSession(opts) {
-  const processRt = opts.processRt ?? createProcessRuntime();
+  const processRt = opts.processRt ?? createProcessRuntime(void 0);
   const handle = createTextSessionAdapter({
     send: opts.onAgentText,
     ...opts.generate ? { generate: opts.generate } : {}
@@ -4133,14 +4810,51 @@ function runTextSession(opts) {
     end: () => handle.close()
   };
 }
+function deriveCollectFromProgram(program) {
+  const collect = {};
+  for (const [nodeId, node] of Object.entries(program.nodes)) {
+    const cfg = node.config;
+    if (node.type === "ask") {
+      const name = typeof cfg.slot === "string" && cfg.slot ? cfg.slot : nodeId;
+      const type = cfg.type;
+      collect[name] = {
+        type: type === "number" || type === "boolean" || type === "datetime" || type === "string[]" ? type : "string",
+        ...cfg.required !== false ? { required: true } : {},
+        ...typeof cfg.ask === "string" ? { ask: cfg.ask } : {},
+        ...typeof cfg.pattern === "string" ? { pattern: new RegExp(cfg.pattern) } : {}
+      };
+    }
+    if (cfg.outputAs && typeof cfg.outputAs === "object") {
+      for (const slot of Object.keys(cfg.outputAs)) {
+        collect[slot] ??= { type: "string" };
+      }
+    }
+    if (Array.isArray(cfg.assignments)) {
+      for (const a of cfg.assignments) {
+        if (a && typeof a.name === "string" && a.name.trim()) collect[a.name.trim()] ??= { type: "string" };
+      }
+    }
+  }
+  return { collect, completeWhen: "all-required-captured" };
+}
+function definitionFor(opts) {
+  if (opts.schema) {
+    try {
+      return processSchemaToDefinition(opts.schema);
+    } catch {
+    }
+  }
+  return deriveCollectFromProgram(opts.program);
+}
 async function runTextTranscript(opts) {
   const replies = [];
   const trace = [];
+  const processRt = opts.processRt ?? createProcessRuntime(definitionFor(opts));
   const session = runTextSession({
     program: opts.program,
     onAgentText: (t) => void replies.push(t),
     onTrace: (e) => void trace.push(e),
-    ...opts.processRt ? { processRt: opts.processRt } : {},
+    ...processRt ? { processRt } : {},
     ...opts.generate ? { generate: opts.generate } : {},
     ...opts.call ? { call: opts.call } : {},
     ...opts.maxSteps !== void 0 ? { maxSteps: opts.maxSteps } : {}