@tangle-network/agent-app 0.44.27 → 0.44.29

package/dist/{auth-anc7mv2W.d.ts → auth-DJs6lfAs.d.ts}

@@ -1,4 +1,4 @@
-import { a as AppToolContext } from './types-BCxK0wyS.js';
+import { A as AppToolContext } from './types-DbU-oO5h.js';
 
 /**
  * Header names carrying the server-set per-turn context + the capability token.

package/dist/chat-routes/index.d.ts

@@ -14,8 +14,8 @@ import '../contract-CEewO6DI.js';
 import '../types-DB82fktc.js';
 import '../plans/index.js';
 import '@tangle-network/sandbox';
-import '../auth-anc7mv2W.js';
-import '../types-BCxK0wyS.js';
+import '../auth-DJs6lfAs.js';
+import '../types-DbU-oO5h.js';
 import '../harness/index.js';
 import '../model-CdCDfBA9.js';
 import '../budget-BOucfcb_.js';

package/dist/chat-routes/index.js

@@ -93,7 +93,7 @@ import {
   flattenHistory,
   readSandboxBinaryBytes,
   statSandboxFileSize
-} from "../chunk-7775L5NN.js";
+} from "../chunk-BAC2B2KI.js";
 import "../chunk-LWSJK546.js";
 import "../chunk-CQZSAR77.js";
 import "../chunk-ICOHEZK6.js";

package/dist/{chunk-7775L5NN.js → chunk-BAC2B2KI.js}

@@ -304,6 +304,11 @@ function createWorkspaceSandboxConnectionHandler(opts) {
     });
   };
 }
+function sandboxSidecarProxyUrl(baseUrl, sandboxId) {
+  if (!baseUrl) throw new Error("baseUrl is required");
+  if (!sandboxId) throw new Error("sandboxId is required");
+  return new URL(`/v1/sidecar-proxy/${encodeURIComponent(sandboxId)}`, baseUrl).toString().replace(/\/+$/, "");
+}
 function createWorkspaceSandboxRuntimeProxyHandler(opts) {
   return async function handleWorkspaceSandboxRuntimeProxy({ request, params }) {
     const user = await opts.requireUser(request);
@@ -325,10 +330,7 @@ function createWorkspaceSandboxRuntimeProxyHandler(opts) {
     const runtimeConnection = await opts.getSandboxRuntimeConnection?.({ request, userId: user.id, workspaceId, sandboxId });
     const directRuntimeConnection = runtimeConnection?.runtimeUrl && runtimeConnection.authToken ? runtimeConnection : null;
     const credentials = directRuntimeConnection ? null : await opts.getSandboxApiCredentials({ request, userId: user.id, workspaceId, sandboxId });
-    const upstreamUrl = directRuntimeConnection ? new URL(encodedRuntimePath, `${directRuntimeConnection.runtimeUrl.replace(/\/+$/, "")}/`) : new URL(
-      `/v1/sandboxes/${encodeURIComponent(sandboxId)}/runtime/${encodedRuntimePath}`,
-      credentials.baseUrl
-    );
+    const upstreamUrl = directRuntimeConnection ? new URL(encodedRuntimePath, `${directRuntimeConnection.runtimeUrl.replace(/\/+$/, "")}/`) : new URL(encodedRuntimePath, `${sandboxSidecarProxyUrl(credentials.baseUrl, sandboxId)}/`);
     upstreamUrl.search = requestUrl.search;
     const headers = buildSandboxRuntimeProxyHeaders(
       request.headers,
@@ -405,17 +407,41 @@ function createWorkspaceSandboxTerminalUpgradeHandler(opts) {
     const runtimeConnection = await opts.getSandboxRuntimeConnection?.({ request, userId: user.id, workspaceId, sandboxId });
     const directRuntimeConnection = runtimeConnection?.runtimeUrl && runtimeConnection.authToken ? runtimeConnection : null;
     const credentials = directRuntimeConnection ? null : await opts.getSandboxApiCredentials({ request, userId: user.id, workspaceId, sandboxId });
-    const upstreamUrl = directRuntimeConnection ? new URL(subPath, `${directRuntimeConnection.runtimeUrl.replace(/\/+$/, "")}/`) : new URL(`/v1/sandboxes/${encodeURIComponent(sandboxId)}/runtime/${subPath}`, credentials.baseUrl);
+    const upstreamUrl = directRuntimeConnection ? new URL(subPath, `${directRuntimeConnection.runtimeUrl.replace(/\/+$/, "")}/`) : new URL(subPath, `${sandboxSidecarProxyUrl(credentials.baseUrl, sandboxId)}/`);
     upstreamUrl.search = url.search;
     const upstreamHeaders = new Headers(request.headers);
     const upstreamBearer = directRuntimeConnection?.authToken ?? credentials.apiKey;
     upstreamHeaders.set("Authorization", `Bearer ${upstreamBearer}`);
     upstreamHeaders.delete("host");
+    const browserProtocol = selectedBearerSubprotocol(request.headers.get("Sec-WebSocket-Protocol"));
     stripBearerSubprotocol(upstreamHeaders);
     const fetchImpl = opts.fetch ?? fetch;
-    return fetchImpl(upstreamUrl.toString(), { method: request.method, headers: upstreamHeaders });
+    const upstream = await fetchImpl(upstreamUrl.toString(), { method: request.method, headers: upstreamHeaders });
+    const echo = terminalUpgradeSubprotocolEcho(upstream, browserProtocol);
+    if (!echo) return upstream;
+    return new Response(null, {
+      status: echo.status,
+      statusText: echo.statusText,
+      headers: echo.headers,
+      webSocket: upstream.webSocket ?? null
+    });
   };
 }
+function terminalUpgradeSubprotocolEcho(upstream, browserProtocol) {
+  if (upstream.status !== 101 || !browserProtocol) return null;
+  if (upstream.headers.has("Sec-WebSocket-Protocol")) return null;
+  const headers = new Headers(upstream.headers);
+  headers.set("Sec-WebSocket-Protocol", browserProtocol);
+  return { status: upstream.status, statusText: upstream.statusText ?? "", headers };
+}
+function selectedBearerSubprotocol(value) {
+  if (!value) return null;
+  for (const part of value.split(",")) {
+    const protocol = part.trim();
+    if (protocol.toLowerCase().startsWith(BEARER_SUBPROTOCOL_PREFIX)) return protocol;
+  }
+  return null;
+}
 var DEFAULT_RUNTIME_PROXY_HEADERS = ["accept", "content-type", "last-event-id", "x-session-id"];
 function buildSandboxRuntimeProxyHeaders(source, sandboxApiKey, forwardHeaders = DEFAULT_RUNTIME_PROXY_HEADERS) {
   const headers = new Headers();
@@ -484,6 +510,139 @@ function validateTerminalSubject(subject) {
   if (!subject.sandboxId) throw new Error("sandboxId is required");
 }
 
+// src/sandbox/prewarm.ts
+function prewarmKey(scope) {
+  return `${scope.workspaceId}::${scope.harness}`;
+}
+function errText(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function createSandboxPrewarmer(shell, options) {
+  const mode = options.mode ?? "resume-only";
+  const claimTtlSeconds = options.claimTtlSeconds ?? 180;
+  const failureCooldownMs = options.failureCooldownMs ?? 6e4;
+  const now = options.now ?? (() => Date.now());
+  const claim = options.claim === "single-isolate-only" ? null : options.claim;
+  const inFlight = /* @__PURE__ */ new Map();
+  const failures = /* @__PURE__ */ new Map();
+  const emit = (event) => {
+    try {
+      options.onEvent?.(event);
+    } catch {
+    }
+  };
+  async function releaseClaim(key) {
+    if (!claim) return;
+    try {
+      await claim.release(key);
+    } catch {
+    }
+  }
+  async function runWarm(key, scope, holdsClaim) {
+    const startedAt = now();
+    emit({ type: "started", key, workspaceId: scope.workspaceId });
+    try {
+      const box = await ensureWorkspaceSandbox(shell, {
+        workspaceId: scope.workspaceId,
+        userId: scope.userId,
+        harness: scope.harness,
+        billingOwnerId: scope.billingOwnerId
+      });
+      const ms = now() - startedAt;
+      failures.delete(key);
+      emit({ type: "succeeded", key, workspaceId: scope.workspaceId, boxId: box.id, ms });
+      return { ok: true, boxId: box.id, ms };
+    } catch (err) {
+      const ms = now() - startedAt;
+      const error = errText(err);
+      failures.set(key, { error, until: now() + failureCooldownMs });
+      emit({ type: "failed", key, workspaceId: scope.workspaceId, error, ms });
+      return { ok: false, error, ms };
+    } finally {
+      inFlight.delete(key);
+      if (holdsClaim) await releaseClaim(key);
+    }
+  }
+  return {
+    async prewarm(scope) {
+      const key = prewarmKey(scope);
+      if (inFlight.has(key)) {
+        emit({ type: "skipped", key, workspaceId: scope.workspaceId, outcome: "already-warming" });
+        return { outcome: "already-warming" };
+      }
+      const failure = failures.get(key);
+      if (failure && now() < failure.until) {
+        emit({ type: "skipped", key, workspaceId: scope.workspaceId, outcome: "cooling-down" });
+        return { outcome: "cooling-down" };
+      }
+      let settle = () => {
+      };
+      const reservation = new Promise((resolve) => {
+        settle = resolve;
+      });
+      inFlight.set(key, reservation);
+      const abandon = (outcome) => {
+        inFlight.delete(key);
+        settle({ ok: false, error: outcome, ms: 0 });
+        emit({ type: "skipped", key, workspaceId: scope.workspaceId, outcome });
+        return { outcome };
+      };
+      try {
+        const peek = await peekWorkspaceSandbox(shell, {
+          workspaceId: scope.workspaceId,
+          userId: scope.userId
+        });
+        if (peek.status === "running") return abandon("already-running");
+        if (peek.status === "absent" && mode === "resume-only") {
+          return abandon("absent-and-resume-only");
+        }
+        if (options.shouldPrewarm) {
+          const allowed = await options.shouldPrewarm(scope);
+          if (!allowed) return abandon("declined-by-policy");
+        }
+        let holdsClaim = false;
+        if (claim) {
+          holdsClaim = await claim.acquire(key, claimTtlSeconds);
+          if (!holdsClaim) return abandon("warming-elsewhere");
+        }
+        const warm = runWarm(key, scope, holdsClaim);
+        void warm.then(settle);
+        return { outcome: "started", completion: warm };
+      } catch (err) {
+        const error = errText(err);
+        inFlight.delete(key);
+        failures.set(key, { error, until: now() + failureCooldownMs });
+        settle({ ok: false, error, ms: 0 });
+        emit({ type: "failed", key, workspaceId: scope.workspaceId, error, ms: 0 });
+        return { outcome: "cooling-down" };
+      }
+    },
+    async readiness(scope) {
+      const key = prewarmKey(scope);
+      const peek = await peekWorkspaceSandbox(shell, {
+        workspaceId: scope.workspaceId,
+        userId: scope.userId
+      });
+      if (peek.status === "running") return { status: "ready", boxId: peek.box.id };
+      if (inFlight.has(key)) return { status: "warming" };
+      if (claim?.isHeld) {
+        try {
+          if (await claim.isHeld(key)) return { status: "warming" };
+        } catch {
+        }
+      }
+      const failure = failures.get(key);
+      if (failure && now() < failure.until) {
+        return { status: "failed", error: failure.error, retryAfterMs: failure.until - now() };
+      }
+      return { status: "absent" };
+    },
+    clearFailure(scope) {
+      failures.delete(prewarmKey(scope));
+    }
+  };
+}
+
 // src/sandbox/index.ts
 var DEFAULT_SANDBOX_DIRECT_KEY_NAMES = [
   "TCLOUD_SANDBOX_API_KEY",
@@ -1726,15 +1885,19 @@ export {
   createSandboxTerminalToken,
   verifySandboxTerminalToken,
   createWorkspaceSandboxConnectionHandler,
+  sandboxSidecarProxyUrl,
   createWorkspaceSandboxRuntimeProxyHandler,
   matchSandboxTerminalWsPath,
   isSandboxTerminalWsUpgrade,
   createWorkspaceSandboxTerminalUpgradeHandler,
+  terminalUpgradeSubprotocolEcho,
+  selectedBearerSubprotocol,
   buildSandboxRuntimeProxyHeaders,
   encodeSandboxRuntimePath,
   bearerToken,
   bearerSubprotocolToken,
   terminalTokenFromRequest,
+  createSandboxPrewarmer,
   resolveSandboxClientCredentials,
   DEFAULT_SANDBOX_RESOURCES,
   getClient,
@@ -1778,4 +1941,4 @@ export {
   isTerminalPromptEvent,
   detectInteractiveQuestion
 };
-//# sourceMappingURL=chunk-7775L5NN.js.map
+//# sourceMappingURL=chunk-BAC2B2KI.js.map