@tangle-network/agent-app 0.45.24 → 0.45.25

package/dist/chat-routes/index.d.ts

@@ -6,7 +6,7 @@ import { C as ChatMessagePart, a as ChatAttachmentPart, e as ChatMentionPart } f
 import { InteractionAnswerRoute, InteractionAnswerRouteOptions } from '../interactions/index.js';
 import { PersistedChatMessageForTurn } from '../stream/index.js';
 import { T as TurnEventStore } from '../turn-buffer-COMQUwO2.js';
-import { M as ModelFailoverAttempt } from '../failover-D-3UXXTb.js';
+import { M as ModelFailoverAttempt, a as ModelFailoverExhaustedError } from '../failover-D-3UXXTb.js';
 export { D as DEFAULT_STALE_TURN_LOCK_GRACE_MS, a as DEFAULT_TERMINAL_TURN_LOCK_GRACE_MS, R as ReconcileStaleTurnLockOptions, b as ReconcileStaleTurnLockResult, S as StaleTurnLockSandboxProbeResult, c as StaleTurnLockSessionProbeResult, r as reconcileStaleTurnLock } from '../stale-turn-lock-DucQzvXu.js';
 import { J as JsonRecord } from '../stream-normalizer-DKRxyVlZ.js';
 import { SandboxInstance } from '@tangle-network/sandbox';
