@tangle-network/agent-app 0.46.54 → 0.46.55

package/dist/sandbox/index.d.ts

@@ -791,8 +791,8 @@ export interface DriveSandboxTurnOptions extends StreamSandboxPromptOptions {
      * starting a second agent run. */
     sessionId: string;
     /** Wall-clock cap in ms from the session's start. A still-running session past
-     * the cap is cancelled and reported `failed` — bounds an unattended run (e.g. a
-     * turn that stalled on an interactive question nothing will answer). Omit for no cap. */
+     * the cap is cancelled and reported `failed` — bounds an unattended run, such as
+     * a turn stalled on an interactive question with no consumer. Omit for no cap. */
     wallCapMs?: number;
 }
 /** Resolve a sandbox turn by processing a message with given configuration and options */

package/dist/sandbox/index.js

@@ -99,7 +99,7 @@ import {
   workspaceSandboxRecoveryMessage,
   workspaceSandboxRecoveryRecommendedActions,
   writeProfileFilesToBox
-} from "../chunk-T374KO42.js";
+} from "../chunk-LKZBMDYM.js";
 import "../chunk-MCYJON3F.js";
 import "../chunk-LWSJK546.js";
 import "../chunk-P5PIAQVS.js";

package/dist/turn-stream/adapters.d.ts

