@tangle-network/agent-app 0.47.12 → 0.47.14

package/dist/chat-routes/model-failover-stream.d.ts

@@ -18,6 +18,14 @@
  * session — including its `step-finish` usage, which must never be billed) and
  * lets `runWithModelFailover` walk to the next model.
  *
+ * `liveLifecycleEvents` relaxes the buffer for progress only. `start`,
+ * `status`, `model-processing`, and session lifecycle carry no answer and no
+ * receipt, so a product may take them the moment they arrive and show what
+ * the turn is waiting on. Measured 2026-09-11 on a warm production box:
+ * OpenCode reports whole parts, so the buffer held every event for 16 s and
+ * the product could show nothing through provisioning and agent startup. Off
+ * by default: with it on, an abandoned model's progress stays in the stream.
+ *
  * The classification itself is `isUpstreamUnavailable` verbatim, so this path
  * inherits the measured facts from the 2026-07-25 outage — above all that an
  * outage is NOT always a thrown error: the sandbox RESOLVES a terminal `error`
@@ -81,6 +89,13 @@ interface TerminalFailure {
  * never by throwing. Both `data` and the whole record are offered to
  * `isUpstreamUnavailable` so a payload nested either way is caught.
  */
+/**
+ * Progress the consumer may see before the commit point: it names no model
+ * output and carries no billing receipt, so streaming it live cannot duplicate
+ * an answer or bill an abandoned attempt. `warning` and every
+ * `message.part.updated` (including `step-start`/`step-finish`) stay buffered.
+ */
+export declare function isLiveLifecycleEvent(event: unknown): boolean;
 export declare function classifyTerminalFailure(event: unknown): TerminalFailure | null;
 /** Open the raw turn stream for one specific model. */
 export type OpenModelStream = (args: {
@@ -118,6 +133,14 @@ export interface ModelFailoverStreamOptions {
     firstResponseTimeoutMs?: number;
     /** Override the commit-point rule. Default {@link isCommittingSandboxEvent}. */
     isCommitting?: (event: unknown) => boolean;
+    /**
+     * Stream {@link isLiveLifecycleEvent} progress to the consumer as it arrives
+     * instead of holding it until the attempt commits. Default `false`, which
+     * keeps an abandoned model's events entirely off the wire. With it on, such
+     * an event is never replayed from the buffer, and one from an abandoned
+     * attempt stays in the stream — it describes the sandbox, not the answer.
+     */
+    liveLifecycleEvents?: boolean;
     onFallback?: (info: ModelFallbackInfo) => void;
     /**
      * How many times to RE-RUN THE SAME MODEL when a turn completes having

package/dist/chat-routes/sandbox-producer.d.ts

@@ -87,6 +87,11 @@ export interface SandboxChatProducerOptions {
      *  answer-bearing event. Default 60 seconds. Processing/lifecycle events do
      *  not extend it. */
     firstResponseTimeoutMs?: number;
+    /** Forward `start`/`status`/`model-processing`/session lifecycle to the
+     *  client as it arrives instead of after the commit point, so a product can
+     *  show what a turn is waiting on. Default `false`. An abandoned model's
+     *  progress then stays on the wire; its answer and receipt never do. */
+    liveLifecycleEvents?: boolean;
     /** 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;

package/dist/{chunk-P6YXUGNA.js → chunk-3G4IUF3D.js}

@@ -1,5 +1,7 @@
 import {
-  assertHarnessModelCompatible
+  DEFAULT_HARNESS,
+  assertHarnessModelCompatible,
+  isHarness
 } from "./chunk-MCYJON3F.js";
 import {
   assertProfilePromptWithinBudget,
@@ -18,6 +20,7 @@ import {
   Sandbox
 } from "@tangle-network/sandbox/core";
 import { createHash } from "crypto";
+import { mergeAgentProfiles } from "@tangle-network/agent-interface";
 
 // src/sandbox/outcome.ts
 var ok = (value) => ({ succeeded: true, value });
@@ -2428,46 +2431,75 @@ function adaptSandboxStream(events) {
     }
   })();
 }
-async function* streamSandboxPrompt(shell, box, message, options) {
-  const harness = options?.harness ?? "opencode";
+async function resolveSandboxPromptBackend(shell, options, operation = "sandbox prompt") {
+  const initialHarness = options.harness ?? options.profile?.harness ?? DEFAULT_HARNESS;
+  if (!isHarness(initialHarness)) throw new Error(`Unsupported sandbox harness: ${initialHarness}`);
+  const extraMcp = mergeExtraMcp(
+    options.appToolMcp ?? {},
+    options.profile?.mcp ?? options.baseProfileMcp ?? {},
+    options.extraMcp
+  );
+  const compose = (harness2) => {
+    if (!shell.profile) throw new Error(`${operation}: supply a profile or a shell profile composer`);
+    return shell.profile({ systemPrompt: options.systemPrompt, extraMcp, harness: harness2 });
+  };
+  let fullProfile = options.profile ? mergeAgentProfiles(options.profile, {
+    ...options.systemPrompt !== void 0 ? { prompt: { systemPrompt: options.systemPrompt } } : {},
+    ...Object.keys(extraMcp).length > 0 ? { mcp: extraMcp } : {}
+  }) : compose(initialHarness);
+  const harness = options.harness ?? fullProfile.harness ?? DEFAULT_HARNESS;
+  if (!isHarness(harness)) throw new Error(`Unsupported sandbox harness: ${harness}`);
+  if (!options.profile && harness !== initialHarness) fullProfile = compose(harness);
+  const explicitModel = trimOrNull(options.model);
+  const profileModel = trimOrNull(fullProfile.model?.default);
+  const profileProvider = !explicitModel && profileModel ? trimOrNull(fullProfile.model?.provider) : null;
   const model = requireTransportableModel(
-    resolveModelSelection(shell.provider, {
-      model: options?.model,
-      modelApiKey: options?.modelApiKey
+    resolveModelSelection({
+      ...shell.provider,
+      providerName: trimOrNull(shell.provider?.providerName) ?? profileProvider ?? void 0
+    }, {
+      model: explicitModel ?? profileModel ?? void 0,
+      modelApiKey: options.modelApiKey
     }),
-    "streamSandboxPrompt"
+    operation
   );
-  if (model?.model) assertHarnessModelCompatible(harness, model);
-  const prompt = typeof message === "string" ? flattenHistory(message, options?.history) : mergeHistoryIntoParts(message, options?.history);
-  const appToolMcp = options?.appToolMcp ?? {};
-  const extraMcp = mergeExtraMcp(appToolMcp, options?.baseProfileMcp ?? {}, options?.extraMcp);
-  const fullProfile = shell.profile({ systemPrompt: options?.systemPrompt, extraMcp, harness });
-  const profile = shell.deferProfileFiles ? splitDeferredProfileFiles(fullProfile).leanProfile : fullProfile;
-  const profileWithLimits = applyPromptTokenLimits(
-    attachReasoningEffort(profile, harness, options?.effort),
+  if (model) assertHarnessModelCompatible(harness, {
+    ...model,
+    provider: profileProvider ?? model.provider
+  });
+  const selectedProfile = {
+    ...fullProfile,
+    harness,
+    ...model ? { model: { ...fullProfile.model, default: model.model } } : {}
+  };
+  const executionProfile = shell.deferProfileFiles && !options.profile ? splitDeferredProfileFiles(selectedProfile).leanProfile : selectedProfile;
+  const profile = applyPromptTokenLimits(
+    attachReasoningEffort(executionProfile, harness, options.effort),
     {
-      maxVisibleOutputTokens: options?.maxOutputTokens,
-      maxReasoningTokens: options?.maxReasoningTokens,
-      maxTotalOutputTokens: options?.maxTotalOutputTokens
+      maxVisibleOutputTokens: options.maxOutputTokens,
+      maxReasoningTokens: options.maxReasoningTokens,
+      maxTotalOutputTokens: options.maxTotalOutputTokens
     }
   );
   assertProfilePromptWithinBudget(
-    profileWithLimits,
+    profile,
     shell.promptBudget ?? {},
-    "streamSandboxPrompt profile systemPrompt",
+    `${operation} profile systemPrompt`,
     SHELL_PROMPT_BUDGET_HINT
   );
-  if (options?.onProfileResolved) {
-    options.onProfileResolved(
-      await fingerprintAgentProfile(profileWithLimits, { model: model?.model, harness })
-    );
+  if (options.onProfileResolved) {
+    options.onProfileResolved(await fingerprintAgentProfile(profile, { model: model?.model, harness }));
   }
-  const backend = {
+  return {
     type: harness,
-    profile: profileWithLimits,
+    profile,
     ...model ? { model } : {},
-    ...options?.interactions ? { interactions: options.interactions } : {}
+    ...options.interactions ? { interactions: options.interactions } : {}
   };
+}
+async function* streamSandboxPrompt(shell, box, message, options) {
+  const backend = await resolveSandboxPromptBackend(shell, options ?? {}, "streamSandboxPrompt");
+  const prompt = typeof message === "string" ? flattenHistory(message, options?.history) : mergeHistoryIntoParts(message, options?.history);
   const stream = options?.detach ? detachedSandboxPromptEvents(box, prompt, options, backend) : box.streamPrompt(prompt, {
     sessionId: options?.sessionId,
     executionId: options?.executionId,
@@ -2625,31 +2657,8 @@ async function mintSandboxScopedToken(box, options) {
   }
 }
 async function driveSandboxTurn(shell, box, message, options) {
-  const harness = options.harness ?? "opencode";
-  const model = requireTransportableModel(
-    resolveModelSelection(shell.provider, {
-      model: options.model,
-      modelApiKey: options.modelApiKey
-    }),
-    "driveSandboxTurn"
-  );
-  if (model?.model) assertHarnessModelCompatible(harness, model);
+  const backend = await resolveSandboxPromptBackend(shell, options, "driveSandboxTurn");
   const prompt = typeof message === "string" ? flattenHistory(message, options.history) : mergeHistoryIntoParts(message, options.history);
-  const appToolMcp = options.appToolMcp ?? {};
-  const extraMcp = mergeExtraMcp(appToolMcp, options.baseProfileMcp ?? {}, options.extraMcp);
-  const fullProfile = shell.profile({ systemPrompt: options.systemPrompt, extraMcp, harness });
-  const executionProfile = shell.deferProfileFiles ? splitDeferredProfileFiles(fullProfile).leanProfile : fullProfile;
-  const profile = attachReasoningEffort(
-    executionProfile,
-    harness,
-    options.effort
-  );
-  assertProfilePromptWithinBudget(
-    profile,
-    shell.promptBudget ?? {},
-    "driveSandboxTurn profile systemPrompt",
-    SHELL_PROMPT_BUDGET_HINT
-  );
   try {
     const drive = await box.driveTurn(prompt, {
       sessionId: options.sessionId,
@@ -2660,12 +2669,7 @@ async function driveSandboxTurn(shell, box, message, options) {
       // Sandbox 0.37 drives through the session message lane, so a gateway
       // consumer can handle these events. Callers without one should omit
       // interactions so the run stays unattended.
-      backend: {
-        type: harness,
-        profile,
-        ...model ? { model } : {},
-        ...options.interactions ? { interactions: options.interactions } : {}
-      }
+      backend
     });
     emitSandboxActivity(options.spend, box);
     return ok(drive);
@@ -2801,6 +2805,7 @@ export {
   attachReasoningEffort,
   applyPromptTokenLimits,
   adaptSandboxStream,
+  resolveSandboxPromptBackend,
   streamSandboxPrompt,
   collectSandboxPromptText,
   runSandboxPrompt,
@@ -2816,4 +2821,4 @@ export {
   isTerminalPromptEvent,
   detectInteractiveQuestion
 };
-//# sourceMappingURL=chunk-P6YXUGNA.js.map
+//# sourceMappingURL=chunk-3G4IUF3D.js.map