@stackbone/cli 0.6.3 → 0.7.1

package/voice-worker/main.js

@@ -0,0 +1,2227 @@
+// libs/runtime/voice-worker/src/main.ts
+import { fileURLToPath } from "node:url";
+import {
+  ServerOptions,
+  cli,
+  defineAgent,
+  inference,
+  telemetry as telemetry2,
+  voice as voice4
+} from "@livekit/agents";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
+
+// libs/runtime/voice-worker/src/thinking-sound.ts
+import { voice } from "@livekit/agents";
+import { AudioFrame } from "@livekit/rtc-node";
+var SAMPLE_RATE = 48e3;
+var FRAME_MS = 20;
+var SAMPLES_PER_FRAME = SAMPLE_RATE * FRAME_MS / 1e3;
+var VOLUME = 0.12;
+var PATTERN = [
+  [660, 140],
+  [0, 60],
+  [880, 160],
+  [0, 900]
+];
+var renderPattern = () => {
+  const total = PATTERN.reduce((n, [, ms]) => n + SAMPLE_RATE * ms / 1e3, 0);
+  const pcm = new Int16Array(total);
+  let offset = 0;
+  for (const [hz, ms] of PATTERN) {
+    const length = SAMPLE_RATE * ms / 1e3;
+    for (let i = 0; hz > 0 && i < length; i++) {
+      const envelope = 0.5 - 0.5 * Math.cos(2 * Math.PI * i / length);
+      const sample = Math.sin(2 * Math.PI * hz * i / SAMPLE_RATE) * envelope * VOLUME;
+      pcm[offset + i] = Math.round(sample * 32767);
+    }
+    offset += length;
+  }
+  return pcm;
+};
+var LOOP = renderPattern();
+async function* thinkingCue() {
+  for (; ; ) {
+    for (let start = 0; start + SAMPLES_PER_FRAME <= LOOP.length; start += SAMPLES_PER_FRAME) {
+      yield new AudioFrame(
+        LOOP.slice(start, start + SAMPLES_PER_FRAME),
+        SAMPLE_RATE,
+        1,
+        SAMPLES_PER_FRAME
+      );
+    }
+  }
+}
+var startThinkingCue = async ({
+  room,
+  session
+}) => {
+  const player = new voice.BackgroundAudioPlayer();
+  await player.start({ room, agentSession: session });
+  let playing;
+  return {
+    start: () => {
+      playing ??= player.play(thinkingCue());
+    },
+    stop: () => {
+      playing?.stop();
+      playing = void 0;
+    }
+  };
+};
+
+// libs/runtime/voice-worker/src/vad.ts
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import * as silero from "@livekit/agents-plugin-silero";
+var WINDOWS_MAX_PATH = 260;
+var SILERO_DEFAULTS = {
+  minSpeechDuration: 50,
+  minSilenceDuration: 550,
+  prefixPaddingDuration: 500,
+  maxBufferedSpeech: 6e4,
+  activationThreshold: 0.5,
+  sampleRate: 16e3,
+  forceCPU: true
+};
+var loadVad = async () => {
+  const require2 = createRequire(import.meta.url);
+  const pluginEntry = require2.resolve("@livekit/agents-plugin-silero");
+  const model = join(dirname(pluginEntry), "silero_vad.onnx");
+  if (process.platform !== "win32" || model.length < WINDOWS_MAX_PATH) {
+    return await silero.VAD.load();
+  }
+  const { InferenceSession } = createRequire(pluginEntry)("onnxruntime-node");
+  const session = await InferenceSession.create(`\\\\?\\${model}`, {
+    interOpNumThreads: 1,
+    intraOpNumThreads: 1,
+    executionMode: "sequential",
+    executionProviders: [{ name: "cpu" }]
+  });
+  return new silero.VAD(session, SILERO_DEFAULTS);
+};
+
+// libs/runtime/voice-worker/src/worker.ts
+import { log as log4, voice as voice3 } from "@livekit/agents";
+import { BackgroundVoiceCancellation } from "@livekit/noise-cancellation-node";
+import { ParticipantKind } from "@livekit/rtc-node";
+
+// libs/shared/validators/src/lib/common/json-object.ts
+import { z } from "zod";
+var jsonObject = () => z.looseObject({});
+
+// libs/shared/validators/src/lib/common/page.ts
+import { z as z2 } from "zod";
+var PAGE_LIMIT_MAX = 100;
+var cursorParamSchema = z2.string().min(1);
+var limitParamSchema = (max = PAGE_LIMIT_MAX) => z2.coerce.number().int().min(1).max(max);
+var orderParamSchema = z2.enum(["asc", "desc"]);
+var pageQuerySchema = z2.object({
+  cursor: cursorParamSchema.optional(),
+  limit: limitParamSchema().optional(),
+  order: orderParamSchema.optional()
+});
+var forwardPageQuerySchema = pageQuerySchema.omit({ order: true });
+var pageCursorSchema = z2.string().nullable();
+var pageResponseSchema = (item) => z2.object({ items: z2.array(item), nextCursor: pageCursorSchema, prevCursor: pageCursorSchema });
+var forwardPageResponseSchema = (item) => z2.object({ items: z2.array(item), nextCursor: pageCursorSchema });
+
+// libs/shared/validators/src/lib/agents/runs.ts
+import { z as z4 } from "zod";
+
+// libs/shared/validators/src/lib/common/system-entries.ts
+import { z as z3 } from "zod";
+var systemEntriesParamSchema = z3.enum(["include", "exclude"]);
+var systemEntriesQuerySchema = z3.object({
+  system: systemEntriesParamSchema.optional()
+});
+
+// libs/shared/validators/src/lib/agents/runs.ts
+var RUN_STATUSES = [
+  "running",
+  "done",
+  "failed",
+  "interrupted",
+  "waiting",
+  "cancelled"
+];
+var runStatusSchema = z4.enum(RUN_STATUSES);
+var RUN_TRIGGERS = [
+  "manual",
+  "webhook",
+  "cron",
+  "event",
+  "job",
+  "workflow",
+  "chat",
+  "eval",
+  "platform",
+  "unknown"
+];
+var runTriggerSchema = z4.enum(RUN_TRIGGERS);
+var runEntityKindSchema = z4.enum(["agent", "workflow"]);
+var runTriggerLinkSchema = z4.object({
+  /** The `trigger_subscriptions.id`: the link the Studio trigger page routes to. */
+  subscriptionId: z4.string(),
+  /** The connector id, e.g. `gmail`. */
+  connector: z4.string(),
+  /** The trigger id within the connector, e.g. `gmail_new_email_received`. */
+  trigger: z4.string(),
+  outcome: z4.enum(["started", "resumed"]).optional(),
+  /** The connector's brand name, e.g. `Gmail`. */
+  connectorDisplayName: z4.string().optional(),
+  /** The trigger's name, e.g. `New Email`. */
+  triggerDisplayName: z4.string().optional(),
+  connectorLogoUrl: z4.string().optional()
+});
+var runSchema = z4.object({
+  id: z4.uuid(),
+  status: runStatusSchema,
+  trigger: runTriggerSchema,
+  createdAt: z4.iso.datetime(),
+  startedAt: z4.iso.datetime().nullable(),
+  finishedAt: z4.iso.datetime().nullable(),
+  durationMs: z4.number().int().nullable(),
+  traceId: z4.string().nullable(),
+  // True when the run was triggered from the Studio Playground (header
+  // `STACKBONE_PLAYGROUND_HEADER` on `POST /api/invoke`). Billing and the Trust
+  // Layer's verified metrics filter on this column to exclude stress-tests.
+  isPlayground: z4.boolean(),
+  // Name of the agent or workflow this run belongs to (migration 0020). Stamped
+  // at run creation: the agent name for `chat` runs, the workflow name for
+  // `workflow` runs. Combined with `trigger` the UI knows the kind. Null for
+  // classic/manual cloud runs (deep-agent chat is dev-only), so the Runs screen renders `—`.
+  entityName: z4.string().nullable(),
+  // Which KIND of entity `entityName` names (STA-426, migration 0037). Stamped at
+  // run creation next to the name, so an agent and a workflow that share a name stop
+  // sharing one row set. Null for a run written before the column existed (no
+  // backfill) — those stay matched by name alone.
+  //
+  // OPTIONAL as well as nullable, unlike `entityName`: the box and the control plane
+  // version independently and the proxy returns the box's body verbatim, so a new
+  // reader (the CLI, or the control plane's response validation) must tolerate an
+  // older box that does not send the field at all. Absent reads the same as null.
+  entityKind: runEntityKindSchema.nullable().optional(),
+  // WHICH Connect link started the run (PLA-1717, migration 0075): the
+  // `trigger_subscriptions.id`, stamped at start for `trigger: 'event'` and null
+  // for every other gate. Optional as well as nullable for the reason `entityKind`
+  // is: an older box does not send the field.
+  triggerRef: z4.string().nullable().optional(),
+  // The Connect link that started or resumed the run, with its names (PLA-1898).
+  // Null for a run no link started; optional for the reason `entityKind` is.
+  triggerLink: runTriggerLinkSchema.nullable().optional(),
+  input: jsonObject().nullable(),
+  output: jsonObject().nullable(),
+  error: z4.object({ message: z4.string(), stack: z4.string().optional() }).nullable(),
+  // Per-turn token usage for deep-agent CHAT runs (feature 68, A5): the chat
+  // recorder folds the turn's usage and stamps the four token counters onto the run.
+  // Null when the run had no model call; `totalTokens` is derived at read
+  // (`input + output`), never stored. No $ cost (D5).
+  inputTokens: z4.number().int().nullable(),
+  outputTokens: z4.number().int().nullable(),
+  cacheReadTokens: z4.number().int().nullable(),
+  cacheWriteTokens: z4.number().int().nullable(),
+  totalTokens: z4.number().int().nullable(),
+  /**
+   * The run's own `metadata` jsonb, verbatim (PLA-1272 slice 4).
+   *
+   * DECLARED AS A BAG rather than a shape, and the reason is the wire: the box
+   * merges stamps onto this column from several places at different times (an
+   * eval stamp, an output-schema violation) and versions independently of the
+   * control plane, so a reader that named today's keys would strip tomorrow's.
+   * It had no field at all until PLA-1272, which is why a violation the box
+   * recorded reached the browser and was thrown away here — zod strips what a
+   * schema does not name, silently, with the typecheck green.
+   *
+   * Read it through a NAMED reader, never by indexing: {@link runOutputViolation}
+   * is the one for the violation, and lives beside this so the runtime that
+   * writes the stamp and the screen that paints it share one declaration.
+   *
+   * Optional as well as nullable for the same reason `entityKind` is: an older
+   * box does not send the field.
+   */
+  metadata: jsonObject().nullable().optional()
+});
+var schemaIssueSchema = z4.object({
+  /** Path segments to the offending field (`[]` for the root value). */
+  path: z4.array(z4.union([z4.string(), z4.number()])),
+  message: z4.string()
+});
+var runOutputViolationSchema = z4.object({
+  /** The workflow whose declared `outputSchema` the return value broke. */
+  workflowName: z4.string(),
+  issues: z4.array(schemaIssueSchema),
+  /**
+   * When the projector observed it (ISO). Not the run's `finishedAt`: the run
+   * closed at that instant whether or not anything validated it.
+   */
+  recordedAt: z4.string()
+});
+var runIdParamSchema = z4.object({ runId: z4.uuid() });
+var runTagKeySchema = z4.string().regex(/^[a-z][a-z0-9_.-]{0,63}$/);
+var RUN_TAG_VALUE_MAX = 256;
+var RUN_TAGS_MAX = 16;
+var UNSTORABLE_TAG_CHAR = (
+  // eslint-disable-next-line no-control-regex
+  /[\u0000-\u001f\u007f]|[\ud800-\udbff](?![\udc00-\udfff])|(?<![\ud800-\udbff])[\udc00-\udfff]/
+);
+var runTagValueSchema = z4.string().min(1).max(RUN_TAG_VALUE_MAX).refine((value) => !UNSTORABLE_TAG_CHAR.test(value), {
+  message: "A tag value holds no control character and no lone surrogate."
+});
+var splitRunTagFilter = (tag) => {
+  const colon = tag.indexOf(":");
+  return colon < 0 ? null : { key: tag.slice(0, colon), value: tag.slice(colon + 1) };
+};
+var runTagFilterSchema = z4.string().superRefine((tag, ctx) => {
+  const filter = splitRunTagFilter(tag);
+  if (!filter) {
+    ctx.addIssue({ code: "custom", message: "A tag filter is `key:value`." });
+    return;
+  }
+  if (!runTagKeySchema.safeParse(filter.key).success) {
+    ctx.addIssue({
+      code: "custom",
+      message: "A tag key is a lowercase slug that starts with a letter, up to 64 characters."
+    });
+  }
+  if (!runTagValueSchema.safeParse(filter.value).success) {
+    ctx.addIssue({
+      code: "custom",
+      message: `A tag value is 1 to ${RUN_TAG_VALUE_MAX} characters, with no control characters.`
+    });
+  }
+});
+var listRunsQuerySchema = pageQuerySchema.extend({
+  status: runStatusSchema.optional(),
+  trigger: runTriggerSchema.optional(),
+  from: z4.iso.datetime().optional(),
+  to: z4.iso.datetime().optional(),
+  // Feature 69 — the Sessions detail screen reads a conversation's turns with
+  // `GET /runs?session_id=<id>&order=asc`. `session_id` is the real
+  // `runs.session_id` join column (the deterministic UUIDv5 of the deep-agent
+  // session key), so it is exact-match on the indexed column.
+  session_id: z4.uuid().optional(),
+  // Migration 0020 — the Runs screen filters to one agent/workflow by its
+  // exact name (the value picked from the name dropdown, or deep-linked from
+  // the agent/workflow detail's "View runs"). Exact-match on `runs.entity_name`.
+  name: z4.string().min(1).optional(),
+  // STA-426 — narrow the name filter to ONE kind of entity, so "the runs of the
+  // workflow named sync" excludes the agent that shares the name. A row that
+  // DECLARES the other kind is always excluded; a row whose kind was never stamped
+  // (pre-0037, no backfill) is kept under the name that matches (STA-435), because
+  // dropping it would empty the history of every entry in a workspace that ran
+  // before the migration. Use the name-only filter to see every kind at once.
+  kind: runEntityKindSchema.optional(),
+  // PLA-1730 — the runs whose input has a top-level `input_key` field containing
+  // `input_value`, case-insensitive: `input_key=senderEmail&input_value=astex.com`
+  // finds every sender at that domain. The field is compared as text, so a number
+  // or boolean matches its JSON spelling (`3`, `true`). The ONE filter here that is
+  // not exact-match: it serves a search box, and a search box that needs the whole
+  // address typed without a typo is not one. Nested paths are out of scope.
+  input_key: z4.string().min(1).optional(),
+  input_value: z4.string().min(1).optional(),
+  // PLA-1785 — `exclude` leaves out the runs of the platform's own entries
+  // (`studio-copilot`, `mapping-suggest`, `rag-ingest`), decided by the box's
+  // `isSystemEntry` and applied before the cursor and the LIMIT, so a page stays
+  // full. Absent keeps every run, which is what `stackbone runs` lists.
+  system: systemEntriesParamSchema.optional(),
+  // FDE-62 S7 — the runs stamped with one `metadata.tags` entry (`channel:voice`
+  // keeps a call's turns). Exact match on the value, case-sensitive.
+  tag: runTagFilterSchema.optional()
+}).refine((q) => !q.from || !q.to || q.from <= q.to, {
+  message: "`from` must be earlier than or equal to `to`",
+  path: ["from"]
+}).refine((q) => q.input_key === void 0 === (q.input_value === void 0), {
+  message: "`input_key` and `input_value` go together",
+  path: ["input_key"]
+}).refine((q) => q.input_key === void 0 || q.name !== void 0, {
+  message: "`input_key` needs `name`: the input filter searches one entry's runs",
+  path: ["input_key"]
+});
+var runListResponseSchema = pageResponseSchema(runSchema);
+var runEntityEntrySchema = z4.object({
+  name: z4.string(),
+  kind: runEntityKindSchema.nullable()
+});
+var runEntityNamesResponseSchema = z4.object({
+  names: z4.array(z4.string()),
+  entries: z4.array(runEntityEntrySchema).optional()
+});
+var cancelRunResponseSchema = z4.object({
+  run: runSchema
+});
+var STACKBONE_SESSION_HEADER = "x-stackbone-session";
+var RUN_TAGS_HEADER = "x-stackbone-run-tags";
+var fixtureSchema = z4.object({
+  id: z4.string(),
+  name: z4.string(),
+  input: jsonObject().nullable(),
+  description: z4.string().nullable(),
+  createdAt: z4.iso.datetime()
+});
+var createFixtureRequestSchema = z4.object({
+  name: z4.string().min(1).max(120),
+  input: jsonObject(),
+  description: z4.string().max(2e3).optional().nullable()
+});
+var fixtureListResponseSchema = pageResponseSchema(fixtureSchema);
+var fixtureIdParamSchema = z4.object({ fxtId: z4.uuid() });
+var handlerSchemaSchema = z4.object({
+  input: jsonObject().nullable(),
+  output: jsonObject().nullable()
+});
+var schemaResponseSchema = z4.object({
+  input: jsonObject().nullable(),
+  output: jsonObject().nullable(),
+  handlers: jsonObject().nullable().optional()
+});
+
+// libs/shared/validators/src/lib/studio/studio-model-provider.ts
+import { z as z5 } from "zod";
+var modelProviderSlotSchema = z5.enum(["baseUrl", "apiKey"]);
+var MODEL_PROVIDER_SLOTS = {
+  baseUrl: ["MODEL_PROVIDER_BASE_URL", "OPENROUTER_BASE_URL"],
+  apiKey: ["MODEL_PROVIDER_API_KEY", "OPENROUTER_API_KEY"]
+};
+var SLOT_NAMES = Object.keys(MODEL_PROVIDER_SLOTS);
+var MODEL_PROVIDER_DEPRECATED_ENV_NAMES = SLOT_NAMES.map(
+  (slot) => MODEL_PROVIDER_SLOTS[slot][1]
+);
+var modelProviderSourceSchema = z5.enum(["environment", "stored", "none"]);
+var isModelProviderValuePresent = (value) => typeof value === "string" && value.trim() !== "";
+var storedOverridesSchema = z5.strictObject({
+  baseUrl: z5.boolean().optional(),
+  apiKey: z5.boolean().optional()
+});
+var modelProviderKindSchema = z5.enum(["openrouter", "ollama", "lmstudio", "generic"]);
+var modelProviderGetResponseSchema = z5.object({
+  configured: z5.boolean(),
+  base_url: z5.string().nullable(),
+  api_key_masked: z5.string().nullable(),
+  source: modelProviderSourceSchema.optional(),
+  env_override: z5.array(z5.string()).optional(),
+  effective_base_url: z5.string().nullable().optional(),
+  // The gateway kind of the endpoint IN EFFECT (the one `effective_base_url`
+  // names), resolved by the box; `null` when nothing is configured. Optional for
+  // the same version-skew reason as `source`: a box that predates the field.
+  kind: modelProviderKindSchema.nullable().optional(),
+  // The slots where a Studio override beats an exported value (PLA-1825, ADR
+  // D8), by SLOT name, never the variable's (D4). Such a slot drops out of
+  // `env_override`, which keeps naming only the variables that actually win.
+  // A box that knows overrides always sends the list, empty or not; an absent
+  // list is a box that predates them, and would drop an `override` it cannot
+  // read, so Studio offers no Override against it.
+  overridden: z5.array(modelProviderSlotSchema).optional()
+});
+var modelProviderPutRequestSchema = z5.object({
+  base_url: z5.url(),
+  api_key: z5.string().optional().nullable(),
+  kind: modelProviderKindSchema.optional(),
+  override: z5.object({ baseUrl: z5.boolean().optional(), apiKey: z5.boolean().optional() }).optional()
+}).refine((body) => body.override?.apiKey !== true || isModelProviderValuePresent(body.api_key), {
+  message: "Overriding the API key needs the key to use.",
+  path: ["api_key"]
+});
+var modelProviderAgentsOutcomeSchema = z5.object({
+  /** Agents that were degraded and are now serving. */
+  ready: z5.number().int().nonnegative(),
+  /** Agents that are still degraded (their reason was refreshed by the retry). */
+  degraded: z5.number().int().nonnegative()
+});
+var modelProviderPutResponseSchema = modelProviderGetResponseSchema.extend({
+  agents: modelProviderAgentsOutcomeSchema.optional()
+});
+var modelProviderFirstRunResponseSchema = z5.object({
+  completed: z5.boolean()
+});
+var modelProviderKeyCheckSchema = z5.enum(["verified", "unverified"]);
+var modelProviderTestResponseSchema = z5.object({
+  ok: z5.boolean(),
+  model_count: z5.number().int().nonnegative().optional(),
+  error: z5.string().optional(),
+  key_checked: modelProviderKeyCheckSchema.optional()
+});
+var modelProviderModelTypeSchema = z5.enum(["chat", "image", "embedding", "other"]);
+var modelProviderModelSchema = z5.object({
+  id: z5.string().min(1),
+  name: z5.string().optional(),
+  context_length: z5.number().int().positive().optional(),
+  pricing: z5.object({
+    prompt: z5.string().optional(),
+    completion: z5.string().optional()
+  }).optional(),
+  owned_by: z5.string().optional(),
+  type: modelProviderModelTypeSchema.optional(),
+  // What the gateway says the model can do (PLA-1605): `true`, `false`, or
+  // `null` for "this gateway does not say". The three values are distinct on
+  // purpose — Studio hides a model that reports no tool support and only WARNS
+  // about one that reports nothing, so collapsing `null` into `false` would hide
+  // every model on a custom OpenAI-compatible endpoint.
+  //
+  // Nullable AND optional: a box on an older runtime sends neither field, and
+  // that must keep validating, exactly as `type` already does.
+  tools: z5.boolean().nullable().optional(),
+  reasoning: z5.boolean().nullable().optional(),
+  // STA3-17: on a box with several providers, the one that serves this entry.
+  // `responding: false` marks an entry remembered from a provider that is down.
+  // Declared so the parse keeps it: an object schema strips what it does not name.
+  provider: z5.object({ id: z5.string(), name: z5.string(), responding: z5.boolean() }).optional()
+});
+var modelProviderModelsRequestSchema = z5.object({
+  base_url: z5.url().optional().nullable(),
+  api_key: z5.string().optional().nullable()
+});
+var modelProviderModelsResponseSchema = z5.object({
+  ok: z5.boolean(),
+  models: z5.array(modelProviderModelSchema).optional(),
+  error: z5.string().optional(),
+  warning: z5.string().optional()
+});
+var MODEL_PROVIDER_DEFAULT_ID = "default";
+var MODEL_PROVIDER_ID_PATTERN = /^[a-z][a-z0-9-]{0,30}[a-z0-9]$/;
+var modelProviderIdSchema = z5.string().regex(MODEL_PROVIDER_ID_PATTERN, {
+  message: "Lowercase letters, digits and dashes, 2 to 32, starting with a letter."
+}).refine((id) => id !== MODEL_PROVIDER_DEFAULT_ID, {
+  message: `'${MODEL_PROVIDER_DEFAULT_ID}' is provider 1's id.`
+});
+var pickedModelProviderIdSchema = z5.string().regex(MODEL_PROVIDER_ID_PATTERN);
+var modelProviderListItemSchema = z5.object({
+  id: z5.string(),
+  name: z5.string(),
+  kind: modelProviderKindSchema,
+  baseUrl: z5.string(),
+  apiKey: z5.string().nullable(),
+  source: z5.enum(["env", "local"]),
+  removable: z5.boolean(),
+  responding: z5.boolean().nullable(),
+  error: z5.string().optional()
+});
+var modelProviderListResponseSchema = z5.object({
+  providers: z5.array(modelProviderListItemSchema),
+  duplicatedIds: z5.array(z5.object({ modelId: z5.string(), providerIds: z5.array(z5.string()) }))
+});
+var providerFields = {
+  name: z5.string().trim().min(1),
+  kind: modelProviderKindSchema,
+  baseUrl: z5.url(),
+  apiKey: z5.string().optional()
+};
+var modelProviderCreateRequestSchema = z5.strictObject({
+  id: modelProviderIdSchema,
+  ...providerFields
+});
+var modelProviderUpdateRequestSchema = z5.strictObject(providerFields);
+
+// libs/shared/validators/src/lib/studio/studio-voice.ts
+import { z as z8 } from "zod";
+
+// libs/shared/validators/src/lib/studio/memory-identities.ts
+import { z as z6 } from "zod";
+var identityKeySchema = z6.string().min(1).max(100);
+var identityValueSchema = z6.string().min(1).max(500);
+var integrationIdentitiesSchema = z6.unknown().superRefine((input, ctx) => {
+  if (input === null || typeof input !== "object" || Array.isArray(input)) {
+    ctx.addIssue({ code: "custom", message: "Identities must be a string map." });
+    return;
+  }
+  const entries = Object.entries(input);
+  if (entries.length > 32)
+    ctx.addIssue({ code: "custom", message: "At most 32 identity fields are allowed." });
+  for (const [key, value] of entries) {
+    if (!identityKeySchema.safeParse(key).success || !identityValueSchema.safeParse(value).success)
+      ctx.addIssue({
+        code: "custom",
+        path: [key],
+        message: "Identity keys must contain 1\u2013100 characters and values 1\u2013500 characters."
+      });
+  }
+}).transform((input) => Object.fromEntries(Object.entries(input)));
+var memoryIdentitySnapshotSchema = z6.union([
+  z6.strictObject({ key: z6.null(), value: z6.null() }),
+  z6.strictObject({ key: identityKeySchema, value: identityValueSchema.nullable() })
+]);
+var memoryIdentityBindingSchema = z6.strictObject({
+  identityKey: identityKeySchema,
+  source: z6.enum(["code", "studio", "legacy"]),
+  fixedAt: z6.iso.datetime()
+});
+
+// libs/shared/validators/src/lib/studio/studio-rag.ts
+import { z as z7 } from "zod";
+var STUDIO_RAG_DOCS_LIMIT_DEFAULT = 50;
+var STUDIO_RAG_DOCS_LIMIT_MAX = 200;
+var STUDIO_RAG_TOPK_DEFAULT = 10;
+var STUDIO_RAG_TOPK_MAX = 50;
+var STUDIO_RAG_JOBS_LIMIT_DEFAULT = 50;
+var STUDIO_RAG_JOBS_LIMIT_MAX = 200;
+var STUDIO_RAG_COLLECTION_REGEX = /^[A-Za-z0-9][A-Za-z0-9._\-/:]{0,127}$/;
+var ragCollectionNameParamSchema = z7.string().min(1).max(128).regex(STUDIO_RAG_COLLECTION_REGEX, "collection must be 1..128 ASCII identifier-safe chars");
+var ragDistanceSchema = z7.enum(["cosine", "l2", "ip"]);
+var ragIndexKindSchema = z7.enum(["hnsw", "exact"]);
+var ragNumberFormatSchema = z7.enum(["eu", "us"]);
+var ragCollectionSchema = z7.object({
+  name: z7.string(),
+  dimensions: z7.number().int().min(1),
+  // Optional for boxes that predate collection-owned embeddings.
+  embedding_provider: z7.string().min(1).optional(),
+  embedding_model: z7.string().min(1).optional(),
+  distance: ragDistanceSchema,
+  index_kind: ragIndexKindSchema,
+  chunk_count: z7.number().int().nonnegative(),
+  doc_count: z7.number().int().nonnegative(),
+  // Maximum `created_at` across the collection's documents. Null when the
+  // collection has zero documents (an empty collection row created before its
+  // first ingest).
+  last_ingested_at: z7.iso.datetime().nullable(),
+  // STA3-57. Optional so a list from a box older than hybrid search still parses.
+  hybrid_enabled: z7.boolean().optional(),
+  number_format: ragNumberFormatSchema.optional()
+});
+var ragCollectionListResponseSchema = z7.object({
+  items: z7.array(ragCollectionSchema)
+});
+var ragJobStatusSchema = z7.enum(["queued", "running", "succeeded", "failed", "cancelled"]);
+var ragDocumentSchema = z7.object({
+  id: z7.string(),
+  namespace: z7.string(),
+  // Zero while the document is still ingesting (staged row, no chunks yet) or
+  // when its ingest run failed before writing any chunk. A ready document has
+  // at least one chunk.
+  chunks_count: z7.number().int().nonnegative(),
+  // Document-level metadata copied onto the chunks at ingest time. We surface
+  // the document's `metadata` so the UI can render filterable tags without
+  // paging through chunks.
+  metadata: jsonObject(),
+  // Truncated content of the first chunk. Full body is one click away via
+  // the docs drawer in the component.
+  preview: z7.string(),
+  first_seen_at: z7.iso.datetime(),
+  last_seen_at: z7.iso.datetime(),
+  // Ingest status of the run that produced this document, when the document
+  // was uploaded through Studio's managed ingest (which fires a durable
+  // `rag-ingest` run). `null` for documents the agent wrote directly via
+  // `client.rag.ingest()` (no run to track — they are ready once they have
+  // chunks). Optional so the cloud control plane, which doesn't project runs,
+  // can omit it without breaking the wire contract.
+  ingest_status: ragJobStatusSchema.nullable().optional(),
+  // Id of the ingest run that produced this document, for deep-linking to the
+  // run details screen (`studio/runs/:runId`). `null`/absent when there is no
+  // tracked run (direct SDK ingest, or the cloud surface).
+  run_id: z7.string().nullable().optional(),
+  // Error message copied off the ingest run when it failed, so the docs table
+  // can surface it inline without opening the run. `null`/absent otherwise.
+  ingest_error: z7.string().nullable().optional(),
+  // STA3-8. Every version of a document is its own row; the list shows the
+  // published one, so `id` is that version's id. `version_count` counts every
+  // version, published or not. `pending_version` is the newest version past the
+  // published one whose ingest finished, the "v2 ready to publish" on the row;
+  // `null` when there is none. Optional, like the ingest fields above, so a box
+  // from before versioning still parses.
+  version: z7.number().int().min(1).optional(),
+  version_count: z7.number().int().min(1).optional(),
+  pending_version: z7.number().int().min(1).nullable().optional()
+});
+var ragFilterSchema = jsonObject();
+var ragDateBoundSchema = z7.string().length(10).regex(/^[0-9]{4}-[0-9]{2}-[0-9]{2}$/).refine((value) => {
+  const year = Number(value.slice(0, 4));
+  const month = Number(value.slice(5, 7));
+  const day = Number(value.slice(8, 10));
+  const date = /* @__PURE__ */ new Date(0);
+  date.setUTCFullYear(year, month - 1, day);
+  return year >= 1 && year <= 9999 && date.getUTCFullYear() === year && date.getUTCMonth() === month - 1 && date.getUTCDate() === day;
+}, "date must be a real YYYY-MM-DD day in years 0001\u20139999");
+var ragRangeFieldSchema = z7.string().min(1).refine((field) => !field.includes("."), {
+  message: "field must be a literal top-level metadata key without dots"
+});
+var ragRangeSchema = z7.discriminatedUnion("type", [
+  z7.strictObject({
+    field: ragRangeFieldSchema,
+    type: z7.literal("number"),
+    gt: z7.number().finite().optional(),
+    gte: z7.number().finite().optional(),
+    lt: z7.number().finite().optional(),
+    lte: z7.number().finite().optional()
+  }),
+  z7.strictObject({
+    field: ragRangeFieldSchema,
+    type: z7.literal("date"),
+    gt: ragDateBoundSchema.optional(),
+    gte: ragDateBoundSchema.optional(),
+    lt: ragDateBoundSchema.optional(),
+    lte: ragDateBoundSchema.optional()
+  })
+]).superRefine((range, ctx) => {
+  const lower = range.gt ?? range.gte;
+  const upper = range.lt ?? range.lte;
+  if (lower === void 0 && upper === void 0) {
+    ctx.addIssue({ code: "custom", message: "range must have at least one bound" });
+  }
+  if (range.gt !== void 0 && range.gte !== void 0) {
+    ctx.addIssue({ code: "custom", message: "gt and gte cannot be combined", path: ["gte"] });
+  }
+  if (range.lt !== void 0 && range.lte !== void 0) {
+    ctx.addIssue({ code: "custom", message: "lt and lte cannot be combined", path: ["lte"] });
+  }
+  if (lower !== void 0 && upper !== void 0 && lower > upper) {
+    ctx.addIssue({ code: "custom", message: "lower bound must not exceed upper bound" });
+  }
+});
+var ragRangesSchema = z7.array(ragRangeSchema).max(10);
+var listRagDocsQuerySchema = forwardPageQuerySchema.extend({
+  limit: limitParamSchema(STUDIO_RAG_DOCS_LIMIT_MAX).default(STUDIO_RAG_DOCS_LIMIT_DEFAULT),
+  // Filter is sent JSON-encoded inside a single query param so the UI can
+  // pass an arbitrarily nested object without colliding with the URL syntax.
+  // Empty/absent => no filter.
+  filter: z7.string().optional()
+});
+var ragDocumentListResponseSchema = forwardPageResponseSchema(ragDocumentSchema);
+var ragDocumentVersionSchema = z7.object({
+  id: z7.string(),
+  version: z7.number().int().min(1),
+  is_active: z7.boolean(),
+  ready: z7.boolean(),
+  chunks_count: z7.number().int().nonnegative(),
+  ingest_status: ragJobStatusSchema.nullable(),
+  run_id: z7.string().nullable(),
+  ingest_error: z7.string().nullable(),
+  filename: z7.string().nullable(),
+  created_at: z7.iso.datetime()
+});
+var ragDocumentVersionListResponseSchema = z7.object({
+  items: z7.array(ragDocumentVersionSchema)
+});
+var ragDocumentVersionNumberSchema = z7.number().int().min(1).max(2147483647);
+var ragDocumentVersionParamSchema = z7.string().regex(/^\d+$/, { message: "version must be a positive integer" }).transform((value) => Number.parseInt(value, 10)).pipe(ragDocumentVersionNumberSchema);
+var activateRagDocumentVersionResponseSchema = z7.object({
+  id: z7.string(),
+  collection: z7.string(),
+  version: z7.number().int().min(1),
+  previous_version: z7.number().int().min(1).nullable(),
+  changed: z7.boolean()
+});
+var ragQueryRequestSchema = z7.object({
+  text: z7.string().min(1).optional(),
+  embedding: z7.array(z7.number().finite()).min(1).optional(),
+  model: z7.string().min(1).optional(),
+  topK: z7.coerce.number().int().min(1).max(STUDIO_RAG_TOPK_MAX).default(STUDIO_RAG_TOPK_DEFAULT),
+  filter: ragFilterSchema.optional(),
+  ranges: ragRangesSchema.optional(),
+  preview: z7.object({ docId: z7.string().min(1), version: ragDocumentVersionNumberSchema }).optional(),
+  hybrid: z7.boolean().optional()
+}).refine((value) => value.embedding !== void 0 || value.text !== void 0, {
+  message: "either `embedding` or `text` must be provided",
+  path: ["embedding"]
+});
+var ragQueryHitSchema = z7.object({
+  id: z7.string(),
+  chunk_idx: z7.number().int().nonnegative(),
+  // Cosine similarity in [-1, 1]. The query handler emits `1 - (embedding <=>
+  // query)` over `stackbone_rag_chunks`, so higher is closer. We surface the
+  // raw value; the UI formats it.
+  score: z7.number(),
+  // The reciprocal rank fusion score a hybrid search ordered by (STA3-57 D10).
+  // Absent when only the search by meaning ran, and from a box older than it.
+  mixed_score: z7.number().optional(),
+  content: z7.string(),
+  metadata: jsonObject()
+});
+var ragQueryResponseSchema = z7.object({
+  items: z7.array(ragQueryHitSchema),
+  // Echoes the dimensions used at retrieval time so the UI can flag a
+  // dim-mismatch before it round-trips to a 4xx.
+  dimensions: z7.number().int().min(1),
+  // Provider-pinned model (`provider::model`) used to embed `text`. Null when
+  // the caller passed `embedding` directly.
+  embedded_with: z7.string().nullable()
+});
+var ragJobSchema = z7.object({
+  id: z7.string(),
+  collection: z7.string(),
+  status: ragJobStatusSchema,
+  attempts: z7.number().int().nonnegative(),
+  error: z7.string().nullable(),
+  created_at: z7.iso.datetime(),
+  finished_at: z7.iso.datetime().nullable()
+});
+var listRagJobsQuerySchema = forwardPageQuerySchema.extend({
+  collection: ragCollectionNameParamSchema.optional(),
+  limit: limitParamSchema(STUDIO_RAG_JOBS_LIMIT_MAX).default(STUDIO_RAG_JOBS_LIMIT_DEFAULT)
+});
+var ragJobListResponseSchema = forwardPageResponseSchema(ragJobSchema);
+var ragJobIdParamSchema = z7.object({
+  jobId: z7.string().min(1).max(128)
+});
+var ragJobActionResponseSchema = z7.object({
+  id: z7.string(),
+  status: ragJobStatusSchema
+});
+var STUDIO_RAG_SUPPORTED_CONTENT_TYPES = [
+  "text/plain",
+  "text/markdown",
+  "application/pdf"
+];
+var ragSupportedContentTypeSchema = z7.enum(STUDIO_RAG_SUPPORTED_CONTENT_TYPES);
+var createRagCollectionRequestSchema = z7.object({
+  name: ragCollectionNameParamSchema,
+  metadata: jsonObject().optional(),
+  embedding_provider: pickedModelProviderIdSchema.optional(),
+  embedding_model: z7.string().trim().min(1).optional(),
+  // Omitted, the box creates the collection with hybrid search off and `eu`.
+  hybrid_enabled: z7.boolean().optional(),
+  number_format: ragNumberFormatSchema.optional()
+}).refine(
+  (value) => value.embedding_provider === void 0 === (value.embedding_model === void 0),
+  {
+    message: "embedding_provider and embedding_model must be provided together",
+    path: ["embedding_model"]
+  }
+);
+var updateRagCollectionRequestSchema = z7.strictObject({
+  hybrid_enabled: z7.boolean().optional(),
+  number_format: ragNumberFormatSchema.optional()
+}).refine((value) => value.hybrid_enabled !== void 0 || value.number_format !== void 0, {
+  message: "Send hybrid_enabled, number_format or both"
+});
+var updateRagCollectionResponseSchema = z7.object({
+  name: z7.string(),
+  hybrid_enabled: z7.boolean(),
+  number_format: ragNumberFormatSchema
+});
+var deleteRagCollectionResponseSchema = z7.object({
+  name: z7.string(),
+  deleted: z7.literal(true)
+});
+var uploadRagDocumentRequestSchema = z7.object({
+  collection: ragCollectionNameParamSchema,
+  filename: z7.string().min(1).max(255),
+  content_type: ragSupportedContentTypeSchema,
+  metadata: jsonObject().optional(),
+  replaces: z7.string().min(1).optional()
+});
+var uploadRagDocumentResponseSchema = z7.object({
+  job_id: z7.string(),
+  status: ragJobStatusSchema,
+  version: z7.number().int().min(1)
+});
+var deleteRagDocumentResponseSchema = z7.object({
+  id: z7.string(),
+  collection: z7.string(),
+  deleted: z7.literal(true)
+});
+var deleteRagDocumentVersionResponseSchema = z7.object({
+  id: z7.string(),
+  collection: z7.string(),
+  version: ragDocumentVersionNumberSchema,
+  deleted: z7.literal(true)
+});
+var downloadRagDocumentResponseSchema = z7.object({
+  url: z7.string(),
+  filename: z7.string(),
+  content_type: z7.string()
+});
+var changeRagEmbeddingRequestSchema = z7.object({
+  provider: pickedModelProviderIdSchema,
+  model: z7.string().trim().min(1)
+});
+var retryRagRebuildRequestSchema = z7.object({ id: z7.uuid() });
+var ragEmbeddingIdentitySchema = z7.object({
+  provider: z7.string().min(1),
+  model: z7.string().min(1),
+  dimension: z7.number().int().positive()
+});
+var ragRebuildStatusSchema = z7.object({
+  id: z7.uuid(),
+  collection: z7.string(),
+  attempt: z7.number().int().positive(),
+  status: z7.enum(["queued", "running", "failed", "interrupted", "complete"]),
+  current: ragEmbeddingIdentitySchema,
+  target: ragEmbeddingIdentitySchema,
+  completed_versions: z7.number().int().nonnegative(),
+  total_versions: z7.number().int().nonnegative(),
+  run_id: z7.string().nullable(),
+  world_run_id: z7.string().nullable(),
+  error: z7.string().nullable()
+});
+var ragRebuildStatusResponseSchema = z7.object({
+  rebuild: ragRebuildStatusSchema.nullable()
+});
+
+// libs/shared/validators/src/lib/studio/studio-voice.ts
+var VOICE_STT_MODELS = [
+  "deepgram/flux-general-multi",
+  "deepgram/nova-3",
+  "assemblyai/universal-3-6-pro"
+];
+var VOICE_TTS_MODELS = [
+  "cartesia/sonic-3.6",
+  "deepgram/aura-2",
+  "gradium/default"
+];
+var isCartesiaTtsModel = (model) => model.startsWith("cartesia/") && VOICE_TTS_MODELS.includes(model);
+var thresholdSchema = z8.number().min(0).max(1);
+var millisecondsSchema = z8.int().min(0).max(1e4);
+var keytermsSchema = z8.array(z8.string().trim().min(1).max(64)).max(50);
+var vadSchema = z8.strictObject({
+  activationThreshold: thresholdSchema,
+  minSpeechMs: millisecondsSchema,
+  minSilenceMs: millisecondsSchema
+});
+var turnSchema = z8.strictObject({
+  mode: z8.enum(["stt", "livekit"]),
+  minEndpointingDelayMs: millisecondsSchema,
+  maxEndpointingDelayMs: millisecondsSchema,
+  detectorThreshold: thresholdSchema
+});
+var interruptionsSchema = z8.strictObject({
+  enabled: z8.boolean(),
+  minDurationMs: millisecondsSchema,
+  minWords: z8.int().min(0).max(20)
+});
+var ragSchema = z8.strictObject({
+  collection: ragCollectionNameParamSchema.nullable(),
+  minScore: z8.number().min(0).max(1),
+  minWords: z8.int().min(0).max(20),
+  topK: z8.int().min(1).max(10),
+  timeoutMs: z8.int().min(200).max(1e4)
+});
+var effectiveVoiceSettingsObjectSchema = z8.strictObject({
+  /** BCP-47-ish tag the STT is hinted with and the TTS speaks (`es`, `en-US`), or `multi`. */
+  language: z8.string().max(16).regex(/^[A-Za-z]{2,8}(?:-[A-Za-z0-9]{1,8})*$/),
+  sttModel: z8.enum(VOICE_STT_MODELS),
+  keyterms: keytermsSchema.default(() => []),
+  vad: vadSchema,
+  turn: turnSchema,
+  interruptions: interruptionsSchema,
+  ttsModel: z8.enum(VOICE_TTS_MODELS),
+  /**
+   * The provider's own voice id (a Cartesia UUID, an ElevenLabs id, a Deepgram name),
+   * so only its outline is checked: no surrounding whitespace, no control characters.
+   */
+  ttsVoice: z8.string().max(128).regex(/^[^\s\p{Cc}](?:[^\p{Cc}]*[^\s\p{Cc}])?$/u),
+  /** Cartesia only (D18): another model keeps its own pace, so it takes only 1. */
+  ttsSpeed: z8.number().min(0.5).max(2),
+  /**
+   * What the agent says when the call connects. `null`: it waits for the caller. A
+   * blank string is refused rather than read as either: it would be an empty
+   * utterance, not a wait.
+   */
+  greeting: z8.string().trim().min(1).max(500).nullable(),
+  /** Band-pass the agent's voice to 300-3400 Hz so it sounds like a phone line (D5). */
+  phoneLine: z8.boolean(),
+  /** LiveKit expressive mode: the turn gets Cartesia's markup guide (D5). Cartesia only. */
+  expressive: z8.boolean(),
+  /**
+   * Whether the box records the call to its bucket (D30). Off, no egress starts: a
+   * box may not be allowed to keep a caller's audio. The box alone reads it, so the
+   * dispatch to the worker leaves it out (`callVoiceSettingsSchema`).
+   */
+  recording: z8.boolean(),
+  /**
+   * Ask OpenRouter to route this agent's model calls to the provider with the
+   * highest throughput (`provider: { sort: 'throughput' }`) instead of its default
+   * price routing. Gemma 4 31B on price routing landed on a 13 tok/s provider (5 s
+   * a turn); throughput routing answered in about 1 s. A request field, not a
+   * `:nitro` model suffix, so the model id the box checks and prices stays the
+   * one written. The box strips it off any other gateway. The SDK applies it when
+   * it builds the graph, so the worker never reads it.
+   */
+  fastModelRouting: z8.boolean(),
+  /** The box runs the search before the model's turn, so the worker never reads it. */
+  rag: ragSchema,
+  /**
+   * What the agent says when an input guardrail stops the caller's sentence (FDE-66):
+   * a policy message written for a chat reader would leak the rule if a TTS read it.
+   * The box answers the turn itself, so the worker never reads it. Not nullable: a
+   * blocked turn always says something.
+   */
+  refusalPhrase: z8.string().trim().min(1).max(300)
+});
+var checkCrossFieldRules = (value, ctx) => {
+  const min = value.turn?.minEndpointingDelayMs;
+  const max = value.turn?.maxEndpointingDelayMs;
+  if (min !== void 0 && max !== void 0 && min > max) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["turn", "minEndpointingDelayMs"],
+      message: "turn.minEndpointingDelayMs must not exceed turn.maxEndpointingDelayMs"
+    });
+  }
+  if (value.expressive === true && value.ttsModel !== void 0 && !isCartesiaTtsModel(value.ttsModel)) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["expressive"],
+      message: "expressive needs a Cartesia ttsModel"
+    });
+  }
+  if (value.ttsSpeed !== void 0 && value.ttsSpeed !== 1 && value.ttsModel !== void 0 && !isCartesiaTtsModel(value.ttsModel)) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["ttsSpeed"],
+      message: "ttsSpeed other than 1 needs a Cartesia ttsModel"
+    });
+  }
+};
+var effectiveVoiceSettingsSchema = effectiveVoiceSettingsObjectSchema.superRefine(checkCrossFieldRules);
+var callVoiceSettingsObjectSchema = effectiveVoiceSettingsObjectSchema.omit({
+  recording: true,
+  fastModelRouting: true,
+  rag: true,
+  refusalPhrase: true
+});
+var callVoiceSettingsSchema = callVoiceSettingsObjectSchema.superRefine(checkCrossFieldRules);
+var VOICE_SETTINGS_LEAF_PATHS = [
+  "language",
+  "sttModel",
+  "keyterms",
+  "vad.activationThreshold",
+  "vad.minSpeechMs",
+  "vad.minSilenceMs",
+  "turn.mode",
+  "turn.minEndpointingDelayMs",
+  "turn.maxEndpointingDelayMs",
+  "turn.detectorThreshold",
+  "interruptions.enabled",
+  "interruptions.minDurationMs",
+  "interruptions.minWords",
+  "ttsModel",
+  "ttsVoice",
+  "ttsSpeed",
+  "greeting",
+  "phoneLine",
+  "expressive",
+  "recording",
+  "fastModelRouting",
+  "rag.collection",
+  "rag.minScore",
+  "rag.minWords",
+  "rag.topK",
+  "rag.timeoutMs",
+  "refusalPhrase"
+];
+var voiceSettingOriginSchema = z8.enum(["studio", "code", "default"]);
+var effectiveVoiceSettingsViewSchema = z8.strictObject({
+  value: effectiveVoiceSettingsObjectSchema,
+  origins: z8.strictObject(
+    Object.fromEntries(
+      VOICE_SETTINGS_LEAF_PATHS.map((path) => [path, voiceSettingOriginSchema])
+    )
+  )
+});
+var checkTtsPair = (value, ctx) => {
+  if (value.ttsModel !== void 0 && value.ttsVoice === void 0) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["ttsVoice"],
+      message: "ttsModel needs a ttsVoice of that provider beside it"
+    });
+  }
+};
+var voiceSettingsSchema = effectiveVoiceSettingsObjectSchema.extend({
+  keyterms: keytermsSchema,
+  vad: vadSchema.partial(),
+  turn: turnSchema.partial(),
+  interruptions: interruptionsSchema.partial(),
+  rag: ragSchema.partial()
+}).partial().superRefine(checkCrossFieldRules).superRefine(checkTtsPair);
+var checkStudioTtsPair = (value, ctx) => {
+  if (value.ttsVoice !== void 0 && value.ttsModel === void 0) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["ttsModel"],
+      message: "ttsVoice needs the ttsModel it was picked for beside it"
+    });
+  }
+};
+var studioVoiceSettingsPatchSchema = voiceSettingsSchema.superRefine(checkStudioTtsPair);
+var voiceSettingsResponseSchema = effectiveVoiceSettingsViewSchema.extend({
+  issue: z8.string().nullable()
+});
+var deepAgentNameSchema = z8.string().regex(/^[a-z0-9][a-z0-9_-]{0,63}$/);
+var voiceCallIdSchema = z8.string().min(1).max(RUN_TAG_VALUE_MAX);
+var voiceTagsSchema = z8.record(runTagKeySchema, runTagValueSchema).refine((tags) => Object.keys(tags).length <= RUN_TAGS_MAX, {
+  message: `A call carries at most ${RUN_TAGS_MAX} tags.`
+});
+var VOICE_TTS_MARKUP_CONTEXT = "voice-tts-markup";
+var isVoiceBoxUrl = (raw) => {
+  if (!/^https?:\/\//i.test(raw) || /[\s?#]/.test(raw)) return false;
+  try {
+    const url = new URL(raw);
+    return url.hostname !== "" && url.username === "" && url.password === "";
+  } catch {
+    return false;
+  }
+};
+var VOICE_BOX_URL_MAX = 2048;
+var voiceBoxUrlSchema = z8.string().max(VOICE_BOX_URL_MAX).refine(isVoiceBoxUrl, {
+  message: "boxUrl must be an absolute http(s) URL with no user part, query or fragment."
+});
+var VOICE_TRACES_PATH = "/voice/v1/traces";
+var VOICE_WORKER_AGENT_NAME = "stackbone-voice";
+var VOICE_WORKER_AGENT_NAME_ENV = "STACKBONE_VOICE_AGENT_NAME";
+var VOICE_WORKER_PORT_ENV = "STACKBONE_VOICE_WORKER_PORT";
+var VOICE_CALL_TOKEN_MAX = 2048;
+var voiceDispatchSchema = z8.strictObject({
+  agent: deepAgentNameSchema,
+  /**
+   * The merged value (Studio > code > box default), cross-field rules included,
+   * without the box-only leaves (`callVoiceSettingsSchema`).
+   */
+  voiceSettings: callVoiceSettingsSchema,
+  sessionKey: voiceCallIdSchema,
+  tags: voiceTagsSchema,
+  boxUrl: voiceBoxUrlSchema,
+  /** The call token: the bearer on every AG-UI request of this call, for this agent and session only. */
+  callToken: z8.string().max(VOICE_CALL_TOKEN_MAX).regex(/^\S+$/, { message: "callToken must be a non-empty token with no whitespace." }),
+  /**
+   * Set only when the box exports traces to an OTLP endpoint of its own (FDE-62 S11):
+   * the worker then sends each call's spans to `<boxUrl>` + {@link VOICE_TRACES_PATH} with the
+   * call token. Off is the absent key, never `false`.
+   */
+  traces: z8.literal(true).optional()
+});
+var voiceRoomRequestSchema = z8.strictObject({
+  agent: deepAgentNameSchema,
+  origin: runTagKeySchema.default("studio"),
+  identities: integrationIdentitiesSchema.optional()
+});
+var voiceRoomResponseSchema = z8.strictObject({
+  url: z8.string().min(1),
+  token: z8.string().min(1),
+  room: voiceCallIdSchema,
+  agent: deepAgentNameSchema,
+  sessionKey: voiceCallIdSchema,
+  voiceSettings: callVoiceSettingsObjectSchema
+});
+var VOICE_RECORDING_STATUSES = ["recording", "ready", "failed"];
+var voiceRecordingQuerySchema = z8.object({ session_id: z8.uuid() });
+var voiceRecordingResponseSchema = z8.strictObject({
+  room: voiceCallIdSchema,
+  status: z8.enum(VOICE_RECORDING_STATUSES),
+  url: z8.string().nullable(),
+  expires_at: z8.iso.datetime().nullable(),
+  started_at: z8.iso.datetime(),
+  ended_at: z8.iso.datetime().nullable()
+});
+var voiceStatusResponseSchema = z8.strictObject({
+  configured: z8.literal(true),
+  reachable: z8.boolean(),
+  checkedAt: z8.iso.datetime()
+});
+var HEARD_TEXT_MAX = 4e3;
+var aguiHeardSchema = z8.strictObject({
+  text: z8.string().min(1).max(HEARD_TEXT_MAX)
+});
+var VOICE_CALLS_PATH = "/voice/v1/calls";
+var voiceCallBootstrapSchema = z8.strictObject({
+  identities: integrationIdentitiesSchema.optional()
+});
+var voiceCallTranscriptSchema = z8.array(
+  z8.strictObject({
+    role: z8.enum(["user", "assistant"]),
+    text: z8.string().trim().min(1).max(16e3)
+  })
+).max(1e3).refine((items) => items.reduce((size, item) => size + item.text.length, 0) <= 2e5, {
+  message: "A call transcript may contain at most 200000 characters."
+});
+var voiceCallCompleteSchema = z8.strictObject({
+  transcript: voiceCallTranscriptSchema,
+  outcome: z8.enum(["completed", "disconnected", "failed"])
+});
+var voiceCallLifecycleResponseSchema = z8.strictObject({ ok: z8.literal(true) });
+
+// libs/runtime/voice-worker/src/box-llm.ts
+import { randomUUID } from "node:crypto";
+import { DEFAULT_API_CONNECT_OPTIONS, llm, log } from "@livekit/agents";
+
+// libs/shared/llm-wire/src/lib/sse/read-sse-data.ts
+async function* readSseData(body) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffered = "";
+  let data = [];
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (!done) buffered += decoder.decode(value, { stream: true });
+      const end = !done && buffered.endsWith("\r") ? buffered.length - 1 : buffered.length;
+      const lines = buffered.slice(0, end).split(/\r\n|\r|\n/);
+      buffered = (lines.pop() ?? "") + buffered.slice(end);
+      for (const line of lines) {
+        if (line === "") {
+          if (data.length > 0) yield data.join("\n");
+          data = [];
+        } else if (line.startsWith("data:")) {
+          const field = line.slice(5);
+          data.push(field.startsWith(" ") ? field.slice(1) : field);
+        }
+      }
+      if (done) return;
+    }
+  } finally {
+    await reader.cancel().catch(() => void 0);
+  }
+}
+
+// libs/runtime/voice-worker/src/box-wire.ts
+var BODY_EXCERPT_CHARS = 300;
+var TURN_IDLE_TIMEOUT_MS = 3e4;
+var NON_ASCII = /[\u007f-\uffff]/g;
+var runErrorOf = ({ message, code }) => new Error(`box run failed${code ? ` (${code})` : ""}: ${message}`);
+var BoxTurnError = class extends Error {
+  constructor(agent, status, body) {
+    super(`box refused the AG-UI turn of ${agent}: HTTP ${status} ${body}`);
+    this.name = "BoxTurnError";
+    this.status = status;
+    this.body = body;
+  }
+};
+var boxEndpoint = (boxUrl, path) => `${boxUrl.replace(/\/+$/, "")}${path}`;
+async function* aguiTurn(opts) {
+  const runId = `run-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  const heard = "toolResult" in opts ? void 0 : opts.heard;
+  const message = "toolResult" in opts ? {
+    id: `tool-${opts.toolResult.toolCallId}`,
+    role: "tool",
+    toolCallId: opts.toolResult.toolCallId,
+    content: opts.toolResult.content
+  } : { id: `user-${runId}`, role: "user", content: opts.text };
+  const res = await fetch(
+    boxEndpoint(opts.boxUrl, `/agui/v1/agents/${encodeURIComponent(opts.agent)}`),
+    {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        accept: "text/event-stream",
+        authorization: `Bearer ${opts.token}`,
+        [STACKBONE_SESSION_HEADER]: opts.sessionKey,
+        [RUN_TAGS_HEADER]: tagsHeader(opts.tags)
+      },
+      body: JSON.stringify({
+        threadId: opts.sessionKey,
+        runId,
+        state: {},
+        messages: [message],
+        tools: opts.tools ?? [],
+        context: opts.context ?? [],
+        forwardedProps: heard ? { heard } : {}
+      }),
+      ...opts.signal ? { signal: opts.signal } : {}
+    }
+  );
+  if (!res.ok || !res.body) throw new BoxTurnError(opts.agent, res.status, await readExcerpt(res));
+  let inStep = false;
+  for await (const data of readSseData(res.body)) {
+    const parsed = JSON.parse(data);
+    const ev = typeof parsed === "object" && parsed !== null ? parsed : {};
+    const wire = toWireEvent(ev);
+    if (wire.kind === "other" && wire.type === "STEP_STARTED") inStep = true;
+    if (wire.kind === "other" && wire.type === "STEP_FINISHED") inStep = false;
+    yield wire.kind === "text" && inStep ? { kind: "other", type: "TEXT_MESSAGE_CONTENT" } : wire;
+  }
+}
+var tagsHeader = (tags) => JSON.stringify(tags).replace(
+  NON_ASCII,
+  (c) => `\\u${c.charCodeAt(0).toString(16).padStart(4, "0")}`
+);
+var readExcerpt = async (res) => {
+  if (!res.body) return "";
+  const reader = res.body.getReader();
+  const decoder = new TextDecoder();
+  let text = "";
+  try {
+    while (text.length < BODY_EXCERPT_CHARS) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      text += decoder.decode(value, { stream: true });
+    }
+  } finally {
+    await reader.cancel().catch(() => void 0);
+  }
+  return text.slice(0, BODY_EXCERPT_CHARS);
+};
+var stringField = (ev, key) => {
+  const value = ev[key];
+  return typeof value === "string" ? value : void 0;
+};
+var toWireEvent = (ev) => {
+  const type = stringField(ev, "type") ?? "";
+  const id = stringField(ev, "toolCallId");
+  switch (type) {
+    case "TEXT_MESSAGE_CONTENT": {
+      const delta = stringField(ev, "delta");
+      return delta ? { kind: "text", text: delta } : { kind: "other", type };
+    }
+    case "TOOL_CALL_START":
+      return id ? { kind: "tool_call_start", id, name: stringField(ev, "toolCallName") ?? "" } : { kind: "other", type };
+    case "TOOL_CALL_RESULT":
+      return id ? { kind: "tool_call_result", id } : { kind: "other", type };
+    case "RUN_FINISHED": {
+      const outcome = ev["outcome"];
+      const paused = typeof outcome === "object" && outcome !== null && outcome["type"] === "interrupt";
+      return { kind: "finish", outcome: paused ? "interrupt" : "success" };
+    }
+    case "RUN_ERROR": {
+      const code = stringField(ev, "code");
+      return {
+        kind: "error",
+        message: stringField(ev, "message") ?? "run error",
+        ...code ? { code } : {}
+      };
+    }
+    default:
+      return { kind: "other", type };
+  }
+};
+var voiceCallRequest = async (wire, operation, payload) => {
+  const response = await fetch(
+    boxEndpoint(
+      wire.boxUrl,
+      `${VOICE_CALLS_PATH}/${encodeURIComponent(wire.sessionKey)}/${operation}`
+    ),
+    {
+      method: "POST",
+      headers: { "content-type": "application/json", authorization: `Bearer ${wire.token}` },
+      signal: AbortSignal.timeout(TURN_IDLE_TIMEOUT_MS),
+      body: JSON.stringify(payload)
+    }
+  );
+  if (!response.ok)
+    throw new BoxTurnError(wire.agent, response.status, await readExcerpt(response));
+  voiceCallLifecycleResponseSchema.parse(await response.json());
+};
+
+// libs/runtime/voice-worker/src/heard.ts
+var VOICE_RESPONSE_MARKER = "stackboneVoiceResponse";
+var WORD_CHAR = /[\p{L}\p{N}]/u;
+var SPACE = /\s/u;
+var TAG = /^<[\p{L}/][^>]*>/u;
+var charAt = (text, index) => String.fromCodePoint(text.codePointAt(index) ?? 0);
+var heardPrefixOf = (boxText, heardText) => {
+  let b = 0;
+  let h = 0;
+  while (h < heardText.length) {
+    const heardChar = charAt(heardText, h);
+    if (b >= boxText.length) {
+      if (!SPACE.test(heardChar)) return void 0;
+      h += heardChar.length;
+      continue;
+    }
+    const boxChar = charAt(boxText, b);
+    const tag = boxChar === "<" ? TAG.exec(boxText.slice(b)) : null;
+    if (boxChar === heardChar) {
+      b += boxChar.length;
+      h += heardChar.length;
+    } else if (tag) {
+      b += tag[0].length;
+    } else if (!WORD_CHAR.test(boxChar)) {
+      b += boxChar.length;
+    } else if (SPACE.test(heardChar)) {
+      h += heardChar.length;
+    } else {
+      return void 0;
+    }
+  }
+  return boxText.slice(0, b).trimEnd() || void 0;
+};
+var TurnReply = class {
+  /** LiveKit's chat items when the turn started: the reply a barge-in cut is a later one. */
+  #seen;
+  /** Every text delta queued to LiveKit this turn. */
+  #text = "";
+  /** Where the current model call's text starts in `#text`. */
+  #callStart = 0;
+  /** A tool result came after the current call: the next text is a new call's. */
+  #callClosed = false;
+  /** The current call is the turn's first: no tool result came before it. */
+  #firstCall = true;
+  /** The current call asked for tools: the box writes it before it runs them. */
+  #callToolCalls = false;
+  /** `RUN_FINISHED` arrived: the box wrote every call of the run. */
+  #finished = false;
+  constructor(chatCtx) {
+    this.#seen = new Set(chatCtx.items.map((item) => item.id));
+  }
+  observe(ev) {
+    switch (ev.kind) {
+      case "text":
+        this.#openCallAfterResult();
+        this.#text += ev.text;
+        break;
+      case "tool_call_start":
+        this.#openCallAfterResult();
+        this.#callToolCalls = true;
+        break;
+      case "tool_call_result":
+        this.#callClosed = true;
+        break;
+      case "finish":
+        this.#finished = true;
+        break;
+    }
+  }
+  #openCallAfterResult() {
+    if (!this.#callClosed) return;
+    this.#callStart = this.#text.length;
+    this.#callClosed = false;
+    this.#firstCall = false;
+    this.#callToolCalls = false;
+  }
+  /**
+   * Whether the box's last AI message after the turn's user message is the current
+   * call's, or there is none (the box then appends `heard` as the reply):
+   * - the run finished: the current call's, unless a tool result closed it, since the
+   *   last model call then said nothing (an empty message);
+   * - cut while the box still sent: the current call's once the box wrote it, which a
+   *   tool call or a tool result proves; none for the turn's first call; for a later
+   *   call torn down mid-text, an EARLIER call's, which the caller's words do not fit.
+   */
+  #boxHoldsCurrentCall() {
+    if (this.#finished) return !this.#callClosed;
+    return this.#callClosed || this.#callToolCalls || this.#firstCall;
+  }
+  finalPrefix(playedText) {
+    const prefix = heardPrefixOf(this.#text, playedText);
+    if (prefix === void 0) return void 0;
+    const remainder = this.#text.slice(prefix.length).replace(/<[\p{L}/][^>]*>/gu, "");
+    return WORD_CHAR.test(remainder) ? prefix : void 0;
+  }
+  /**
+   * What the caller heard of this reply's last model call, from the next turn's chat
+   * context: only when a barge-in cut it there, and never the whole call's text.
+   * `undefined` when no barge-in cut it; otherwise the heard part or why there is none.
+   */
+  heardIn(chatCtx) {
+    const played = lastNewAssistantMessage(chatCtx, this.#seen);
+    if (!played?.interrupted) return void 0;
+    if (!this.#boxHoldsCurrentCall()) return { skipped: "not_box_held" };
+    const prefix = heardPrefixOf(this.#text, played.textContent ?? "");
+    if (prefix === void 0) return { skipped: "unaligned" };
+    if (prefix.length <= this.#callStart) return { skipped: "earlier_call" };
+    const text = prefix.slice(this.#callStart);
+    const whole = this.#text.slice(this.#callStart).trimEnd();
+    if (text.length >= whole.length) return { skipped: "whole" };
+    return text.length <= HEARD_TEXT_MAX ? { heard: { text } } : { skipped: "over_max" };
+  }
+};
+var HeardTracker = class {
+  #last;
+  #responses = /* @__PURE__ */ new Map();
+  /**
+   * Starts a turn that is about to send: what the caller heard of the previous turn's
+   * reply (or why a cut reply sends nothing), and this turn's reply. The previous
+   * reply is read once.
+   */
+  openTurn(chatCtx, responseId) {
+    const read = this.#last?.heardIn(chatCtx);
+    const reply = new TurnReply(chatCtx);
+    this.#last = reply;
+    if (responseId) this.#responses.set(responseId, reply);
+    return {
+      heard: read && "heard" in read ? read.heard : void 0,
+      skipped: read && "skipped" in read ? read.skipped : void 0,
+      reply
+    };
+  }
+  transcript(history, onUncertain) {
+    const transcript = [];
+    for (const item of history.items) {
+      if (item.type !== "message" || item.role !== "user" && item.role !== "assistant") continue;
+      let text = item.textContent?.trim();
+      if (!text) continue;
+      if (item.role === "assistant" && item.interrupted) {
+        const responseId = item.extra[VOICE_RESPONSE_MARKER];
+        const response = typeof responseId === "string" ? this.#responses.get(responseId) : void 0;
+        text = response?.finalPrefix(text)?.trim();
+        if (!text) {
+          onUncertain(response ? "unverified_interrupted_prefix" : "unowned_interruption");
+          continue;
+        }
+      }
+      transcript.push({ role: item.role, text });
+    }
+    return transcript;
+  }
+  /** A failed turn: the box keeps none of its reply, so the next turn sends nothing for it. */
+  dropTurn(reply) {
+    if (this.#last === reply) this.#last = void 0;
+    for (const [id, response] of this.#responses)
+      if (response === reply) this.#responses.delete(id);
+  }
+};
+var lastNewAssistantMessage = (chatCtx, seen) => {
+  for (let i = chatCtx.items.length - 1; i >= 0; i--) {
+    const item = chatCtx.items[i];
+    if (item === void 0 || seen.has(item.id)) continue;
+    if (item.type === "message" && item.role === "assistant") return item;
+  }
+  return void 0;
+};
+
+// libs/runtime/voice-worker/src/box-llm.ts
+var BoxLLM = class extends llm.LLM {
+  #opts;
+  #replies = new HeardTracker();
+  #pending = /* @__PURE__ */ new Set();
+  async settled() {
+    await Promise.all(this.#pending);
+  }
+  constructor(opts) {
+    super();
+    this.#opts = opts;
+  }
+  heardTranscript(history) {
+    return this.#replies.transcript(
+      history,
+      (reason) => log().warn(
+        { agent: this.#opts.agent, sessionKey: this.#opts.sessionKey, reason },
+        "voice worker: omitted uncertain interrupted output"
+      )
+    );
+  }
+  label() {
+    return "stackbone.BoxLLM";
+  }
+  get model() {
+    return this.#opts.agent;
+  }
+  get provider() {
+    return "stackbone";
+  }
+  chat({
+    chatCtx,
+    connOptions
+  }) {
+    let done = () => void 0;
+    const pending = new Promise((resolve) => {
+      done = resolve;
+    });
+    this.#pending.add(pending);
+    return new BoxLLMStream(
+      this,
+      this.#opts,
+      this.#replies,
+      () => {
+        this.#pending.delete(pending);
+        done();
+      },
+      {
+        chatCtx,
+        connOptions: { ...connOptions ?? DEFAULT_API_CONNECT_OPTIONS, maxRetry: 0 }
+      }
+    );
+  }
+};
+var refusedHeard = (err) => {
+  if (!(err instanceof BoxTurnError) || err.status !== 400) return false;
+  try {
+    return JSON.parse(err.body)?.code === "invalid_heard";
+  } catch {
+    return false;
+  }
+};
+async function* textTurnEvents({
+  heard,
+  ...turn
+}) {
+  if (heard) {
+    try {
+      yield* aguiTurn({ ...turn, heard });
+      return;
+    } catch (err) {
+      if (!refusedHeard(err)) throw err;
+      log().warn(
+        { agent: turn.agent, sessionKey: turn.sessionKey, status: err.status, error: err.message },
+        "voice worker: the box refused heard; the turn goes on without it"
+      );
+    }
+  }
+  yield* aguiTurn(turn);
+}
+var HEARD_SKIP_LEVEL = {
+  not_box_held: "debug",
+  earlier_call: "debug",
+  whole: "debug",
+  unaligned: "warn",
+  over_max: "warn"
+};
+var logHeardSkip = (skipped, turn) => log()[HEARD_SKIP_LEVEL[skipped]](
+  { reason: skipped, agent: turn.agent, sessionKey: turn.sessionKey },
+  "voice worker: no heard for the reply cut"
+);
+var lastUserText = (chatCtx) => {
+  for (let i = chatCtx.items.length - 1; i >= 0; i--) {
+    const item = chatCtx.items[i];
+    if (item?.type === "message" && item.role === "user") return item.textContent ?? "";
+  }
+  return "";
+};
+var BoxLLMStream = class extends llm.LLMStream {
+  #opts;
+  #replies;
+  #settle;
+  constructor(owner, opts, replies, settle, init) {
+    super(owner, init);
+    this.#opts = opts;
+    this.#replies = replies;
+    this.#settle = settle;
+  }
+  async run() {
+    try {
+      await this.runTurn();
+    } finally {
+      this.#settle();
+    }
+  }
+  async runTurn() {
+    const {
+      onToolCall,
+      onTurnError,
+      onRunFinished,
+      onClientToolCall,
+      pendingResume,
+      isEnding,
+      clientTools = [],
+      turnIdleTimeoutMs = TURN_IDLE_TIMEOUT_MS,
+      ...turn
+    } = this.#opts;
+    const id = randomUUID();
+    const { signal } = this.abortController;
+    await pendingResume?.();
+    if (signal.aborted || isEnding?.()) return;
+    const { heard, skipped, reply } = this.#replies.openTurn(this.chatCtx, id);
+    if (skipped) logHeardSkip(skipped, turn);
+    const clientToolNames = new Set(clientTools.map((tool) => tool.name));
+    const clientToolCalls = /* @__PURE__ */ new Map();
+    const idle = new AbortController();
+    let timer;
+    const restartIdle = () => {
+      clearTimeout(timer);
+      timer = setTimeout(() => idle.abort(), turnIdleTimeoutMs);
+    };
+    const openToolCalls = /* @__PURE__ */ new Set();
+    let finished;
+    let failure;
+    try {
+      restartIdle();
+      const turnSignal = AbortSignal.any([signal, idle.signal]);
+      for await (const ev of textTurnEvents({
+        ...turn,
+        tools: clientTools,
+        text: lastUserText(this.chatCtx),
+        ...heard ? { heard } : {},
+        signal: turnSignal
+      })) {
+        restartIdle();
+        reply.observe(ev);
+        switch (ev.kind) {
+          case "text":
+            this.queue.put({
+              id,
+              delta: {
+                role: "assistant",
+                content: ev.text,
+                extra: { [VOICE_RESPONSE_MARKER]: id }
+              }
+            });
+            break;
+          case "tool_call_start":
+            if (clientToolNames.has(ev.name)) {
+              clientToolCalls.set(ev.id, { id: ev.id, name: ev.name });
+            } else if (!openToolCalls.has(ev.id)) {
+              openToolCalls.add(ev.id);
+              onToolCall?.("start", ev.id);
+            }
+            break;
+          case "tool_call_result":
+            clientToolCalls.delete(ev.id);
+            if (openToolCalls.delete(ev.id)) onToolCall?.("end", ev.id);
+            break;
+          case "finish":
+            finished = ev.outcome;
+            break;
+          case "error":
+            throw runErrorOf(ev);
+        }
+      }
+      if (!finished) throw new Error("box closed the turn before RUN_FINISHED");
+    } catch (err) {
+      if (finished) {
+      } else if (signal.aborted) {
+      } else if (idle.signal.aborted) {
+        failure = new Error(`box sent no event for ${turnIdleTimeoutMs} ms`);
+      } else {
+        failure = err instanceof Error ? err : new Error(String(err));
+      }
+    } finally {
+      clearTimeout(timer);
+    }
+    for (const callId of openToolCalls) onToolCall?.("end", callId);
+    if (failure) {
+      this.#replies.dropTurn(reply);
+      onTurnError?.(failure);
+      return;
+    }
+    if (finished === "success")
+      for (const call of clientToolCalls.values()) onClientToolCall?.(call);
+    if (finished) onRunFinished?.(finished);
+  }
+};
+
+// libs/runtime/voice-worker/src/dispatch.ts
+var readDispatch = (metadata) => {
+  if (!metadata) return null;
+  let value;
+  try {
+    value = JSON.parse(metadata);
+  } catch {
+    return null;
+  }
+  const parsed = voiceDispatchSchema.safeParse(value);
+  return parsed.success ? parsed.data : null;
+};
+
+// libs/runtime/voice-worker/src/hang-up.ts
+import { log as log2 } from "@livekit/agents";
+var HANG_UP_TOOL = Object.freeze({
+  name: "hang_up",
+  description: "End the phone call. Say goodbye first, in the same reply, then call it.",
+  parameters: Object.freeze({ type: "object", properties: {}, additionalProperties: false })
+});
+var HANG_UP_RESULT = "Done: the call ends after your goodbye.";
+var HANG_UP_PLAYOUT_CAP_MS = 6e4;
+var untilGoodbyePlayed = (session, capMs = HANG_UP_PLAYOUT_CAP_MS) => {
+  let cap;
+  const capped = new Promise((resolve) => {
+    cap = setTimeout(() => {
+      log2().warn({ capMs }, "voice worker: the goodbye did not play out; hanging up anyway");
+      resolve();
+    }, capMs);
+  });
+  const idle = session.waitForIdle().then(
+    () => void 0,
+    () => void 0
+  );
+  return Promise.race([idle, capped]).finally(() => clearTimeout(cap));
+};
+var createHangUp = ({
+  wire,
+  untilPlayed,
+  hangUpAfter,
+  isEnding,
+  onResumeFailed
+}) => {
+  let resumeInFlight;
+  const resume = async (toolCallId) => {
+    let finished = false;
+    try {
+      for await (const ev of aguiTurn({
+        ...wire,
+        tools: [HANG_UP_TOOL],
+        toolResult: { toolCallId, content: HANG_UP_RESULT },
+        // No turn timer watches it: a box that hangs on it must not hold the call open.
+        signal: AbortSignal.timeout(TURN_IDLE_TIMEOUT_MS)
+      })) {
+        if (ev.kind === "error") throw runErrorOf(ev);
+        if (ev.kind === "finish") finished = true;
+      }
+      if (!finished) throw new Error("box closed the resume before RUN_FINISHED");
+    } catch (err) {
+      if (!finished) onResumeFailed(err);
+    }
+  };
+  return {
+    onClientToolCall: ({ id }) => {
+      if (isEnding()) return;
+      const resumed = resume(id).finally(() => {
+        resumeInFlight = void 0;
+      });
+      resumeInFlight = resumed;
+      hangUpAfter(() => Promise.allSettled([untilPlayed(), resumed]), "agent hung up");
+    },
+    pendingResume: () => resumeInFlight
+  };
+};
+
+// libs/runtime/voice-worker/src/session-options.ts
+import { tts, voice as voice2 } from "@livekit/agents";
+
+// libs/runtime/voice-worker/src/number-text.ts
+import { TransformStream } from "node:stream/web";
+var THOUSANDS_COMMA = /(\d),(?=\d{3}(?!\d))/g;
+var TRAILING_NUMBER = /[\d.,]+$/;
+var rewrite = (text) => text.replace(THOUSANDS_COMMA, "$1");
+var dropThousandsComma = (input) => {
+  let pending = "";
+  return input.pipeThrough(
+    new TransformStream({
+      transform(chunk, controller) {
+        const text = pending + chunk;
+        const tail = TRAILING_NUMBER.exec(text)?.[0] ?? "";
+        pending = tail;
+        const ready = text.slice(0, text.length - tail.length);
+        if (ready) controller.enqueue(rewrite(ready));
+      },
+      flush(controller) {
+        if (pending) controller.enqueue(rewrite(pending));
+      }
+    })
+  );
+};
+
+// libs/runtime/voice-worker/src/phone-voice.ts
+import { AudioFrame as AudioFrame2 } from "@livekit/rtc-node";
+import { TransformStream as TransformStream2 } from "node:stream/web";
+var LOW_CUT_HZ = 300;
+var HIGH_CUT_HZ = 3400;
+var Q = Math.SQRT1_2;
+var DRIVE = 1.8;
+var biquad = (kind, hz, sampleRate) => {
+  const w0 = 2 * Math.PI * hz / sampleRate;
+  const alpha = Math.sin(w0) / (2 * Q);
+  const cos = Math.cos(w0);
+  const a0 = 1 + alpha;
+  const [b0, b1, b2] = kind === "lowpass" ? [(1 - cos) / 2, 1 - cos, (1 - cos) / 2] : [(1 + cos) / 2, -(1 + cos), (1 + cos) / 2];
+  return {
+    b0: b0 / a0,
+    b1: b1 / a0,
+    b2: b2 / a0,
+    a1: -2 * cos / a0,
+    a2: (1 - alpha) / a0,
+    x1: 0,
+    x2: 0,
+    y1: 0,
+    y2: 0
+  };
+};
+var run = (f, x) => {
+  const y = f.b0 * x + f.b1 * f.x1 + f.b2 * f.x2 - f.a1 * f.y1 - f.a2 * f.y2;
+  f.x2 = f.x1;
+  f.x1 = x;
+  f.y2 = f.y1;
+  f.y1 = y;
+  return y;
+};
+var phoneLine = (audio) => {
+  let chain;
+  let chainRate = 0;
+  const norm = Math.tanh(DRIVE);
+  return audio.pipeThrough(
+    new TransformStream2({
+      transform(frame, controller) {
+        if (!chain || chainRate !== frame.sampleRate) {
+          chainRate = frame.sampleRate;
+          chain = [
+            biquad("highpass", LOW_CUT_HZ, chainRate),
+            biquad("lowpass", HIGH_CUT_HZ, chainRate),
+            biquad("lowpass", HIGH_CUT_HZ, chainRate)
+          ];
+        }
+        const out = new Int16Array(frame.data.length);
+        for (let i = 0; i < frame.data.length; i++) {
+          let y = frame.data[i] / 32768;
+          for (const f of chain) y = run(f, y);
+          y = Math.tanh(y * DRIVE) / norm;
+          out[i] = Math.max(-32768, Math.min(32767, Math.round(y * 32767)));
+        }
+        controller.enqueue(
+          new AudioFrame2(out, frame.sampleRate, frame.channels, frame.samplesPerChannel)
+        );
+      }
+    })
+  );
+};
+
+// libs/runtime/voice-worker/src/session-options.ts
+var sttOptions = ({ sttModel, language, keyterms }) => {
+  const terms = keyterms.length > 0 ? [...keyterms] : void 0;
+  const keyterm = terms ? { keyterm: terms } : void 0;
+  if (sttModel.startsWith("deepgram/flux")) {
+    return { model: sttModel, modelOptions: { language_hint: language, ...keyterm } };
+  }
+  if (sttModel.startsWith("assemblyai/")) {
+    return {
+      model: sttModel,
+      language,
+      modelOptions: { max_turn_silence: 1e3, ...terms ? { keyterms_prompt: terms } : {} }
+    };
+  }
+  return { model: sttModel, language, ...keyterm ? { modelOptions: keyterm } : {} };
+};
+var ttsOptions = ({ ttsModel, ttsVoice, ttsSpeed, language }) => {
+  const options = { model: ttsModel, voice: ttsVoice, language };
+  if (ttsSpeed === 1 || !isCartesiaTtsModel(ttsModel)) return options;
+  return { ...options, modelOptions: { speed: ttsSpeed } };
+};
+var markupContext = (expressive, speech) => {
+  if (!expressive) return [];
+  const guide = speech.markup.llmInstructions({
+    speechSteering: tts.DEFAULT_SPEECH_STEERING_OPTIONS
+  });
+  return guide === void 0 ? [] : [{ description: VOICE_TTS_MARKUP_CONTEXT, value: guide }];
+};
+var PhoneLineAgent = class extends voice2.Agent {
+  async ttsNode(text, modelSettings) {
+    const audio = await super.ttsNode(text, modelSettings);
+    return audio && phoneLine(audio);
+  }
+};
+var voiceSessionOptions = (settings, pieces) => {
+  const { turn, vad, interruptions } = settings;
+  pieces.vad.updateOptions({
+    activationThreshold: vad.activationThreshold,
+    minSpeechDuration: vad.minSpeechMs,
+    minSilenceDuration: vad.minSilenceMs
+  });
+  const speech = pieces.createTts(ttsOptions(settings));
+  return {
+    session: {
+      vad: pieces.vad,
+      stt: pieces.createStt(sttOptions(settings)),
+      tts: speech,
+      // The prompt asks for numbers in words; the comma filter is the net for digits.
+      ttsTextTransforms: ["filter_markdown", "filter_emoji", dropThousandsComma],
+      // LiveKit's TTS only normalizes the model's markup, converts it to Cartesia's
+      // and drops bracket cues when the session is expressive: without it the caller
+      // hears the tags. The guide LiveKit then injects into its own chat context never
+      // reaches the box (`BoxLLM` sends the last user text); `boxContext` carries it.
+      expressive: settings.expressive,
+      // LiveKit 1.9.0 feeds the STT silence for the first 3 s the agent speaks (its AEC
+      // warmup), so a caller who talks over the greeting lost the start of the sentence
+      // ("Hola Andrés…" reached the box as "Andrés…"). The browser and the phone network
+      // already cancel echo; LiveKit itself disables it for outbound SIP.
+      aecWarmupDuration: null,
+      turnHandling: {
+        // `stt`: an STT that ends turns itself (Flux) decides; `livekit`: LiveKit's detector.
+        turnDetection: turn.mode === "stt" ? "stt" : pieces.createTurnDetector({ unlikelyThreshold: turn.detectorThreshold }),
+        endpointing: { minDelay: turn.minEndpointingDelayMs, maxDelay: turn.maxEndpointingDelayMs },
+        // LiveKit 1.9.0 reads `enabled` as the session's `allowInterruptions`, the
+        // default of every speech; the old top-level option is deprecated.
+        // `adaptive` explicitly: with no mode, LiveKit 1.9.0 (`resolveInterruptionDetector`)
+        // turns adaptive interruption off unless the worker runs on LiveKit Cloud or in its
+        // deprecated `dev` mode, and `stackbone dev` runs `start` since S15, so a "sí", a
+        // "vale" or a cough cut the agent off. LiveKit still skips it, with a warning,
+        // when interruptions are off or the STT gives no word-aligned transcript.
+        interruption: {
+          mode: "adaptive",
+          enabled: interruptions.enabled,
+          minDuration: interruptions.minDurationMs,
+          minWords: interruptions.minWords
+        },
+        // A preemptive reply is a box turn: a durable run, with tools, started on a
+        // guess at what the caller said. Off explicitly, whatever LiveKit's default.
+        preemptiveGeneration: { enabled: false, preemptiveTts: false }
+      }
+    },
+    // The box holds the prompt: LiveKit's own chat context stays prompt-less.
+    agent: settings.phoneLine ? new PhoneLineAgent({ instructions: "" }) : new voice2.Agent({ instructions: "" }),
+    boxContext: markupContext(settings.expressive, speech)
+  };
+};
+
+// libs/runtime/voice-worker/src/telemetry/call-traces.ts
+import { log as log3, telemetry } from "@livekit/agents";
+import { ExportResultCode } from "@opentelemetry/core";
+import { defaultResource, resourceFromAttributes } from "@opentelemetry/resources";
+import {
+  BatchSpanProcessor,
+  NodeTracerProvider
+} from "@opentelemetry/sdk-trace-node";
+var SERVICE_NAME = "stackbone-voice-worker";
+var warnOnRefusedBatch = (exporter, sessionKey) => ({
+  export: (spans, done) => exporter.export(spans, (result) => {
+    try {
+      if (result.code !== ExportResultCode.SUCCESS) {
+        log3().warn(
+          { sessionKey, error: result.error?.message ?? "unknown" },
+          "voice worker: a batch of call spans failed to export to the box"
+        );
+      }
+    } finally {
+      done(result);
+    }
+  }),
+  shutdown: () => exporter.shutdown(),
+  ...exporter.forceFlush ? { forceFlush: exporter.forceFlush.bind(exporter) } : {}
+});
+var installCallTraces = (dispatch, job, deps) => {
+  if (dispatch.traces !== true) return;
+  const exporter = warnOnRefusedBatch(
+    deps.createExporter({
+      url: boxEndpoint(dispatch.boxUrl, VOICE_TRACES_PATH),
+      headers: { authorization: `Bearer ${dispatch.callToken}` }
+    }),
+    dispatch.sessionKey
+  );
+  const fanout = new telemetry.FanoutSpanProcessor();
+  const provider = new NodeTracerProvider({
+    resource: defaultResource().merge(resourceFromAttributes({ "service.name": SERVICE_NAME })),
+    spanProcessors: [fanout, new BatchSpanProcessor(exporter)]
+  });
+  provider.register();
+  deps.setTracerProvider(provider, {
+    metadata: {
+      "stackbone.voice.session_key": dispatch.sessionKey,
+      ...job.room === void 0 ? {} : { "livekit.room": job.room },
+      "livekit.job_id": job.jobId
+    },
+    registerSpanProcessor: (processor) => fanout.add(processor),
+    allowPii: false
+  });
+  job.addShutdownCallback(() => provider.shutdown());
+};
+
+// libs/runtime/voice-worker/src/worker.ts
+var resolveWorkerAgentName = (env) => env[VOICE_WORKER_AGENT_NAME_ENV]?.trim() || VOICE_WORKER_AGENT_NAME;
+var resolveWorkerHealthServer = (env) => {
+  const port = Number(env[VOICE_WORKER_PORT_ENV]);
+  if (!Number.isInteger(port) || port <= 0 || port > 65535) return {};
+  return { host: "127.0.0.1", port, numIdleProcesses: 1 };
+};
+var TURN_FALLBACK_PHRASE = Object.freeze({
+  es: "Perdona, no he podido responderte. \xBFMe lo repites?",
+  en: "Sorry, I couldn't answer that. Could you say it again?"
+});
+var PAUSED_RUN_PHRASE = Object.freeze({
+  es: "Esto lo tiene que revisar una persona. Te contactaremos en cuanto est\xE9. Hasta luego.",
+  en: "Someone needs to review this. We'll contact you once it's done. Goodbye."
+});
+var CALL_CLOSING_PHRASE = Object.freeze({
+  es: "Lo siento, ahora mismo no puedo atenderte. Por favor, vuelve a llamar m\xE1s tarde.",
+  en: "Sorry, I can't help you right now. Please call again later."
+});
+var MAX_FAILED_TURNS_IN_A_ROW = 3;
+var inCallLanguage = (phrase, language) => language.split("-")[0]?.toLowerCase() === "es" ? phrase.es : phrase.en;
+var toolCallCue = () => {
+  let cue;
+  let open = 0;
+  return {
+    // A call can open before the cue's track is up.
+    attach: (ready) => {
+      cue = ready;
+      if (open > 0) cue.start();
+    },
+    onToolCall: (phase) => {
+      if (phase === "start") {
+        open += 1;
+        if (open === 1) cue?.start();
+      } else if (open > 0) {
+        open -= 1;
+        if (open === 0) cue?.stop();
+      }
+    }
+  };
+};
+var messageOf = (err) => err instanceof Error ? err.message : String(err);
+var callerNoiseCancellation = () => {
+  try {
+    return BackgroundVoiceCancellation();
+  } catch (err) {
+    log4().warn({ error: messageOf(err) }, "voice worker: no noise cancellation on this call");
+    return void 0;
+  }
+};
+var runVoiceJob = async (ctx, deps) => {
+  const dispatch = readDispatch(ctx.job.metadata);
+  if (!dispatch) {
+    log4().warn(
+      { metadataChars: ctx.job.metadata?.length ?? 0 },
+      "voice worker: refused a job without a valid dispatch"
+    );
+    ctx.shutdown("invalid dispatch");
+    return;
+  }
+  await ctx.connect();
+  const caller = await ctx.waitForParticipant().catch((err) => {
+    log4().info(
+      { reason: messageOf(err) },
+      "voice worker: the room closed before the caller joined"
+    );
+    return void 0;
+  });
+  if (caller === void 0) {
+    ctx.shutdown("caller left");
+    return;
+  }
+  installCallTraces(
+    dispatch,
+    {
+      jobId: ctx.job.id,
+      room: ctx.room.name,
+      addShutdownCallback: (callback) => ctx.addShutdownCallback(callback)
+    },
+    deps
+  );
+  const settings = dispatch.voiceSettings;
+  const cue = toolCallCue();
+  const fallback = inCallLanguage(TURN_FALLBACK_PHRASE, settings.language);
+  let failedInARow = 0;
+  let ending = false;
+  const sayIfOpen = (text, what) => {
+    try {
+      session.say(text);
+    } catch (err) {
+      log4().info({ error: messageOf(err) }, `voice worker: the ${what} was not spoken`);
+    }
+  };
+  const hangUpAfter = (played, reason) => {
+    ending = true;
+    session.input.setAudioEnabled(false);
+    void Promise.resolve().then(played).catch((err) => {
+      log4().info({ error: messageOf(err) }, "voice worker: the closing phrase was not spoken");
+    }).then(() => ctx.deleteRoom()).catch((err) => {
+      log4().warn({ error: messageOf(err) }, "voice worker: the room was not deleted");
+    }).then(
+      () => finishCall(
+        reason === "turns kept failing" || reason === "box refused the call token" ? "failed" : "completed"
+      )
+    ).catch(() => {
+      log4().warn(
+        { agent: dispatch.agent, sessionKey: dispatch.sessionKey, reason: "completion_failed" },
+        "voice worker: call finalization failed"
+      );
+    }).finally(() => ctx.shutdown(reason));
+  };
+  const endCall = (phrase, reason) => hangUpAfter(
+    () => session.say(inCallLanguage(phrase, settings.language), { allowInterruptions: false }).waitForPlayout(),
+    reason
+  );
+  const boxFailure = (err) => ({
+    agent: dispatch.agent,
+    sessionKey: dispatch.sessionKey,
+    room: ctx.room.name,
+    // A refusal carries only its status.
+    ...err instanceof BoxTurnError ? { status: err.status } : {},
+    error: messageOf(err)
+  });
+  const onTurnError = (err) => {
+    if (err instanceof BoxTurnError && err.status === 401) {
+      log4().error(boxFailure(err), "voice worker: the box refused the call token (401)");
+      if (!ending) endCall(CALL_CLOSING_PHRASE, "box refused the call token");
+      return;
+    }
+    failedInARow += 1;
+    log4().warn({ ...boxFailure(err), failedInARow }, "voice worker: a turn failed");
+    if (ending) return;
+    if (failedInARow >= MAX_FAILED_TURNS_IN_A_ROW) {
+      endCall(CALL_CLOSING_PHRASE, "turns kept failing");
+      return;
+    }
+    sayIfOpen(fallback, "fallback");
+  };
+  const onRunFinished = (outcome) => {
+    failedInARow = 0;
+    if (outcome === "interrupt" && !ending) endCall(PAUSED_RUN_PHRASE, "run paused for review");
+  };
+  const plan = voiceSessionOptions(settings, { ...deps, vad: ctx.proc.userData.vad });
+  const wire = {
+    boxUrl: dispatch.boxUrl,
+    token: dispatch.callToken,
+    agent: dispatch.agent,
+    sessionKey: dispatch.sessionKey,
+    tags: dispatch.tags,
+    // With `expressive`, the TTS markup guide: LiveKit gives it only to its own chat context.
+    context: plan.boxContext
+  };
+  const participant = caller ?? {};
+  const attributes = participant.attributes;
+  const phoneNumber = participant.kind === ParticipantKind.SIP && attributes && Object.hasOwn(attributes, "sip.phoneNumber") ? attributes["sip.phoneNumber"] : void 0;
+  await voiceCallRequest(wire, "bootstrap", {
+    identities: typeof phoneNumber === "string" && phoneNumber.length > 0 ? { phoneNumber } : {}
+  });
+  const hangUp = createHangUp({
+    wire,
+    untilPlayed: () => untilGoodbyePlayed(session),
+    hangUpAfter,
+    isEnding: () => ending,
+    onResumeFailed: (err) => {
+      log4().warn(boxFailure(err), "voice worker: the hang_up resume failed");
+    }
+  });
+  const brain = new BoxLLM({
+    ...wire,
+    clientTools: [HANG_UP_TOOL],
+    onClientToolCall: hangUp.onClientToolCall,
+    pendingResume: hangUp.pendingResume,
+    isEnding: () => ending,
+    onToolCall: cue.onToolCall,
+    onTurnError,
+    onRunFinished
+  });
+  const session = deps.createSession({ ...plan.session, llm: brain });
+  let completion;
+  const finishCall = (outcome = "disconnected") => {
+    if (completion) return completion;
+    ending = true;
+    completion = Promise.resolve().then(async () => {
+      await hangUp.pendingResume();
+      await session.close();
+      await brain.settled();
+      await voiceCallRequest(
+        wire,
+        "complete",
+        voiceCallCompleteSchema.parse({
+          transcript: brain.heardTranscript(session.history),
+          outcome
+        })
+      );
+    }).catch((error) => {
+      log4().warn(
+        { agent: dispatch.agent, sessionKey: dispatch.sessionKey, reason: "completion_failed" },
+        "voice worker: call finalization failed"
+      );
+      throw error;
+    });
+    return completion;
+  };
+  ctx.addShutdownCallback(() => finishCall());
+  session.on(voice3.AgentSessionEventTypes.Close, () => {
+    if (completion || ending) return;
+    void finishCall().catch(() => void 0).finally(() => ctx.shutdown("caller left"));
+  });
+  const noiseCancellation = callerNoiseCancellation();
+  await session.start({
+    agent: plan.agent,
+    room: ctx.room,
+    inputOptions: noiseCancellation ? { noiseCancellation } : {}
+  });
+  if (settings.greeting !== null) sayIfOpen(settings.greeting, "greeting");
+  await deps.createCue({ room: ctx.room, session }).then(cue.attach, (err) => {
+    log4().warn({ error: messageOf(err) }, "voice worker: the thinking cue did not start");
+  });
+};
+
+// libs/runtime/voice-worker/src/main.ts
+var liveDeps = () => ({
+  createSession: (options) => new voice4.AgentSession(options),
+  createStt: (options) => new inference.STT(options),
+  createTts: (options) => new inference.TTS(options),
+  createTurnDetector: (options) => new inference.TurnDetector(options),
+  createCue: startThinkingCue,
+  // OTLP/HTTP JSON, uncompressed: the encoding the box relay takes and forwards as is.
+  // `compression` is set so an `OTEL_EXPORTER_OTLP_COMPRESSION=gzip` in the worker's
+  // environment cannot turn every export into a body the relay refuses.
+  createExporter: ({ url, headers }) => new OTLPTraceExporter({
+    url,
+    headers: { ...headers },
+    compression: "none"
+  }),
+  setTracerProvider: telemetry2.setTracerProvider
+});
+var main_default = defineAgent({
+  prewarm: async (proc) => {
+    proc.userData.vad = await loadVad();
+  },
+  entry: (ctx) => runVoiceJob(ctx, liveDeps())
+});
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+  cli.runApp(
+    new ServerOptions({
+      agent: fileURLToPath(import.meta.url),
+      agentName: resolveWorkerAgentName(process.env),
+      ...resolveWorkerHealthServer(process.env)
+    })
+  );
+}
+export {
+  main_default as default
+};
+//# sourceMappingURL=main.js.map