@@ -785,8 +785,8 @@ declare function createChatTurnRoutes<TContext = void>(options: CreateChatTurnRo
  *   platform flake that a same-model re-run recovers (8 hard cases: 7/8
  *   delivered on the first pass, 8/8 with one re-run, at a cost of 1 extra turn
  *   in 9). Default `0`, so the behavior is unchanged unless a product asks.
- * - A chain of length 1 costs nothing: one attempt, no extra call, no added
- *   latency, byte-identical to no failover at all.
+ * - A responsive chain of length 1 costs no extra call or latency and remains
+ *   byte-identical to no failover. A silent chain is now deliberately bounded.
  */
 
 /**
@@ -834,6 +834,10 @@ type OpenModelStream = (args: {
     model: string;
     /** 1 for the preferred model, 2 for the first fallback, and so on. */
     attempt: number;
+    /** Aborted when this attempt times out, is abandoned, or finishes. Forward
+     *  this to `streamSandboxPrompt(..., { signal })` so a blocked transport is
+     *  cancelled immediately rather than only receiving iterator.return(). */
+    signal: AbortSignal;
 }) => AsyncIterable<unknown> | Promise<AsyncIterable<unknown>>;
 /** Fired when a model is abandoned and the next one is about to be tried. */
 interface ModelFallbackInfo {
@@ -846,6 +850,19 @@ interface ModelFailoverStreamOptions {
     /** Preferred model first, then fallbacks in descending preference. */
     models: readonly string[];
     open: OpenModelStream;
+    /**
+     * Maximum time to open/start one model's event source, including its first
+     * iterator pull. Default 120 seconds, matching the sandbox provisioning
+     * ceiling so cold infrastructure startup is bounded independently from
+     * provider inference.
+     */
+    openTimeoutMs?: number;
+    /**
+     * Hard deadline from the source's first lifecycle event to its first
+     * answer-bearing event. Default 60 seconds. Processing/lifecycle events do
+     * not commit the attempt and do not extend this deadline.
+     */
+    firstResponseTimeoutMs?: number;
     /** Override the commit-point rule. Default {@link isCommittingSandboxEvent}. */
     isCommitting?: (event: unknown) => boolean;
     onFallback?: (info: ModelFallbackInfo) => void;
@@ -886,6 +903,24 @@ interface ModelFailoverStreamHandle {
     /** True when the preferred model did not serve — the attributability signal. */
     usedFallback(): boolean;
 }
+/** Default ceiling for opening/starting one source through its first event. */
+declare const DEFAULT_MODEL_STREAM_OPEN_TIMEOUT_MS = 120000;
+/** Default ceiling for the first answer-bearing event after the source's first event. */
+declare const DEFAULT_MODEL_FIRST_RESPONSE_TIMEOUT_MS = 60000;
+/** Structured timeout codes surfaced by the producer on final exhaustion. */
+type ModelAttemptTimeoutCode = 'model_stream_open_timeout' | 'provider_first_response_timeout';
+/** Every configured model was exhausted and the final one timed out. */
+declare class ModelFailoverTimeoutError extends ModelFailoverExhaustedError {
+    readonly code: ModelAttemptTimeoutCode;
+    readonly model: string;
+    readonly timeoutMs: number;
+    constructor(input: {
+        attempts: ModelFailoverAttempt[];
+        code: ModelAttemptTimeoutCode;
+        model: string;
+        timeoutMs: number;
+    });
+}
 /**
  * Hard ceiling on same-model re-runs. A turn that comes back blank three times
  * running is not a flake this can retry away, and each pass costs a full
@@ -908,9 +943,11 @@ declare function resolveEmptyTurnRetries(value: number | undefined): number;
  * Zero added latency on the happy path: the preferred model is opened first and,
  * the moment it emits anything meaningful, its events flow straight through.
  *
- * @throws ModelFailoverExhaustedError when every model's upstream is down, and
+ * @throws ModelFailoverTimeoutError when the final model times out,
+ *         ModelFailoverExhaustedError when every model's upstream is down, and
  *         re-throws a non-outage error from the FIRST model without walking the
- *         chain (both behaviors inherited from `runWithModelFailover`).
+ *         chain (the latter behaviors are inherited from
+ *         `runWithModelFailover`).
  */
 declare function streamWithModelFailover(options: ModelFailoverStreamOptions): ModelFailoverStreamHandle;
 
@@ -993,6 +1030,14 @@ interface SandboxChatProducerOptions {
     /** Opt out of failover while still using {@link openEvents}. `false` collapses
      *  the chain to `model` alone. */
     modelFailover?: false;
+    /** Maximum time to open/start one model event source through its first event.
+     *  Default 120 seconds. This is separate from provider first-output latency
+     *  so cold sandbox startup is not mislabeled as an inference failure. */
+    openTimeoutMs?: number;
+    /** Hard deadline after the source's first lifecycle event for the first
+     *  answer-bearing event. Default 60 seconds. Processing/lifecycle events do
+     *  not extend it. */
+    firstResponseTimeoutMs?: number;
     /** Fired when a model is abandoned mid-chain (telemetry/alerting). The user
      *  already sees a transcript notice; this is for the operator. */
     onModelFallback?: (info: ModelFallbackInfo) => void;
@@ -1121,6 +1166,12 @@ interface DetachedTurnOptions {
     fallbackModels?: SandboxChatProducerOptions['fallbackModels'];
     /** Opt out of failover while still using {@link openEvents}. */
     modelFailover?: false;
+    /** Maximum time to open/start one model event source through its first event.
+     *  Forwarded to the producer; default 120 seconds. */
+    openTimeoutMs?: SandboxChatProducerOptions['openTimeoutMs'];
+    /** Hard deadline after the source's first lifecycle event for the first
+     *  answer-bearing event. Forwarded to the producer; default 60 seconds. */
+    firstResponseTimeoutMs?: SandboxChatProducerOptions['firstResponseTimeoutMs'];
     /** Fired when a model is abandoned mid-chain (telemetry/alerting). */
     onModelFallback?: SandboxChatProducerOptions['onModelFallback'];
     /** The PREFERRED model. Recorded on the persisted assistant message + usage
@@ -1787,4 +1838,4 @@ interface PromoteAgentFilePartOptions {
 /** Promote a part of an agent file with optional byte limits and MIME type detection */
 declare function promoteAgentFilePart(options: PromoteAgentFilePartOptions): Promise<PromoteFilePartResult>;
 
-export { type AssistantDraftSnapshot, type AssistantDraftStore, type AssistantDraftWriter, type AssistantDraftWriterOptions, type AssistantRowValues, type AttachmentPathArgs, type AttachmentPathCheck, type AttachmentReadResult, type AttachmentUploadAuthorization, type AttachmentWriteResult, type BuildDispatchPartsInput, ChatAttachmentKind, type ChatRouteDurableProjection, type ChatRouteDurableProjectionLogger, type ChatRouteEvent, type ChatTurnAuthorization, type ChatTurnAuthorizeArgs, type ChatTurnCompleteInput, ChatTurnFilePartInput, type ChatTurnGateResult, type ChatTurnHeartbeat, type ChatTurnInputPatch, type ChatTurnLifecycle, type ChatTurnLifecycleComplete, type ChatTurnLifecycleError, type ChatTurnLifecycleStart, type ChatTurnLock, type ChatTurnLockResult, type ChatTurnMessageStore, type ChatTurnModelAttribution, type ChatTurnModelFailover, ChatTurnPartInput, type ChatTurnProduceArgs, ChatTurnRequestPayload, type ChatTurnRouteProducer, type ChatTurnRoutes, type ChatTurnUsage, type CompletedSandboxTurnSource, type CreateAttachmentUploadRouteOptions, type CreateChatTurnRoutesOptions, type CreateUploadRouteOptions, type DetachedTurnFinal, type DetachedTurnOptions, type DetachedTurnParts, type DetachedTurnResult, type DispatchPartsOutcome, type DraftPersistenceTuning, type DraftStoredMessage, type EmptyTurnRetryInfo, type FilePartPromotionOutcome, MAX_EMPTY_TURN_RETRIES, type ModelFailoverStreamHandle, type ModelFailoverStreamOptions, type ModelFallbackInfo, type OpenModelStream, PROMOTE_MAX_FILE_BYTES, type PromoteAgentFilePartOptions, type PromoteFilePartResult, PromptInputPart, type RawAgentFilePart, type ReadAttachmentFn, type ReadCompletedSandboxTurnOptions, type ReadSandboxMentionFn, type ResolveChatAttachmentsOptions, type ResolveChatAttachmentsResult, type SandboxChatProducerOptions, type SandboxUploadSink, UPLOAD_INLINE_MAX_BYTES, UPLOAD_MAX_FILE_BYTES, type UploadAuthorization, type UploadedChatFile, type WriteAttachmentFn, assistantRowIdForTurn, buildDispatchParts, bytesToBase64, classifyTerminalFailure, createAssistantDraftWriter, createAttachmentUploadRoute, createChatTurnRoutes, createSandboxChatProducer, createUploadRoute, defaultValidateAttachmentPath, isCommittingSandboxEvent, isDraftContentEvent, normalizeChatPromptForSandbox, promoteAgentFilePart, readCompletedSandboxTurn, resolveChatAttachments, resolveEmptyTurnRetries, rowIdOf, runDetachedTurn, sanitizeUploadFilename, sniffMimeFromName, storeSupportsDraftPersistence, streamWithModelFailover, summarizeFailoverReason, withDurableChatProjection };
+export { type AssistantDraftSnapshot, type AssistantDraftStore, type AssistantDraftWriter, type AssistantDraftWriterOptions, type AssistantRowValues, type AttachmentPathArgs, type AttachmentPathCheck, type AttachmentReadResult, type AttachmentUploadAuthorization, type AttachmentWriteResult, type BuildDispatchPartsInput, ChatAttachmentKind, type ChatRouteDurableProjection, type ChatRouteDurableProjectionLogger, type ChatRouteEvent, type ChatTurnAuthorization, type ChatTurnAuthorizeArgs, type ChatTurnCompleteInput, ChatTurnFilePartInput, type ChatTurnGateResult, type ChatTurnHeartbeat, type ChatTurnInputPatch, type ChatTurnLifecycle, type ChatTurnLifecycleComplete, type ChatTurnLifecycleError, type ChatTurnLifecycleStart, type ChatTurnLock, type ChatTurnLockResult, type ChatTurnMessageStore, type ChatTurnModelAttribution, type ChatTurnModelFailover, ChatTurnPartInput, type ChatTurnProduceArgs, ChatTurnRequestPayload, type ChatTurnRouteProducer, type ChatTurnRoutes, type ChatTurnUsage, type CompletedSandboxTurnSource, type CreateAttachmentUploadRouteOptions, type CreateChatTurnRoutesOptions, type CreateUploadRouteOptions, DEFAULT_MODEL_FIRST_RESPONSE_TIMEOUT_MS, DEFAULT_MODEL_STREAM_OPEN_TIMEOUT_MS, type DetachedTurnFinal, type DetachedTurnOptions, type DetachedTurnParts, type DetachedTurnResult, type DispatchPartsOutcome, type DraftPersistenceTuning, type DraftStoredMessage, type EmptyTurnRetryInfo, type FilePartPromotionOutcome, MAX_EMPTY_TURN_RETRIES, type ModelAttemptTimeoutCode, type ModelFailoverStreamHandle, type ModelFailoverStreamOptions, ModelFailoverTimeoutError, type ModelFallbackInfo, type OpenModelStream, PROMOTE_MAX_FILE_BYTES, type PromoteAgentFilePartOptions, type PromoteFilePartResult, PromptInputPart, type RawAgentFilePart, type ReadAttachmentFn, type ReadCompletedSandboxTurnOptions, type ReadSandboxMentionFn, type ResolveChatAttachmentsOptions, type ResolveChatAttachmentsResult, type SandboxChatProducerOptions, type SandboxUploadSink, UPLOAD_INLINE_MAX_BYTES, UPLOAD_MAX_FILE_BYTES, type UploadAuthorization, type UploadedChatFile, type WriteAttachmentFn, assistantRowIdForTurn, buildDispatchParts, bytesToBase64, classifyTerminalFailure, createAssistantDraftWriter, createAttachmentUploadRoute, createChatTurnRoutes, createSandboxChatProducer, createUploadRoute, defaultValidateAttachmentPath, isCommittingSandboxEvent, isDraftContentEvent, normalizeChatPromptForSandbox, promoteAgentFilePart, readCompletedSandboxTurn, resolveChatAttachments, resolveEmptyTurnRetries, rowIdOf, runDetachedTurn, sanitizeUploadFilename, sniffMimeFromName, storeSupportsDraftPersistence, streamWithModelFailover, summarizeFailoverReason, withDurableChatProjection };

package/dist/chat-routes/index.js

@@ -99,6 +99,7 @@ import {
   planToPersistedPart
 } from "../chunk-YJMCRXQQ.js";
 import {
+  ModelFailoverExhaustedError,
   buildModelChain,
   isUpstreamUnavailable,
   readHttpStatusHint,
@@ -883,7 +884,7 @@ function isCommittingSandboxEvent(event) {
     }
     return true;
   }
-  if (type === "start" || type === "execution.started" || type === "status" || type === "model-processing" || type === "session.created" || type === "session.updated" || type === "session.idle" || type === "step-start" || type === "step-finish" || type === "turn" || type === "warning") {
+  if (type === "start" || type === "execution.started" || type === "status" || type === "model-processing" || type === "model.processing" || type === "session.created" || type === "session.updated" || type === "session.idle" || type === "step-start" || type === "step-finish" || type === "turn" || type === "warning") {
     return false;
   }
   return true;
@@ -912,6 +913,44 @@ function classifyTerminalFailure(event) {
   const code = asString(data?.errorCode) ?? asString(data?.code);
   return { outage, reason, ...code ? { code } : {} };
 }
+var DEFAULT_MODEL_STREAM_OPEN_TIMEOUT_MS = 12e4;
+var DEFAULT_MODEL_FIRST_RESPONSE_TIMEOUT_MS = 6e4;
+var ModelFailoverTimeoutError = class extends ModelFailoverExhaustedError {
+  code;
+  model;
+  timeoutMs;
+  constructor(input) {
+    super(input.attempts);
+    this.name = "ModelFailoverTimeoutError";
+    this.code = input.code;
+    this.model = input.model;
+    this.timeoutMs = input.timeoutMs;
+    this.message = input.code === "model_stream_open_timeout" ? `Opening the model event source for ${input.model} exceeded ${input.timeoutMs}ms.` : `Model ${input.model} produced no first answer-bearing event within ${input.timeoutMs}ms.`;
+  }
+};
+function resolveTimeoutMs(value, fallback, label) {
+  if (value === void 0) return fallback;
+  if (!Number.isFinite(value) || value <= 0) {
+    throw new RangeError(`${label} must be a finite number greater than 0`);
+  }
+  return Math.max(1, Math.trunc(value));
+}
+var TIMED_OUT = /* @__PURE__ */ Symbol("model-attempt-timed-out");
+function deadlineAfter(timeoutMs) {
+  let timer;
+  const promise = new Promise((resolve) => {
+    timer = setTimeout(() => resolve(TIMED_OUT), timeoutMs);
+  });
+  return {
+    promise,
+    clear: () => {
+      if (timer !== void 0) {
+        clearTimeout(timer);
+        timer = void 0;
+      }
+    }
+  };
+}
 function isEmptyTerminalReceipt(event) {
   const record = asRecord(event);
   if (!record) return false;
@@ -940,24 +979,128 @@ async function closeIterator(iterator, log) {
 function streamWithModelFailover(options) {
   const committing = options.isCommitting ?? isCommittingSandboxEvent;
   const emptyTurnRetries = resolveEmptyTurnRetries(options.emptyTurnRetries);
+  const openTimeoutMs = resolveTimeoutMs(
+    options.openTimeoutMs,
+    DEFAULT_MODEL_STREAM_OPEN_TIMEOUT_MS,
+    "openTimeoutMs"
+  );
+  const firstResponseTimeoutMs = resolveTimeoutMs(
+    options.firstResponseTimeoutMs,
+    DEFAULT_MODEL_FIRST_RESPONSE_TIMEOUT_MS,
+    "firstResponseTimeoutMs"
+  );
   let serving;
   let trail = [];
   let fellBack = false;
   let attemptIndex = 0;
+  let finalTimeout;
   const drainOnce = async (model) => {
     attemptIndex += 1;
-    const source = await options.open({ model, attempt: attemptIndex });
-    const iterator = source[Symbol.asyncIterator]();
+    const controller = new AbortController();
+    const abort = () => {
+      if (!controller.signal.aborted) controller.abort();
+    };
+    const opening = Promise.resolve().then(() => options.open({
+      model,
+      attempt: attemptIndex,
+      signal: controller.signal
+    }));
+    const openDeadline = deadlineAfter(openTimeoutMs);
+    let opened;
+    try {
+      opened = await Promise.race([opening, openDeadline.promise]);
+    } catch (err) {
+      openDeadline.clear();
+      abort();
+      throw err;
+    }
+    if (opened === TIMED_OUT) {
+      openDeadline.clear();
+      abort();
+      void opening.then(
+        (lateSource) => {
+          try {
+            void closeIterator(lateSource[Symbol.asyncIterator](), options.log);
+          } catch (err) {
+            options.log?.("[chat-routes] closing a late model stream threw", {
+              error: err instanceof Error ? err.message : String(err)
+            });
+          }
+        },
+        (err) => {
+          options.log?.("[chat-routes] abandoned model stream open rejected after timeout", {
+            error: err instanceof Error ? err.message : String(err)
+          });
+        }
+      );
+      return {
+        outcome: {
+          committed: false,
+          error: `Opening the model event source for ${model} exceeded ${openTimeoutMs}ms`,
+          errorCode: "model_stream_open_timeout",
+          timeoutCode: "model_stream_open_timeout"
+        },
+        empty: false
+      };
+    }
+    const source = opened;
+    let iterator;
+    try {
+      iterator = source[Symbol.asyncIterator]();
+    } catch (err) {
+      openDeadline.clear();
+      abort();
+      throw err;
+    }
     const buffered = [];
+    let next;
+    try {
+      next = await Promise.race([
+        Promise.resolve(iterator.next()),
+        openDeadline.promise
+      ]);
+    } catch (err) {
+      openDeadline.clear();
+      abort();
+      void closeIterator(iterator, options.log);
+      throw err;
+    }
+    openDeadline.clear();
+    if (next === TIMED_OUT) {
+      abort();
+      void closeIterator(iterator, options.log);
+      return {
+        outcome: {
+          committed: false,
+          error: `Starting the model event source for ${model} exceeded ${openTimeoutMs}ms`,
+          errorCode: "model_stream_open_timeout",
+          timeoutCode: "model_stream_open_timeout"
+        },
+        empty: false
+      };
+    }
+    if (next.done) {
+      abort();
+      return { outcome: { committed: true, buffered, iterator: null, abort }, empty: true };
+    }
+    const firstResponseDeadline = deadlineAfter(firstResponseTimeoutMs);
     for (; ; ) {
-      const next = await iterator.next();
-      if (next.done) {
-        return { outcome: { committed: true, buffered, iterator: null }, empty: true };
-      }
       const event = next.value;
-      const failure = classifyTerminalFailure(event);
+      let failure;
+      let commits = false;
+      try {
+        failure = classifyTerminalFailure(event);
+        commits = !failure && committing(event);
+      } catch (err) {
+        firstResponseDeadline.clear();
+        abort();
+        void closeIterator(iterator, options.log);
+        throw err;
+      }
       if (failure?.outage) {
-        await closeIterator(iterator, options.log);
+        firstResponseDeadline.clear();
+        abort();
+        void closeIterator(iterator, options.log);
         return {
           outcome: {
             committed: false,
@@ -968,18 +1111,65 @@ function streamWithModelFailover(options) {
         };
       }
       buffered.push(event);
-      if (failure) return { outcome: { committed: true, buffered, iterator }, empty: false };
-      if (committing(event)) {
-        return { outcome: { committed: true, buffered, iterator }, empty: isEmptyTerminalReceipt(event) };
+      if (failure) {
+        firstResponseDeadline.clear();
+        return { outcome: { committed: true, buffered, iterator, abort }, empty: false };
+      }
+      if (commits) {
+        firstResponseDeadline.clear();
+        return { outcome: { committed: true, buffered, iterator, abort }, empty: isEmptyTerminalReceipt(event) };
+      }
+      try {
+        next = await Promise.race([
+          Promise.resolve(iterator.next()),
+          firstResponseDeadline.promise
+        ]);
+      } catch (err) {
+        firstResponseDeadline.clear();
+        abort();
+        void closeIterator(iterator, options.log);
+        throw err;
+      }
+      if (next === TIMED_OUT) {
+        firstResponseDeadline.clear();
+        abort();
+        void closeIterator(iterator, options.log);
+        return {
+          outcome: {
+            committed: false,
+            error: `Model ${model} produced no first answer-bearing event within ${firstResponseTimeoutMs}ms`,
+            errorCode: "provider_first_response_timeout",
+            timeoutCode: "provider_first_response_timeout"
+          },
+          empty: false
+        };
+      }
+      if (next.done) {
+        firstResponseDeadline.clear();
+        abort();
+        return { outcome: { committed: true, buffered, iterator: null, abort }, empty: true };
       }
     }
   };
   const probe = async (model) => {
+    finalTimeout = void 0;
     for (let retry = 0; ; retry += 1) {
       const pass = await drainOnce(model);
-      if (!pass.empty || retry >= emptyTurnRetries) return pass.outcome;
+      if (!pass.empty || retry >= emptyTurnRetries) {
+        if (!pass.outcome.committed && pass.outcome.timeoutCode) {
+          finalTimeout = {
+            code: pass.outcome.timeoutCode,
+            model,
+            timeoutMs: pass.outcome.timeoutCode === "model_stream_open_timeout" ? openTimeoutMs : firstResponseTimeoutMs
+          };
+        } else {
+          finalTimeout = void 0;
+        }
+        return pass.outcome;
+      }
       const iterator = pass.outcome.committed ? pass.outcome.iterator : null;
-      if (iterator) await closeIterator(iterator, options.log);
+      if (pass.outcome.committed) pass.outcome.abort();
+      if (iterator) void closeIterator(iterator, options.log);
       const info = { model, retry: retry + 1, remaining: emptyTurnRetries - retry - 1 };
       options.log?.("[chat-routes] turn completed with no assistant text; re-running the same model", {
         ...info
@@ -1014,11 +1204,20 @@ function streamWithModelFailover(options) {
     } catch (err) {
       const attempts = err?.attempts;
       if (Array.isArray(attempts)) trail = attempts;
+      if (err instanceof ModelFailoverExhaustedError && finalTimeout) {
+        throw new ModelFailoverTimeoutError({
+          attempts: trail,
+          ...finalTimeout
+        });
+      }
       throw err;
     }
     for (const event of handle.buffered) yield event;
     const live = handle.iterator;
-    if (!live) return;
+    if (!live) {
+      handle.abort();
+      return;
+    }
     try {
       for (; ; ) {
         const next = await live.next();
@@ -1026,6 +1225,7 @@ function streamWithModelFailover(options) {
         yield next.value;
       }
     } finally {
+      handle.abort();
       await closeIterator(live, options.log);
     }
   })();
@@ -1154,7 +1354,8 @@ function sandboxStreamFailureDiagnostic(error) {
     "Please retry. If it repeats, send these support details to the team."
   ].join("\n\n");
   const failureNote = diagnosticText ? `sandbox-stream: ${message}; ${diagnosticText}` : `sandbox-stream: ${message}`;
-  return { userMessage, failureNote };
+  const code = error instanceof ModelFailoverTimeoutError ? error.code : "sandbox.stream_failed";
+  return { userMessage, failureNote, code };
 }
 function createSandboxChatProducer(options) {
   const log = options.log ?? ((message, meta) => console.error(message, meta ?? ""));
@@ -1182,6 +1383,8 @@ function createSandboxChatProducer(options) {
       models: chain,
       open: options.openEvents,
       log,
+      ...options.openTimeoutMs !== void 0 ? { openTimeoutMs: options.openTimeoutMs } : {},
+      ...options.firstResponseTimeoutMs !== void 0 ? { firstResponseTimeoutMs: options.firstResponseTimeoutMs } : {},
       ...options.emptyTurnRetries !== void 0 ? { emptyTurnRetries: options.emptyTurnRetries } : {},
       ...options.onEmptyTurnRetry ? { onEmptyTurnRetry: options.onEmptyTurnRetry } : {},
       onFallback: (info) => {
@@ -1519,7 +1722,7 @@ ${diagnostic.userMessage}` : diagnostic.userMessage;
         type: "error",
         data: {
           message: diagnostic.userMessage,
-          code: "sandbox.stream_failed",
+          code: diagnostic.code,
           details: { failureNote: diagnostic.failureNote }
         }
       };
@@ -1712,6 +1915,8 @@ async function runDetachedTurn(opts) {
     model: opts.model,
     ...opts.fallbackModels ? { fallbackModels: opts.fallbackModels } : {},
     ...opts.modelFailover === false ? { modelFailover: false } : {},
+    ...opts.openTimeoutMs !== void 0 ? { openTimeoutMs: opts.openTimeoutMs } : {},
+    ...opts.firstResponseTimeoutMs !== void 0 ? { firstResponseTimeoutMs: opts.firstResponseTimeoutMs } : {},
     ...opts.onModelFallback ? { onModelFallback: opts.onModelFallback } : {},
     isRenderableInteraction: opts.isRenderableInteraction,
     declineInteraction: opts.declineInteraction,
@@ -2670,6 +2875,8 @@ export {
   ATTACHMENT_ACCEPT,
   ATTACHMENT_MAX_COUNT,
   ChatTurnInputError,
+  DEFAULT_MODEL_FIRST_RESPONSE_TIMEOUT_MS,
+  DEFAULT_MODEL_STREAM_OPEN_TIMEOUT_MS,
   DEFAULT_STALE_TURN_LOCK_GRACE_MS,
   DEFAULT_TERMINAL_TURN_LOCK_GRACE_MS,
   DISPATCH_MAX_MEDIA_PARTS,
@@ -2683,6 +2890,7 @@ export {
   MAX_EMPTY_TURN_RETRIES,
   MAX_TEXT_ATTACHMENT_BYTES,
   MENTION_MAX_COUNT,
+  ModelFailoverTimeoutError,
   OOXML_PRESENTATION_MACRO_ENABLED_MIME,
   OOXML_PRESENTATION_MIME,
   OOXML_SNIFFED_MIMES,