@stackbone/cli 0.9.2 → 0.9.3

package/voice-worker/main.js

@@ -152,6 +152,7 @@ var loadVad = async () => {
 import { log as log5, voice as voice4 } from "@livekit/agents";
 import {
   BackgroundVoiceCancellation,
+  NoiseCancellation,
   TelephonyBackgroundVoiceCancellation
 } from "@livekit/noise-cancellation-node";
 import { ParticipantKind } from "@livekit/rtc-node";
@@ -562,14 +563,255 @@ var schemaResponseSchema = z5.object({
   handlers: jsonObject().nullable().optional()
 });
 
+// libs/shared/validators/src/lib/agents/queue-jobs.ts
+import cronParser from "cron-parser";
+import { z as z7 } from "zod";
+
+// libs/shared/validators/src/lib/common/utf8-byte-length.ts
+var ENCODER = new TextEncoder();
+function utf8ByteLength(value) {
+  return ENCODER.encode(value).length;
+}
+
+// libs/shared/validators/src/lib/studio/studio-queues.ts
+import { z as z6 } from "zod";
+var QUEUE_NAME_REGEX = /^[A-Za-z0-9_.-]+$/;
+var queueNameSchema = z6.string().min(1).max(128).regex(QUEUE_NAME_REGEX, "queue name must be a BullMQ queue identifier ([A-Za-z0-9_.-])");
+var jobSourceSchema = z6.enum(["bullmq", "journal"]);
+var bullmqJobStatusSchema = z6.enum(["pending", "active", "delayed", "failed"]);
+var journalTerminalStatusSchema = z6.enum(["done", "failed"]);
+var journalJobStatusSchema = z6.enum([
+  ...journalTerminalStatusSchema.options,
+  "running",
+  "lost"
+]);
+var jobStatusSchema = z6.enum([
+  ...bullmqJobStatusSchema.options,
+  ...journalJobStatusSchema.options
+]);
+var jobStatusFilterSchema = z6.enum([
+  ...bullmqJobStatusSchema.options,
+  ...journalTerminalStatusSchema.options
+]);
+var queueSummarySchema = z6.object({
+  name: z6.string(),
+  // `is_dlq: true` flags queues whose name follows the `*-dlq` / `*_dlq`
+  // convention. Studio renders them under a "Dead-letter" subgroup; the
+  // server-side actions (retry/discard) are unchanged.
+  is_dlq: z6.boolean(),
+  // BullMQ live counts. `failed` is the dispatch-failure / exhausted-retry
+  // bucket the inspector surfaces for manual retry. Completed jobs are not
+  // counted here — their record lives in the agent journal.
+  pending: z6.number().int().nonnegative(),
+  active: z6.number().int().nonnegative(),
+  delayed: z6.number().int().nonnegative(),
+  failed: z6.number().int().nonnegative()
+}).strict();
+var queueListResponseSchema = z6.object({
+  items: z6.array(queueSummarySchema)
+});
+var jobCommonFields = {
+  id: z6.string(),
+  queue: z6.string(),
+  // Opaque job name the agent chose at publish time (e.g. `send-email`).
+  // Null for legacy/anonymous rows that predate named jobs.
+  name: z6.string().nullable(),
+  // BullMQ `attemptsMade` for in-flight rows; the journal's recorded attempt
+  // count for execution rows.
+  attempts: z6.number().int().nonnegative(),
+  enqueued_at: z6.iso.datetime(),
+  // Failure reason: the BullMQ `failedReason` (dispatch failure) or the
+  // application error the agent returned (also persisted in the journal).
+  error: z6.string().nullable(),
+  // Correlation key between a BullMQ job and its journal execution row.
+  // BullMQ rows carry their own id here; journal rows carry the originating
+  // BullMQ job id. Null when uncorrelated.
+  dispatch_id: z6.string().nullable(),
+  payload: jsonObject()
+};
+var bullmqJobSchema = z6.object({
+  ...jobCommonFields,
+  source: z6.literal("bullmq"),
+  status: bullmqJobStatusSchema,
+  // When the job is next expected to run: BullMQ `delay`/next-retry timestamp
+  // for `delayed`/`pending` rows, null when it runs immediately.
+  next_run_at: z6.iso.datetime().nullable(),
+  // BullMQ does not own an execution window; null until/unless the journal
+  // correlates one. A dispatch failure has neither.
+  started_at: z6.iso.datetime().nullable(),
+  finished_at: z6.iso.datetime().nullable()
+}).strict();
+var journalJobSchema = z6.object({
+  ...jobCommonFields,
+  source: z6.literal("journal"),
+  status: journalJobStatusSchema,
+  // A journal row has no live scheduling state, so `next_run_at` is always
+  // null. Modelled as a nullable date-time pinned to null (rather than a bare
+  // `z.null()`) so it emits the `anyOf:[date-time, null]` shape the OpenAPI
+  // 3.0 downgrader already collapses to `nullable: true` — a standalone
+  // `{ type: 'null' }` is not valid OpenAPI 3.0 and orval rejects it.
+  next_run_at: z6.iso.datetime().nullable().refine((value) => value === null, {
+    message: "a journal row never carries a live next_run_at"
+  }),
+  started_at: z6.iso.datetime(),
+  finished_at: z6.iso.datetime().nullable()
+}).strict();
+var jobSchema = z6.discriminatedUnion("source", [bullmqJobSchema, journalJobSchema]);
+var listJobsQuerySchema = forwardPageQuerySchema.extend({
+  queue: queueNameSchema,
+  // Filter by the BullMQ-live or journal-terminal states only. The journal
+  // `running` row exists in the DB as a NULL status, so a `WHERE status =
+  // 'running'` filter could never match it — it is reachable only on an
+  // unfiltered page, never as a filter value.
+  status: jobStatusFilterSchema.optional(),
+  limit: limitParamSchema(200).default(50)
+});
+var jobListResponseSchema = forwardPageResponseSchema(jobSchema);
+var jobActionParamsSchema = z6.object({
+  queue: queueNameSchema,
+  jobId: z6.string().min(1, "job id must be a non-empty BullMQ job id")
+});
+var jobActionResponseSchema = z6.object({
+  // Echoes the job id the action operated on. Retry re-enqueues the same job;
+  // discard only drops it.
+  id: z6.string(),
+  queue: z6.string(),
+  status: jobStatusSchema
+});
+var peekQueueResponseSchema = z6.object({
+  items: z6.array(bullmqJobSchema)
+});
+var purgeQueueResponseSchema = z6.object({
+  purged: z6.number().int().nonnegative()
+});
+var pushJobRequestSchema = z6.object({
+  payload: jsonObject(),
+  retries: z6.number().int().nonnegative().optional(),
+  delay: z6.number().int().nonnegative().optional()
+});
+var pushJobResponseSchema = z6.object({
+  message_id: z6.string(),
+  queue: queueNameSchema
+});
+var queueNameParamsSchema = z6.object({
+  name: queueNameSchema
+});
+var peekQueueQuerySchema = z6.object({
+  limit: limitParamSchema(50).default(10)
+});
+
+// libs/shared/validators/src/lib/agents/queue-jobs.ts
+var MAX_JOB_ATTEMPTS = 20;
+var CRON_FIELD_COUNT = 5;
+var MAX_DELAY_MS = 30 * 24 * 60 * 60 * 1e3;
+var MAX_JOB_PAYLOAD_BYTES = 100 * 1024;
+var MAX_JOB_REQUEST_BYTES = MAX_JOB_PAYLOAD_BYTES + 16 * 1024;
+var boundedJobPayload = jsonObject().refine(
+  (payload) => utf8ByteLength(JSON.stringify(payload)) <= MAX_JOB_PAYLOAD_BYTES,
+  { message: `payload exceeds the ${MAX_JOB_PAYLOAD_BYTES}-byte limit` }
+);
+var baseJobFields = {
+  // The job name the agent chose. Surfaced in the Studio inspector and used as
+  // the BullMQ job name. Same character class as a queue name so it stays a
+  // clean Redis-keyed identifier.
+  name: queueNameSchema,
+  payload: boundedJobPayload,
+  // Per-job override of the platform retry default. Omitted → DEFAULT_JOB_ATTEMPTS.
+  retries: z7.number().int().min(0).max(MAX_JOB_ATTEMPTS).optional()
+};
+var publishJobRequestSchema = z7.object({
+  ...baseJobFields,
+  // Deferred delivery in milliseconds. Omitted / 0 → immediate. Capped at
+  // MAX_DELAY_MS (30 days) so a unit slip can't pin a delayed job indefinitely.
+  delay: z7.number().int().min(0).max(MAX_DELAY_MS).optional(),
+  // Optional idempotency hint. When set the dispatcher uses it as the BullMQ
+  // job id so a duplicate publish with the same key collapses to one job.
+  deduplicationId: z7.string().min(1).max(255).optional()
+}).strict();
+var publishJobResponseSchema = z7.object({
+  // The BullMQ job id the dispatcher minted (or the dedupe id when supplied).
+  messageId: z7.string()
+}).strict();
+var cronExpressionSchema = z7.string().min(1).max(120);
+function isKnownTimeZone(tz) {
+  try {
+    new Intl.DateTimeFormat("en-US", { timeZone: tz });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function validateCronAndTz(cron, tz) {
+  const issues = [];
+  const trimmed = cron.trim();
+  const isMacro = trimmed.startsWith("@");
+  const fields = trimmed.split(/\s+/).filter(Boolean);
+  const shapeValid = isMacro || fields.length === CRON_FIELD_COUNT;
+  if (!shapeValid) {
+    issues.push({
+      path: "cron",
+      message: `cron must have exactly ${CRON_FIELD_COUNT} fields (minute hour day month weekday) or a macro (@hourly, @daily, @weekly, @monthly, @yearly); sub-minute schedules are not allowed`
+    });
+  }
+  const tzValid = tz === void 0 || isKnownTimeZone(tz);
+  if (!tzValid) {
+    issues.push({ path: "tz", message: `unknown IANA timezone: ${tz}` });
+  }
+  if (shapeValid && tzValid) {
+    try {
+      cronParser.parseExpression(trimmed, tz === void 0 ? void 0 : { tz }).next();
+    } catch {
+      issues.push({ path: "cron", message: `invalid cron expression: ${cron}` });
+    }
+  }
+  return issues;
+}
+var scheduleJobRequestSchema = z7.object({
+  ...baseJobFields,
+  cron: cronExpressionSchema,
+  // IANA timezone the cron pattern is evaluated in. Defaults to UTC.
+  tz: z7.string().min(1).max(64).optional()
+}).strict().superRefine((value, ctx) => {
+  for (const issue of validateCronAndTz(value.cron, value.tz)) {
+    ctx.addIssue({ code: "custom", path: [issue.path], message: issue.message });
+  }
+});
+var scheduleJobResponseSchema = z7.object({
+  // The scheduler id (unique per installation) the dispatcher upserted.
+  scheduleId: z7.string(),
+  name: z7.string(),
+  cron: z7.string(),
+  tz: z7.string()
+}).strict();
+var unscheduleJobRequestSchema = z7.object({
+  name: queueNameSchema
+}).strict();
+var unscheduleJobResponseSchema = z7.object({
+  name: z7.string(),
+  // True when a schedule with that name existed and was removed; false when
+  // nothing matched (the call stays idempotent either way).
+  removed: z7.boolean()
+}).strict();
+var scheduleSummarySchema = z7.object({
+  scheduleId: z7.string(),
+  name: z7.string(),
+  cron: z7.string(),
+  tz: z7.string(),
+  // Next planned fire time (ISO), null when BullMQ has not computed one yet.
+  next_run_at: z7.iso.datetime().nullable()
+}).strict();
+var listSchedulesResponseSchema = z7.object({
+  items: z7.array(scheduleSummarySchema)
+}).strict();
+
 // libs/shared/validators/src/lib/studio/studio-voice.ts
-import { z as z8 } from "zod";
+import { z as z11 } 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) => {
+import { z as z8 } from "zod";
+var identityKeySchema = z8.string().min(1).max(100);
+var identityValueSchema = z8.string().min(1).max(500);
+var integrationIdentitiesSchema = z8.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;
@@ -586,18 +828,45 @@ var integrationIdentitiesSchema = z6.unknown().superRefine((input, ctx) => {
       });
   }
 }).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 memoryIdentitySnapshotSchema = z8.union([
+  z8.strictObject({ key: z8.null(), value: z8.null() }),
+  z8.strictObject({ key: identityKeySchema, value: identityValueSchema.nullable() })
 ]);