@@ -48,14 +48,14 @@ export interface TurnStreamNamespaceLike {
  * instance; `listRunning` reconnect discovery rides a per-scope index
  * instance. Drops in wherever `createD1TurnEventStore(env.DB)` would.
  *
- * KEPT and load-bearing for AUTONOMOUS work. A detached run
- * (`dispatchPrompt({ detach: true })`, `driveTurn`) executes on the sandbox
- * run/stream lane, which publishes nothing to the session event bus — a
- * `SessionGatewayClient` attached to that session sees zero turn events
- * (measured: 0 of 71 / 0 of 527 / 0 of 408 across three session-id
- * strategies). So a browser that must tail a mission step, a queue job, or
- * an inbound-email review has no SDK path; it needs these durable rows plus
- * `runDetachedTurn` (`/chat-routes`). Nothing here is deprecated.
+ * KEPT and load-bearing for AUTONOMOUS work. A detached run driven through
+ * `dispatchPrompt({ detach: true })` or `streamPrompt` executes on the sandbox
+ * run/stream lane, which publishes nothing to the session event bus on the
+ * measured path (0 of 71 / 0 of 527 / 0 of 408 across three session-id
+ * strategies). Sandbox 0.37 `driveTurn` uses the session message lane and is
+ * gateway-visible by SDK contract. A browser tailing a stream/dispatch run
+ * needs these durable rows plus `runDetachedTurn` (`/chat-routes`). Nothing
+ * here is deprecated.
  */
 export declare function createDurableObjectTurnEventStore(namespace: TurnStreamNamespaceLike): TurnEventStore;
 /** Define input parameters required to acquire a durable turn lock in a workspace thread context */
@@ -190,8 +190,8 @@ export declare function createDurableTurnLock<TContext>(options: CreateDurableTu
  * the message lane delivered 297 of 297.
  *
  * Two things this deprecation does NOT cover, both still supported:
- * DETACHED runs (no gateway fanout at all — keep `runDetachedTurn` over the
- * durable turn-event rows) and the per-workspace signals
+ * stream/dispatch DETACHED runs (keep `runDetachedTurn` over the durable
+ * turn-event rows) and the per-workspace signals
  * ({@link broadcastWorkspaceActivity} / {@link broadcastThreadCreated}).
  * A SANDBOX-FREE copilot that wants a second viewer should use `/stream`'s
  * `replayTurnEvents` (`GET /chat/stream/:turnId`), which follows a running

package/dist/turn-stream/core.d.ts

@@ -21,12 +21,15 @@
  *   | ------------------------------------ | --------------- | --------------- |
  *   | `box.streamPrompt()` (run/stream)    | 71 / 527 / 408  | 0 / 0 / 0       |
  *   | `box.session(id).sendMessage()`      | 297             | 297             |
+ *   | `box.driveTurn()` (Sandbox 0.37+)    | —               | SDK contract    |
  *
  * `POST /agents/run/stream` publishes nothing to the sidecar session event
  * bus, so a `SessionGatewayClient` attached to that session receives zero
  * turn events — three different session-id strategies all got 0, the id was
  * not the variable. `POST /agents/sessions/{id}/messages` publishes to the
  * bus and the gateway delivered every frame, byte-matching the sidecar tail.
+ * Sandbox 0.37 admits `driveTurn` through the session message lane, so the
+ * gateway can observe it. That is an SDK contract, not a new production count.
  *
  * Consequences for this module, and they cut both ways:
  *
@@ -37,12 +40,11 @@
  *    That half is `@deprecated` (see the tags on {@link createSegmentStore},
  *    {@link appendSegmentEvent}, {@link replayActiveSegment} and
  *    `broadcastTurnStreamEvent` in `./adapters`).
- * 2. DETACHED/autonomous turns are INVISIBLE to the gateway:
- *    `dispatchPrompt({ detach: true })` and `driveTurn` both go through
- *    `streamPrompt` internally, i.e. the run/stream lane, which does not fan
- *    out. A browser that must tail an unattended run still needs a buffer —
- *    `runDetachedTurn` (`/chat-routes`) over the durable turn-event rows
- *    below. That half is NOT deprecated and has no SDK replacement today.
+ * 2. Detached turns driven through `dispatchPrompt({ detach: true })` or
+ *    `streamPrompt` remain on the run/stream lane and need a buffer when a
+ *    browser must tail them. Sandbox 0.37 `driveTurn` is different: it uses
+ *    the session message lane and the gateway can observe it. The buffer
+ *    remains the path for stream/dispatch runs and has no SDK replacement.
  * 3. The LOCK and the per-workspace SIGNALS have no gateway equivalent at
  *    all (the gateway is per-session and read-only). They stay canonical.
  *
@@ -90,9 +92,9 @@ export declare function workspaceChannelKey(workspaceId: string): string;
 export declare function turnLockChannelKey(workspaceId: string, threadId: string, scope: TurnLockScope): string;
 /** Generate a storage channel key string for a given turn identifier.
  *
- *  KEPT and canonical: the DETACHED lane's durable turn-event rows live on
- *  this instance. A detached run never reaches the session gateway, so this
- *  is the only way a browser tails one. */
+ *  KEPT and canonical: durable turn-event rows for stream/dispatch detached
+ *  runs live on this instance. Those run/stream paths do not reach the
+ *  session gateway, so this is how a browser tails one. */
 export declare function turnStorageChannelKey(turnId: string): string;
 /** Generate a unique channel key string based on the provided scope identifier.
  *
@@ -121,8 +123,8 @@ export interface SegmentStore {
  *  self-heals via the final `result` event + loader revalidation).
  *
  *  @deprecated Sizes the interactive turn-rebroadcast buffer only. The
- *  DETACHED lane's durable rows (`turnEvent:` storage) are uncapped and are
- *  not affected. */
+ *  stream/dispatch detached lanes' durable rows (`turnEvent:` storage) are
+ *  uncapped and are not affected. */
 export declare const MAX_SEGMENT_EVENTS = 2000;
 /** Recent `thread.created` markers kept for late-connecting sidebars.
  *
@@ -140,7 +142,8 @@ export declare const ACTIVITY_TTL_MS: number;
  *  the browser attach with `box.mintScopedToken({ scope: 'session' })` +
  *  `SessionGatewayClient`. Sandbox-FREE turns: `/stream`'s
  *  `replayTurnEvents` (`GET /chat/stream/:turnId`) already follows a running
- *  turn from a cursor. Detached turns keep the durable turn-event rows —
+ *  turn from a cursor. Stream/dispatch detached turns keep the durable
+ *  turn-event rows —
  *  they are a different, non-deprecated lane. Removal is a major-version
  *  change; nothing is deleted here. */
 export declare function createSegmentStore(): SegmentStore;

package/dist/turn-stream/do.d.ts

@@ -16,8 +16,8 @@
  * - **turn storage** (`turn:${turnId}`) — the durable `TurnEventStore` rows +
  *   status for one buffered turn (replay survives DO eviction — this is what
  *   graduates the vertical's `turnStore` from no-op). KEPT and load-bearing:
- *   a DETACHED run never reaches the gateway, so this is the only way a
- *   browser tails autonomous work.
+ *   a stream/dispatch DETACHED run does not reach the gateway on the
+ *   measured path, so this is how a browser tails that autonomous work.
  * - **scope index** (`scope:${scopeId}`) — the running-turn index backing
  *   `TurnEventStore.listRunning` reconnect discovery. KEPT.
  *

package/dist/turn-stream/index.d.ts

@@ -41,10 +41,11 @@
  *     `productSyncEvents`) — the gateway is per-session;
  *   • the durable TURN-EVENT rows + running-turn index
  *     (`createDurableObjectTurnEventStore`) that `runDetachedTurn` streams
- *     into — a detached run (`dispatchPrompt({ detach: true })`,
- *     `driveTurn`) goes through `streamPrompt` internally, so it never
- *     reaches the gateway at all. Autonomous work a browser must tail has
- *     no other path today.
+ *     into — stream/dispatch detached runs (`dispatchPrompt({ detach: true })`,
+ *     `streamPrompt`) do not reach the gateway on the measured path. Sandbox
+ *     0.37 `driveTurn` uses the session message lane and is gateway-visible
+ *     by SDK contract. Autonomous stream/dispatch work a browser must tail
+ *     still needs the durable rows.
  *
  * DEPRECATED — duplicates the SDK:
  *   • the interactive per-turn REBROADCAST/replay on the thread channel