@tangle-network/agent-app 0.60.217 → 0.60.219

package/dist/runtime/gzip-request.d.ts

@@ -0,0 +1,12 @@
+/**
+ * `fetch` that gzips a large string request body before it leaves the app.
+ *
+ * A Router turn sends its whole system prompt on every model call. From a
+ * Worker in another region, a 37k-token prompt (about 150 kB of JSON) spent
+ * 118–672 ms uploading before the Router's first step (tangle-router
+ * `body_read`), because each round trip of a new connection carries only a
+ * slow-start window. Prompt JSON compresses about tenfold, so the upload fits
+ * in fewer round trips. The Tangle Router decodes `Content-Encoding: gzip` on
+ * /v1/chat/completions, /v1/messages and /v1/responses; another endpoint may not.
+ */
+export declare function gzipRequestBodies(base: typeof fetch, minBytes: number): typeof fetch;

package/dist/runtime/index.js

@@ -2,7 +2,7 @@ import {
   ProtectedModelSettlementError,
   createRouterProtectedModelPort,
   runProtectedRouterTurn
-} from "../chunk-R75P63W5.js";
+} from "../chunk-MAOTZ77B.js";
 import {
   DURABLE_HOP_BUDGET_MS,
   asksForLanguage,
@@ -24,7 +24,7 @@ import {
   turnKnowledgeInstructions,
   workspaceKnowledgeForTurn,
   workspaceTurnCheckpoints
-} from "../chunk-7LMHBLFH.js";
+} from "../chunk-NHCS55QI.js";
 import "../chunk-J63KUZBE.js";
 import {
   DEFAULT_TANGLE_BILLING_ENFORCEMENT_ENV_VAR,

package/dist/runtime/router-turn.d.ts

@@ -282,6 +282,12 @@ export interface RouterTurnOptions {
      * chat completions otherwise. A buffered turn (`stream: false`) always uses chat completions.
      */
     api?: 'auto' | 'chat' | 'responses';
+    /**
+     * Gzip a model request body of at least this many bytes (`Content-Encoding: gzip`), so a large system prompt
+     * uploads in fewer round trips. The Tangle Router accepts gzip on its model APIs; leave it unset for an
+     * endpoint that may not. Default: unset, bodies are sent as they are.
+     */
+    gzipRequestAboveBytes?: number;
 }
 /** OpenAI-compatible function names allow only `[A-Za-z0-9_-]{1,64}`; app tool names often use dots. */
 export declare function routerFunctionName(name: string): string;

package/dist/runtime/router-turn.js

@@ -11,7 +11,7 @@ import {
   turnKnowledgeInstructions,
   workspaceKnowledgeForTurn,
   workspaceTurnCheckpoints
-} from "../chunk-7LMHBLFH.js";
+} from "../chunk-NHCS55QI.js";
 import "../chunk-J63KUZBE.js";
 import "../chunk-D6UJEOZQ.js";
 import "../chunk-AMUXRAUO.js";

package/dist/sandbox/index.d.ts

@@ -7,6 +7,8 @@ import { type TangleExecutionEnvironment } from '../runtime/model';
 import { type Outcome } from './outcome';
 import type { TurnSpan, TurnTrace } from '../turn-trace/recorder';
 export { traceSandboxPromptEvents, type TraceSandboxPromptOptions } from './prompt-trace';
+import { type ReuseStateStore } from './reuse-state';
+export { createCacheReuseStore, type ReuseCacheLike, type ReuseChecks, type ReuseStateStore, type SharedReuseState } from './reuse-state';
 import { type ProfileFingerprint } from '../profile/fingerprint';
 import { type ComposeProfileBudget } from '../profile/budget';
 import { resolveModel, resolveModelSelection, backendModelFields, requireTransportableModel, SandboxModelResolutionError, type ProviderResolutionConfig, type ResolvedModel, type ModelSelection, type ModelSelectionFailure, type ModelSelectionError, type ModelSelectionSource } from './model';
