@tangle-network/agent-app 0.60.218 → 0.60.219

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.218",
+  "version": "0.60.219",
   "packageManager": "pnpm@11.24.0",
   "description": "Build agent applications with typed chat, tools, sandboxes, integrations, billing, and evaluation.",
   "keywords": [