-var memoryIdentityBindingSchema = z6.strictObject({
+var memoryIdentityBindingSchema = z8.strictObject({
   identityKey: identityKeySchema,
-  source: z6.enum(["code", "studio", "legacy"]),
-  fixedAt: z6.iso.datetime()
+  source: z8.enum(["code", "studio", "legacy"]),
+  fixedAt: z8.iso.datetime()
 });
 
+// libs/shared/validators/src/lib/studio/voice-greeting.ts
+import { z as z9 } from "zod";
+var VOICE_GREETING_MAX = 500;
+var VOICE_CALL_VARIABLES_MAX = 20;
+var VOICE_CALL_VARIABLE_VALUE_MAX = 200;
+var VARIABLE_NAME = /^[A-Za-z_][A-Za-z0-9_]{0,63}$/;
+var voiceCallVariablesSchema = z9.unknown().superRefine((input, ctx) => {
+  if (input === null || typeof input !== "object" || Array.isArray(input)) {
+    ctx.addIssue({ code: "custom", message: "Call variables must be a string map." });
+    return;
+  }
+  const entries = Object.entries(input);
+  if (entries.length > VOICE_CALL_VARIABLES_MAX)
+    ctx.addIssue({
+      code: "custom",
+      message: `At most ${VOICE_CALL_VARIABLES_MAX} call variables are allowed.`
+    });
+  for (const [key, value] of entries) {
+    if (!VARIABLE_NAME.test(key) || typeof value !== "string" || value.trim() === "" || value.length > VOICE_CALL_VARIABLE_VALUE_MAX)
+      ctx.addIssue({
+        code: "custom",
+        path: [key],
+        message: `Call variable names are letters, digits and _ (not starting with a digit); values are 1\u2013${VOICE_CALL_VARIABLE_VALUE_MAX} characters.`
+      });
+  }
+}).transform((input) => Object.fromEntries(Object.entries(input)));
+
 // libs/shared/validators/src/lib/studio/studio-rag.ts
-import { z as z7 } from "zod";
+import { z as z10 } from "zod";
 var STUDIO_RAG_DOCS_LIMIT_DEFAULT = 50;
 var STUDIO_RAG_DOCS_LIMIT_MAX = 200;
 var STUDIO_RAG_TOPK_DEFAULT = 10;
@@ -605,63 +874,63 @@ 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 ragRangeFieldSchema = z7.string().min(1).refine((field) => !field.includes("."), {
+var ragCollectionNameParamSchema = z10.string().min(1).max(128).regex(STUDIO_RAG_COLLECTION_REGEX, "collection must be 1..128 ASCII identifier-safe chars");
+var ragDistanceSchema = z10.enum(["cosine", "l2", "ip"]);
+var ragIndexKindSchema = z10.enum(["hnsw", "exact"]);
+var ragNumberFormatSchema = z10.enum(["eu", "us"]);
+var ragRangeFieldSchema = z10.string().min(1).refine((field) => !field.includes("."), {
   message: "field must be a literal top-level metadata key without dots"
 });
-var ragExtractFieldSchema = z7.object({
-  name: z7.string().trim().pipe(ragRangeFieldSchema),
-  type: z7.enum(["number", "date", "text"]),
-  removed: z7.boolean().optional()
+var ragExtractFieldSchema = z10.object({
+  name: z10.string().trim().pipe(ragRangeFieldSchema),
+  type: z10.enum(["number", "date", "text"]),
+  removed: z10.boolean().optional()
 });
 var uniqueFieldNames = (fields) => new Set(fields.map((field) => field.name)).size === fields.length;
-var ragExtractFieldsRequestSchema = z7.array(ragExtractFieldSchema).refine(uniqueFieldNames, {
+var ragExtractFieldsRequestSchema = z10.array(ragExtractFieldSchema).refine(uniqueFieldNames, {
   message: "Field names must be unique"
 });
-var ragCollectionSchema = z7.object({
-  name: z7.string(),
-  dimensions: z7.number().int().min(1),
-  embedding_state: z7.enum(["ready", "rebuilding", "failed"]).optional(),
+var ragCollectionSchema = z10.object({
+  name: z10.string(),
+  dimensions: z10.number().int().min(1),
+  embedding_state: z10.enum(["ready", "rebuilding", "failed"]).optional(),
   // Optional for boxes that predate collection-owned embeddings.
-  embedding_provider: z7.string().min(1).optional(),
-  embedding_model: z7.string().min(1).optional(),
+  embedding_provider: z10.string().min(1).optional(),
+  embedding_model: z10.string().min(1).optional(),
   distance: ragDistanceSchema,
   index_kind: ragIndexKindSchema,
-  chunk_count: z7.number().int().nonnegative(),
-  doc_count: z7.number().int().nonnegative(),
+  chunk_count: z10.number().int().nonnegative(),
+  doc_count: z10.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(),
+  last_ingested_at: z10.iso.datetime().nullable(),
   // STA3-57. Optional so a list from a box older than hybrid search still parses.
-  hybrid_enabled: z7.boolean().optional(),
+  hybrid_enabled: z10.boolean().optional(),
   number_format: ragNumberFormatSchema.optional(),
-  extract_enabled: z7.boolean().optional(),
-  extract_fields: z7.array(ragExtractFieldSchema).optional()
+  extract_enabled: z10.boolean().optional(),
+  extract_fields: z10.array(ragExtractFieldSchema).optional()
 });
-var ragCollectionListResponseSchema = z7.object({
-  items: z7.array(ragCollectionSchema)
+var ragCollectionListResponseSchema = z10.object({
+  items: z10.array(ragCollectionSchema)
 });
-var ragJobStatusSchema = z7.enum(["queued", "running", "succeeded", "failed", "cancelled"]);
-var ragDocumentSchema = z7.object({
-  id: z7.string(),
-  namespace: z7.string(),
+var ragJobStatusSchema = z10.enum(["queued", "running", "succeeded", "failed", "cancelled"]);
+var ragDocumentSchema = z10.object({
+  id: z10.string(),
+  namespace: z10.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(),
+  chunks_count: z10.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(),
+  preview: z10.string(),
+  first_seen_at: z10.iso.datetime(),
+  last_seen_at: z10.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
@@ -672,22 +941,22 @@ var ragDocumentSchema = z7.object({
   // 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(),
+  run_id: z10.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(),
+  ingest_error: z10.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()
+  version: z10.number().int().min(1).optional(),
+  version_count: z10.number().int().min(1).optional(),
+  pending_version: z10.number().int().min(1).nullable().optional()
 });
 var ragFilterSchema = jsonObject();
-var ragDateValueSchema = z7.string().length(10).regex(/^[0-9]{4}-[0-9]{2}-[0-9]{2}$/).refine((value) => {
+var ragDateValueSchema = z10.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));
@@ -695,18 +964,18 @@ var ragDateValueSchema = z7.string().length(10).regex(/^[0-9]{4}-[0-9]{2}-[0-9]{
   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 ragRangeSchema = z7.discriminatedUnion("type", [
-  z7.strictObject({
+var ragRangeSchema = z10.discriminatedUnion("type", [
+  z10.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()
+    type: z10.literal("number"),
+    gt: z10.number().finite().optional(),
+    gte: z10.number().finite().optional(),
+    lt: z10.number().finite().optional(),
+    lte: z10.number().finite().optional()
   }),
-  z7.strictObject({
+  z10.strictObject({
     field: ragRangeFieldSchema,
-    type: z7.literal("date"),
+    type: z10.literal("date"),
     gt: ragDateValueSchema.optional(),
     gte: ragDateValueSchema.optional(),
     lt: ragDateValueSchema.optional(),
@@ -728,121 +997,121 @@ var ragRangeSchema = z7.discriminatedUnion("type", [
     ctx.addIssue({ code: "custom", message: "lower bound must not exceed upper bound" });
   }
 });
-var ragRangesSchema = z7.array(ragRangeSchema).max(10);
+var ragRangesSchema = z10.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()
+  filter: z10.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(),
+var ragDocumentVersionSchema = z10.object({
+  id: z10.string(),
+  version: z10.number().int().min(1),
+  is_active: z10.boolean(),
+  ready: z10.boolean(),
+  chunks_count: z10.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()
+  run_id: z10.string().nullable(),
+  ingest_error: z10.string().nullable(),
+  filename: z10.string().nullable(),
+  created_at: z10.iso.datetime()
 });
-var ragDocumentVersionListResponseSchema = z7.object({
-  items: z7.array(ragDocumentVersionSchema)
+var ragDocumentVersionListResponseSchema = z10.object({
+  items: z10.array(ragDocumentVersionSchema)
 });
-var ragDocumentVersionNumberSchema = z7.number().int().min(1).max(2147483647);
-var updateRagDocumentValuesRequestSchema = z7.strictObject({
+var ragDocumentVersionNumberSchema = z10.number().int().min(1).max(2147483647);
+var updateRagDocumentValuesRequestSchema = z10.strictObject({
   version: ragDocumentVersionNumberSchema.optional(),
   values: jsonObject(),
-  add_fields: z7.array(ragExtractFieldSchema.omit({ removed: true })).refine(uniqueFieldNames, {
+  add_fields: z10.array(ragExtractFieldSchema.omit({ removed: true })).refine(uniqueFieldNames, {
     message: "Field names must be unique"
   }).optional()
 });
-var updateRagDocumentValuesResponseSchema = z7.object({
-  id: z7.string(),
-  collection: z7.string(),
+var updateRagDocumentValuesResponseSchema = z10.object({
+  id: z10.string(),
+  collection: z10.string(),
   version: ragDocumentVersionNumberSchema,
   metadata: jsonObject()
 });
-var extractRagDocumentRequestSchema = z7.strictObject({
+var extractRagDocumentRequestSchema = z10.strictObject({
   version: ragDocumentVersionNumberSchema.optional()
 });
-var extractRagDocumentResponseSchema = z7.object({
-  proposal: z7.array(
+var extractRagDocumentResponseSchema = z10.object({
+  proposal: z10.array(
     ragExtractFieldSchema.omit({ removed: true }).extend({
-      value: z7.union([z7.number().finite(), z7.string()]),
-      new: z7.boolean()
+      value: z10.union([z10.number().finite(), z10.string()]),
+      new: z10.boolean()
     })
   ),
-  failed: z7.boolean(),
-  truncated: z7.boolean()
-});
-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),
+  failed: z10.boolean(),
+  truncated: z10.boolean()
+});
+var ragDocumentVersionParamSchema = z10.string().regex(/^\d+$/, { message: "version must be a positive integer" }).transform((value) => Number.parseInt(value, 10)).pipe(ragDocumentVersionNumberSchema);
+var activateRagDocumentVersionResponseSchema = z10.object({
+  id: z10.string(),
+  collection: z10.string(),
+  version: z10.number().int().min(1),
+  previous_version: z10.number().int().min(1).nullable(),
+  changed: z10.boolean()
+});
+var ragQueryRequestSchema = z10.object({
+  text: z10.string().min(1).optional(),
+  embedding: z10.array(z10.number().finite()).min(1).optional(),
+  model: z10.string().min(1).optional(),
+  topK: z10.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()
+  preview: z10.object({ docId: z10.string().min(1), version: ragDocumentVersionNumberSchema }).optional(),
+  hybrid: z10.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(),
+var ragQueryHitSchema = z10.object({
+  id: z10.string(),
+  chunk_idx: z10.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(),
+  score: z10.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(),
-  dense_rank: z7.number().int().positive().optional(),
-  lexical_rank: z7.number().int().positive().optional(),
-  content: z7.string(),
+  mixed_score: z10.number().optional(),
+  dense_rank: z10.number().int().positive().optional(),
+  lexical_rank: z10.number().int().positive().optional(),
+  content: z10.string(),
   metadata: jsonObject()
 });
-var ragQueryResponseSchema = z7.object({
-  items: z7.array(ragQueryHitSchema),
+var ragQueryResponseSchema = z10.object({
+  items: z10.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),
+  dimensions: z10.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()
+  embedded_with: z10.string().nullable()
 });
-var ragJobSchema = z7.object({
-  id: z7.string(),
-  collection: z7.string(),
+var ragJobSchema = z10.object({
+  id: z10.string(),
+  collection: z10.string(),
   status: ragJobStatusSchema,
-  attempts: z7.number().int().nonnegative(),
-  error: z7.string().nullable(),
-  created_at: z7.iso.datetime(),
-  finished_at: z7.iso.datetime().nullable()
+  attempts: z10.number().int().nonnegative(),
+  error: z10.string().nullable(),
+  created_at: z10.iso.datetime(),
+  finished_at: z10.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 ragJobIdParamSchema = z10.object({
+  jobId: z10.string().min(1).max(128)
 });
-var ragJobActionResponseSchema = z7.object({
-  id: z7.string(),
+var ragJobActionResponseSchema = z10.object({
+  id: z10.string(),
   status: ragJobStatusSchema
 });
 var STUDIO_RAG_SUPPORTED_CONTENT_TYPES = [
@@ -850,16 +1119,16 @@ var STUDIO_RAG_SUPPORTED_CONTENT_TYPES = [
   "text/markdown",
   "application/pdf"
 ];
-var ragSupportedContentTypeSchema = z7.enum(STUDIO_RAG_SUPPORTED_CONTENT_TYPES);
-var createRagCollectionRequestSchema = z7.object({
+var ragSupportedContentTypeSchema = z10.enum(STUDIO_RAG_SUPPORTED_CONTENT_TYPES);
+var createRagCollectionRequestSchema = z10.object({
   name: ragCollectionNameParamSchema,
   metadata: jsonObject().optional(),
   embedding_provider: pickedModelProviderIdSchema.optional(),
-  embedding_model: z7.string().trim().min(1).optional(),
+  embedding_model: z10.string().trim().min(1).optional(),
   // Omitted, the box creates the collection with hybrid search off and `eu`.
-  hybrid_enabled: z7.boolean().optional(),
+  hybrid_enabled: z10.boolean().optional(),
   number_format: ragNumberFormatSchema.optional(),
-  extract_enabled: z7.boolean().optional(),
+  extract_enabled: z10.boolean().optional(),
   extract_fields: ragExtractFieldsRequestSchema.optional()
 }).refine(
   (value) => value.embedding_provider === void 0 === (value.embedding_model === void 0),
@@ -868,78 +1137,78 @@ var createRagCollectionRequestSchema = z7.object({
     path: ["embedding_model"]
   }
 );
-var updateRagCollectionRequestSchema = z7.strictObject({
-  hybrid_enabled: z7.boolean().optional(),
+var updateRagCollectionRequestSchema = z10.strictObject({
+  hybrid_enabled: z10.boolean().optional(),
   number_format: ragNumberFormatSchema.optional(),
-  extract_enabled: z7.boolean().optional(),
+  extract_enabled: z10.boolean().optional(),
   extract_fields: ragExtractFieldsRequestSchema.optional()
 }).refine((value) => Object.values(value).some((setting) => setting !== void 0), {
   message: "Send at least one collection setting"
 });
-var updateRagCollectionResponseSchema = z7.object({
-  name: z7.string(),
-  hybrid_enabled: z7.boolean(),
+var updateRagCollectionResponseSchema = z10.object({
+  name: z10.string(),
+  hybrid_enabled: z10.boolean(),
   number_format: ragNumberFormatSchema,
-  extract_enabled: z7.boolean().optional(),
-  extract_fields: z7.array(ragExtractFieldSchema).optional(),
-  unconverted: z7.number().int().nonnegative().optional()
+  extract_enabled: z10.boolean().optional(),
+  extract_fields: z10.array(ragExtractFieldSchema).optional(),
+  unconverted: z10.number().int().nonnegative().optional()
 });
-var deleteRagCollectionResponseSchema = z7.object({
-  name: z7.string(),
-  deleted: z7.literal(true)
+var deleteRagCollectionResponseSchema = z10.object({
+  name: z10.string(),
+  deleted: z10.literal(true)
 });
-var uploadRagDocumentRequestSchema = z7.object({
+var uploadRagDocumentRequestSchema = z10.object({
   collection: ragCollectionNameParamSchema,
-  filename: z7.string().min(1).max(255),
+  filename: z10.string().min(1).max(255),
   content_type: ragSupportedContentTypeSchema,
   metadata: jsonObject().optional(),
-  replaces: z7.string().min(1).optional()
+  replaces: z10.string().min(1).optional()
 });
-var uploadRagDocumentResponseSchema = z7.object({
-  job_id: z7.string(),
+var uploadRagDocumentResponseSchema = z10.object({
+  job_id: z10.string(),
   status: ragJobStatusSchema,
-  version: z7.number().int().min(1)
+  version: z10.number().int().min(1)
 });
-var deleteRagDocumentResponseSchema = z7.object({
-  id: z7.string(),
-  collection: z7.string(),
-  deleted: z7.literal(true)
+var deleteRagDocumentResponseSchema = z10.object({
+  id: z10.string(),
+  collection: z10.string(),
+  deleted: z10.literal(true)
 });
-var deleteRagDocumentVersionResponseSchema = z7.object({
-  id: z7.string(),
-  collection: z7.string(),
+var deleteRagDocumentVersionResponseSchema = z10.object({
+  id: z10.string(),
+  collection: z10.string(),
   version: ragDocumentVersionNumberSchema,
-  deleted: z7.literal(true)
+  deleted: z10.literal(true)
 });
-var downloadRagDocumentResponseSchema = z7.object({
-  url: z7.string(),
-  filename: z7.string(),
-  content_type: z7.string()
+var downloadRagDocumentResponseSchema = z10.object({
+  url: z10.string(),
+  filename: z10.string(),
+  content_type: z10.string()
 });
-var changeRagEmbeddingRequestSchema = z7.object({
+var changeRagEmbeddingRequestSchema = z10.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"]),
+  model: z10.string().trim().min(1)
+});
+var retryRagRebuildRequestSchema = z10.object({ id: z10.uuid() });
+var ragEmbeddingIdentitySchema = z10.object({
+  provider: z10.string().min(1),
+  model: z10.string().min(1),
+  dimension: z10.number().int().positive()
+});
+var ragRebuildStatusSchema = z10.object({
+  id: z10.uuid(),
+  collection: z10.string(),
+  attempt: z10.number().int().positive(),
+  status: z10.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()
+  completed_versions: z10.number().int().nonnegative(),
+  total_versions: z10.number().int().nonnegative(),
+  run_id: z10.string().nullable(),
+  world_run_id: z10.string().nullable(),
+  error: z10.string().nullable()
 });
-var ragRebuildStatusResponseSchema = z7.object({
+var ragRebuildStatusResponseSchema = z10.object({
   rebuild: ragRebuildStatusSchema.nullable()
 });
 
@@ -963,62 +1232,81 @@ var VOICE_BACKGROUND_CLIPS = [
 ];
 var VOICE_AMBIENT_SOUNDS = ["none", ...VOICE_BACKGROUND_CLIPS];
 var VOICE_THINKING_SOUNDS = ["none", "chime", ...VOICE_BACKGROUND_CLIPS];
-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({
+var thresholdSchema = z11.number().min(0).max(1);
+var millisecondsSchema = z11.int().min(0).max(1e4);
+var keytermsSchema = z11.array(z11.string().trim().min(1).max(64)).max(50);
+var vadSchema = z11.strictObject({
   activationThreshold: thresholdSchema,
   minSpeechMs: millisecondsSchema,
   minSilenceMs: millisecondsSchema
 });
-var turnSchema = z8.strictObject({
-  mode: z8.enum(["stt", "livekit"]),
+var turnSchema = z11.strictObject({
+  mode: z11.enum(["stt", "livekit"]),
   minEndpointingDelayMs: millisecondsSchema,
   maxEndpointingDelayMs: millisecondsSchema,
   detectorThreshold: thresholdSchema,
   // Flux refuses under 0.3 and above its own end-of-turn threshold (0.7 by default,
   // not a setting), so the bound is the range Flux takes with that default.
-  eagerThreshold: z8.number().min(0.3).max(0.7)
+  eagerThreshold: z11.number().min(0.3).max(0.7)
 });
 var VOICE_EAGER_THRESHOLD_DEFAULT = 0.3;
-var interruptionsSchema = z8.strictObject({
-  enabled: z8.boolean(),
+var VOICE_SPEAK_FIRST_CLAUSE_DEFAULT = false;
+var timeZoneSchema = z11.string().max(64).refine(isKnownTimeZone, { message: "timeZone must be an IANA zone such as Europe/Madrid" }).nullable();
+var VOICE_TIME_ZONE_DEFAULT = null;
+var VOICE_NOISE_CANCELLATIONS = ["background", "standard", "off"];
+var noiseCancellationSchema = z11.enum(VOICE_NOISE_CANCELLATIONS);
+var VOICE_NOISE_CANCELLATION_DEFAULT = "background";
+var VOICE_INTERRUPTION_MODES = ["adaptive", "vad"];
+var VOICE_INTERRUPTION_MODE_DEFAULT = "adaptive";
+var interruptionsSchema = z11.strictObject({
+  enabled: z11.boolean(),
+  mode: z11.enum(VOICE_INTERRUPTION_MODES),
   minDurationMs: millisecondsSchema,
-  minWords: z8.int().min(0).max(20)
+  minWords: z11.int().min(0).max(20)
 });
-var ragSchema = z8.strictObject({
+var ragSchema = z11.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),
-  previousExchanges: z8.int().min(0).max(5)
-});
-var volumeSchema = z8.number().min(0).max(1);
-var backgroundAudioSchema = z8.strictObject({
-  ambientSound: z8.enum(VOICE_AMBIENT_SOUNDS),
+  minScore: z11.number().min(0).max(1),
+  minWords: z11.int().min(0).max(20),
+  topK: z11.int().min(1).max(10),
+  timeoutMs: z11.int().min(200).max(1e4),
+  previousExchanges: z11.int().min(0).max(5)
+});
+var volumeSchema = z11.number().min(0).max(1);
+var backgroundAudioSchema = z11.strictObject({
+  ambientSound: z11.enum(VOICE_AMBIENT_SOUNDS),
   ambientVolume: volumeSchema,
-  thinkingSound: z8.enum(VOICE_THINKING_SOUNDS),
+  thinkingSound: z11.enum(VOICE_THINKING_SOUNDS),
   thinkingVolume: volumeSchema,
   /**
    * How long a reply's wait runs before the thinking sound starts, when no box tool
-   * call is open (a tool call starts it at once). Every turn waits for the knowledge
-   * search and the model's first token, about 1.4 s at the median on a voice box
-   * (2026-11-09), so a delay under that plays the sound on nearly every reply.
+   * call is open. A box tool starts it at once, or, after a holding line, 300 ms after
+   * the line has played out (at once when its TTS is lost, at most
+   * `holdingLineMaxWaitMs` after the tool start), so the caller hears the line first
+   * (STA3-99). Every turn waits for the knowledge search and the model's first token,
+   * about 1.4 s at the median on a voice box (2026-11-09), so a delay under that plays
+   * the sound on nearly every reply.
    */
-  thinkingDelayMs: millisecondsSchema
+  thinkingDelayMs: millisecondsSchema,
+  /**
+   * The cap on the thinking sound's wait for a holding line to play out, from the tool
+   * start (STA3-99): a long line, or a TTS that never reports its end, must not keep
+   * the caller in silence while the tool runs.
+   */
+  holdingLineMaxWaitMs: millisecondsSchema
 });
 var VOICE_BACKGROUND_AUDIO_DEFAULTS = Object.freeze({
   ambientSound: "office-ambience",
   ambientVolume: 0.7,
   thinkingSound: "keyboard-typing",
   thinkingVolume: 0.6,
-  thinkingDelayMs: 2e3
+  thinkingDelayMs: 2e3,
+  holdingLineMaxWaitMs: 1e4
 });
-var effectiveVoiceSettingsObjectSchema = z8.strictObject({
+var effectiveVoiceSettingsObjectSchema = z11.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),
+  language: z11.string().max(16).regex(/^[A-Za-z]{2,8}(?:-[A-Za-z0-9]{1,8})*$/),
+  sttModel: z11.enum(VOICE_STT_MODELS),
   keyterms: keytermsSchema.default(() => []),
   vad: vadSchema,
   // Defaulted here, on the read side only: a box older than STA3-94 answers, and
@@ -1027,32 +1315,57 @@ var effectiveVoiceSettingsObjectSchema = z8.strictObject({
   turn: turnSchema.extend({
     eagerThreshold: turnSchema.shape.eagerThreshold.default(VOICE_EAGER_THRESHOLD_DEFAULT)
   }),
-  interruptions: interruptionsSchema,
-  ttsModel: z8.enum(VOICE_TTS_MODELS),
+  // Read side only, like `turn.eagerThreshold`: a box older than the setting answers,
+  // and dispatches, a group without it.
+  interruptions: interruptionsSchema.extend({
+    mode: interruptionsSchema.shape.mode.default(VOICE_INTERRUPTION_MODE_DEFAULT)
+  }),
+  /** The filter on the caller's track (`VOICE_NOISE_CANCELLATIONS`). */
+  // Read side only, like `speakFirstClause`.
+  noiseCancellation: noiseCancellationSchema.default(VOICE_NOISE_CANCELLATION_DEFAULT),
+  ttsModel: z11.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),
+  ttsVoice: z11.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),
+  ttsSpeed: z11.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.
+   * utterance, not a wait. It may hold `{{name}}` placeholders, filled per call from
+   * the call's variables (`renderVoiceGreeting`).
    */
-  greeting: z8.string().trim().min(1).max(500).nullable(),
+  greeting: z11.string().trim().min(1).max(VOICE_GREETING_MAX).nullable(),
   /** Band-pass the agent's voice to 300-3400 Hz so it sounds like a phone line (D5). */
-  phoneLine: z8.boolean(),
+  phoneLine: z11.boolean(),
   /** LiveKit expressive mode: the turn gets Cartesia's markup guide (D5). Cartesia only. */
-  expressive: z8.boolean(),
-  backgroundAudio: backgroundAudioSchema,
+  expressive: z11.boolean(),
+  /**
+   * The reply's first clause goes to the TTS at its first comma or sentence end,
+   * instead of when the next sentence starts or the reply ends: LiveKit's sentence
+   * tokenizer holds a one-sentence reply until the model has finished it, 550 to 790 ms
+   * of silence on a model that writes 25 to 45 tokens/s (2026-11-11). The clause is its
+   * own TTS segment, so the intonation can change at that pause.
+   */
+  // Defaulted on the read side only, like `turn.eagerThreshold`: a box older than the
+  // setting answers, and dispatches, settings without it. The layer schema drops the
+  // default, or every layer would declare it.
+  speakFirstClause: z11.boolean().default(VOICE_SPEAK_FIRST_CLAUSE_DEFAULT),
+  // Read side only, like `turn.eagerThreshold`: a box older than STA3-99 answers a
+  // group without it.
+  backgroundAudio: backgroundAudioSchema.extend({
+    holdingLineMaxWaitMs: backgroundAudioSchema.shape.holdingLineMaxWaitMs.default(
+      VOICE_BACKGROUND_AUDIO_DEFAULTS.holdingLineMaxWaitMs
+    )
+  }),
   /**
    * 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(),
+  recording: z11.boolean(),
   /** The box runs the search before the model's turn, so the worker never reads it. */
   rag: ragSchema,
   /**
@@ -1062,7 +1375,16 @@ var effectiveVoiceSettingsObjectSchema = z8.strictObject({
    * 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)
+  refusalPhrase: z11.string().trim().min(1).max(300),
+  /**
+   * The zone of the date every model call of a call is told as today. The agent's
+   * prompt is rendered once when its graph is built and kept for days, so a date
+   * written into it goes stale, and a `today` tool costs the caller a second model
+   * call. The box writes the date into the turn itself, so the worker never reads it.
+   */
+  // Defaulted on the read side only, like `speakFirstClause`: a box older than the
+  // setting answers settings without it.
+  timeZone: timeZoneSchema.default(VOICE_TIME_ZONE_DEFAULT)
 });
 var checkCrossFieldRules = (value, ctx) => {
   const min = value.turn?.minEndpointingDelayMs;
@@ -1093,10 +1415,12 @@ var effectiveVoiceSettingsSchema = effectiveVoiceSettingsObjectSchema.superRefin
 var callVoiceSettingsObjectSchema = effectiveVoiceSettingsObjectSchema.omit({
   recording: true,
   rag: true,
-  refusalPhrase: true
+  refusalPhrase: true,
+  timeZone: true
 }).extend({
-  // A box older than `thinkingDelayMs` dispatches the group without it.
-  backgroundAudio: backgroundAudioSchema.extend({
+  // A box older than `thinkingDelayMs` or `holdingLineMaxWaitMs` dispatches the group
+  // without it; the effective schema already defaults the second.
+  backgroundAudio: effectiveVoiceSettingsObjectSchema.shape.backgroundAudio.extend({
     thinkingDelayMs: millisecondsSchema.default(
       VOICE_BACKGROUND_AUDIO_DEFAULTS.thinkingDelayMs
     )
@@ -1116,19 +1440,23 @@ var VOICE_SETTINGS_LEAF_PATHS = [
   "turn.detectorThreshold",
   "turn.eagerThreshold",
   "interruptions.enabled",
+  "interruptions.mode",
   "interruptions.minDurationMs",
   "interruptions.minWords",
+  "noiseCancellation",
   "ttsModel",
   "ttsVoice",
   "ttsSpeed",
   "greeting",
   "phoneLine",
   "expressive",
+  "speakFirstClause",
   "backgroundAudio.ambientSound",
   "backgroundAudio.ambientVolume",
   "backgroundAudio.thinkingSound",
   "backgroundAudio.thinkingVolume",
   "backgroundAudio.thinkingDelayMs",
+  "backgroundAudio.holdingLineMaxWaitMs",
   "recording",
   "rag.collection",
   "rag.minScore",
@@ -1136,15 +1464,21 @@ var VOICE_SETTINGS_LEAF_PATHS = [
   "rag.topK",
   "rag.timeoutMs",
   "rag.previousExchanges",
-  "refusalPhrase"
+  "refusalPhrase",
+  "timeZone"
 ];
-var voiceSettingOriginSchema = z8.enum(["studio", "code", "default"]);
+var voiceSettingOriginSchema = z11.enum(["studio", "code", "default"]);
 var LEAVES_NEWER_THAN_SOME_BOXES = /* @__PURE__ */ new Set([
-  "turn.eagerThreshold"
+  "turn.eagerThreshold",
+  "interruptions.mode",
+  "noiseCancellation",
+  "speakFirstClause",
+  "backgroundAudio.holdingLineMaxWaitMs",
+  "timeZone"
 ]);
-var effectiveVoiceSettingsViewSchema = z8.strictObject({
+var effectiveVoiceSettingsViewSchema = z11.strictObject({
   value: effectiveVoiceSettingsObjectSchema,
-  origins: z8.strictObject(
+  origins: z11.strictObject(
     Object.fromEntries(
       // A leaf newer than the box answering does not come back: that box runs its default.
       // Every other leaf stays required, so a box that drops one is still caught.
@@ -1166,6 +1500,9 @@ var checkTtsPair = (value, ctx) => {
 };
 var voiceSettingsSchema = effectiveVoiceSettingsObjectSchema.extend({
   keyterms: keytermsSchema,
+  noiseCancellation: noiseCancellationSchema,
+  speakFirstClause: z11.boolean(),
+  timeZone: timeZoneSchema,
   vad: vadSchema.partial(),
   turn: turnSchema.partial(),
   interruptions: interruptionsSchema.partial(),
@@ -1183,11 +1520,11 @@ var checkStudioTtsPair = (value, ctx) => {
 };
 var studioVoiceSettingsPatchSchema = voiceSettingsSchema.superRefine(checkStudioTtsPair);
 var voiceSettingsResponseSchema = effectiveVoiceSettingsViewSchema.extend({
-  issue: z8.string().nullable()
+  issue: z11.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, {
+var deepAgentNameSchema = z11.string().regex(/^[a-z0-9][a-z0-9_-]{0,63}$/);
+var voiceCallIdSchema = z11.string().min(1).max(RUN_TAG_VALUE_MAX);
+var voiceTagsSchema = z11.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";
@@ -1201,7 +1538,7 @@ var isVoiceBoxUrl = (raw) => {
   }
 };
 var VOICE_BOX_URL_MAX = 2048;
-var voiceBoxUrlSchema = z8.string().max(VOICE_BOX_URL_MAX).refine(isVoiceBoxUrl, {
+var voiceBoxUrlSchema = z11.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";
@@ -1210,7 +1547,7 @@ var VOICE_WORKER_AGENT_NAME_ENV = "STACKBONE_VOICE_AGENT_NAME";
 var VOICE_WORKER_PORT_ENV = "STACKBONE_VOICE_WORKER_PORT";
 var VOICE_TURN_METRICS_MESSAGE = "voice turn metrics";
 var VOICE_CALL_TOKEN_MAX = 2048;
-var voiceDispatchSchema = z8.strictObject({
+var voiceDispatchSchema = z11.strictObject({
   agent: deepAgentNameSchema,
   /**
    * The merged value (Studio > code > box default), cross-field rules included,
@@ -1221,57 +1558,59 @@ var voiceDispatchSchema = z8.strictObject({
   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." }),
+  callToken: z11.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()
+  traces: z11.literal(true).optional()
 });
-var voiceRoomRequestSchema = z8.strictObject({
+var voiceRoomRequestSchema = z11.strictObject({
   agent: deepAgentNameSchema,
   origin: runTagKeySchema.default("studio"),
-  identities: integrationIdentitiesSchema.optional()
+  identities: integrationIdentitiesSchema.optional(),
+  /** Fill the greeting's placeholders and reach the agent as data (PLA-2409). */
+  variables: voiceCallVariablesSchema.optional()
 });
-var voiceRoomResponseSchema = z8.strictObject({
-  url: z8.string().min(1),
-  token: z8.string().min(1),
+var voiceRoomResponseSchema = z11.strictObject({
+  url: z11.string().min(1),
+  token: z11.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({
+var voiceRecordingQuerySchema = z11.object({ session_id: z11.uuid() });
+var voiceRecordingResponseSchema = z11.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()
+  status: z11.enum(VOICE_RECORDING_STATUSES),
+  url: z11.string().nullable(),
+  expires_at: z11.iso.datetime().nullable(),
+  started_at: z11.iso.datetime(),
+  ended_at: z11.iso.datetime().nullable()
 });
-var voiceStatusResponseSchema = z8.strictObject({
-  configured: z8.literal(true),
-  reachable: z8.boolean(),
-  checkedAt: z8.iso.datetime()
+var voiceStatusResponseSchema = z11.strictObject({
+  configured: z11.literal(true),
+  reachable: z11.boolean(),
+  checkedAt: z11.iso.datetime()
 });
 var HEARD_TEXT_MAX = 4e3;
-var aguiHeardSchema = z8.strictObject({
-  text: z8.string().min(1).max(HEARD_TEXT_MAX)
+var aguiHeardSchema = z11.strictObject({
+  text: z11.string().min(1).max(HEARD_TEXT_MAX)
 });
 var VOICE_CALLS_PATH = "/voice/v1/calls";
-var voiceCallBootstrapSchema = z8.strictObject({
+var voiceCallBootstrapSchema = z11.strictObject({
   identities: integrationIdentitiesSchema.optional()
 });
-var voiceCallKnowledgeSchema = z8.strictObject({
-  text: z8.string().min(1).max(HEARD_TEXT_MAX)
+var voiceCallKnowledgeSchema = z11.strictObject({
+  text: z11.string().min(1).max(HEARD_TEXT_MAX)
 });
-var voiceCallTranscriptSchema = z8.array(
-  z8.strictObject({
-    role: z8.enum(["user", "assistant"]),
-    text: z8.string().trim().min(1).max(16e3)
+var voiceCallTranscriptSchema = z11.array(
+  z11.strictObject({
+    role: z11.enum(["user", "assistant"]),
+    text: z11.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."
@@ -1279,10 +1618,10 @@ var voiceCallTranscriptSchema = z8.array(
 var VOICE_CALL_TURNS_MAX = 1e3;
 var AGUI_RUN_ID_MAX = 200;
 var VOICE_TURN_LATENCY_MAX_MS = 36e5;
-var turnLatencyMs = z8.number().int().min(0).max(VOICE_TURN_LATENCY_MAX_MS).optional();
-var voiceCallTurnMetricsSchema = z8.strictObject({
+var turnLatencyMs = z11.number().int().min(0).max(VOICE_TURN_LATENCY_MAX_MS).optional();
+var voiceCallTurnMetricsSchema = z11.strictObject({
   /** The AG-UI `runId` of the box run that answered; absent on a reply the box did not run. */
-  runId: z8.string().min(1).max(AGUI_RUN_ID_MAX).optional(),
+  runId: z11.string().min(1).max(AGUI_RUN_ID_MAX).optional(),
   endOfTurnMs: turnLatencyMs,
   transcriptionMs: turnLatencyMs,
   llmTtftMs: turnLatencyMs,
@@ -1291,21 +1630,26 @@ var voiceCallTurnMetricsSchema = z8.strictObject({
   /** How long before the final transcript the turn's last eager end of turn left for the box (STA3-94). */
   preflightLeadMs: turnLatencyMs
 });
-var voiceCallTurnsSchema = z8.array(voiceCallTurnMetricsSchema).max(VOICE_CALL_TURNS_MAX);
-var voiceCallCompleteSchema = z8.strictObject({
+var voiceCallTurnsSchema = z11.array(voiceCallTurnMetricsSchema).max(VOICE_CALL_TURNS_MAX);
+var voiceCallCompleteSchema = z11.strictObject({
   transcript: voiceCallTranscriptSchema,
-  outcome: z8.enum(["completed", "disconnected", "failed"]),
+  outcome: z11.enum(["completed", "disconnected", "failed"]),
   // The transcript, the memory and the `onEnd` start this body carries must not be
   // refused over a bad latency, so `turns` is any value here and read apart through
   // `readVoiceCallTurns`. Not `.catch()` on the array: this schema is a documented
   // route's body, and the OpenAPI generator cannot describe a catch (STA3-56).
-  turns: z8.unknown().optional()
+  turns: z11.unknown().optional()
 });
-var voiceCallLifecycleResponseSchema = z8.strictObject({ ok: z8.literal(true) });
+var voiceCallLifecycleResponseSchema = z11.strictObject({ ok: z11.literal(true) });
 
 // libs/runtime/voice-worker/src/box-llm.ts
 import { randomUUID } from "node:crypto";
-import { DEFAULT_API_CONNECT_OPTIONS, llm as llm2, log } from "@livekit/agents";
+import {
+  DEFAULT_API_CONNECT_OPTIONS,
+  FlushSentinel,
+  llm as llm2,
+  log
+} from "@livekit/agents";
 
 // libs/shared/llm-wire/src/lib/sse/read-sse-data.ts
 async function* readSseData(body) {
@@ -1486,7 +1830,8 @@ var voiceCallKnowledge = async (wire, text) => {
 var VOICE_RESPONSE_MARKER = "stackboneVoiceResponse";
 var WORD_CHAR = /[\p{L}\p{N}]/u;
 var SPACE = /\s/u;
-var TAG = /^<[\p{L}/][^>]*>/u;
+var TAG_NAME_START = /[\p{L}/]/u;
+var TAG = new RegExp(`^<${TAG_NAME_START.source}[^>]*>`, "u");
 var charAt = (text, index) => String.fromCodePoint(text.codePointAt(index) ?? 0);
 var heardPrefixOf = (boxText, heardText) => {
   let b = 0;
@@ -1649,6 +1994,60 @@ var lastNewAssistantMessage = (chatCtx, seen) => {
   return void 0;
 };
 
+// libs/runtime/voice-worker/src/first-clause.ts
+var FIRST_CLAUSE_MIN_CHARS = 25;
+var CLAUSE_END = /* @__PURE__ */ new Set([",", ";", ":", ".", "?", "!", "\u2026"]);
+var FirstClause = class {
+  #done = false;
+  #spoken = 0;
+  /** The text of the tag being read, from its `<`. */
+  #tag;
+  #openTags = 0;
+  /** The last character was a mark that can end the clause: the next one decides. */
+  #markPending = false;
+  push(text) {
+    if (!this.#done) {
+      let at = 0;
+      for (const char of text) {
+        if (this.#markPending && SPACE.test(char)) {
+          this.#done = true;
+          return { head: text.slice(0, at), cut: true, tail: text.slice(at) };
+        }
+        this.#read(char);
+        at += char.length;
+      }
+    }
+    return { head: text, cut: false, tail: "" };
+  }
+  #read(char) {
+    this.#markPending = false;
+    if (this.#tag !== void 0) {
+      if (this.#tag !== "<" || TAG_NAME_START.test(char)) {
+        this.#tag += char;
+        if (char === ">") this.#closeTag(this.#tag);
+        return;
+      }
+      this.#tag = void 0;
+      this.#spoken += 1;
+    }
+    if (char === "<") {
+      this.#tag = "<";
+      return;
+    }
+    if (SPACE.test(char)) {
+      if (this.#spoken > 0) this.#spoken += 1;
+      return;
+    }
+    this.#spoken += 1;
+    this.#markPending = CLAUSE_END.has(char) && this.#openTags === 0 && this.#spoken >= FIRST_CLAUSE_MIN_CHARS;
+  }
+  #closeTag(tag) {
+    this.#tag = void 0;
+    if (tag.startsWith("</")) this.#openTags = Math.max(0, this.#openTags - 1);
+    else if (!tag.endsWith("/>")) this.#openTags += 1;
+  }
+};
+
 // libs/runtime/voice-worker/src/turn-metrics.ts
 import { llm, voice as voice2 } from "@livekit/agents";
 var AGUI_RUN_ID_EXTRA = "stackboneAguiRunId";
@@ -1808,6 +2207,8 @@ var BoxLLMStream = class extends llm2.LLMStream {
   async runTurn() {
     const {
       onToolCall,
+      speakFirstClause = false,
+      onSpeechSegments,
       onTurnError,
       onRunFinished,
       onClientToolCall,
@@ -1833,6 +2234,28 @@ var BoxLLMStream = class extends llm2.LLMStream {
       timer = setTimeout(() => idle.abort(), turnIdleTimeoutMs);
     };
     const openToolCalls = /* @__PURE__ */ new Set();
+    let textSinceFlush = false;
+    let speechSinceTool = false;
+    let lastChar = "";
+    let flushed = false;
+    let segments = 0;
+    const newClause = () => speakFirstClause ? new FirstClause() : void 0;
+    let clause = newClause();
+    const put = (content) => this.queue.put({
+      id,
+      delta: {
+        role: "assistant",
+        content,
+        extra: { [VOICE_RESPONSE_MARKER]: id, [AGUI_RUN_ID_EXTRA]: runId }
+      }
+    });
+    const flushSegment = () => {
+      this.queue.put(FlushSentinel);
+      textSinceFlush = false;
+      segments += 1;
+      onSpeechSegments?.(segments);
+    };
+    onSpeechSegments?.(0);
     let finished;
     let failure;
     try {
@@ -1849,22 +2272,38 @@ var BoxLLMStream = class extends llm2.LLMStream {
         restartIdle();
         reply.observe(ev);
         switch (ev.kind) {
-          case "text":
-            this.queue.put({
-              id,
-              delta: {
-                role: "assistant",
-                content: ev.text,
-                extra: { [VOICE_RESPONSE_MARKER]: id, [AGUI_RUN_ID_EXTRA]: runId }
-              }
-            });
+          case "text": {
+            const content = flushed && !/^\s/.test(ev.text) && !/\s$/.test(lastChar) ? ` ${ev.text}` : ev.text;
+            flushed = false;
+            if (/\S/.test(ev.text)) {
+              textSinceFlush = true;
+              speechSinceTool = true;
+            }
+            lastChar = content.slice(-1);
+            const split = clause?.push(content);
+            if (!split?.cut) {
+              put(content);
+              break;
+            }
+            if (split.head) put(split.head);
+            flushSegment();
+            textSinceFlush = /\S/.test(split.tail);
+            put(split.tail);
             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)) {
+              const afterSpeech = speechSinceTool;
+              if (textSinceFlush) {
+                flushSegment();
+                flushed = true;
+              }
+              speechSinceTool = false;
+              clause = newClause();
               openToolCalls.add(ev.id);
-              onToolCall?.("start", ev.id);
+              onToolCall?.("start", ev.id, afterSpeech);
             }
             break;
           case "tool_call_result":
@@ -2252,13 +2691,18 @@ var voiceSessionOptions = (settings, pieces) => {
         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.
+        // The mode is always sent: with none, 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.
+        // `adaptive`: shortly after the agent starts speaking (LiveKit's backchannel
+        // boundary) LiveKit stops cutting on voice activity and cuts only when its model
+        // calls the overlap a barge-in, so a "sí", a "vale" or a cough do not cut the
+        // agent off, and a real barge-in can be missed. LiveKit still skips adaptive, with
+        // a warning, when the STT gives no word-aligned transcript, and when interruptions
+        // are off. `vad`: any speech of `minDuration` (and `minWords`, when set) cuts, so
+        // a short acknowledgement or a cough can cut too.
         interruption: {
-          mode: "adaptive",
+          mode: interruptions.mode,
           enabled: interruptions.enabled,
           minDuration: interruptions.minDurationMs,
           minWords: interruptions.minWords
@@ -2346,19 +2790,35 @@ var CALL_CLOSING_PHRASE = Object.freeze({
 });
 var MAX_FAILED_TURNS_IN_A_ROW = 3;
 var inCallLanguage = (phrase, language) => language.split("-")[0]?.toLowerCase() === "es" ? phrase.es : phrase.en;
-var thinkingCue = (delayMs) => {
+var CUE_AFTER_HOLDING_LINE_MS = 300;
+var thinkingCue = (delayMs, holdingLineMaxWaitMs) => {
   let cue;
   let open = 0;
   let waitedLong = false;
   let wait;
   let playing = false;
+  let holding = false;
+  let flushedSegments = 0;
+  let playedSegments = 0;
+  let beat;
+  let cap;
   const sync = () => {
-    const play = waitedLong || open > 0;
+    const play = waitedLong || open > 0 && !holding;
     if (play === playing || !cue) return;
     playing = play;
     if (play) cue.start();
     else cue.stop();
   };
+  const clearHold = () => {
+    clearTimeout(beat);
+    clearTimeout(cap);
+    beat = cap = void 0;
+    holding = false;
+  };
+  const releaseHold = () => {
+    clearHold();
+    sync();
+  };
   return {
     // A turn can start before the track is up.
     attach: (ready) => {
@@ -2380,25 +2840,49 @@ var thinkingCue = (delayMs) => {
         sync();
       }, delayMs);
     },
-    onToolCall: (phase) => {
-      if (phase === "start") open += 1;
-      else if (open > 0) open -= 1;
+    onToolCall: (phase, _id, afterSpeech = false) => {
+      if (phase === "start") {
+        open += 1;
+        if (afterSpeech && holdingLineMaxWaitMs > 0 && playedSegments < flushedSegments) {
+          clearHold();
+          holding = true;
+          cap = setTimeout(releaseHold, holdingLineMaxWaitMs);
+        }
+      } else if (open > 0) open -= 1;
+      if (open === 0) clearHold();
       sync();
     },
+    /** BoxLLM's count of the turn's flushed segments; a turn starts at 0 (`onSpeechSegments`). */
+    onSpeechSegments: (count) => {
+      if (count === 0) playedSegments = 0;
+      flushedSegments = count;
+    },
+    /** A segment of a reply finished playing out, or was cut. */
+    onPlaybackFinished: () => {
+      if (playedSegments < flushedSegments) playedSegments += 1;
+      if (!holding || beat !== void 0 || playedSegments < flushedSegments) return;
+      beat = setTimeout(releaseHold, CUE_AFTER_HOLDING_LINE_MS);
+    },
+    onSessionError: ({ error }) => {
+      if (holding && error.type === "tts_error" && !error.recoverable) releaseHold();
+    },
     /** The call is ending: a pending delay must not start the sound in a closed room. */
     close: () => {
       clearTimeout(wait);
       wait = void 0;
       waitedLong = false;
       open = 0;
+      clearHold();
       sync();
     }
   };
 };
 var messageOf = (err) => err instanceof Error ? err.message : String(err);
-var callerNoiseCancellation = (caller) => {
+var callerNoiseCancellation = (caller, mode) => {
+  if (mode === "off") return void 0;
   try {
-    return caller.kind === ParticipantKind.SIP ? TelephonyBackgroundVoiceCancellation() : BackgroundVoiceCancellation();
+    if (caller.kind === ParticipantKind.SIP) return TelephonyBackgroundVoiceCancellation();
+    return mode === "standard" ? NoiseCancellation() : BackgroundVoiceCancellation();
   } catch (err) {
     log5().warn({ error: messageOf(err) }, "voice worker: no noise cancellation on this call");
     return void 0;
@@ -2436,7 +2920,10 @@ var runVoiceJob = async (ctx, deps) => {
     deps
   );
   const settings = dispatch.voiceSettings;
-  const cue = thinkingCue(settings.backgroundAudio.thinkingDelayMs);
+  const cue = thinkingCue(
+    settings.backgroundAudio.thinkingDelayMs,
+    settings.backgroundAudio.holdingLineMaxWaitMs
+  );
   const fallback = inCallLanguage(TURN_FALLBACK_PHRASE, settings.language);
   let failedInARow = 0;
   let ending = false;
@@ -2535,6 +3022,8 @@ var runVoiceJob = async (ctx, deps) => {
     pendingResume: hangUp.pendingResume,
     isEnding: () => ending,
     onToolCall: cue.onToolCall,
+    speakFirstClause: settings.speakFirstClause,
+    onSpeechSegments: cue.onSpeechSegments,
     onTurnError,
     onRunFinished
   });
@@ -2577,6 +3066,7 @@ var runVoiceJob = async (ctx, deps) => {
     voice4.AgentSessionEventTypes.AgentStateChanged,
     ({ newState }) => cue.onAgentState(newState)
   );
+  session.on(voice4.AgentSessionEventTypes.Error, cue.onSessionError);
   session.on(voice4.AgentSessionEventTypes.Close, () => {
     if (completion || ending) return;
     void finishCall().catch(() => void 0).finally(() => ctx.shutdown("caller left"));
@@ -2595,12 +3085,13 @@ var runVoiceJob = async (ctx, deps) => {
       preflightLeadMs: () => plan.agent.takePreflightLead()
     }
   );
-  const noiseCancellation = callerNoiseCancellation(participant);
+  const noiseCancellation = callerNoiseCancellation(participant, settings.noiseCancellation);
   await session.start({
     agent: plan.agent,
     room: ctx.room,
     inputOptions: noiseCancellation ? { noiseCancellation } : {}
   });
+  session.output?.audio?.on("playbackFinished", cue.onPlaybackFinished);
   if (settings.greeting !== null) sayIfOpen(settings.greeting, "greeting");
   await deps.createCue({ room: ctx.room, session, audio: settings.backgroundAudio }).then(cue.attach, (err) => {
     log5().warn({ error: messageOf(err) }, "voice worker: the background audio did not start");