@tangle-network/agent-app 0.60.218 → 0.60.219

package/dist/chat-routes/index.js

@@ -40,7 +40,7 @@ import {
   flattenHistory,
   readSandboxBinaryBytes,
   statSandboxFileSize
-} from "../chunk-4QUOPWIG.js";
+} from "../chunk-RDLOC7BJ.js";
 import "../chunk-4LBCTFBP.js";
 import {
   ModelFailoverExhaustedError,

package/dist/{chunk-4QUOPWIG.js → chunk-RDLOC7BJ.js}

@@ -165,6 +165,57 @@ async function* traceSandboxPromptEvents(events, options) {
   }
 }
 
+// src/sandbox/reuse-state.ts
+var CACHE_NAME = "agent-app-sandbox-reuse";
+var KEY_ORIGIN = "https://sandbox-reuse.agent-app.invalid/";
+var ENTRY_MAX_AGE_SECONDS = 15 * 60;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stamped(value, field) {
+  if (!isRecord(value) || typeof value.at !== "number" || typeof value[field] !== "string") return void 0;
+  return { text: value[field], at: value.at };
+}
+function parseState(value) {
+  if (!isRecord(value) || typeof value.boxId !== "string" || !isRecord(value.checks)) return null;
+  const checks = value.checks;
+  if (typeof checks.identity !== "string") return null;
+  const parsed = { identity: checks.identity };
+  if (typeof checks.alive === "number") parsed.alive = checks.alive;
+  const egress = stamped(checks.egress, "key");
+  if (egress) parsed.egress = { key: egress.text, at: egress.at };
+  const env = stamped(checks.env, "digest");
+  if (env) parsed.env = { digest: env.text, at: env.at };
+  const corpus = stamped(checks.corpus, "hash");
+  if (corpus) parsed.corpus = { hash: corpus.text, at: corpus.at };
+  return { boxId: value.boxId, checks: parsed };
+}
+function createCacheReuseStore(open) {
+  let cache;
+  const handle = async () => cache ??= await open();
+  const request = (name) => new Request(`${KEY_ORIGIN}${encodeURIComponent(name)}`);
+  return {
+    async load(name) {
+      const hit = await (await handle()).match(request(name));
+      if (!hit) return null;
+      return parseState(await hit.json());
+    },
+    async save(name, state) {
+      await (await handle()).put(request(name), new Response(JSON.stringify(state), {
+        headers: { "content-type": "application/json", "cache-control": `public, max-age=${ENTRY_MAX_AGE_SECONDS}` }
+      }));
+    },
+    async drop(name) {
+      await (await handle()).delete(request(name));
+    }
+  };
+}
+function workersReuseStore() {
+  const storage = globalThis.caches;
+  if (typeof storage?.open !== "function") return null;
+  return createCacheReuseStore(() => storage.open(CACHE_NAME));
+}
+
 // src/sandbox/model.ts
 function backendModelFields(model) {
   return {
@@ -1547,6 +1598,10 @@ var REUSE_CHECKS_MAX = 1e3;
 var reuseChecks = /* @__PURE__ */ new Map();
 var runningBoxIds = /* @__PURE__ */ new Map();
 var trustedBoxes = /* @__PURE__ */ new WeakSet();
+var reuseNames = /* @__PURE__ */ new Map();
+var savedShared = /* @__PURE__ */ new Map();
+var defaultReuseStore;
+var activeReuseStore = null;
 function boxIdentity(box) {
   const startedAt = box.startedAt instanceof Date ? box.startedAt.getTime() : Number.NaN;
   return `${Number.isFinite(startedAt) ? startedAt : ""}|${box.filesystemIncarnationId ?? ""}`;
@@ -1573,6 +1628,10 @@ function recordCheck(box, patch) {
 }
 function forgetBox(boxId) {
   reuseChecks.delete(boxId);
+  const name = reuseNames.get(boxId);
+  if (name === void 0 || !activeReuseStore) return;
+  savedShared.delete(name);
+  void Promise.resolve(activeReuseStore.drop(name)).catch(() => void 0);
 }
 function isRecent(at, ttlMs, now = Date.now()) {
   return at !== void 0 && Number.isFinite(ttlMs) && ttlMs > 0 && now - at < ttlMs;
@@ -1600,6 +1659,10 @@ function resetClientCache() {
   _cached = null;
   reuseChecks.clear();
   runningBoxIds.clear();
+  reuseNames.clear();
+  savedShared.clear();
+  defaultReuseStore = void 0;
+  activeReuseStore = null;
 }
 function buildAppToolMcpServers(options) {
   const entries = {};
@@ -2075,11 +2138,17 @@ async function listRunning(client, name) {
 function rememberRunningBox(name, box) {
   runningBoxIds.delete(name);
   runningBoxIds.set(name, box.id);
+  reuseNames.set(box.id, name);
   while (runningBoxIds.size > REUSE_CHECKS_MAX) {
     const oldest = runningBoxIds.keys().next().value;
     if (oldest === void 0) break;
     runningBoxIds.delete(oldest);
   }
+  while (reuseNames.size > REUSE_CHECKS_MAX) {
+    const oldest = reuseNames.keys().next().value;
+    if (oldest === void 0) break;
+    reuseNames.delete(oldest);
+  }
   return box;
 }
 async function getRunningBox(client, id, name) {
@@ -2612,16 +2681,57 @@ async function ensureWorkspaceSandbox(shell, options) {
   return box;
 }
 async function reuseWorkspaceSandbox(shell, options) {
-  if (options.forceNew || !hasRecentProbe(shell, options)) return void 0;
+  if (options.forceNew) return void 0;
+  await hydrateReuseState(shell, options);
+  if (!hasRecentProbe(shell, options)) return void 0;
   return claimWorkspaceSandbox(shell, options, true);
 }
+function boxNameFor(shell, options) {
+  const scope = { workspaceId: options.workspaceId, ...options.userId ? { userId: options.userId } : {} };
+  return shell.boxKey ? shell.boxKey(scope) : shell.name(options.workspaceId);
+}
 function hasRecentProbe(shell, options) {
   const probe = shell.livenessProbe;
   if (!probe || options.forceNew) return false;
-  const scope = { workspaceId: options.workspaceId, ...options.userId ? { userId: options.userId } : {} };
-  const id = runningBoxIds.get(shell.boxKey ? shell.boxKey(scope) : shell.name(options.workspaceId));
+  const id = runningBoxIds.get(boxNameFor(shell, options));
   return isRecent(id === void 0 ? void 0 : reuseChecks.get(id)?.alive, probe.cacheTtlMs ?? TRUSTED_REUSE_TTL_MS);
 }
+function reuseStoreOf(shell) {
+  if (shell.reuseState !== void 0) return shell.reuseState;
+  if (defaultReuseStore === void 0) defaultReuseStore = workersReuseStore();
+  return defaultReuseStore;
+}
+async function hydrateReuseState(shell, options) {
+  if (options.forceNew) return;
+  const store = reuseStoreOf(shell);
+  activeReuseStore = store;
+  if (!store) return;
+  const name = boxNameFor(shell, options);
+  if (runningBoxIds.has(name)) return;
+  try {
+    const shared = await store.load(name);
+    if (!shared) return;
+    runningBoxIds.set(name, shared.boxId);
+    reuseNames.set(shared.boxId, name);
+    reuseChecks.set(shared.boxId, shared.checks);
+    savedShared.set(name, JSON.stringify(shared));
+  } catch {
+  }
+}
+async function persistReuseState(shell, box) {
+  const store = reuseStoreOf(shell);
+  const name = reuseNames.get(box.id);
+  const checks = reuseChecks.get(box.id);
+  if (!store || name === void 0 || !checks) return;
+  const state = { boxId: box.id, checks };
+  const serialized = JSON.stringify(state);
+  if (savedShared.get(name) === serialized) return;
+  try {
+    await store.save(name, state);
+    savedShared.set(name, serialized);
+  } catch {
+  }
+}
 function spendGate(options) {
   let gated;
   return () => {
@@ -2637,6 +2747,7 @@ function spendGate(options) {
 async function claimWorkspaceSandbox(shell, options, reuseOnly) {
   const { trace } = options;
   const gate = spendGate(options);
+  await hydrateReuseState(shell, options);
   if (!hasRecentProbe(shell, options)) await gate();
   const claim = trace?.start("sandbox.claim", "sandbox", { "workspace.harness": options.harness }, options.traceParent);
   const traced = trace && claim ? {
@@ -2654,6 +2765,7 @@ async function claimWorkspaceSandbox(shell, options, reuseOnly) {
     }
     claim?.end({ "sandbox.id": box.id, ...trustedBoxes.has(box) ? { "sandbox.probe_trusted": true } : {} });
     if (!trustedBoxes.has(box)) await observeProvisionedBox(shell, options, box);
+    await persistReuseState(shell, box);
     return box;
   } catch (error) {
     claim?.end(void 0, error);
@@ -3579,6 +3691,7 @@ function firstQuestionText(value) {
 
 export {
   traceSandboxPromptEvents,
+  createCacheReuseStore,
   backendModelFields,
   resolveModelSelection,
   resolveModel,
@@ -3680,4 +3793,4 @@ export {
   isTerminalPromptEvent,
   detectInteractiveQuestion
 };
-//# sourceMappingURL=chunk-4QUOPWIG.js.map
+//# sourceMappingURL=chunk-RDLOC7BJ.js.map