@@ -214,6 +216,15 @@ export interface SandboxRuntimeConfig {
      * the box is returned. It never deletes the box.
      */
     migrateEgressPolicy?: boolean;
+    /**
+     * Where Worker isolates share what a reuse last checked on a box (its id, the
+     * exec probe, the egress read, the runtime environment delivered). A request is
+     * not promised the isolate that served the last one, so without a shared store
+     * a reuse often finds nothing to trust. Default: the runtime's Cache API when
+     * it has one; `null` keeps the state in the isolate. Holds ids, times and
+     * digests only.
+     */
+    reuseState?: ReuseStateStore | null;
     storage?: (ctx: SandboxBuildContext) => StorageConfig | undefined;
     restore?: (ctx: SandboxBuildContext) => SandboxRestoreSpec | undefined | Promise<SandboxRestoreSpec | undefined>;
     boxKey?: (scope: SandboxScope) => string;

package/dist/sandbox/index.js

@@ -41,6 +41,7 @@ import {
   buildSandboxToolPathSetupScript,
   classifySeveredStream,
   collectSandboxPromptText,
+  createCacheReuseStore,
   createD1PrewarmClaimStore,
   createD1WarmLeaseStore,
   createEscalationSpeculator,
@@ -100,7 +101,7 @@ import {
   warmBinOf,
   warmWeekdayOf,
   writeProfileFilesToBox
-} from "../chunk-4QUOPWIG.js";
+} from "../chunk-RDLOC7BJ.js";
 import {
   EGRESS_PROXY_RECOVERY_PHASE,
   EGRESS_PROXY_RECOVERY_REQUIRED,
@@ -209,6 +210,7 @@ export {
   classifySandboxTransientFailure,
   classifySeveredStream,
   collectSandboxPromptText,
+  createCacheReuseStore,
   createD1PrewarmClaimStore,
   createD1WarmLeaseStore,
   createEscalationSpeculator,

package/dist/sandbox/reuse-state.d.ts

@@ -0,0 +1,55 @@
+/**
+ * What isolates share about a running box: its id and the checks a reuse may
+ * trust (see `ReuseChecks` in `./index`).
+ *
+ * A Worker request is not promised the isolate that served the last one. Legal's
+ * sandbox lane, 8 consecutive turns on 2026-10-20, found no check from the turn
+ * before in any of them, so a trust held only in isolate memory never opened. The
+ * state is small and best effort, so it rides the Workers Cache API (one read at
+ * the start of a reuse, a write only when a check changed); a miss costs the full
+ * verification, as before.
+ *
+ * Nothing secret is stored: ids, times, and digests of the policy and the
+ * runtime environment.
+ */
+export interface ReuseChecks {
+    /** What tells one run of the box from the next (see `boxIdentity`). */
+    identity: string;
+    /** When the exec probe last passed. */
+    alive?: number;
+    /** The egress policy (normalized) the box was last read at or migrated to. */
+    egress?: {
+        key: string;
+        at: number;
+    };
+    /** The digest of the runtime environment last delivered to the box. */
+    env?: {
+        digest: string;
+        at: number;
+    };
+    /** The deferred corpus the box was last found to hold, by its hash. */
+    corpus?: {
+        hash: string;
+        at: number;
+    };
+}
+export interface SharedReuseState {
+    boxId: string;
+    checks: ReuseChecks;
+}
+/** Where isolates keep {@link SharedReuseState}, by box name. Failures are the caller's to swallow. */
+export interface ReuseStateStore {
+    load(name: string): Promise<SharedReuseState | null>;
+    save(name: string, state: SharedReuseState): Promise<void>;
+    drop(name: string): Promise<void>;
+}
+/** The slice of a Workers `Cache` this store uses. */
+export interface ReuseCacheLike {
+    match(request: Request): Promise<Response | undefined>;
+    put(request: Request, response: Response): Promise<void>;
+    delete(request: Request): Promise<boolean>;
+}
+/** A store over a Workers-style cache. The cache is opened on first use. */
+export declare function createCacheReuseStore(open: () => Promise<ReuseCacheLike>): ReuseStateStore;
+/** The runtime's own cache when it has one (a Worker does), else null. */
+export declare function workersReuseStore(): ReuseStateStore | null;

package/package.json

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