@tangle-network/agent-app 0.47.12 → 0.47.13

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/agent-app",
-  "version": "0.47.12",
+  "version": "0.47.13",
   "packageManager": "pnpm@11.24.0",
   "description": "Build agent applications with typed chat, tools, sandboxes, integrations, billing, and evaluation.",
   "keywords": [