openpond 0.0.40 → 0.0.42

package/dist/chunks/{chunk-34U5C7ZD.js → chunk-UNNPZEFB.js}

@@ -33,14 +33,14 @@ import {
   truncatePatch,
   uniqueSortedPaths,
   workspaceImageContentType
-} from "./chunk-HHALVXPK.js";
+} from "./chunk-KWZJAKIR.js";
 import {
   HOSTED_CHAT_SYSTEM_PROMPT,
   VERSION,
   event,
   now,
   textFromUnknown
-} from "./chunk-CZG4XKVF.js";
+} from "./chunk-SGWTAB4R.js";
 import {
   AppPreferencesSchema,
   ApplyCreateImproveRunActionRequestSchema,
@@ -160,6 +160,8 @@ import {
   ImprovementRouteDecisionSchema,
   OPENPOND_MANIFEST_FILE_NAME,
   RefinementTriggerDecisionSchema,
+  SANDBOX_TEMPLATE_PREVIEW_PORT_MAX,
+  SANDBOX_TEMPLATE_PREVIEW_PORT_MIN,
   WorkEvidenceReceiptSchema,
   WorkFeedbackReceiptSchema,
   WorkProcessTraceSchema,
@@ -16140,6 +16142,3678 @@ var MUTATING_WORKSPACE_TOOL_ACTIONS = [
   "work_agent_package_install"
 ];
 
+// ../../packages/sdk/dist/index.js
+function createSandboxRuntimeNamespace(client) {
+  return {
+    list: (input = {}) => client.listSandboxRuntimes(input),
+    create: (input) => client.createSandboxRuntime(input),
+    handle: (runtimeId, initial = null) => client.sandboxRuntime(runtimeId, initial),
+    get: (runtimeId) => client.getSandboxRuntime(runtimeId),
+    createSandbox: (runtimeId, input = {}, options = {}) => client.createSandboxRuntimeSandbox(runtimeId, input, options),
+    updateStatus: (runtimeId, input) => client.updateSandboxRuntimeStatus(runtimeId, input),
+    events: (runtimeId) => client.listSandboxRuntimeEvents(runtimeId),
+    event: (runtimeId, input) => client.emitSandboxRuntimeEvent(runtimeId, input),
+    checkpoint: (runtimeId, input = {}) => client.checkpointSandboxRuntime(runtimeId, input),
+    promote: (runtimeId, input, options = {}) => client.promoteSandboxRuntime(runtimeId, input, options),
+    preserveSource: (runtimeId, input = {}, options = {}) => client.preserveSandboxRuntimeSource(runtimeId, input, options)
+  };
+}
+function createSandboxNamespace(client) {
+  return {
+    list: (input = {}) => client.list(input),
+    create: (input) => client.create(input),
+    get: (sandboxId) => client.get(sandboxId),
+    pricing: () => client.pricing(),
+    costs: (input = {}) => client.costs(input)
+  };
+}
+function createSandboxProjectNamespace(client) {
+  return {
+    list: (input) => client.listProjects(input),
+    upsert: (input) => client.upsertProject(input),
+    upsertGitRemote: (input) => client.upsertProjectGitRemote(input),
+    get: (projectId, input) => client.getProject(projectId, input),
+    update: (projectId, input) => client.updateProject(projectId, input),
+    sync: (projectId, input) => client.syncProject(projectId, input),
+    ensureGitRemote: (projectId, input) => client.ensureProjectGitRemote(projectId, input),
+    getGitRemote: (projectId, input) => client.ensureProjectGitRemote(projectId, input),
+    git: (projectId, input) => client.ensureProjectGitRemote(projectId, input),
+    uploadSource: (projectId, input) => client.uploadProjectSource(projectId, input),
+    archive: (projectId, input) => client.archiveProject(projectId, input)
+  };
+}
+function createSandboxProfileNamespace(client) {
+  return {
+    get: (input) => client.getHostedProfile(input),
+    status: (input) => client.getHostedProfile(input),
+    ensureHosted: (input) => client.ensureHostedProfile(input),
+    push: (input) => client.pushHostedProfile(input)
+  };
+}
+function createSandboxAgentNamespace(client) {
+  return {
+    list: (input) => client.listAgents(input),
+    upsert: (input) => client.upsertAgent(input),
+    get: (agentId, input) => client.getAgent(agentId, input),
+    update: (agentId, input) => client.updateAgent(agentId, input),
+    archive: (agentId, input) => client.archiveAgent(agentId, input),
+    run: (agentId, input) => client.runAgent(agentId, input),
+    sourceDeployPlan: (agentId, input) => client.getAgentSourceDeployPlan(agentId, input),
+    manifestSnapshots: (agentId, input) => client.listAgentManifestSnapshots(agentId, input),
+    requestSourceChecks: (agentId, input) => client.requestAgentSourceChecks(agentId, input),
+    publishSource: (agentId, input) => client.publishAgentSource(agentId, input)
+  };
+}
+function createSandboxRuntimeHandle(client, runtimeId, initial = null) {
+  const currentSandbox = async (input = {}, options = {}) => {
+    const runtime = await client.getSandboxRuntime(runtimeId);
+    if (runtime.sandboxId) {
+      return client.get(runtime.sandboxId);
+    }
+    return client.createSandboxRuntimeSandbox(runtimeId, input, options).then((payload) => payload.sandbox);
+  };
+  const resume = async (input = {}, options = {}) => {
+    const runtime = await client.getSandboxRuntime(runtimeId);
+    if (!runtime.sandboxId) {
+      return client.createSandboxRuntimeSandbox(runtimeId, input, options).then((payload) => payload.sandbox);
+    }
+    const sandbox = await client.get(runtime.sandboxId);
+    if (sandbox.state === "stopped") {
+      return client.start(sandbox.id, options).then((payload) => payload.sandbox);
+    }
+    if (sandbox.state === "archived") {
+      return client.restore(sandbox.id).then((payload) => payload.sandbox);
+    }
+    if (sandbox.state === "deleted" || sandbox.state === "error") {
+      return client.createSandboxRuntimeSandbox(runtimeId, input, options).then((payload) => payload.sandbox);
+    }
+    return sandbox;
+  };
+  const checkpointHint = (input = {}) => client.emitSandboxRuntimeEvent(runtimeId, {
+    type: "workflow.checkpoint_hint",
+    summary: input.summary ?? input.reason ?? "Workflow checkpoint hint",
+    payload: {
+      ...input.payload,
+      reason: input.reason ?? null
+    },
+    artifactRefs: input.artifactRefs,
+    lifecycleHint: {
+      kind: "checkpoint",
+      reason: input.reason ?? null
+    }
+  });
+  const waitForUser = async (input = {}) => {
+    await client.emitSandboxRuntimeEvent(runtimeId, {
+      type: "workflow.waiting_for_user",
+      summary: input.summary ?? input.reason ?? "Waiting for user",
+      payload: {
+        ...input.payload,
+        reason: input.reason ?? null
+      },
+      lifecycleHint: {
+        kind: "waiting_for_user",
+        reason: input.reason ?? null
+      }
+    });
+    const current = await client.getSandboxRuntime(runtimeId);
+    if (current.status === "waiting_for_user")
+      return current;
+    return client.updateSandboxRuntimeStatus(runtimeId, {
+      status: "waiting_for_user",
+      expectedVersion: current.version,
+      summary: input.summary ?? input.reason,
+      metadata: {
+        workflowWaitForUserReason: input.reason ?? null
+      }
+    });
+  };
+  const keepAlive = (input = {}) => {
+    const keepaliveUntil = runtimeKeepaliveUntilIso(input);
+    return client.emitSandboxRuntimeEvent(runtimeId, {
+      type: "workflow.keepalive",
+      summary: input.summary ?? input.reason ?? "Workflow keepalive",
+      payload: {
+        ...input.payload,
+        reason: input.reason ?? null,
+        keepaliveUntil
+      },
+      lifecycleHint: {
+        kind: "keepalive",
+        reason: input.reason ?? null,
+        keepaliveUntil
+      }
+    });
+  };
+  return {
+    id: runtimeId,
+    initial,
+    get: () => client.getSandboxRuntime(runtimeId),
+    sandbox: currentSandbox,
+    resume,
+    createSandbox: (input = {}, options = {}) => client.createSandboxRuntimeSandbox(runtimeId, input, options),
+    status: async (input) => {
+      if (typeof input !== "string") {
+        return client.updateSandboxRuntimeStatus(runtimeId, input);
+      }
+      const current = await client.getSandboxRuntime(runtimeId);
+      return client.updateSandboxRuntimeStatus(runtimeId, {
+        status: input,
+        expectedVersion: current.version
+      });
+    },
+    events: () => client.listSandboxRuntimeEvents(runtimeId),
+    event: (input) => client.emitSandboxRuntimeEvent(runtimeId, input),
+    recordCommit: (commitSha, input = {}) => client.emitSandboxRuntimeEvent(runtimeId, {
+      ...input,
+      type: input.type ?? "git.commit",
+      commitSha
+    }),
+    checkpointHint,
+    waitForUser,
+    keepAlive,
+    checkpoint: (input) => client.checkpointSandboxRuntime(runtimeId, input),
+    files: {
+      write: async (path37, contents) => client.uploadFile((await resume()).id, path37, contents),
+      read: async (path37) => client.downloadFile((await resume()).id, path37),
+      readResponse: async (input) => client.downloadFileResponse((await resume()).id, input),
+      list: async (input = {}) => client.listFiles((await resume()).id, input),
+      delete: async (path37, input = {}) => client.deleteFile((await resume()).id, path37, input),
+      search: async (input) => client.searchFiles((await resume()).id, input),
+      stat: async (path37) => client.statFile((await resume()).id, path37),
+      mkdir: async (input) => client.mkdir((await resume()).id, input),
+      move: async (input) => client.moveFile((await resume()).id, input)
+    },
+    commands: {
+      run: async (command) => client.exec((await resume()).id, typeof command === "string" ? { command } : command)
+    },
+    ports: {
+      expose: async (port) => client.openPort((await resume()).id, typeof port === "number" ? { port } : port)
+    },
+    promote: (input, options = {}) => client.promoteSandboxRuntime(runtimeId, input, options),
+    preserveSource: (input = {}, options = {}) => client.preserveSandboxRuntimeSource(runtimeId, input, options),
+    archive: async (expectedVersion) => {
+      const version = expectedVersion ?? (await client.getSandboxRuntime(runtimeId)).version;
+      return client.updateSandboxRuntimeStatus(runtimeId, {
+        status: "archived",
+        expectedVersion: version
+      });
+    }
+  };
+}
+function runtimeKeepaliveUntilIso(input) {
+  if (input?.until instanceof Date) {
+    return input.until.toISOString();
+  }
+  if (typeof input?.until === "string" && input.until.trim()) {
+    return new Date(input.until).toISOString();
+  }
+  const seconds = typeof input?.seconds === "number" && Number.isFinite(input.seconds) ? Math.max(1, Math.trunc(input.seconds)) : 60;
+  return new Date(Date.now() + seconds * 1e3).toISOString();
+}
+async function runSandboxSmoke(client, options = {}) {
+  const runId = `openpond-code-smoke-${Date.now()}`;
+  const expectedExec = `openpond-code-exec-ok:${runId}`;
+  const expectedPreview = `openpond-code-preview-ok:${runId}`;
+  const expectedFile = `openpond-code-file-ok:${runId}`;
+  const previewPort = 4173;
+  let sandboxId = null;
+  let forkSandboxId = null;
+  let deleted = false;
+  let forkDeleted = false;
+  try {
+    const sandbox = await waitForCreateReady(client, await client.create({
+      repo: options.repo ?? "https://github.com/octocat/Hello-World",
+      resources: {
+        cpu: options.cpu ?? 1,
+        memoryGb: options.memoryGb ?? 1,
+        diskGb: options.diskGb ?? 8
+      },
+      budget: { maxUsd: options.budgetUsd ?? "0.05" },
+      quotas: {
+        maxSpendUsd: options.budgetUsd ?? "0.05",
+        maxDurationSeconds: 600,
+        idleTimeoutSeconds: 600,
+        maxOpenPorts: 2
+      },
+      metadata: {
+        runId,
+        source: "openpond-code-sandbox-smoke"
+      }
+    }, { async: true }));
+    sandboxId = sandbox.id;
+    const expectedMppMode = options.expectedMppMode;
+    if (expectedMppMode && sandbox.reservation.mpp?.mode !== expectedMppMode) {
+      throw new Error(`expected ${expectedMppMode} reservation, got ${sandbox.reservation.mpp?.mode ?? "none"}`);
+    }
+    if (!expectedMppMode && !sandbox.reservation.mpp?.mode) {
+      throw new Error("expected sandbox reservation MPP metadata");
+    }
+    const exec = await client.exec(sandbox.id, {
+      command: [
+        `printf '${expectedExec}\\n'`,
+        "test -f README && printf 'repo-clone-ok\\n'",
+        "cat > server.cjs <<'EOF'",
+        "const { createServer } = require('node:http');",
+        `createServer((_request, response) => response.end('${expectedPreview}')).listen(${previewPort}, '0.0.0.0');`,
+        "EOF",
+        "nohup node server.cjs > server.log 2>&1 & sleep 1"
+      ].join("\n"),
+      timeoutSeconds: 120
+    });
+    if (exec.command.status !== "succeeded") {
+      throw new Error(`expected command success, got ${exec.command.status}`);
+    }
+    if (!exec.command.output.includes(expectedExec)) {
+      throw new Error("expected exec marker");
+    }
+    await client.uploadFile(sandbox.id, "openpond-code-smoke.txt", expectedFile);
+    const downloaded = await client.downloadFile(sandbox.id, "openpond-code-smoke.txt");
+    if (downloaded !== expectedFile) {
+      throw new Error("expected file roundtrip marker");
+    }
+    let snapshotId = null;
+    if (options.snapshot || options.fork) {
+      const snapshotResponse = await client.createSnapshot(sandbox.id, {
+        async: true,
+        name: `openpond-code-smoke-${runId}`,
+        replay: {
+          entrypoints: [
+            {
+              command: "cat openpond-code-smoke.txt",
+              name: "default"
+            }
+          ],
+          retention: {
+            class: "pinned"
+          },
+          safety: {
+            cleanup: "delete",
+            idleTimeoutSeconds: 600,
+            internetEgress: "block",
+            maxDurationSeconds: 600,
+            maxSpendUsd: options.budgetUsd ?? "0.05",
+            publicPreview: false
+          },
+          validation: {
+            commands: [
+              {
+                command: "test -f openpond-code-smoke.txt"
+              }
+            ]
+          }
+        }
+      });
+      const snapshot = snapshotResponse.snapshot ?? (await waitForSnapshotReady(client, sandbox.id, snapshotResponse.snapshotJob?.snapshotId)).snapshot;
+      snapshotId = snapshot.id;
+      if (snapshot.state !== "ready") {
+        throw new Error(`expected ready snapshot, got ${snapshot.state}`);
+      }
+    }
+    if (options.fork) {
+      if (!snapshotId) {
+        throw new Error("expected snapshot id before fork");
+      }
+      const forked = await waitForCreateReady(client, (await client.forkSnapshot(snapshotId, {
+        budget: { maxUsd: options.budgetUsd ?? "0.05" },
+        metadata: {
+          source: "openpond-code-sandbox-smoke-fork",
+          templateSnapshotId: snapshotId
+        }
+      }, { async: true })).sandbox);
+      forkSandboxId = forked.id;
+      const forkExec = await client.exec(forked.id, {
+        command: "cat openpond-code-smoke.txt",
+        timeoutSeconds: 120
+      });
+      if (forkExec.command.status !== "succeeded") {
+        throw new Error(`expected fork command success, got ${forkExec.command.status}`);
+      }
+      if (!forkExec.command.output.includes(expectedFile)) {
+        throw new Error("expected fork snapshot marker");
+      }
+      if (!options.keep) {
+        await deleteSandboxForSmoke(client, forked.id);
+        forkDeleted = true;
+      }
+    }
+    let previewStatus = null;
+    if (options.preview !== false) {
+      const opened = await client.openPort(sandbox.id, {
+        label: "openpond-code-smoke",
+        port: previewPort
+      });
+      const preview = await fetch(opened.preview.url);
+      previewStatus = preview.status;
+      const body = await preview.text();
+      if (preview.status !== 200) {
+        throw new Error(`expected preview HTTP 200, got ${preview.status}`);
+      }
+      if (!body.includes(expectedPreview)) {
+        throw new Error("expected preview marker");
+      }
+    }
+    const { sandbox: readback, receipts } = await stopSandboxForSmoke(client, sandbox.id);
+    if (!options.keep) {
+      await deleteSandboxForSmoke(client, sandbox.id);
+      deleted = true;
+    }
+    return {
+      deleted,
+      execOutput: exec.command.output.trim(),
+      fileRoundtrip: true,
+      forkSandboxId,
+      previewStatus,
+      receiptRefs: receipts.map((receipt) => receipt.mpp.receiptRef ?? null),
+      reservationRef: sandbox.reservation.mpp?.reservationRef ?? null,
+      runId,
+      sandboxId: sandbox.id,
+      snapshotId,
+      state: readback.state
+    };
+  } finally {
+    if (forkSandboxId && !options.keep && !forkDeleted) {
+      await cleanupSandboxBestEffort(client, forkSandboxId);
+    }
+    if (sandboxId && !options.keep && !deleted) {
+      await cleanupSandboxBestEffort(client, sandboxId);
+    }
+  }
+}
+async function stopSandboxForSmoke(client, sandboxId) {
+  try {
+    await client.stop(sandboxId);
+  } catch {
+    await client.stop(sandboxId, { async: true });
+  }
+  const sandbox = await waitForSandboxState(client, sandboxId, /* @__PURE__ */ new Set(["stopped", "deleted"]), "stop");
+  const receipts = await waitForReceipts(client, sandboxId);
+  if (receipts.length === 0) {
+    throw new Error("expected receipt readback");
+  }
+  return { sandbox, receipts };
+}
+async function deleteSandboxForSmoke(client, sandboxId) {
+  try {
+    const deleted = await client.delete(sandboxId);
+    if (deleted.state === "deleted") {
+      return deleted;
+    }
+    await client.delete(sandboxId, { async: true });
+  } catch {
+    await client.delete(sandboxId, { async: true });
+  }
+  return waitForSandboxState(client, sandboxId, /* @__PURE__ */ new Set(["deleted"]), "delete");
+}
+async function cleanupSandboxBestEffort(client, sandboxId) {
+  try {
+    await deleteSandboxForSmoke(client, sandboxId);
+  } catch {
+    await client.delete(sandboxId, { async: true }).catch(() => void 0);
+  }
+}
+async function waitForSandboxState(client, sandboxId, targetStates, operation) {
+  const timeoutMs = 5 * 6e4;
+  const pollMs = 3e3;
+  const deadline = Date.now() + timeoutMs;
+  let latest = await client.get(sandboxId);
+  while (Date.now() < deadline) {
+    if (targetStates.has(latest.state)) {
+      return latest;
+    }
+    if (latest.state === "error") {
+      throw new Error(`sandbox ${operation} failed: ${sandboxId}`);
+    }
+    await sleep2(pollMs);
+    latest = await client.get(sandboxId);
+  }
+  throw new Error(`sandbox ${operation} did not reach ${[...targetStates].join("/")} before timeout: ${sandboxId} (${latest.state})`);
+}
+async function waitForReceipts(client, sandboxId) {
+  const timeoutMs = 2 * 6e4;
+  const pollMs = 3e3;
+  const deadline = Date.now() + timeoutMs;
+  let receipts = await client.receipts(sandboxId);
+  while (Date.now() < deadline) {
+    if (receipts.length > 0) {
+      return receipts;
+    }
+    await sleep2(pollMs);
+    receipts = await client.receipts(sandboxId);
+  }
+  return receipts;
+}
+async function waitForCreateReady(client, sandbox) {
+  if (sandbox.state === "running" || sandbox.state === "stopped") {
+    return sandbox;
+  }
+  if (sandbox.state === "error") {
+    throw new Error(`sandbox create failed: ${sandbox.id}
+${sandbox.logs.join("\n")}`);
+  }
+  const timeoutMs = 12 * 6e4;
+  const pollMs = 3e3;
+  const deadline = Date.now() + timeoutMs;
+  let latest = sandbox;
+  while (Date.now() < deadline) {
+    await sleep2(pollMs);
+    latest = await client.get(sandbox.id);
+    if (latest.state === "running" || latest.state === "stopped") {
+      return latest;
+    }
+    if (latest.state === "error") {
+      throw new Error(`sandbox create failed: ${latest.id}
+${latest.logs.join("\n")}`);
+    }
+  }
+  throw new Error(`sandbox create did not reach running state before timeout: ${latest.id} (${latest.state})`);
+}
+async function waitForSnapshotReady(client, sandboxId, snapshotId) {
+  if (!snapshotId) {
+    throw new Error("snapshot job did not return snapshot id");
+  }
+  const timeoutMs = 12 * 6e4;
+  const pollMs = 3e3;
+  const deadline = Date.now() + timeoutMs;
+  let latest = await client.get(sandboxId);
+  while (Date.now() < deadline) {
+    const snapshot = latest.snapshots?.find((item) => item.id === snapshotId);
+    if (snapshot?.state === "ready") {
+      return { sandbox: latest, snapshot };
+    }
+    const job = latest.snapshotJobs?.find((item) => item.snapshotId === snapshotId);
+    if (job?.status === "failed") {
+      throw new Error(`snapshot job failed: ${job.error ?? snapshotId}`);
+    }
+    await sleep2(pollMs);
+    latest = await client.get(sandboxId);
+  }
+  throw new Error(`snapshot did not reach ready state before timeout: ${snapshotId}`);
+}
+function sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function asyncRequestHeaders(options = {}) {
+  return options.async || options.respondAsync ? { Prefer: "respond-async" } : void 0;
+}
+var VERCEL_PROTECTION_BYPASS_HEADER = "x-vercel-protection-bypass";
+function withVercelProtectionBypass2(requestUrl, inputHeaders, env = typeof process === "undefined" ? {} : process.env) {
+  const headers = new Headers(inputHeaders);
+  const secret = env.VERCEL_AUTOMATION_BYPASS_SECRET?.trim();
+  if (!secret || !isOpenPondStagingUrl(requestUrl))
+    return headers;
+  headers.set(VERCEL_PROTECTION_BYPASS_HEADER, secret);
+  return headers;
+}
+function isOpenPondStagingUrl(requestUrl) {
+  try {
+    const hostname = new URL(requestUrl).hostname.toLowerCase();
+    return hostname === "staging.openpond.ai" || hostname === "staging-api.openpond.ai" || hostname.endsWith(".staging-api.openpond.ai");
+  } catch {
+    return false;
+  }
+}
+var DEFAULT_API_TIMEOUT_MS = 3e4;
+var DEFAULT_API_RESPONSE_BYTES = 8 * 1024 * 1024;
+var LONG_STREAM_API_OPTIONS = { timeoutMs: 15 * 60 * 1e3, maxResponseBytes: 64 * 1024 * 1024 };
+var ApiTimeoutError = class extends Error {
+  timeoutMs;
+  requestUrl;
+  code = "OPENPOND_API_TIMEOUT";
+  constructor(timeoutMs, requestUrl) {
+    super(`API request timed out after ${timeoutMs}ms: ${requestUrl}`);
+    this.timeoutMs = timeoutMs;
+    this.requestUrl = requestUrl;
+    this.name = "ApiTimeoutError";
+  }
+};
+var ApiResponseTooLargeError = class extends Error {
+  maximumBytes;
+  requestUrl;
+  code = "OPENPOND_API_RESPONSE_TOO_LARGE";
+  constructor(maximumBytes, requestUrl) {
+    super(`API response exceeded ${maximumBytes} bytes: ${requestUrl}`);
+    this.maximumBytes = maximumBytes;
+    this.requestUrl = requestUrl;
+    this.name = "ApiResponseTooLargeError";
+  }
+};
+var OpenPondApiError = class extends Error {
+  status;
+  apiMessage;
+  code;
+  constructor(status, errorCode, label, apiMessage = null) {
+    const detail = apiMessage || errorCode;
+    super(`${label} failed: ${status}${detail ? ` ${detail}` : ""}`);
+    this.status = status;
+    this.apiMessage = apiMessage;
+    this.name = "OpenPondApiError";
+    this.code = errorCode || "OPENPOND_API_ERROR";
+  }
+};
+async function apiFetch2(baseUrl, token, requestPath, options = {}) {
+  const { timeoutMs = DEFAULT_API_TIMEOUT_MS, maxResponseBytes = DEFAULT_API_RESPONSE_BYTES, ...init } = options;
+  const requestUrl = `${baseUrl}${requestPath}`;
+  const headers = withVercelProtectionBypass2(requestUrl, init.headers);
+  headers.set("Content-Type", "application/json");
+  const apiKey = process.env.OPENPOND_API_KEY;
+  const trimmedToken = token?.trim() || "";
+  const tokenIsApiKey = trimmedToken.startsWith("opk_");
+  const effectiveApiKey = apiKey || (tokenIsApiKey ? trimmedToken : null);
+  if (effectiveApiKey && !headers.has("openpond-api-key"))
+    headers.set("openpond-api-key", effectiveApiKey);
+  if (token) {
+    headers.set("Authorization", tokenIsApiKey ? `ApiKey ${trimmedToken}` : `Bearer ${token}`);
+  } else if (apiKey && !headers.has("Authorization")) {
+    headers.set("Authorization", `ApiKey ${apiKey}`);
+  }
+  const timeoutController = new AbortController();
+  const timeoutError = new ApiTimeoutError(timeoutMs, requestUrl);
+  const timer = timeoutMs > 0 ? setTimeout(() => timeoutController.abort(timeoutError), timeoutMs) : null;
+  timer?.unref?.();
+  const signal = composedSignal(init.signal, timeoutController.signal, timeoutMs);
+  const cleanup = () => {
+    if (timer)
+      clearTimeout(timer);
+  };
+  try {
+    const response = await fetch(requestUrl, { ...init, headers, signal });
+    return boundedResponse(response, {
+      cleanup,
+      maximumBytes: maxResponseBytes,
+      requestUrl,
+      timeoutController,
+      timeoutError
+    });
+  } catch (error) {
+    cleanup();
+    if (timeoutController.signal.aborted)
+      throw timeoutError;
+    throw error;
+  }
+}
+async function readApiJson(response, label) {
+  let payload;
+  try {
+    const text = await response.text();
+    payload = text ? JSON.parse(text) : {};
+  } catch (error) {
+    if (error instanceof ApiTimeoutError || error instanceof ApiResponseTooLargeError)
+      throw error;
+    payload = {};
+  }
+  if (!response.ok) {
+    const errorCode = typeof payload.error === "string" ? payload.error : null;
+    const apiMessage = typeof payload.message === "string" ? payload.message : null;
+    throw new OpenPondApiError(response.status, errorCode, label, apiMessage);
+  }
+  return payload;
+}
+function boundedResponse(response, input) {
+  if (!response.body) {
+    input.cleanup();
+    return response;
+  }
+  const contentLength = Number(response.headers.get("content-length"));
+  if (input.maximumBytes > 0 && Number.isFinite(contentLength) && contentLength > input.maximumBytes) {
+    input.cleanup();
+    void response.body.cancel();
+    throw new ApiResponseTooLargeError(input.maximumBytes, input.requestUrl);
+  }
+  const reader = response.body.getReader();
+  let receivedBytes = 0;
+  const body = new ReadableStream({
+    async pull(controller) {
+      try {
+        const result = await reader.read();
+        if (result.done) {
+          input.cleanup();
+          controller.close();
+          return;
+        }
+        receivedBytes += result.value.byteLength;
+        if (input.maximumBytes > 0 && receivedBytes > input.maximumBytes) {
+          input.cleanup();
+          await reader.cancel();
+          controller.error(new ApiResponseTooLargeError(input.maximumBytes, input.requestUrl));
+          return;
+        }
+        controller.enqueue(result.value);
+      } catch (error) {
+        input.cleanup();
+        controller.error(input.timeoutController.signal.aborted ? input.timeoutError : error);
+      }
+    },
+    async cancel(reason) {
+      input.cleanup();
+      await reader.cancel(reason);
+    }
+  });
+  return new Response(body, {
+    headers: response.headers,
+    status: response.status,
+    statusText: response.statusText
+  });
+}
+function composedSignal(callerSignal, timeoutSignal, timeoutMs) {
+  if (timeoutMs <= 0)
+    return callerSignal ?? void 0;
+  return callerSignal ? AbortSignal.any([callerSignal, timeoutSignal]) : timeoutSignal;
+}
+var DEFAULT_OPENPOND_WEB_BASE_URL = "https://openpond.ai";
+var DEFAULT_OPENPOND_API_BASE_URL2 = "https://api.openpond.ai";
+async function streamSandboxEventOutput(params) {
+  const response = await apiFetch2(params.sandboxApiUrl, params.apiKey, params.path, { timeoutMs: 0, maxResponseBytes: 0 });
+  if (!response.body) {
+    return;
+  }
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffered = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      buffered += decoder.decode(value, { stream: true });
+      let separatorIndex = buffered.indexOf("\n\n");
+      while (separatorIndex !== -1) {
+        const event2 = buffered.slice(0, separatorIndex);
+        buffered = buffered.slice(separatorIndex + 2);
+        const output = parseProcessOutputEvent(event2);
+        if (output)
+          process.stdout.write(output);
+        separatorIndex = buffered.indexOf("\n\n");
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+function normalizePtyInput(input) {
+  if (typeof input === "string") {
+    return { dataBase64: Buffer.from(input, "utf-8").toString("base64") };
+  }
+  if (input instanceof Uint8Array) {
+    return { dataBase64: Buffer.from(input).toString("base64") };
+  }
+  return input;
+}
+function parseProcessOutputEvent(event2) {
+  if (!event2.includes("event: output")) {
+    return null;
+  }
+  const dataLines = event2.split(/\r?\n/).filter((line) => line.startsWith("data: ")).map((line) => line.slice("data: ".length));
+  if (dataLines.length === 0) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(dataLines.join("\n"));
+    return typeof parsed.output === "string" ? parsed.output : null;
+  } catch {
+    return null;
+  }
+}
+function normalizeSandboxApiUrl2(baseUrlOrApiUrl) {
+  const trimmed = baseUrlOrApiUrl.trim().replace(/\/$/, "");
+  if (!trimmed) {
+    throw new Error("sandbox API URL must be non-empty");
+  }
+  const url = new URL(trimmed);
+  const normalizedPath = url.pathname.replace(/\/$/, "");
+  if (normalizedPath.endsWith("/v1/sandboxes") || normalizedPath.endsWith("/api/sandboxes")) {
+    return `${url.origin}${normalizedPath}`;
+  }
+  if (normalizedPath.endsWith("/v1")) {
+    return `${url.origin}${normalizedPath}/sandboxes`;
+  }
+  if (isOpenPondHostedApiHost(url.hostname)) {
+    return `${url.origin}${normalizedPath}/v1/sandboxes`;
+  }
+  if (url.origin === DEFAULT_OPENPOND_WEB_BASE_URL) {
+    return `${DEFAULT_OPENPOND_API_BASE_URL2}/v1/sandboxes`;
+  }
+  return `${url.origin}${normalizedPath}/api/sandboxes`;
+}
+function apiRootUrlFromSandboxApiUrl(sandboxApiUrl) {
+  const suffix = "/sandboxes";
+  if (!sandboxApiUrl.endsWith(suffix)) {
+    throw new Error("sandbox API URL must end with /sandboxes");
+  }
+  return sandboxApiUrl.slice(0, -suffix.length);
+}
+function isOpenPondHostedApiHost(hostname) {
+  return hostname === "api.openpond.ai" || hostname === "staging-api.openpond.ai" || hostname.startsWith("api") && hostname.endsWith(".openpond.ai");
+}
+var OpenPondSandboxInstanceClient = class {
+  apiKey;
+  apiRootUrl;
+  sandboxApiUrl;
+  constructor(options) {
+    this.apiKey = options.apiKey;
+    this.sandboxApiUrl = normalizeSandboxApiUrl2(options.sandboxApiUrl ?? options.baseUrl ?? DEFAULT_OPENPOND_API_BASE_URL2);
+    this.apiRootUrl = apiRootUrlFromSandboxApiUrl(this.sandboxApiUrl);
+  }
+  create(input, options = {}) {
+    return this.request("", {
+      method: "POST",
+      headers: asyncRequestHeaders(options),
+      body: JSON.stringify(input)
+    }).then((payload) => payload.sandbox);
+  }
+  get(sandboxId) {
+    return this.request(`/${encodeURIComponent(sandboxId)}`).then((payload) => payload.sandbox);
+  }
+  exec(sandboxId, input) {
+    return this.request(`/${encodeURIComponent(sandboxId)}/exec`, {
+      method: "POST",
+      body: JSON.stringify(input)
+    });
+  }
+  startProcess(sandboxId, input) {
+    return this.request(`/${encodeURIComponent(sandboxId)}/processes`, {
+      method: "POST",
+      body: JSON.stringify(input)
+    });
+  }
+  listProcesses(sandboxId) {
+    return this.request(`/${encodeURIComponent(sandboxId)}/processes`);
+  }
+  getProcess(sandboxId, processId, input = {}) {
+    const query = new URLSearchParams();
+    if (input.since !== void 0)
+      query.set("since", String(Math.max(0, input.since)));
+    return this.request(`/${encodeURIComponent(sandboxId)}/processes/${encodeURIComponent(processId)}${query.size > 0 ? `?${query.toString()}` : ""}`);
+  }
+  stopProcess(sandboxId, processId) {
+    return this.request(`/${encodeURIComponent(sandboxId)}/processes/${encodeURIComponent(processId)}`, {
+      method: "DELETE"
+    });
+  }
+  async streamProcessOutput(sandboxId, processId, input = {}) {
+    const query = new URLSearchParams();
+    if (input.since !== void 0)
+      query.set("since", String(Math.max(0, input.since)));
+    await streamSandboxEventOutput({
+      sandboxApiUrl: this.sandboxApiUrl,
+      apiKey: this.apiKey,
+      path: `/${encodeURIComponent(sandboxId)}/processes/${encodeURIComponent(processId)}/stream${query.size > 0 ? `?${query.toString()}` : ""}`
+    });
+  }
+  startPty(sandboxId, input = {}) {
+    return this.request(`/${encodeURIComponent(sandboxId)}/pty`, {
+      method: "POST",
+      body: JSON.stringify(input)
+    });
+  }
+  listPtys(sandboxId) {
+    return this.request(`/${encodeURIComponent(sandboxId)}/pty`);
+  }
+  getPty(sandboxId, ptyId, input = {}) {
+    const query = new URLSearchParams();
+    if (input.since !== void 0)
+      query.set("since", String(Math.max(0, input.since)));
+    return this.request(`/${encodeURIComponent(sandboxId)}/pty/${encodeURIComponent(ptyId)}${query.size > 0 ? `?${query.toString()}` : ""}`);
+  }
+  writePtyInput(sandboxId, ptyId, input) {
+    return this.request(`/${encodeURIComponent(sandboxId)}/pty/${encodeURIComponent(ptyId)}/input`, {
+      method: "POST",
+      body: JSON.stringify(normalizePtyInput(input))
+    });
+  }
+  stopPty(sandboxId, ptyId) {
+    return this.request(`/${encodeURIComponent(sandboxId)}/pty/${encodeURIComponent(ptyId)}`, {
+      method: "DELETE"
+    });
+  }
+  async streamPtyOutput(sandboxId, ptyId, input = {}) {
+    const query = new URLSearchParams();
+    if (input.since !== void 0)
+      query.set("since", String(Math.max(0, input.since)));
+    await streamSandboxEventOutput({
+      sandboxApiUrl: this.sandboxApiUrl,
+      apiKey: this.apiKey,
+      path: `/${encodeURIComponent(sandboxId)}/pty/${encodeURIComponent(ptyId)}/stream${query.size > 0 ? `?${query.toString()}` : ""}`
+    });
+  }
+  uploadFile(sandboxId, path37, contents) {
+    return this.uploadFileBase64(sandboxId, path37, Buffer.from(contents, "utf-8").toString("base64"));
+  }
+  uploadFileBase64(sandboxId, path37, contentsBase64) {
+    return this.request(`/${encodeURIComponent(sandboxId)}/files`, {
+      method: "POST",
+      body: JSON.stringify({
+        path: path37,
+        contentsBase64
+      })
+    });
+  }
+  async downloadFile(sandboxId, path37) {
+    const payload = await this.downloadFileResponse(sandboxId, path37);
+    return Buffer.from(payload.file.contentsBase64, "base64").toString("utf-8");
+  }
+  downloadFileResponse(sandboxId, input) {
+    const normalized = typeof input === "string" ? { path: input } : input;
+    const query = new URLSearchParams({ path: normalized.path });
+    if (normalized.offsetBytes !== void 0) {
+      query.set("offsetBytes", String(normalized.offsetBytes));
+    }
+    if (normalized.maxBytes !== void 0) {
+      query.set("maxBytes", String(normalized.maxBytes));
+    }
+    return this.request(`/${encodeURIComponent(sandboxId)}/files?${query.toString()}`);
+  }
+  listFiles(sandboxId, input = {}) {
+    const query = new URLSearchParams({ list: "1" });
+    if (input.path)
+      query.set("path", input.path);
+    if (input.recursive !== void 0)
+      query.set("recursive", String(input.recursive));
+    if (input.maxEntries !== void 0)
+      query.set("maxEntries", String(input.maxEntries));
+    return this.request(`/${encodeURIComponent(sandboxId)}/files?${query.toString()}`);
+  }
+  deleteFile(sandboxId, path37, input = {}) {
+    const query = new URLSearchParams({ path: path37 });
+    if (input.recursive !== void 0)
+      query.set("recursive", String(input.recursive));
+    return this.request(`/${encodeURIComponent(sandboxId)}/files?${query.toString()}`, {
+      method: "DELETE"
+    });
+  }
+  statFile(sandboxId, path37) {
+    const query = new URLSearchParams({ stat: "1", path: path37 });
+    return this.request(`/${encodeURIComponent(sandboxId)}/files?${query.toString()}`);
+  }
+  mkdir(sandboxId, input) {
+    const normalized = typeof input === "string" ? { path: input } : input;
+    const query = new URLSearchParams({ path: normalized.path });
+    if (normalized.recursive !== void 0)
+      query.set("recursive", String(normalized.recursive));
+    return this.request(`/${encodeURIComponent(sandboxId)}/files?${query.toString()}`, {
+      method: "PUT"
+    });
+  }
+  moveFile(sandboxId, input) {
+    const query = new URLSearchParams({
+      fromPath: input.fromPath,
+      toPath: input.toPath
+    });
+    if (input.overwrite !== void 0)
+      query.set("overwrite", String(input.overwrite));
+    return this.request(`/${encodeURIComponent(sandboxId)}/files?${query.toString()}`, {
+      method: "PATCH"
+    });
+  }
+  searchFiles(sandboxId, input) {
+    const query = new URLSearchParams({
+      search: "1",
+      query: input.query
+    });
+    if (input.path)
+      query.set("path", input.path);
+    if (input.maxResults !== void 0)
+      query.set("maxResults", String(input.maxResults));
+    return this.request(`/${encodeURIComponent(sandboxId)}/files?${query.toString()}`);
+  }
+  openPort(sandboxId, input) {
+    return this.request(`/${encodeURIComponent(sandboxId)}/ports`, {
+      method: "POST",
+      body: JSON.stringify(input)
+    });
+  }
+  createSnapshot(sandboxId, input) {
+    return this.request(`/${encodeURIComponent(sandboxId)}/snapshots`, {
+      method: "POST",
+      body: JSON.stringify(input)
+    });
+  }
+  updateSnapshot(sandboxId, snapshotId, input) {
+    return this.request(`/${encodeURIComponent(sandboxId)}/snapshots/${encodeURIComponent(snapshotId)}`, {
+      method: "PATCH",
+      body: JSON.stringify(input)
+    });
+  }
+  validateSnapshot(sandboxId, snapshotId, input = {}) {
+    return this.request(`/${encodeURIComponent(sandboxId)}/snapshots/${encodeURIComponent(snapshotId)}/validate`, {
+      method: "POST",
+      body: JSON.stringify(input)
+    });
+  }
+  publishSnapshot(sandboxId, snapshotId) {
+    return this.request(`/${encodeURIComponent(sandboxId)}/snapshots/${encodeURIComponent(snapshotId)}/publish`, {
+      method: "POST"
+    });
+  }
+  fork(sandboxId, input = {}) {
+    return this.request(`/${encodeURIComponent(sandboxId)}/fork`, {
+      method: "POST",
+      body: JSON.stringify(input)
+    });
+  }
+  stop(sandboxId, options = {}) {
+    const query = new URLSearchParams();
+    if (options.failOnUnpreservedChanges) {
+      query.set("failOnUnpreservedChanges", "true");
+    }
+    return this.request(`/${encodeURIComponent(sandboxId)}/stop${query.size > 0 ? `?${query.toString()}` : ""}`, {
+      method: "POST",
+      headers: asyncRequestHeaders(options)
+    });
+  }
+  start(sandboxId, options = {}) {
+    return this.request(`/${encodeURIComponent(sandboxId)}/start`, {
+      method: "POST",
+      headers: asyncRequestHeaders(options)
+    });
+  }
+  restore(sandboxId) {
+    return this.request(`/${encodeURIComponent(sandboxId)}/restore`, {
+      method: "POST"
+    });
+  }
+  delete(sandboxId, options = {}) {
+    const query = new URLSearchParams();
+    if (options.failOnUnpreservedChanges) {
+      query.set("failOnUnpreservedChanges", "true");
+    }
+    return this.request(`/${encodeURIComponent(sandboxId)}${query.size > 0 ? `?${query.toString()}` : ""}`, {
+      method: "DELETE",
+      headers: asyncRequestHeaders(options)
+    }).then((payload) => payload.sandbox);
+  }
+  receipts(sandboxId) {
+    return this.request(`/${encodeURIComponent(sandboxId)}/receipts`).then((payload) => payload.receipts);
+  }
+  logs(sandboxId) {
+    return this.request(`/${encodeURIComponent(sandboxId)}/logs`).then((payload) => payload.logs);
+  }
+  gitStatus(sandboxId) {
+    return this.request(`/${encodeURIComponent(sandboxId)}/git/status`);
+  }
+  gitDiff(sandboxId, input = {}) {
+    return this.request(`/${encodeURIComponent(sandboxId)}/git/diff`, {
+      method: "POST",
+      body: JSON.stringify(input)
+    });
+  }
+  gitExportPatch(sandboxId, input = {}) {
+    return this.request(`/${encodeURIComponent(sandboxId)}/git/export-patch`, {
+      method: "POST",
+      body: JSON.stringify(input)
+    });
+  }
+  gitBranch(sandboxId, input) {
+    return this.request(`/${encodeURIComponent(sandboxId)}/git/branch`, {
+      method: "POST",
+      body: JSON.stringify(input)
+    });
+  }
+  gitCommit(sandboxId, input) {
+    return this.request(`/${encodeURIComponent(sandboxId)}/git/commit`, {
+      method: "POST",
+      body: JSON.stringify(input)
+    });
+  }
+  gitPull(sandboxId, input = {}) {
+    return this.request(`/${encodeURIComponent(sandboxId)}/git/pull`, {
+      method: "POST",
+      body: JSON.stringify(input)
+    });
+  }
+  gitPush(sandboxId, input = {}) {
+    return this.request(`/${encodeURIComponent(sandboxId)}/git/push`, {
+      method: "POST",
+      body: JSON.stringify(input)
+    });
+  }
+  billing(sandboxId) {
+    return this.request(`/${encodeURIComponent(sandboxId)}/billing`);
+  }
+  pricing() {
+    return this.request("/pricing");
+  }
+  costs(input = {}) {
+    const query = new URLSearchParams();
+    if (input.teamId)
+      query.set("teamId", input.teamId);
+    if (input.projectId)
+      query.set("projectId", input.projectId);
+    if (input.agentId)
+      query.set("agentId", input.agentId);
+    return this.request(`/costs${query.size > 0 ? `?${query.toString()}` : ""}`);
+  }
+  integrationLeases(sandboxId) {
+    return this.request(`/${encodeURIComponent(sandboxId)}/integrations`);
+  }
+  attachIntegrationConnection(sandboxId, input) {
+    return this.request(`/${encodeURIComponent(sandboxId)}/integrations`, {
+      method: "POST",
+      body: JSON.stringify(input)
+    });
+  }
+  removeIntegrationLease(sandboxId, leaseId) {
+    return this.request(`/${encodeURIComponent(sandboxId)}/integrations`, {
+      method: "DELETE",
+      body: JSON.stringify({ leaseId })
+    });
+  }
+  async request(path37, init = {}) {
+    const response = await apiFetch2(this.sandboxApiUrl, this.apiKey, path37, init);
+    return readApiJson(response, "Sandbox request");
+  }
+  async requestApiRoot(path37, init = {}) {
+    const response = await apiFetch2(this.apiRootUrl, this.apiKey, path37, init);
+    return readApiJson(response, "OpenPond API request");
+  }
+};
+var OpenPondSandboxClient = class extends OpenPondSandboxInstanceClient {
+  runtimes = createSandboxRuntimeNamespace(this);
+  sandboxes = createSandboxNamespace(this);
+  profile = createSandboxProfileNamespace(this);
+  projects = createSandboxProjectNamespace(this);
+  agents = createSandboxAgentNamespace(this);
+  list(input = {}) {
+    const query = new URLSearchParams();
+    if (input.teamId)
+      query.set("teamId", input.teamId);
+    if (input.projectId)
+      query.set("projectId", input.projectId);
+    if (input.agentId)
+      query.set("agentId", input.agentId);
+    return this.request(query.size > 0 ? `?${query.toString()}` : "").then((payload) => payload.sandboxes);
+  }
+  listSecrets(input = {}) {
+    const query = new URLSearchParams();
+    if (input.teamId)
+      query.set("teamId", input.teamId);
+    return this.requestApiRoot(`/sandbox-secrets${query.size > 0 ? `?${query.toString()}` : ""}`).then((payload) => payload.secrets);
+  }
+  getSecret(secretId, input = {}) {
+    const query = new URLSearchParams();
+    if (input.teamId)
+      query.set("teamId", input.teamId);
+    return this.requestApiRoot(`/sandbox-secrets/${encodeURIComponent(secretId)}${query.size > 0 ? `?${query.toString()}` : ""}`).then((payload) => payload.secret);
+  }
+  createSecret(input) {
+    return this.requestApiRoot("/sandbox-secrets", {
+      method: "POST",
+      body: JSON.stringify(input)
+    }).then((payload) => payload.secret);
+  }
+  rotateSecret(secretId, input) {
+    const query = new URLSearchParams();
+    if (input.teamId)
+      query.set("teamId", input.teamId);
+    const { teamId: _teamId, ...body } = input;
+    return this.requestApiRoot(`/sandbox-secrets/${encodeURIComponent(secretId)}/rotate${query.size > 0 ? `?${query.toString()}` : ""}`, {
+      method: "POST",
+      body: JSON.stringify(body)
+    }).then((payload) => payload.secret);
+  }
+  attachSecret(secretId, input) {
+    const query = new URLSearchParams();
+    if (input.teamId)
+      query.set("teamId", input.teamId);
+    const { teamId: _teamId, ...body } = input;
+    return this.requestApiRoot(`/sandbox-secrets/${encodeURIComponent(secretId)}/attach${query.size > 0 ? `?${query.toString()}` : ""}`, {
+      method: "POST",
+      body: JSON.stringify(body)
+    }).then((payload) => payload.secret);
+  }
+  revokeSecret(secretId, input = {}) {
+    const query = new URLSearchParams();
+    if (input.teamId)
+      query.set("teamId", input.teamId);
+    return this.requestApiRoot(`/sandbox-secrets/${encodeURIComponent(secretId)}/revoke${query.size > 0 ? `?${query.toString()}` : ""}`, { method: "POST" }).then((payload) => payload.secret);
+  }
+  deleteSecret(secretId, input = {}) {
+    const query = new URLSearchParams();
+    if (input.teamId)
+      query.set("teamId", input.teamId);
+    return this.requestApiRoot(`/sandbox-secrets/${encodeURIComponent(secretId)}${query.size > 0 ? `?${query.toString()}` : ""}`, { method: "DELETE" }).then((payload) => payload.secret);
+  }
+  snapshotCatalog(input = {}) {
+    const query = new URLSearchParams();
+    if (input.teamId)
+      query.set("teamId", input.teamId);
+    if (input.projectId)
+      query.set("projectId", input.projectId);
+    if (input.agentId)
+      query.set("agentId", input.agentId);
+    if (input.q)
+      query.set("q", input.q);
+    if (input.kind)
+      query.set("kind", input.kind);
+    if (input.replayState)
+      query.set("replayState", input.replayState);
+    if (input.visibility)
+      query.set("visibility", input.visibility);
+    if (input.tag)
+      query.set("tag", input.tag);
+    if (input.useCase)
+      query.set("useCase", input.useCase);
+    if (input.limit)
+      query.set("limit", String(input.limit));
+    return this.request(`/catalog/snapshots${query.size > 0 ? `?${query.toString()}` : ""}`);
+  }
+  listSandboxRuntimes(input = {}) {
+    const query = new URLSearchParams();
+    if (input.teamId)
+      query.set("teamId", input.teamId);
+    if (input.projectId)
+      query.set("projectId", input.projectId);
+    if (input.agentId)
+      query.set("agentId", input.agentId);
+    return this.requestApiRoot(`/runtimes${query.size > 0 ? `?${query.toString()}` : ""}`).then((payload) => payload.runtimes);
+  }
+  listProjects(input) {
+    const query = new URLSearchParams({ teamId: input.teamId });
+    return this.requestApiRoot(`/projects?${query.toString()}`).then((payload) => payload.projects);
+  }
+  upsertProject(input) {
+    return this.requestApiRoot("/projects", {
+      method: "POST",
+      body: JSON.stringify(input)
+    }).then((payload) => payload.project);
+  }
+  getHostedProfile(input) {
+    const query = new URLSearchParams({ teamId: input.teamId });
+    return this.requestApiRoot(`/profile?${query.toString()}`).then((payload) => payload.profile);
+  }
+  ensureHostedProfile(input) {
+    const query = new URLSearchParams({ teamId: input.teamId });
+    return this.requestApiRoot(`/profile/ensure?${query.toString()}`, { method: "POST" }).then((payload) => {
+      if (!payload.profile) {
+        throw new Error("hosted_profile_missing");
+      }
+      return payload.profile;
+    });
+  }
+  pushHostedProfile(input) {
+    const query = new URLSearchParams({ teamId: input.teamId });
+    const { teamId: _teamId, ...body } = input;
+    return this.requestApiRoot(`/profile/push?${query.toString()}`, {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+  }
+  async upsertProjectGitRemote(input) {
+    const project = await this.upsertProject(input);
+    return this.ensureProjectGitRemote(project.id, { teamId: input.teamId });
+  }
+  getProject(projectId, input) {
+    const query = new URLSearchParams({ teamId: input.teamId });
+    return this.requestApiRoot(`/projects/${encodeURIComponent(projectId)}?${query.toString()}`).then((payload) => payload.project);
+  }
+  syncProject(projectId, input) {
+    const query = new URLSearchParams({ teamId: input.teamId });
+    return this.requestApiRoot(`/projects/${encodeURIComponent(projectId)}/sync?${query.toString()}`, { method: "POST" }).then((payload) => payload.project);
+  }
+  ensureProjectGitRemote(projectId, input) {
+    const query = new URLSearchParams({ teamId: input.teamId });
+    return this.requestApiRoot(`/projects/${encodeURIComponent(projectId)}/git?${query.toString()}`, { method: "POST" });
+  }
+  uploadProjectSource(projectId, input) {
+    const query = new URLSearchParams({ teamId: input.teamId });
+    const { teamId: _teamId, ...body } = input;
+    return this.requestApiRoot(`/projects/${encodeURIComponent(projectId)}/source?${query.toString()}`, {
+      method: "POST",
+      body: JSON.stringify(body)
+    }).then((payload) => payload.project);
+  }
+  updateProject(projectId, input) {
+    const query = new URLSearchParams({ teamId: input.teamId });
+    const { teamId: _teamId, ...body } = input;
+    return this.requestApiRoot(`/projects/${encodeURIComponent(projectId)}?${query.toString()}`, {
+      method: "PATCH",
+      body: JSON.stringify(body)
+    }).then((payload) => payload.project);
+  }
+  archiveProject(projectId, input) {
+    const query = new URLSearchParams({ teamId: input.teamId });
+    return this.requestApiRoot(`/projects/${encodeURIComponent(projectId)}?${query.toString()}`, { method: "DELETE" }).then((payload) => payload.project);
+  }
+  listAgents(input) {
+    const query = new URLSearchParams({ teamId: input.teamId });
+    return this.requestApiRoot(`/agents?${query.toString()}`).then((payload) => payload.agents);
+  }
+  upsertAgent(input) {
+    return this.requestApiRoot("/agents", {
+      method: "POST",
+      body: JSON.stringify(input)
+    }).then((payload) => payload.agent);
+  }
+  getAgent(agentId, input) {
+    const query = new URLSearchParams({ teamId: input.teamId });
+    return this.requestApiRoot(`/agents/${encodeURIComponent(agentId)}?${query.toString()}`).then((payload) => payload.agent);
+  }
+  archiveAgent(agentId, input) {
+    const query = new URLSearchParams({ teamId: input.teamId });
+    return this.requestApiRoot(`/agents/${encodeURIComponent(agentId)}?${query.toString()}`, { method: "DELETE" }).then((payload) => payload.agent);
+  }
+  updateAgent(agentId, input) {
+    const query = new URLSearchParams({ teamId: input.teamId });
+    const { teamId: _teamId, ...body } = input;
+    return this.requestApiRoot(`/agents/${encodeURIComponent(agentId)}?${query.toString()}`, {
+      method: "PATCH",
+      body: JSON.stringify(body)
+    }).then((payload) => payload.agent);
+  }
+  runAgent(agentId, input) {
+    return this.requestApiRoot(`/agents/${encodeURIComponent(agentId)}/run`, {
+      method: "POST",
+      headers: {
+        Prefer: "respond-async"
+      },
+      body: JSON.stringify(input)
+    });
+  }
+  getAgentSourceDeployPlan(agentId, input) {
+    const query = new URLSearchParams({ teamId: input.teamId });
+    return this.requestApiRoot(`/agents/${encodeURIComponent(agentId)}/source/deploy-plan?${query.toString()}`).then((payload) => payload.deployPlan);
+  }
+  listAgentManifestSnapshots(agentId, input) {
+    const query = new URLSearchParams({ teamId: input.teamId });
+    if (input.limit !== void 0)
+      query.set("limit", String(input.limit));
+    return this.requestApiRoot(`/agents/${encodeURIComponent(agentId)}/source/manifest-snapshots?${query.toString()}`).then((payload) => payload.manifestSnapshots);
+  }
+  requestAgentSourceChecks(agentId, input) {
+    const query = new URLSearchParams({ teamId: input.teamId });
+    const { teamId: _teamId, ...body } = input;
+    return this.requestApiRoot(`/agents/${encodeURIComponent(agentId)}/source/checks?${query.toString()}`, {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+  }
+  publishAgentSource(agentId, input) {
+    const query = new URLSearchParams({ teamId: input.teamId });
+    const { teamId: _teamId, ...body } = input;
+    return this.requestApiRoot(`/agents/${encodeURIComponent(agentId)}/source/publish?${query.toString()}`, {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+  }
+  getMicrosoftTeamsBotOverview(input) {
+    const query = new URLSearchParams({ teamId: input.teamId });
+    return this.requestApiRoot(`/teams/bot/overview?${query.toString()}`);
+  }
+  bindMicrosoftTeamsBotConversation(input) {
+    return this.requestApiRoot("/teams/bot/bindings", {
+      method: "POST",
+      body: JSON.stringify(input)
+    });
+  }
+  rebindMicrosoftTeamsBotConversation(bindingId, input) {
+    return this.requestApiRoot(`/teams/bot/bindings/${encodeURIComponent(bindingId)}`, {
+      method: "PATCH",
+      body: JSON.stringify(input)
+    });
+  }
+  unlinkMicrosoftTeamsBotConversation(input) {
+    return this.requestApiRoot(`/teams/bot/bindings/${encodeURIComponent(input.bindingId)}`, {
+      method: "DELETE",
+      body: JSON.stringify({ teamId: input.teamId })
+    });
+  }
+  sendMicrosoftTeamsBotDiagnostic(input) {
+    return this.requestApiRoot("/teams/bot/diagnostics", {
+      method: "POST",
+      body: JSON.stringify(input)
+    });
+  }
+  sendMicrosoftTeamsBotDiagnosticRun(input) {
+    return this.requestApiRoot("/teams/bot/diagnostics/run", {
+      method: "POST",
+      body: JSON.stringify(input)
+    });
+  }
+  createSandboxRuntime(input) {
+    return this.requestApiRoot("/runtimes", {
+      method: "POST",
+      body: JSON.stringify(input)
+    }).then((payload) => payload.runtime);
+  }
+  sandboxRuntime(runtimeId, initial = null) {
+    return createSandboxRuntimeHandle(this, runtimeId, initial);
+  }
+  getSandboxRuntime(runtimeId) {
+    return this.requestApiRoot(`/runtimes/${encodeURIComponent(runtimeId)}`).then((payload) => payload.runtime);
+  }
+  createSandboxRuntimeSandbox(runtimeId, input = {}, options = {}) {
+    return this.requestApiRoot(`/runtimes/${encodeURIComponent(runtimeId)}/sandbox`, {
+      method: "POST",
+      headers: asyncRequestHeaders(options),
+      body: JSON.stringify(input)
+    });
+  }
+  updateSandboxRuntimeStatus(runtimeId, input) {
+    return this.requestApiRoot(`/runtimes/${encodeURIComponent(runtimeId)}/status`, {
+      method: "PATCH",
+      body: JSON.stringify(input)
+    }).then((payload) => payload.runtime);
+  }
+  listSandboxRuntimeEvents(runtimeId) {
+    return this.requestApiRoot(`/runtimes/${encodeURIComponent(runtimeId)}/events`);
+  }
+  emitSandboxRuntimeEvent(runtimeId, input) {
+    return this.requestApiRoot(`/runtimes/${encodeURIComponent(runtimeId)}/events`, {
+      method: "POST",
+      body: JSON.stringify(input)
+    });
+  }
+  checkpointSandboxRuntime(runtimeId, input) {
+    return this.requestApiRoot(`/runtimes/${encodeURIComponent(runtimeId)}/checkpoints`, {
+      method: "POST",
+      body: JSON.stringify(input)
+    }).then((payload) => payload.runtime);
+  }
+  promoteSandboxRuntime(runtimeId, input, options = {}) {
+    const query = new URLSearchParams();
+    if (options.teamId)
+      query.set("teamId", options.teamId);
+    return this.requestApiRoot(`/runtimes/${encodeURIComponent(runtimeId)}/promote${query.size > 0 ? `?${query.toString()}` : ""}`, {
+      method: "POST",
+      body: JSON.stringify(input)
+    });
+  }
+  preserveSandboxRuntimeSource(runtimeId, input = {}, options = {}) {
+    const query = new URLSearchParams();
+    if (options.teamId)
+      query.set("teamId", options.teamId);
+    return this.requestApiRoot(`/runtimes/${encodeURIComponent(runtimeId)}/preserve-source${query.size > 0 ? `?${query.toString()}` : ""}`, {
+      method: "POST",
+      body: JSON.stringify(input)
+    });
+  }
+  forkSnapshot(snapshotId, input = {}, options = {}) {
+    const query = new URLSearchParams();
+    if (input.teamId)
+      query.set("teamId", input.teamId);
+    if (input.projectId)
+      query.set("projectId", input.projectId);
+    if (options.async)
+      query.set("async", "1");
+    const { teamId: _teamId, projectId: _projectId, ...body } = input;
+    return this.request(`/catalog/snapshots/${encodeURIComponent(snapshotId)}/fork${query.size > 0 ? `?${query.toString()}` : ""}`, {
+      method: "POST",
+      headers: options.async ? { Prefer: "respond-async" } : void 0,
+      body: JSON.stringify({
+        ...body,
+        snapshotId
+      })
+    });
+  }
+  templates(input = {}) {
+    const query = new URLSearchParams();
+    if (input.teamId)
+      query.set("teamId", input.teamId);
+    if (input.projectId)
+      query.set("projectId", input.projectId);
+    if (input.q)
+      query.set("q", input.q);
+    if (input.name)
+      query.set("name", input.name);
+    if (input.version)
+      query.set("version", input.version);
+    if (input.visibility)
+      query.set("visibility", input.visibility);
+    if (input.tag)
+      query.set("tag", input.tag);
+    if (input.useCase)
+      query.set("useCase", input.useCase);
+    if (input.limit)
+      query.set("limit", String(input.limit));
+    return this.request(`/templates${query.size > 0 ? `?${query.toString()}` : ""}`);
+  }
+  publishedSnapshots(input = {}) {
+    const query = new URLSearchParams();
+    if (input.teamId)
+      query.set("teamId", input.teamId);
+    if (input.projectId)
+      query.set("projectId", input.projectId);
+    if (input.q)
+      query.set("q", input.q);
+    if (input.name)
+      query.set("name", input.name);
+    if (input.version)
+      query.set("version", input.version);
+    if (input.visibility)
+      query.set("visibility", input.visibility);
+    if (input.tag)
+      query.set("tag", input.tag);
+    if (input.useCase)
+      query.set("useCase", input.useCase);
+    if (input.limit)
+      query.set("limit", String(input.limit));
+    return this.request(`/published-snapshots${query.size > 0 ? `?${query.toString()}` : ""}`).then((payload) => {
+      const publishedSnapshots = payload.publishedSnapshots ?? payload.templates;
+      return {
+        ...payload,
+        templates: publishedSnapshots,
+        publishedSnapshots
+      };
+    });
+  }
+  launchTemplate(input) {
+    const query = new URLSearchParams();
+    if (input.teamId)
+      query.set("teamId", input.teamId);
+    if (input.projectId)
+      query.set("projectId", input.projectId);
+    const { teamId: _teamId, projectId: _projectId, ...body } = input;
+    return this.request(`/templates/launch${query.size > 0 ? `?${query.toString()}` : ""}`, {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+  }
+  runPublishedSnapshot(input) {
+    const query = new URLSearchParams();
+    if (input.teamId)
+      query.set("teamId", input.teamId);
+    if (input.projectId)
+      query.set("projectId", input.projectId);
+    const { teamId: _teamId, projectId: _projectId, ...body } = input;
+    return this.request(`/published-snapshots/launch${query.size > 0 ? `?${query.toString()}` : ""}`, {
+      method: "POST",
+      body: JSON.stringify(body)
+    }).then((payload) => {
+      const publishedSnapshot = payload.publishedSnapshot ?? payload.template;
+      return {
+        ...payload,
+        template: publishedSnapshot,
+        publishedSnapshot
+      };
+    });
+  }
+  listSchedules(input = {}) {
+    const query = new URLSearchParams();
+    if (input.teamId)
+      query.set("teamId", input.teamId);
+    if (input.projectId)
+      query.set("projectId", input.projectId);
+    if (input.sourceSandboxId)
+      query.set("sourceSandboxId", input.sourceSandboxId);
+    return this.request(`/schedules${query.size > 0 ? `?${query.toString()}` : ""}`);
+  }
+  createSchedule(input) {
+    const query = new URLSearchParams();
+    if (input.projectId)
+      query.set("projectId", input.projectId);
+    const { projectId: _projectId, ...body } = input;
+    return this.request(`/schedules${query.size > 0 ? `?${query.toString()}` : ""}`, {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+  }
+  getSchedule(scheduleId) {
+    return this.request(`/schedules/${encodeURIComponent(scheduleId)}`);
+  }
+  updateSchedule(scheduleId, input) {
+    return this.request(`/schedules/${encodeURIComponent(scheduleId)}`, {
+      method: "PATCH",
+      body: JSON.stringify(input)
+    });
+  }
+  deleteSchedule(scheduleId) {
+    return this.request(`/schedules/${encodeURIComponent(scheduleId)}`, {
+      method: "DELETE"
+    });
+  }
+  listScheduleRuns(scheduleId, input = {}) {
+    const query = new URLSearchParams();
+    if (input.limit !== void 0)
+      query.set("limit", String(input.limit));
+    return this.request(`/schedules/${encodeURIComponent(scheduleId)}/runs${query.size > 0 ? `?${query.toString()}` : ""}`);
+  }
+  runScheduleNow(scheduleId, input = {}) {
+    return this.request(`/schedules/${encodeURIComponent(scheduleId)}/run`, {
+      method: "POST",
+      body: JSON.stringify(input)
+    });
+  }
+  listTemplateBuilds(input) {
+    const query = new URLSearchParams({ teamId: input.teamId });
+    return this.requestApiRoot(`/sandbox-template-builds?${query.toString()}`).then((payload) => payload.builds);
+  }
+  createTemplateBuild(input) {
+    return this.requestApiRoot("/sandbox-template-builds", {
+      method: "POST",
+      body: JSON.stringify(input)
+    }).then((payload) => payload.build);
+  }
+  getTemplateBuild(buildId) {
+    return this.requestApiRoot(`/sandbox-template-builds/${encodeURIComponent(buildId)}`).then((payload) => payload.build);
+  }
+  getTemplateBuildLogs(buildId) {
+    return this.requestApiRoot(`/sandbox-template-builds/${encodeURIComponent(buildId)}/logs`);
+  }
+  cancelTemplateBuild(buildId) {
+    return this.requestApiRoot(`/sandbox-template-builds/${encodeURIComponent(buildId)}/cancel`, {
+      method: "POST"
+    }).then((payload) => payload.build);
+  }
+  listPublishedSnapshotBuilds(input) {
+    const query = new URLSearchParams({ teamId: input.teamId });
+    return this.requestApiRoot(`/published-snapshot-builds?${query.toString()}`).then((payload) => payload.builds);
+  }
+  createPublishedSnapshotBuild(input) {
+    return this.requestApiRoot("/published-snapshot-builds", {
+      method: "POST",
+      body: JSON.stringify(input)
+    }).then((payload) => payload.build);
+  }
+  getPublishedSnapshotBuild(buildId) {
+    return this.requestApiRoot(`/published-snapshot-builds/${encodeURIComponent(buildId)}`).then((payload) => payload.build);
+  }
+  getPublishedSnapshotBuildLogs(buildId) {
+    return this.requestApiRoot(`/published-snapshot-builds/${encodeURIComponent(buildId)}/logs`);
+  }
+  cancelPublishedSnapshotBuild(buildId) {
+    return this.requestApiRoot(`/published-snapshot-builds/${encodeURIComponent(buildId)}/cancel`, {
+      method: "POST"
+    }).then((payload) => payload.build);
+  }
+  listOrganizations() {
+    return this.requestApiRoot("/organizations").then((payload) => payload.organizations ?? payload.teams ?? []);
+  }
+  createOrganization(input) {
+    return this.requestApiRoot("/organizations", {
+      method: "POST",
+      body: JSON.stringify(input)
+    }).then((payload) => payload.organization);
+  }
+  getOrganization(slug) {
+    return this.requestApiRoot(`/organizations/${encodeURIComponent(slug)}`).then((payload) => payload.organization);
+  }
+  updateOrganization(slug, input) {
+    return this.requestApiRoot(`/organizations/${encodeURIComponent(slug)}`, {
+      method: "PATCH",
+      body: JSON.stringify(input)
+    }).then((payload) => payload.organization);
+  }
+  listOrganizationMembers(slug) {
+    return this.requestApiRoot(`/organizations/${encodeURIComponent(slug)}/members`).then((payload) => payload.members);
+  }
+  upsertOrganizationMember(slug, input) {
+    return this.requestApiRoot(`/organizations/${encodeURIComponent(slug)}/members`, {
+      method: "POST",
+      body: JSON.stringify(input)
+    }).then((payload) => payload.member);
+  }
+  getOrganizationMcpServer(slug) {
+    return this.requestApiRoot(`/organizations/${encodeURIComponent(slug)}/mcp-server`).then((payload) => payload.mcpServer);
+  }
+  generateOrganizationMcpServer(slug, input = {}) {
+    return this.requestApiRoot(`/organizations/${encodeURIComponent(slug)}/mcp-server`, {
+      method: "POST",
+      body: JSON.stringify(input)
+    }).then((payload) => payload.mcpServer);
+  }
+  rotateOrganizationMcpServer(slug) {
+    return this.requestApiRoot(`/organizations/${encodeURIComponent(slug)}/mcp-server/rotate`, {
+      method: "POST"
+    }).then((payload) => payload.mcpServer);
+  }
+  disableOrganizationMcpServer(slug) {
+    return this.requestApiRoot(`/organizations/${encodeURIComponent(slug)}/mcp-server/disable`, {
+      method: "POST"
+    }).then((payload) => payload.mcpServer);
+  }
+  enableOrganizationMcpServer(slug) {
+    return this.requestApiRoot(`/organizations/${encodeURIComponent(slug)}/mcp-server/enable`, {
+      method: "POST"
+    }).then((payload) => payload.mcpServer);
+  }
+  startReplay(input) {
+    const query = new URLSearchParams();
+    if (input.teamId)
+      query.set("teamId", input.teamId);
+    if (input.projectId)
+      query.set("projectId", input.projectId);
+    const { teamId: _teamId, projectId: _projectId, ...body } = input;
+    return this.requestApiRoot(`/sandbox-replays${query.size > 0 ? `?${query.toString()}` : ""}`, {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+  }
+  listReplays(input = {}) {
+    const query = new URLSearchParams();
+    if (input.teamId)
+      query.set("teamId", input.teamId);
+    if (input.projectId)
+      query.set("projectId", input.projectId);
+    return this.requestApiRoot(`/sandbox-replays${query.size > 0 ? `?${query.toString()}` : ""}`);
+  }
+  getReplay(replayId, input = {}) {
+    const query = new URLSearchParams();
+    if (input.teamId)
+      query.set("teamId", input.teamId);
+    if (input.projectId)
+      query.set("projectId", input.projectId);
+    return this.requestApiRoot(`/sandbox-replays/${encodeURIComponent(replayId)}${query.size > 0 ? `?${query.toString()}` : ""}`);
+  }
+  getReplayLogs(replayId, input = {}) {
+    const query = new URLSearchParams();
+    if (input.teamId)
+      query.set("teamId", input.teamId);
+    if (input.projectId)
+      query.set("projectId", input.projectId);
+    return this.requestApiRoot(`/sandbox-replays/${encodeURIComponent(replayId)}/logs${query.size > 0 ? `?${query.toString()}` : ""}`);
+  }
+  getReplayArtifacts(replayId, input = {}) {
+    const query = new URLSearchParams();
+    if (input.teamId)
+      query.set("teamId", input.teamId);
+    if (input.projectId)
+      query.set("projectId", input.projectId);
+    return this.requestApiRoot(`/sandbox-replays/${encodeURIComponent(replayId)}/artifacts${query.size > 0 ? `?${query.toString()}` : ""}`);
+  }
+  cancelReplay(replayId, input = {}) {
+    const query = new URLSearchParams();
+    if (input.teamId)
+      query.set("teamId", input.teamId);
+    if (input.projectId)
+      query.set("projectId", input.projectId);
+    return this.requestApiRoot(`/sandbox-replays/${encodeURIComponent(replayId)}/cancel${query.size > 0 ? `?${query.toString()}` : ""}`, {
+      method: "POST"
+    });
+  }
+  integrationConnections(input = {}) {
+    const query = new URLSearchParams();
+    if (input.teamId)
+      query.set("teamId", input.teamId);
+    if (input.projectId)
+      query.set("projectId", input.projectId);
+    if (input.agentId)
+      query.set("agentId", input.agentId);
+    if (input.status)
+      query.set("status", input.status);
+    return this.requestApiRoot(`/integrations/connections${query.size > 0 ? `?${query.toString()}` : ""}`);
+  }
+  mcpServerConfig() {
+    return {
+      name: "openpond-sandboxes",
+      transport: "streamable-http",
+      url: `${this.sandboxApiUrl}/mcp`,
+      headers: {
+        "openpond-api-key": this.apiKey
+      }
+    };
+  }
+  smoke(options = {}) {
+    return runSandboxSmoke(this, options);
+  }
+};
+function createOpenPondSandboxClient2(options) {
+  return new OpenPondSandboxClient(options);
+}
+var MAX_WORK_INPUT_BYTES = 100 * 1024 * 1024;
+var WORK_OUTPUT_MIME_TYPES = Object.freeze({
+  ".avif": "image/avif",
+  ".csv": "text/csv",
+  ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  ".gif": "image/gif",
+  ".html": "text/html",
+  ".jpeg": "image/jpeg",
+  ".jpg": "image/jpeg",
+  ".json": "application/json",
+  ".m4a": "audio/mp4",
+  ".md": "text/markdown",
+  ".mov": "video/quicktime",
+  ".mp3": "audio/mpeg",
+  ".mp4": "video/mp4",
+  ".pdf": "application/pdf",
+  ".png": "image/png",
+  ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+  ".svg": "image/svg+xml",
+  ".tsv": "text/tab-separated-values",
+  ".txt": "text/plain",
+  ".wav": "audio/wav",
+  ".webm": "video/webm",
+  ".webp": "image/webp",
+  ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+});
+
+// ../server/src/openpond/sandbox-inputs.ts
+function normalizeOptionalUrl3(value) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed.replace(/\/$/, "") : null;
+}
+function asRecord4(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+var UI_PURPOSE_METADATA_KEYS = ["workspacePurpose", "purpose"];
+function sanitizeCreateMetadata(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const metadata = { ...value };
+  for (const key of UI_PURPOSE_METADATA_KEYS) {
+    delete metadata[key];
+  }
+  return metadata;
+}
+function sanitizeSandboxRuntimeInput(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const runtime = { ...value };
+  for (const key of UI_PURPOSE_METADATA_KEYS) {
+    delete runtime[key];
+  }
+  const metadata = sanitizeCreateMetadata(runtime.metadata);
+  if (metadata) {
+    runtime.metadata = metadata;
+  } else {
+    delete runtime.metadata;
+  }
+  return runtime;
+}
+function normalizeCreateInput(payload) {
+  const input = asRecord4(payload);
+  if (input.sandboxRuntime) {
+    throw new Error(
+      "Sandbox runtime settings must use /v1/runtimes before materializing a sandbox."
+    );
+  }
+  const out = {};
+  if (typeof input.repo === "string" && input.repo.trim()) out.repo = input.repo.trim();
+  if (typeof input.teamId === "string" && input.teamId.trim()) out.teamId = input.teamId.trim();
+  if (typeof input.projectId === "string" && input.projectId.trim()) {
+    out.projectId = input.projectId.trim();
+  }
+  if (typeof input.agentId === "string" && input.agentId.trim()) {
+    out.agentId = input.agentId.trim();
+  }
+  if (typeof input.command === "string" && input.command.trim()) out.command = input.command.trim();
+  if (typeof input.runtimeProfileId === "string" && input.runtimeProfileId.trim()) {
+    out.runtimeProfileId = input.runtimeProfileId.trim();
+  }
+  if (input.workloadSource && typeof input.workloadSource === "object" && !Array.isArray(input.workloadSource)) {
+    out.workloadSource = input.workloadSource;
+  }
+  if (input.sourceArchive && typeof input.sourceArchive === "object" && !Array.isArray(input.sourceArchive)) {
+    out.sourceArchive = input.sourceArchive;
+  }
+  if (input.visibility === "private" || input.visibility === "team") {
+    out.visibility = input.visibility;
+  }
+  if (input.resources && typeof input.resources === "object" && !Array.isArray(input.resources)) {
+    out.resources = input.resources;
+  }
+  if (input.budget && typeof input.budget === "object" && !Array.isArray(input.budget)) {
+    out.budget = input.budget;
+  }
+  if ("env" in input) {
+    out.env = normalizeSandboxEnvRefsForApp(input.env);
+  }
+  if (input.networkPolicy && typeof input.networkPolicy === "object" && !Array.isArray(input.networkPolicy)) {
+    out.networkPolicy = input.networkPolicy;
+  }
+  if (input.quotas && typeof input.quotas === "object" && !Array.isArray(input.quotas)) {
+    out.quotas = input.quotas;
+  }
+  if (Array.isArray(input.volumes)) {
+    out.volumes = input.volumes;
+  }
+  if ("integrationLeases" in input) {
+    out.integrationLeases = normalizeIntegrationLeaseRefsForRuntime(input.integrationLeases);
+  }
+  if (Array.isArray(input.integrationConnectionLeases)) {
+    out.integrationConnectionLeases = input.integrationConnectionLeases;
+  }
+  const metadata = sanitizeCreateMetadata(input.metadata);
+  if (metadata) out.metadata = metadata;
+  return out;
+}
+function normalizeSandboxRuntimeCreateInput(payload) {
+  const input = asRecord4(payload);
+  const runtime = sanitizeSandboxRuntimeInput(input) ?? {};
+  const out = {};
+  if (typeof runtime.teamId === "string" && runtime.teamId.trim()) {
+    out.teamId = runtime.teamId.trim();
+  }
+  if (typeof runtime.projectId === "string" && runtime.projectId.trim()) {
+    out.projectId = runtime.projectId.trim();
+  }
+  if (typeof runtime.agentId === "string" && runtime.agentId.trim()) {
+    out.agentId = runtime.agentId.trim();
+  }
+  if (typeof runtime.workflowMode === "string" && runtime.workflowMode.trim()) {
+    out.workflowMode = runtime.workflowMode.trim();
+  } else if (typeof runtime.mode === "string" && runtime.mode.trim()) {
+    out.workflowMode = runtime.mode.trim();
+  }
+  if (typeof runtime.baseBranch === "string" && runtime.baseBranch.trim()) {
+    out.baseBranch = runtime.baseBranch.trim();
+  }
+  if (typeof runtime.baseSha === "string" && runtime.baseSha.trim()) {
+    out.baseSha = runtime.baseSha.trim();
+  }
+  if (typeof runtime.sandboxId === "string" && runtime.sandboxId.trim()) {
+    out.sandboxId = runtime.sandboxId.trim();
+  }
+  if (typeof runtime.rootfsSnapshotId === "string" && runtime.rootfsSnapshotId.trim()) {
+    out.rootfsSnapshotId = runtime.rootfsSnapshotId.trim();
+  }
+  if (typeof runtime.dependencySnapshotId === "string" && runtime.dependencySnapshotId.trim()) {
+    out.dependencySnapshotId = runtime.dependencySnapshotId.trim();
+  }
+  if (typeof runtime.runtimeProfileId === "string" && runtime.runtimeProfileId.trim()) {
+    out.runtimeProfileId = runtime.runtimeProfileId.trim();
+  }
+  if (typeof runtime.promotionPolicy === "string" && runtime.promotionPolicy.trim()) {
+    out.promotionPolicy = runtime.promotionPolicy.trim();
+  }
+  if (runtime.metadata && typeof runtime.metadata === "object" && !Array.isArray(runtime.metadata)) {
+    out.metadata = runtime.metadata;
+  }
+  return out;
+}
+function normalizeSandboxRuntimeSandboxCreateInput(payload) {
+  return normalizeCreateInput(payload);
+}
+function normalizeSnapshotCreateInput(payload) {
+  return asRecord4(payload);
+}
+function normalizeSandboxListInput(payload) {
+  const input = asRecord4(payload);
+  const teamId = typeof input.teamId === "string" ? input.teamId.trim() : "";
+  const projectId = typeof input.projectId === "string" ? input.projectId.trim() : "";
+  const agentId = typeof input.agentId === "string" ? input.agentId.trim() : "";
+  return {
+    ...teamId ? { teamId } : {},
+    ...projectId ? { projectId } : {},
+    ...agentId ? { agentId } : {}
+  };
+}
+function normalizeReplayStartInput(payload) {
+  const input = asRecord4(payload);
+  const teamId = typeof input.teamId === "string" ? input.teamId.trim() : "";
+  const projectId = typeof input.projectId === "string" ? input.projectId.trim() : "";
+  const {
+    teamId: _teamId,
+    projectId: _projectId,
+    appId: _appId,
+    ...body
+  } = input;
+  const out = body;
+  if (teamId) out.teamId = teamId;
+  if (projectId) out.projectId = projectId;
+  return out;
+}
+function normalizeIntegrationStatusFilter(value) {
+  if (value === "active" || value === "revoked" || value === "error" || value === "all") {
+    return value;
+  }
+  return void 0;
+}
+function normalizeIntegrationAttachInput(payload) {
+  const input = asRecord4(payload);
+  const connectionId = typeof input.connectionId === "string" ? input.connectionId.trim() : "";
+  if (!connectionId) {
+    throw new Error("Sandbox integration connection is required.");
+  }
+  const capabilities = normalizeStringArray(input.capabilities);
+  if (capabilities.length === 0) {
+    throw new Error("Sandbox integration capabilities are required.");
+  }
+  validateIntegrationCapabilitiesForProvider(input.provider, capabilities);
+  const scopes = normalizeOptionalStringArray(input.scopes, "Sandbox integration scopes");
+  const expiresAt = normalizeIntegrationExpiresAt(input.expiresAt);
+  const ttlSeconds = normalizeIntegrationTtlSeconds(input.ttlSeconds);
+  const resourcePolicy = normalizeIntegrationResourcePolicy(input.resourcePolicy);
+  return {
+    connectionId,
+    capabilities,
+    ...scopes.length > 0 ? { scopes } : {},
+    ...resourcePolicy ? { resourcePolicy } : {},
+    ...expiresAt ? { expiresAt } : {},
+    ...ttlSeconds !== void 0 ? { ttlSeconds } : {},
+    ...typeof input.required === "boolean" ? { required: input.required } : {}
+  };
+}
+function normalizeIntegrationLeaseRefsForRuntime(value) {
+  if (value === void 0 || value === null) return [];
+  if (!Array.isArray(value)) {
+    throw new Error("Sandbox integration leases must be an array.");
+  }
+  return value.map((item) => normalizeIntegrationLeaseRefForRuntime(item));
+}
+function normalizeIntegrationLeaseRefForRuntime(value) {
+  const input = asRecord4(value);
+  const leaseId = typeof input.leaseId === "string" ? input.leaseId.trim() : "";
+  if (!leaseId) {
+    throw new Error("Sandbox integration leaseId is required.");
+  }
+  if ("connectionId" in input) {
+    throw new Error("Sandbox integration leases must use leaseId/proxy refs, not connection ids.");
+  }
+  assertNoSensitiveIntegrationLeaseKeys(input);
+  const provider = normalizeLeaseableIntegrationProvider(input.provider);
+  const capabilities = normalizeStringArray(input.capabilities);
+  if (capabilities.length === 0) {
+    throw new Error("Sandbox integration lease capabilities are required.");
+  }
+  validateIntegrationCapabilitiesForProvider(provider, capabilities);
+  const scopes = normalizeOptionalStringArray(input.scopes, "Sandbox integration lease scopes");
+  const resourcePolicy = normalizeIntegrationResourcePolicy(input.resourcePolicy);
+  const expiresAt = normalizeIntegrationExpiresAt(input.expiresAt);
+  const proxyUrl = typeof input.proxyUrl === "string" ? input.proxyUrl.trim() : "";
+  return {
+    leaseId,
+    provider,
+    capabilities,
+    ...scopes.length > 0 ? { scopes } : {},
+    ...resourcePolicy ? { resourcePolicy } : {},
+    ...expiresAt ? { expiresAt } : {},
+    ...proxyUrl ? { proxyUrl } : {},
+    ...typeof input.required === "boolean" ? { required: input.required } : {}
+  };
+}
+function normalizeLeaseableIntegrationProvider(value) {
+  if (typeof value !== "string") {
+    throw new Error("Sandbox integration lease provider is required.");
+  }
+  const provider = normalizeConnectedAppProviderFamilyId(value);
+  if (!provider) {
+    throw new Error(`Sandbox integration provider is not supported: ${value}`);
+  }
+  const bundle = connectedAppBundleByProvider(provider);
+  if (!bundle?.leasePolicy.leaseable) {
+    throw new Error(`Sandbox integration provider is not leaseable: ${provider}`);
+  }
+  return provider;
+}
+function assertNoSensitiveIntegrationLeaseKeys(value) {
+  for (const key of Object.keys(value)) {
+    if (isSensitivePolicyKey(key)) {
+      throw new Error("Sandbox integration leases must not include secrets or credentials.");
+    }
+  }
+}
+function validateIntegrationCapabilitiesForProvider(providerValue, capabilities) {
+  if (providerValue === void 0 || providerValue === null || providerValue === "") {
+    return;
+  }
+  if (typeof providerValue !== "string") {
+    throw new Error("Sandbox integration provider must be a string.");
+  }
+  const provider = normalizeConnectedAppProviderFamilyId(providerValue);
+  if (!provider) {
+    throw new Error(`Sandbox integration provider is not supported: ${providerValue}`);
+  }
+  const bundle = connectedAppBundleByProvider(provider);
+  if (!bundle?.leasePolicy.leaseable) {
+    throw new Error(`Sandbox integration provider is not leaseable: ${provider}`);
+  }
+  const allowedCapabilities = new Set(bundle.leasePolicy.allowedCapabilityIds);
+  const deniedCapabilities = capabilities.filter((capability) => !allowedCapabilities.has(capability));
+  if (deniedCapabilities.length > 0) {
+    throw new Error(
+      `Sandbox integration capabilities are not allowed for ${provider}: ${deniedCapabilities.join(", ")}`
+    );
+  }
+}
+function normalizeIntegrationLeaseId(payload) {
+  const input = asRecord4(payload);
+  const leaseId = typeof input.leaseId === "string" ? input.leaseId.trim() : "";
+  if (!leaseId) {
+    throw new Error("Sandbox integration lease is required.");
+  }
+  return leaseId;
+}
+function normalizeStringArray(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.map((item) => typeof item === "string" ? item.trim() : "").filter(Boolean);
+}
+function normalizeOptionalStringArray(value, label) {
+  if (value === void 0 || value === null) return [];
+  if (!Array.isArray(value)) {
+    throw new Error(`${label} must be an array of strings.`);
+  }
+  return value.map((item) => {
+    if (typeof item !== "string") {
+      throw new Error(`${label} must contain only strings.`);
+    }
+    const trimmed = item.trim();
+    if (!trimmed) {
+      throw new Error(`${label} must not contain empty values.`);
+    }
+    return trimmed;
+  });
+}
+function normalizeIntegrationTtlSeconds(value) {
+  if (value === void 0 || value === null || value === "") return void 0;
+  const ttlSeconds = Number(value);
+  if (!Number.isFinite(ttlSeconds) || ttlSeconds <= 0) {
+    throw new Error("Sandbox integration ttlSeconds must be a positive number.");
+  }
+  return Math.max(1, Math.floor(ttlSeconds));
+}
+function normalizeIntegrationExpiresAt(value) {
+  if (value === void 0 || value === null || value === "") return void 0;
+  if (typeof value !== "string") {
+    throw new Error("Sandbox integration expiresAt must be an ISO timestamp string.");
+  }
+  const trimmed = value.trim();
+  if (!trimmed) return void 0;
+  const parsed = Date.parse(trimmed);
+  if (!Number.isFinite(parsed)) {
+    throw new Error("Sandbox integration expiresAt must be a valid ISO timestamp.");
+  }
+  return trimmed;
+}
+function normalizeIntegrationResourcePolicy(value) {
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("Sandbox integration resourcePolicy must be an object.");
+  }
+  assertNoSensitiveResourcePolicyKeys(value, []);
+  const serialized = JSON.stringify(value);
+  if (serialized.length > 16 * 1024) {
+    throw new Error("Sandbox integration resourcePolicy is too large.");
+  }
+  return value;
+}
+function assertNoSensitiveResourcePolicyKeys(value, path37) {
+  if (!value || typeof value !== "object") return;
+  if (path37.length > 8) {
+    throw new Error("Sandbox integration resourcePolicy is too deeply nested.");
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) assertNoSensitiveResourcePolicyKeys(item, path37);
+    return;
+  }
+  for (const [key, child] of Object.entries(value)) {
+    if (isSensitivePolicyKey(key)) {
+      throw new Error("Sandbox integration resourcePolicy must not include secrets or credentials.");
+    }
+    assertNoSensitiveResourcePolicyKeys(child, [...path37, key]);
+  }
+}
+function isSensitivePolicyKey(key) {
+  const normalized = key.toLowerCase().replace(/[^a-z0-9]/g, "");
+  return normalized.includes("accesstoken") || normalized.includes("refreshtoken") || normalized.includes("idtoken") || normalized.includes("oauth") || normalized.includes("bearer") || normalized.includes("authorization") || normalized.includes("cookie") || normalized.includes("secret") || normalized.includes("password") || normalized.includes("credential");
+}
+function normalizeExecInput(payload) {
+  const input = asRecord4(payload);
+  const command = typeof input.command === "string" ? input.command.trim() : "";
+  if (!command) throw new Error("Sandbox command is required.");
+  const timeoutSeconds = typeof input.timeoutSeconds === "number" && Number.isFinite(input.timeoutSeconds) ? Math.max(1, Math.floor(input.timeoutSeconds)) : void 0;
+  const pipefailCommand = pipefailSandboxShellCommand(command);
+  return timeoutSeconds ? { command: pipefailCommand, timeoutSeconds } : { command: pipefailCommand };
+}
+function normalizeProcessStartInput(payload) {
+  const input = asRecord4(payload);
+  const command = typeof input.command === "string" ? input.command.trim() : "";
+  if (!command) throw new Error("Sandbox process command is required.");
+  const timeoutSeconds = typeof input.timeoutSeconds === "number" && Number.isFinite(input.timeoutSeconds) ? Math.max(1, Math.floor(input.timeoutSeconds)) : void 0;
+  return timeoutSeconds ? { command, timeoutSeconds } : { command };
+}
+function normalizeProcessCursorInput(payload) {
+  const input = asRecord4(payload);
+  const since = Number(input.since);
+  return Number.isFinite(since) ? { since: Math.max(0, Math.floor(since)) } : {};
+}
+function normalizeOpenPortInput(payload) {
+  const input = asRecord4(payload);
+  const port = typeof input.port === "number" ? input.port : Number(input.port);
+  if (!Number.isInteger(port) || port < SANDBOX_TEMPLATE_PREVIEW_PORT_MIN || port > SANDBOX_TEMPLATE_PREVIEW_PORT_MAX) {
+    throw new Error(
+      `Sandbox preview port must be between ${SANDBOX_TEMPLATE_PREVIEW_PORT_MIN} and ${SANDBOX_TEMPLATE_PREVIEW_PORT_MAX}.`
+    );
+  }
+  const label = typeof input.label === "string" && input.label.trim() ? input.label.trim() : void 0;
+  const access3 = input.access === "public" || input.access === "private" ? input.access : void 0;
+  const autoStart = input.autoStart === true;
+  const customDomain = typeof input.customDomain === "string" && input.customDomain.trim() ? input.customDomain.trim() : void 0;
+  const out = {
+    port,
+    ...label ? { label } : {},
+    ...access3 ? { access: access3 } : {},
+    ...autoStart ? { autoStart } : {},
+    ...customDomain ? { customDomain } : {}
+  };
+  if (input.cors && typeof input.cors === "object" && !Array.isArray(input.cors)) {
+    out.cors = input.cors;
+  }
+  if (input.headerPolicy && typeof input.headerPolicy === "object" && !Array.isArray(input.headerPolicy)) {
+    out.headerPolicy = input.headerPolicy;
+  }
+  if (input.authPolicy && typeof input.authPolicy === "object" && !Array.isArray(input.authPolicy)) {
+    out.authPolicy = input.authPolicy;
+  }
+  return out;
+}
+function normalizeSnapshotUpdateInput(payload) {
+  const input = asRecord4(payload);
+  const out = {};
+  if (input.template && typeof input.template === "object" && !Array.isArray(input.template)) {
+    const template = asRecord4(input.template);
+    const nextTemplate = {};
+    if (typeof template.description === "string") {
+      nextTemplate.description = template.description.trim();
+    } else if (template.description === null) {
+      nextTemplate.description = null;
+    }
+    if (Array.isArray(template.tags)) {
+      nextTemplate.tags = template.tags.map((item) => typeof item === "string" ? item.trim() : "").filter(Boolean).slice(0, 20);
+    }
+    if (template.visibility === "private" || template.visibility === "team") {
+      nextTemplate.visibility = template.visibility;
+    }
+    if (typeof template.useCase === "string") {
+      nextTemplate.useCase = template.useCase.trim();
+    } else if (template.useCase === null) {
+      nextTemplate.useCase = null;
+    }
+    if (Object.keys(nextTemplate).length > 0) {
+      out.template = nextTemplate;
+    }
+  }
+  if (input.retention && typeof input.retention === "object" && !Array.isArray(input.retention)) {
+    const retention = asRecord4(input.retention);
+    const nextRetention = {};
+    if (retention.class === "ephemeral" || retention.class === "cached" || retention.class === "pinned") {
+      nextRetention.class = retention.class;
+    }
+    if (retention.ttlSeconds === null) {
+      nextRetention.ttlSeconds = null;
+    } else if (typeof retention.ttlSeconds === "number" && Number.isFinite(retention.ttlSeconds)) {
+      nextRetention.ttlSeconds = Math.max(1, Math.floor(retention.ttlSeconds));
+    }
+    if (Object.keys(nextRetention).length > 0) {
+      out.retention = nextRetention;
+    }
+  }
+  if (!out.template && !out.retention) {
+    throw new Error("Snapshot update requires template or retention changes.");
+  }
+  return out;
+}
+function normalizeSnapshotValidateInput(payload) {
+  const input = asRecord4(payload);
+  const cleanup = typeof input.cleanup === "string" ? input.cleanup.trim() : "";
+  if (cleanup === "delete" || cleanup === "stop" || cleanup === "archive") {
+    return { cleanup };
+  }
+  return {};
+}
+function normalizeForkInput(payload) {
+  const input = asRecord4(payload);
+  const out = {};
+  if (typeof input.snapshotId === "string" && input.snapshotId.trim()) {
+    out.snapshotId = input.snapshotId.trim();
+  }
+  if (input.visibility === "private" || input.visibility === "team") {
+    out.visibility = input.visibility;
+  }
+  if (input.resources && typeof input.resources === "object" && !Array.isArray(input.resources)) {
+    out.resources = input.resources;
+  }
+  if (input.budget && typeof input.budget === "object" && !Array.isArray(input.budget)) {
+    out.budget = input.budget;
+  }
+  if (input.networkPolicy && typeof input.networkPolicy === "object" && !Array.isArray(input.networkPolicy)) {
+    out.networkPolicy = input.networkPolicy;
+  }
+  if (input.quotas && typeof input.quotas === "object" && !Array.isArray(input.quotas)) {
+    out.quotas = input.quotas;
+  }
+  if (Array.isArray(input.volumes)) {
+    out.volumes = input.volumes;
+  }
+  if ("integrationLeases" in input) {
+    out.integrationLeases = normalizeIntegrationLeaseRefsForRuntime(input.integrationLeases);
+  }
+  if ("env" in input) {
+    out.env = normalizeSandboxEnvRefsForApp(input.env);
+  }
+  if (input.metadata && typeof input.metadata === "object" && !Array.isArray(input.metadata)) {
+    out.metadata = input.metadata;
+  }
+  return out;
+}
+function normalizeSandboxEnvRefsForApp(value) {
+  if (value === void 0 || value === null) return [];
+  if (!Array.isArray(value)) {
+    throw new Error("Sandbox env must be an array.");
+  }
+  return value.map((item) => {
+    if (!item || typeof item !== "object" || Array.isArray(item)) {
+      throw new Error("Sandbox env entries must be objects.");
+    }
+    const record5 = item;
+    if ("value" in record5) {
+      throw new Error("Sandbox env entries must use secretRef, not inline values.");
+    }
+    const name = typeof record5.name === "string" ? record5.name.trim() : "";
+    const secretRef = typeof record5.secretRef === "string" ? record5.secretRef.trim() : "";
+    if (!name || !secretRef) {
+      throw new Error("Sandbox env entries require name and secretRef.");
+    }
+    return { name, secretRef };
+  });
+}
+function normalizeTemplateLaunchInput(payload) {
+  const input = asRecord4(payload);
+  const teamId = typeof input.teamId === "string" ? input.teamId.trim() : "";
+  const projectId = typeof input.projectId === "string" ? input.projectId.trim() : "";
+  const snapshotId = typeof input.snapshotId === "string" ? input.snapshotId.trim() : "";
+  const templateName = typeof input.templateName === "string" ? input.templateName.trim() : "";
+  const version = typeof input.version === "string" ? input.version.trim() : "";
+  const useCase = typeof input.useCase === "string" ? input.useCase.trim() : "";
+  if (!snapshotId && !templateName && !useCase) {
+    throw new Error("Sandbox template launch requires snapshotId, templateName, or useCase.");
+  }
+  return {
+    ...normalizeForkInput(payload),
+    ...teamId ? { teamId } : {},
+    ...projectId ? { projectId } : {},
+    ...snapshotId ? { snapshotId } : {},
+    ...templateName ? { templateName } : {},
+    ...version ? { version } : {},
+    ...useCase ? { useCase } : {}
+  };
+}
+function normalizeListFilesInput(payload) {
+  const input = asRecord4(payload);
+  const path37 = typeof input.path === "string" ? input.path.trim() : "";
+  const maxEntries = Number(input.maxEntries);
+  return {
+    ...path37 ? { path: path37 } : {},
+    ...typeof input.recursive === "boolean" ? { recursive: input.recursive } : {},
+    ...Number.isFinite(maxEntries) ? { maxEntries } : {}
+  };
+}
+function normalizeSearchFilesInput(payload) {
+  const input = asRecord4(payload);
+  const query = typeof input.query === "string" ? input.query.trim() : "";
+  if (!query) {
+    throw new Error("Sandbox file search query is required.");
+  }
+  const path37 = typeof input.path === "string" ? input.path.trim() : "";
+  const maxResults = Number(input.maxResults);
+  return {
+    query,
+    ...path37 ? { path: path37 } : {},
+    ...Number.isFinite(maxResults) ? { maxResults } : {}
+  };
+}
+function normalizeDeleteFileInput(payload) {
+  const input = asRecord4(payload);
+  const path37 = typeof input.path === "string" ? input.path.trim() : "";
+  if (!path37) {
+    throw new Error("Sandbox file path is required.");
+  }
+  return {
+    path: path37,
+    recursive: typeof input.recursive === "boolean" ? input.recursive : void 0
+  };
+}
+function normalizeDownloadFileInput(payload) {
+  const input = normalizeDeleteFileInput(payload);
+  const raw = asRecord4(payload);
+  const offsetBytes = Number(raw.offsetBytes);
+  const maxBytes = Number(raw.maxBytes);
+  return {
+    path: input.path,
+    ...Number.isFinite(offsetBytes) ? { offsetBytes } : {},
+    ...Number.isFinite(maxBytes) ? { maxBytes } : {}
+  };
+}
+function normalizeUploadFileInput(payload) {
+  const input = asRecord4(payload);
+  const path37 = typeof input.path === "string" ? input.path.trim() : "";
+  const contents = typeof input.contents === "string" ? input.contents : "";
+  const contentsBase64 = typeof input.contentsBase64 === "string" ? input.contentsBase64.trim() : "";
+  if (!path37) {
+    throw new Error("Sandbox file path is required.");
+  }
+  if (!contents && !contentsBase64) {
+    throw new Error("Sandbox file contents are required.");
+  }
+  return {
+    path: path37,
+    contents,
+    contentsBase64
+  };
+}
+function normalizeMoveFileInput(payload) {
+  const input = asRecord4(payload);
+  const fromPath = typeof input.fromPath === "string" ? input.fromPath.trim() : "";
+  const toPath = typeof input.toPath === "string" ? input.toPath.trim() : "";
+  if (!fromPath || !toPath) {
+    throw new Error("Sandbox file source and target paths are required.");
+  }
+  return {
+    fromPath,
+    toPath,
+    overwrite: typeof input.overwrite === "boolean" ? input.overwrite : void 0
+  };
+}
+function normalizeGitBranchInput(payload) {
+  const input = asRecord4(payload);
+  const branch = typeof input.branch === "string" ? input.branch.trim() : "";
+  const startPoint = typeof input.startPoint === "string" ? input.startPoint.trim() : "";
+  if (!branch) {
+    throw new Error("Sandbox git branch name is required.");
+  }
+  return {
+    branch,
+    create: input.create === true,
+    ...startPoint ? { startPoint } : {}
+  };
+}
+function normalizeGitCommitInput(payload) {
+  const input = asRecord4(payload);
+  const message = typeof input.message === "string" ? input.message.trim() : "";
+  const all = input.all === true;
+  const paths = Array.isArray(input.paths) ? input.paths.filter((path37) => typeof path37 === "string" && path37.trim() !== "") : [];
+  if (!message) {
+    throw new Error("Sandbox git commit message is required.");
+  }
+  if (!all && paths.length === 0) {
+    throw new Error("Sandbox git commit requires all=true or at least one path.");
+  }
+  return {
+    message,
+    ...all ? { all: true } : { paths: paths.map((path37) => path37.trim()) }
+  };
+}
+function normalizeGitPullInput(payload) {
+  const input = asRecord4(payload);
+  const remote = typeof input.remote === "string" ? input.remote.trim() : "";
+  const branch = typeof input.branch === "string" ? input.branch.trim() : "";
+  const rebase = input.rebase === true;
+  const ffOnly = typeof input.ffOnly === "boolean" ? input.ffOnly : void 0;
+  if (rebase && ffOnly) {
+    throw new Error("Sandbox git pull cannot use rebase and ff-only together.");
+  }
+  return {
+    ...remote ? { remote } : {},
+    ...branch ? { branch } : {},
+    ...rebase ? { rebase } : {},
+    ...typeof ffOnly === "boolean" ? { ffOnly } : {}
+  };
+}
+function normalizeGitPushInput(payload) {
+  const input = asRecord4(payload);
+  const remote = typeof input.remote === "string" ? input.remote.trim() : "";
+  const branch = typeof input.branch === "string" ? input.branch.trim() : "";
+  return {
+    ...remote ? { remote } : {},
+    ...branch ? { branch } : {},
+    ...input.setUpstream === true ? { setUpstream: true } : {},
+    ...input.forceWithLease === true ? { forceWithLease: true } : {}
+  };
+}
+
+// ../server/src/openpond/sandboxes.ts
+async function resolveOpenPondSandboxClient() {
+  return (await resolveSandboxClient()).client;
+}
+var DEFAULT_OPENPOND_SANDBOX_BASE_URL = "https://api.openpond.ai";
+async function sandboxRequestPayload(action) {
+  const { client, context, apiKey, sandboxApiUrl } = await resolveSandboxClient();
+  const account = sandboxAccountSummary(context, sandboxApiUrl);
+  if (action.type === "list") {
+    return {
+      sandboxes: await client.list(normalizeSandboxListInput(action.payload)),
+      account
+    };
+  }
+  if (action.type === "snapshot_catalog") {
+    const input = asRecord4(action.payload);
+    const teamId = typeof input.teamId === "string" ? input.teamId.trim() : "";
+    const projectId = typeof input.projectId === "string" ? input.projectId.trim() : "";
+    const agentId = typeof input.agentId === "string" ? input.agentId.trim() : "";
+    const query = typeof input.q === "string" ? input.q.trim() : "";
+    const tag = typeof input.tag === "string" ? input.tag.trim() : "";
+    const useCase = typeof input.useCase === "string" ? input.useCase.trim() : "";
+    const replayState = input.replayState === "draft" || input.replayState === "validated" || input.replayState === "published" ? input.replayState : void 0;
+    return {
+      ...await client.snapshotCatalog({
+        ...teamId ? { teamId } : {},
+        ...projectId ? { projectId } : {},
+        ...agentId ? { agentId } : {},
+        ...query ? { q: query } : {},
+        ...tag ? { tag } : {},
+        ...useCase ? { useCase } : {},
+        ...replayState ? { replayState } : {}
+      }),
+      account
+    };
+  }
+  if (action.type === "snapshot_create") {
+    return {
+      ...await client.createSnapshot(
+        action.sandboxId,
+        normalizeSnapshotCreateInput(action.payload)
+      ),
+      account
+    };
+  }
+  if (action.type === "template_catalog") {
+    const input = asRecord4(action.payload);
+    const teamId = typeof input.teamId === "string" ? input.teamId.trim() : "";
+    const projectId = typeof input.projectId === "string" ? input.projectId.trim() : "";
+    const query = typeof input.q === "string" ? input.q.trim() : "";
+    const name = typeof input.name === "string" ? input.name.trim() : "";
+    const version = typeof input.version === "string" ? input.version.trim() : "";
+    const tag = typeof input.tag === "string" ? input.tag.trim() : "";
+    const useCase = typeof input.useCase === "string" ? input.useCase.trim() : "";
+    return {
+      ...await client.templates({
+        ...teamId ? { teamId } : {},
+        ...projectId ? { projectId } : {},
+        ...query ? { q: query } : {},
+        ...name ? { name } : {},
+        ...version ? { version } : {},
+        ...tag ? { tag } : {},
+        ...useCase ? { useCase } : {}
+      }),
+      account
+    };
+  }
+  if (action.type === "integration_connections") {
+    const input = asRecord4(action.payload);
+    const teamId = typeof input.teamId === "string" ? input.teamId.trim() : "";
+    const projectId = typeof input.projectId === "string" ? input.projectId.trim() : "";
+    const agentId = typeof input.agentId === "string" ? input.agentId.trim() : "";
+    const status = normalizeIntegrationStatusFilter(input.status);
+    const query = {
+      ...projectId ? { projectId } : {},
+      ...agentId ? { agentId } : {},
+      status: status ?? "all"
+    };
+    const result = teamId ? await client.integrationConnections({
+      teamId,
+      ...query
+    }) : await resolveImplicitConnectedAppStatusConnections(client, query);
+    return {
+      ...result,
+      account
+    };
+  }
+  if (action.type === "connected_app_status") {
+    const input = asRecord4(action.payload);
+    const explicitTeamId = typeof input.teamId === "string" ? input.teamId.trim() : "";
+    const projectId = typeof input.projectId === "string" ? input.projectId.trim() : "";
+    const agentId = typeof input.agentId === "string" ? input.agentId.trim() : "";
+    const status = normalizeIntegrationStatusFilter(input.status) ?? "all";
+    const query = {
+      ...projectId ? { projectId } : {},
+      ...agentId ? { agentId } : {},
+      status
+    };
+    const result = explicitTeamId ? await client.integrationConnections({
+      teamId: explicitTeamId,
+      ...query
+    }) : await resolveImplicitConnectedAppStatusConnections(client, query);
+    return {
+      teamId: result.teamId,
+      apps: buildConnectedAppStatusRows({ connections: result.connections }),
+      account
+    };
+  }
+  if (action.type === "sandbox_runtime_list") {
+    return {
+      runtimes: await client.listSandboxRuntimes(
+        normalizeSandboxListInput(action.payload)
+      ),
+      account
+    };
+  }
+  if (action.type === "sandbox_runtime_get") {
+    return {
+      runtime: await client.getSandboxRuntime(action.runtimeId),
+      account
+    };
+  }
+  if (action.type === "sandbox_runtime_create") {
+    return {
+      runtime: await client.createSandboxRuntime(
+        normalizeSandboxRuntimeCreateInput(action.payload)
+      ),
+      account
+    };
+  }
+  if (action.type === "sandbox_runtime_sandbox_create") {
+    return {
+      ...await client.createSandboxRuntimeSandbox(
+        action.runtimeId,
+        normalizeSandboxRuntimeSandboxCreateInput(action.payload),
+        { respondAsync: true }
+      ),
+      account
+    };
+  }
+  if (action.type === "sandbox_runtime_resume") {
+    const sandbox = await client.sandboxRuntime(action.runtimeId).resume(normalizeSandboxRuntimeSandboxCreateInput(action.payload), {
+      respondAsync: true
+    });
+    const runtime = await client.getSandboxRuntime(action.runtimeId);
+    return {
+      runtime,
+      sandbox,
+      account
+    };
+  }
+  if (action.type === "sandbox_runtime_preserve_source") {
+    const input = asRecord4(action.payload);
+    return {
+      ...await client.preserveSandboxRuntimeSource(
+        action.runtimeId,
+        {
+          ...typeof input.sandboxId === "string" && input.sandboxId.trim() ? { sandboxId: input.sandboxId.trim() } : {},
+          ...typeof input.message === "string" && input.message.trim() ? { message: input.message.trim() } : {},
+          ...input.source === "profile" ? { source: "profile" } : {}
+        },
+        normalizeSandboxListInput(action.payload)
+      ),
+      account
+    };
+  }
+  if (action.type === "sandbox_runtime_promote") {
+    const input = asRecord4(action.payload);
+    return {
+      ...await client.promoteSandboxRuntime(
+        action.runtimeId,
+        {
+          expectedTargetSha: typeof input.expectedTargetSha === "string" ? input.expectedTargetSha.trim() : "",
+          ...input.validationState === "pending" || input.validationState === "passed" ? { validationState: input.validationState } : {},
+          ...typeof input.summary === "string" && input.summary.trim() ? { summary: input.summary.trim() } : {}
+        },
+        normalizeSandboxListInput(action.payload)
+      ),
+      account
+    };
+  }
+  if (action.type === "project_list") {
+    return {
+      ...await requestSandboxPublicApiRoot({
+        apiKey,
+        sandboxApiUrl,
+        path: sandboxScopedCollectionPath(
+          "/projects",
+          normalizeSandboxListInput(action.payload)
+        )
+      }),
+      account
+    };
+  }
+  if (action.type === "profile_get") {
+    return {
+      ...await requestSandboxPublicApiRoot({
+        apiKey,
+        sandboxApiUrl,
+        path: sandboxScopedCollectionPath(
+          "/profile",
+          normalizeSandboxListInput(action.payload)
+        )
+      }),
+      account
+    };
+  }
+  if (action.type === "profile_ensure") {
+    return {
+      ...await requestSandboxPublicApiRoot({
+        apiKey,
+        sandboxApiUrl,
+        path: sandboxScopedCollectionPath(
+          "/profile/ensure",
+          normalizeSandboxListInput(action.payload)
+        ),
+        method: "POST"
+      }),
+      account
+    };
+  }
+  if (action.type === "profile_push") {
+    const payload = asRecord4(action.payload);
+    const { teamId: _teamId, ...body } = payload;
+    return {
+      ...await requestSandboxPublicApiRoot({
+        apiKey,
+        sandboxApiUrl,
+        path: sandboxScopedCollectionPath(
+          "/profile/push",
+          normalizeSandboxListInput(payload)
+        ),
+        method: "POST",
+        body
+      }),
+      account
+    };
+  }
+  if (action.type === "project_upsert") {
+    return {
+      ...await requestSandboxPublicApiRoot({
+        apiKey,
+        sandboxApiUrl,
+        path: "/projects",
+        method: "POST",
+        body: asRecord4(action.payload)
+      }),
+      account
+    };
+  }
+  if (action.type === "project_get") {
+    return {
+      ...await requestSandboxPublicApiRoot({
+        apiKey,
+        sandboxApiUrl,
+        path: sandboxScopedCollectionPath(
+          `/projects/${encodeURIComponent(action.projectId)}`,
+          normalizeSandboxListInput(action.payload)
+        )
+      }),
+      account
+    };
+  }
+  if (action.type === "project_git") {
+    return {
+      ...await requestSandboxPublicApiRoot({
+        apiKey,
+        sandboxApiUrl,
+        path: sandboxScopedCollectionPath(
+          `/projects/${encodeURIComponent(action.projectId)}/git`,
+          normalizeSandboxListInput(action.payload)
+        ),
+        method: "POST"
+      }),
+      account
+    };
+  }
+  if (action.type === "project_sync") {
+    return {
+      ...await requestSandboxPublicApiRoot({
+        apiKey,
+        sandboxApiUrl,
+        path: sandboxScopedCollectionPath(
+          `/projects/${encodeURIComponent(action.projectId)}/sync`,
+          normalizeSandboxListInput(action.payload)
+        ),
+        method: "POST"
+      }),
+      account
+    };
+  }
+  if (action.type === "project_source_upload") {
+    const payload = asRecord4(action.payload);
+    const { teamId: _teamId, ...body } = payload;
+    return {
+      ...await requestSandboxPublicApiRoot({
+        apiKey,
+        sandboxApiUrl,
+        path: sandboxScopedCollectionPath(
+          `/projects/${encodeURIComponent(action.projectId)}/source`,
+          normalizeSandboxListInput(payload)
+        ),
+        method: "POST",
+        body
+      }),
+      account
+    };
+  }
+  if (action.type === "project_archive") {
+    return {
+      ...await requestSandboxPublicApiRoot({
+        apiKey,
+        sandboxApiUrl,
+        path: sandboxScopedCollectionPath(
+          `/projects/${encodeURIComponent(action.projectId)}`,
+          normalizeSandboxListInput(action.payload)
+        ),
+        method: "DELETE"
+      }),
+      account
+    };
+  }
+  if (action.type === "agent_list") {
+    return {
+      ...await requestSandboxPublicApiRoot({
+        apiKey,
+        sandboxApiUrl,
+        path: sandboxScopedCollectionPath(
+          "/agents",
+          normalizeSandboxListInput(action.payload)
+        )
+      }),
+      account
+    };
+  }
+  if (action.type === "agent_upsert") {
+    return {
+      ...await requestSandboxPublicApiRoot({
+        apiKey,
+        sandboxApiUrl,
+        path: "/agents",
+        method: "POST",
+        body: asRecord4(action.payload)
+      }),
+      account
+    };
+  }
+  if (action.type === "agent_run") {
+    return {
+      ...await requestSandboxPublicApiRoot({
+        apiKey,
+        sandboxApiUrl,
+        path: `/agents/${encodeURIComponent(action.agentId)}/run`,
+        method: "POST",
+        body: asRecord4(action.payload)
+      }),
+      account
+    };
+  }
+  if (action.type === "agent_source_deploy_plan") {
+    return {
+      ...await requestSandboxPublicApiRoot({
+        apiKey,
+        sandboxApiUrl,
+        path: sandboxScopedCollectionPath(
+          `/agents/${encodeURIComponent(action.agentId)}/source/deploy-plan`,
+          normalizeSandboxListInput(action.payload)
+        )
+      }),
+      account
+    };
+  }
+  if (action.type === "agent_source_checks") {
+    const payload = asRecord4(action.payload);
+    const { teamId: _teamId, ...body } = payload;
+    return {
+      ...await requestSandboxPublicApiRoot({
+        apiKey,
+        sandboxApiUrl,
+        path: sandboxScopedCollectionPath(
+          `/agents/${encodeURIComponent(action.agentId)}/source/checks`,
+          normalizeSandboxListInput(payload)
+        ),
+        method: "POST",
+        body
+      }),
+      account
+    };
+  }
+  if (action.type === "agent_source_publish") {
+    const payload = asRecord4(action.payload);
+    const { teamId: _teamId, ...body } = payload;
+    return {
+      ...await requestSandboxPublicApiRoot({
+        apiKey,
+        sandboxApiUrl,
+        path: sandboxScopedCollectionPath(
+          `/agents/${encodeURIComponent(action.agentId)}/source/publish`,
+          normalizeSandboxListInput(payload)
+        ),
+        method: "POST",
+        body
+      }),
+      account
+    };
+  }
+  if (action.type === "create") {
+    return {
+      sandbox: await client.create(normalizeCreateInput(action.payload)),
+      account
+    };
+  }
+  if (action.type === "get") {
+    return { sandbox: await client.get(action.sandboxId), account };
+  }
+  if (action.type === "start") {
+    return {
+      ...await client.start(action.sandboxId, { respondAsync: true }),
+      account
+    };
+  }
+  if (action.type === "delete") {
+    const options = await sandboxLifecycleRequestOptions(
+      client,
+      action.sandboxId,
+      {
+        failOnUnpreservedChanges: action.failOnUnpreservedChanges
+      }
+    );
+    const sandbox = await client.delete(action.sandboxId, options).catch(
+      (error) => throwSandboxLifecycleRequestFailure(
+        "delete",
+        client,
+        action.sandboxId,
+        error
+      )
+    );
+    assertTerminalSandboxLifecycleSettled("delete", sandbox);
+    return {
+      sandbox,
+      account
+    };
+  }
+  if (action.type === "exec") {
+    return {
+      ...await client.exec(
+        action.sandboxId,
+        normalizeExecInput(action.payload)
+      ),
+      account
+    };
+  }
+  if (action.type === "action_run") {
+    return {
+      ...await requestSandboxApiRoot({
+        apiKey,
+        sandboxApiUrl,
+        path: `/sandboxes/${encodeURIComponent(
+          action.sandboxId
+        )}/actions/${encodeURIComponent(action.actionName)}/run`,
+        method: "POST",
+        body: asRecord4(action.payload)
+      }),
+      account
+    };
+  }
+  if (action.type === "open_port") {
+    return {
+      ...await client.openPort(
+        action.sandboxId,
+        normalizeOpenPortInput(action.payload)
+      ),
+      account
+    };
+  }
+  if (action.type === "snapshot_update") {
+    return {
+      ...await client.updateSnapshot(
+        action.sandboxId,
+        action.snapshotId,
+        normalizeSnapshotUpdateInput(action.payload)
+      ),
+      account
+    };
+  }
+  if (action.type === "snapshot_validate") {
+    return {
+      ...await client.validateSnapshot(
+        action.sandboxId,
+        action.snapshotId,
+        normalizeSnapshotValidateInput(action.payload)
+      ),
+      account
+    };
+  }
+  if (action.type === "snapshot_publish") {
+    return {
+      ...await client.publishSnapshot(action.sandboxId, action.snapshotId),
+      account
+    };
+  }
+  if (action.type === "replays") {
+    return {
+      ...await client.listReplays(normalizeSandboxListInput(action.payload)),
+      account
+    };
+  }
+  if (action.type === "replay_start") {
+    return {
+      ...await client.startReplay(normalizeReplayStartInput(action.payload)),
+      account
+    };
+  }
+  if (action.type === "replay_get") {
+    return {
+      ...await client.getReplay(
+        action.replayId,
+        normalizeSandboxListInput(action.payload)
+      ),
+      account
+    };
+  }
+  if (action.type === "replay_logs") {
+    return {
+      ...await client.getReplayLogs(
+        action.replayId,
+        normalizeSandboxListInput(action.payload)
+      ),
+      account
+    };
+  }
+  if (action.type === "replay_artifacts") {
+    return {
+      ...await client.getReplayArtifacts(
+        action.replayId,
+        normalizeSandboxListInput(action.payload)
+      ),
+      account
+    };
+  }
+  if (action.type === "replay_cancel") {
+    return {
+      ...await client.cancelReplay(
+        action.replayId,
+        normalizeSandboxListInput(action.payload)
+      ),
+      account
+    };
+  }
+  if (action.type === "schedule_create") {
+    return {
+      ...await client.createSchedule(
+        asRecord4(action.payload)
+      ),
+      account
+    };
+  }
+  if (action.type === "template_launch") {
+    return {
+      ...await client.launchTemplate(
+        normalizeTemplateLaunchInput(action.payload)
+      ),
+      account
+    };
+  }
+  if (action.type === "fork") {
+    return {
+      ...await client.fork(
+        action.sandboxId,
+        normalizeForkInput(action.payload)
+      ),
+      account
+    };
+  }
+  if (action.type === "stop") {
+    const options = await sandboxLifecycleRequestOptions(
+      client,
+      action.sandboxId,
+      {
+        failOnUnpreservedChanges: action.failOnUnpreservedChanges
+      }
+    );
+    const result = await client.stop(action.sandboxId, options).catch(
+      (error) => throwSandboxLifecycleRequestFailure(
+        "stop",
+        client,
+        action.sandboxId,
+        error
+      )
+    );
+    assertTerminalSandboxLifecycleSettled("stop", result.sandbox);
+    return {
+      ...result,
+      account
+    };
+  }
+  if (action.type === "receipts") {
+    return { receipts: await client.receipts(action.sandboxId), account };
+  }
+  if (action.type === "logs") {
+    return { logs: await client.logs(action.sandboxId), account };
+  }
+  if (action.type === "integration_leases") {
+    return { ...await client.integrationLeases(action.sandboxId), account };
+  }
+  if (action.type === "integration_attach") {
+    return {
+      ...await client.attachIntegrationConnection(
+        action.sandboxId,
+        normalizeIntegrationAttachInput(action.payload)
+      ),
+      account
+    };
+  }
+  if (action.type === "integration_remove") {
+    return {
+      ...await client.removeIntegrationLease(
+        action.sandboxId,
+        normalizeIntegrationLeaseId(action.payload)
+      ),
+      account
+    };
+  }
+  if (action.type === "process_start") {
+    return {
+      ...await client.startProcess(
+        action.sandboxId,
+        normalizeProcessStartInput(action.payload)
+      ),
+      account
+    };
+  }
+  if (action.type === "process_get") {
+    return {
+      ...await client.getProcess(
+        action.sandboxId,
+        action.processId,
+        normalizeProcessCursorInput(action.payload)
+      ),
+      account
+    };
+  }
+  if (action.type === "upload_file") {
+    const input = normalizeUploadFileInput(action.payload);
+    return {
+      ...input.contentsBase64 ? await client.uploadFileBase64(
+        action.sandboxId,
+        input.path,
+        input.contentsBase64
+      ) : await client.uploadFile(
+        action.sandboxId,
+        input.path,
+        input.contents
+      ),
+      account
+    };
+  }
+  if (action.type === "download_file") {
+    const input = normalizeDownloadFileInput(action.payload);
+    return {
+      ...await client.downloadFileResponse(action.sandboxId, input),
+      account
+    };
+  }
+  if (action.type === "list_files") {
+    return {
+      ...await client.listFiles(
+        action.sandboxId,
+        normalizeListFilesInput(action.payload)
+      ),
+      account
+    };
+  }
+  if (action.type === "search_files") {
+    return {
+      ...await client.searchFiles(
+        action.sandboxId,
+        normalizeSearchFilesInput(action.payload)
+      ),
+      account
+    };
+  }
+  if (action.type === "delete_file") {
+    const input = normalizeDeleteFileInput(action.payload);
+    return {
+      ...await client.deleteFile(action.sandboxId, input.path, {
+        recursive: input.recursive
+      }),
+      account
+    };
+  }
+  if (action.type === "stat_file") {
+    const input = normalizeDeleteFileInput(action.payload);
+    return {
+      ...await client.statFile(action.sandboxId, input.path),
+      account
+    };
+  }
+  if (action.type === "mkdir") {
+    const input = normalizeDeleteFileInput(action.payload);
+    return {
+      ...await client.mkdir(action.sandboxId, {
+        path: input.path,
+        recursive: input.recursive
+      }),
+      account
+    };
+  }
+  if (action.type === "move_file") {
+    const input = normalizeMoveFileInput(action.payload);
+    return {
+      ...await client.moveFile(action.sandboxId, input),
+      account
+    };
+  }
+  if (action.type === "git_status") {
+    return { ...await client.gitStatus(action.sandboxId), account };
+  }
+  if (action.type === "git_diff") {
+    const input = asRecord4(action.payload);
+    const baseRef = typeof input.baseRef === "string" ? input.baseRef.trim() : "";
+    return {
+      ...await client.gitDiff(action.sandboxId, {
+        ...baseRef ? { baseRef } : {}
+      }),
+      account
+    };
+  }
+  if (action.type === "git_export_patch") {
+    const input = asRecord4(action.payload);
+    const baseRef = typeof input.baseRef === "string" ? input.baseRef.trim() : "";
+    return {
+      ...await client.gitExportPatch(action.sandboxId, {
+        ...baseRef ? { baseRef } : {}
+      }),
+      account
+    };
+  }
+  if (action.type === "git_branch") {
+    return {
+      ...await client.gitBranch(
+        action.sandboxId,
+        normalizeGitBranchInput(action.payload)
+      ),
+      account
+    };
+  }
+  if (action.type === "git_commit") {
+    return {
+      ...await client.gitCommit(
+        action.sandboxId,
+        normalizeGitCommitInput(action.payload)
+      ),
+      account
+    };
+  }
+  if (action.type === "git_pull") {
+    return {
+      ...await client.gitPull(
+        action.sandboxId,
+        normalizeGitPullInput(action.payload)
+      ),
+      account
+    };
+  }
+  if (action.type === "git_push") {
+    return {
+      ...await client.gitPush(
+        action.sandboxId,
+        normalizeGitPushInput(action.payload)
+      ),
+      account
+    };
+  }
+  throw new Error(
+    `Unsupported sandbox action: ${action.type}`
+  );
+}
+async function listSandboxIntegrationConnections(input = {}) {
+  const { client } = await resolveSandboxClient();
+  if (input.teamId) return client.integrationConnections(input);
+  return resolveImplicitConnectedAppStatusConnections(client, {
+    ...input.projectId ? { projectId: input.projectId } : {},
+    ...input.agentId ? { agentId: input.agentId } : {},
+    status: input.status ?? "all"
+  });
+}
+async function sandboxLifecycleRequestOptions(client, sandboxId, input = {}) {
+  const respondAsync = await client.get(sandboxId).then((sandbox) => !sandboxLifecycleRequiresSynchronousAccounting(sandbox)).catch(() => true);
+  return {
+    failOnUnpreservedChanges: input.failOnUnpreservedChanges,
+    ...respondAsync ? { respondAsync: true } : {}
+  };
+}
+function sandboxLifecycleRequiresSynchronousAccounting(sandbox) {
+  return sandbox.reservation.status === "reserved" && (sandbox.state === "creating" || terminalSandboxLifecycleStates.has(sandbox.state));
+}
+function assertTerminalSandboxLifecycleSettled(operation, sandbox) {
+  if (!terminalSandboxLifecycleStates.has(sandbox.state)) return;
+  if (sandbox.reservation.status !== "reserved") return;
+  throw new Error(
+    `Sandbox ${operation} reached ${sandbox.state}, but reservation ${sandbox.reservation.id} is still reserved. Cleanup accounting has not settled; retry status before treating cleanup as complete.`
+  );
+}
+async function throwSandboxLifecycleRequestFailure(operation, client, sandboxId, error) {
+  const latest = await client.get(sandboxId).catch(() => null);
+  if (latest && sandboxLifecycleRequiresSynchronousAccounting(latest)) {
+    const originalMessage = error instanceof Error ? error.message : String(error);
+    throw new Error(
+      `Sandbox ${operation} failed while sandbox ${sandboxId} is still creating with active reservation ${latest.reservation.id}. Cleanup accounting has not settled; retry status before treating cleanup as complete. Original error: ${originalMessage}`
+    );
+  }
+  throw error instanceof Error ? error : new Error(String(error));
+}
+var terminalSandboxLifecycleStates = /* @__PURE__ */ new Set([
+  "stopped",
+  "archived",
+  "deleted",
+  "error"
+]);
+async function resolveImplicitConnectedAppStatusConnections(client, query) {
+  const organizations = await client.listOrganizations().catch(() => {
+    throw new Error(
+      "Connected app status is unavailable because organizations could not be loaded."
+    );
+  });
+  const teamIds = implicitConnectedAppStatusTeamIds(organizations);
+  const fallbackTeamId = selectImplicitConnectedAppStatusTeamId(organizations) || null;
+  if (teamIds.length === 0) {
+    return {
+      teamId: fallbackTeamId,
+      connections: []
+    };
+  }
+  const results = await Promise.all(
+    teamIds.map(
+      (teamId) => client.integrationConnections({
+        teamId,
+        ...query.projectId ? { projectId: query.projectId } : {},
+        ...query.agentId ? { agentId: query.agentId } : {},
+        status: query.status
+      }).catch(() => null)
+    )
+  );
+  const successfulResults = successfulConnectedAppStatusConnectionResults(results);
+  return {
+    teamId: connectedAppStatusTeamIdWithConnections(successfulResults) ?? fallbackTeamId ?? successfulResults.find((result) => result.teamId.trim())?.teamId.trim() ?? null,
+    connections: mergeConnectedAppStatusConnectionResults(successfulResults)
+  };
+}
+function connectedAppStatusTeamIdWithConnections(results) {
+  for (const result of results) {
+    if ((result.connections?.length ?? 0) === 0) continue;
+    const teamId = result.teamId?.trim();
+    if (teamId) return teamId;
+  }
+  return null;
+}
+function mergeConnectedAppStatusConnectionResults(results) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const result of results) {
+    for (const connection of result.connections ?? []) {
+      const key = connection.id.trim() || [
+        connection.teamId,
+        connection.provider,
+        connection.providerAccountId
+      ].join(":");
+      if (seen.has(key)) continue;
+      seen.add(key);
+      out.push(connection);
+    }
+  }
+  return out;
+}
+function successfulConnectedAppStatusConnectionResults(results) {
+  const successfulResults = results.filter(
+    (result) => result !== null
+  );
+  const failedCount = results.length - successfulResults.length;
+  const successfulConnectionCount = successfulResults.reduce(
+    (count, result) => count + (result.connections?.length ?? 0),
+    0
+  );
+  if (failedCount > 0 && successfulConnectionCount === 0) {
+    throw new Error(
+      "Connected app status is unavailable because one or more team integration connection lookups could not be loaded."
+    );
+  }
+  return successfulResults;
+}
+function selectImplicitConnectedAppStatusTeamId(organizations) {
+  const active = organizations.filter(
+    (organization) => organizationStatus(organization) === "active"
+  );
+  return organizationTeamId(
+    active.find((organization) => organization.role === "owner")
+  ) ?? organizationTeamId(
+    active.find((organization) => organization.role === "admin")
+  ) ?? organizationTeamId(active[0]) ?? "";
+}
+function implicitConnectedAppStatusTeamIds(organizations) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const organization of organizations) {
+    if (organizationStatus(organization) !== "active") continue;
+    const teamId = organizationTeamId(organization);
+    if (!teamId || seen.has(teamId)) continue;
+    seen.add(teamId);
+    out.push(teamId);
+  }
+  return out;
+}
+function organizationTeamId(organization) {
+  if (!organization) return null;
+  const legacyId = organization.id;
+  const value = typeof organization.teamId === "string" ? organization.teamId : typeof legacyId === "string" ? legacyId : "";
+  const trimmed = value.trim();
+  return trimmed || null;
+}
+function organizationStatus(organization) {
+  return typeof organization.status === "string" ? organization.status : "active";
+}
+async function resolveSandboxClient() {
+  const configuredSandboxApiUrl = normalizeOptionalUrl3(
+    process.env.OPENPOND_SANDBOX_API_URL
+  );
+  const configuredSandboxApiKey = process.env.OPENPOND_SANDBOX_API_KEY?.trim();
+  if (configuredSandboxApiKey && configuredSandboxApiUrl) {
+    return {
+      client: createOpenPondSandboxClient2({
+        apiKey: configuredSandboxApiKey,
+        sandboxApiUrl: configuredSandboxApiUrl
+      }),
+      context: await loadOpenPondAccountContext().catch(() => null),
+      apiKey: configuredSandboxApiKey,
+      sandboxApiUrl: normalizeSandboxApiUrl2(configuredSandboxApiUrl)
+    };
+  }
+  const context = await loadOpenPondAccountContext();
+  const apiKey = context.token?.trim();
+  if (!apiKey) {
+    throw new Error(
+      "OpenPond account API key is required to manage sandboxes."
+    );
+  }
+  if (configuredSandboxApiUrl) {
+    return {
+      client: createOpenPondSandboxClient2({
+        apiKey,
+        sandboxApiUrl: configuredSandboxApiUrl
+      }),
+      context,
+      apiKey,
+      sandboxApiUrl: normalizeSandboxApiUrl2(configuredSandboxApiUrl)
+    };
+  }
+  const baseUrl = resolveSandboxBaseUrl(context);
+  return {
+    client: createOpenPondSandboxClient2({ apiKey, baseUrl }),
+    context,
+    apiKey,
+    sandboxApiUrl: normalizeSandboxApiUrl2(baseUrl)
+  };
+}
+function sandboxApiRootUrl(sandboxApiUrl) {
+  return normalizeSandboxApiUrl2(sandboxApiUrl).replace(/\/sandboxes\/?$/, "");
+}
+function sandboxPublicApiRootUrl(sandboxApiUrl) {
+  const normalized = normalizeSandboxApiUrl2(sandboxApiUrl);
+  if (/\/api\/sandboxes\/?$/.test(normalized)) {
+    return normalized.replace(/\/api\/sandboxes\/?$/, "/v1");
+  }
+  return normalized.replace(/\/sandboxes\/?$/, "");
+}
+function sandboxScopedCollectionPath(path37, queryInput) {
+  const query = new URLSearchParams();
+  if (queryInput.teamId) query.set("teamId", queryInput.teamId);
+  if (queryInput.projectId) query.set("projectId", queryInput.projectId);
+  if (queryInput.agentId) query.set("agentId", queryInput.agentId);
+  return `${path37}${query.size > 0 ? `?${query.toString()}` : ""}`;
+}
+async function requestSandboxApiRoot(params) {
+  const response = await apiFetch(
+    sandboxApiRootUrl(params.sandboxApiUrl),
+    params.apiKey,
+    params.path,
+    {
+      method: params.method ?? "GET",
+      ...params.body ? { body: JSON.stringify(params.body) } : {}
+    }
+  );
+  const payload = await response.json().catch(() => ({}));
+  if (!response.ok) {
+    const error = typeof payload.error === "string" ? payload.error : `Sandbox API request failed with status ${response.status}`;
+    throw new Error(error);
+  }
+  return payload;
+}
+async function requestSandboxPublicApiRoot(params) {
+  const response = await apiFetch(
+    sandboxPublicApiRootUrl(params.sandboxApiUrl),
+    params.apiKey,
+    params.path,
+    {
+      method: params.method ?? "GET",
+      ...params.body ? { body: JSON.stringify(params.body) } : {}
+    }
+  );
+  const payload = await response.json().catch(() => ({}));
+  if (!response.ok) {
+    const error = typeof payload.error === "string" ? payload.error : `Sandbox API request failed with status ${response.status}`;
+    throw new Error(error);
+  }
+  return payload;
+}
+async function requestOpenPondPublicApi(params) {
+  const { apiKey, sandboxApiUrl } = await resolveSandboxClient();
+  return requestSandboxPublicApiRoot({
+    apiKey,
+    sandboxApiUrl,
+    ...params
+  });
+}
+function sandboxAccountSummary(context, sandboxApiUrl) {
+  if (!context) {
+    return {
+      label: "Sandbox API",
+      handle: null,
+      baseUrl: null,
+      sandboxApiUrl,
+      state: "signed_out"
+    };
+  }
+  const account = context.accountState;
+  return {
+    label: account.label,
+    handle: account.activeProfile?.handle ?? context.account?.handle ?? null,
+    baseUrl: account.baseUrl ?? context.account?.baseUrl ?? null,
+    sandboxApiUrl,
+    state: account.state
+  };
+}
+function resolveSandboxBaseUrl(context) {
+  return normalizeOptionalUrl3(process.env.OPENPOND_SANDBOX_BASE_URL) ?? normalizeOptionalUrl3(process.env.OPENPOND_API_URL) ?? normalizeOptionalUrl3(context.apiBaseUrl) ?? normalizeOptionalUrl3(context.account?.baseUrl) ?? normalizeOptionalUrl3(context.config.baseUrl) ?? DEFAULT_OPENPOND_SANDBOX_BASE_URL;
+}
+
+// ../server/src/runtime/app-server-sandbox-tools.ts
+import { Buffer as Buffer2 } from "node:buffer";
+var REMOTE_SANDBOX_ACTIONS = /* @__PURE__ */ new Set([
+  "sandbox_status",
+  "sandbox_start",
+  "sandbox_list_files",
+  "sandbox_read_file",
+  "sandbox_search_files",
+  "sandbox_upload_file",
+  "sandbox_write_file",
+  "sandbox_edit_file",
+  "sandbox_delete_file",
+  "sandbox_mkdir",
+  "sandbox_move_file",
+  "sandbox_exec",
+  "sandbox_open_port",
+  "sandbox_snapshot_create"
+]);
+async function executeAppServerSandboxTool(input) {
+  if (!REMOTE_SANDBOX_ACTIONS.has(input.request.action)) return null;
+  if (input.session.workspaceKind !== "sandbox" || !input.session.workspaceId) {
+    throw new Error("The hosted Work task is not attached to a sandbox.");
+  }
+  const args = input.request.args ?? {};
+  const sandboxId = input.session.workspaceId;
+  const requestedSandboxId = optionalString(args.sandboxId);
+  if (requestedSandboxId && requestedSandboxId !== sandboxId) {
+    throw new Error("Hosted Work cannot target a different sandbox.");
+  }
+  const action = input.request.action;
+  let data;
+  if (action === "sandbox_status") {
+    data = await input.sandboxRequest({ type: "get", sandboxId });
+  } else if (action === "sandbox_start") {
+    data = await input.sandboxRequest({ type: "start", sandboxId });
+  } else if (action === "sandbox_list_files") {
+    data = await input.sandboxRequest({
+      type: "list_files",
+      sandboxId,
+      payload: {
+        path: optionalString(args.path) || ".",
+        recursive: args.recursive === true,
+        ...numberValue2(args.maxEntries) === null ? {} : { maxEntries: numberValue2(args.maxEntries) }
+      }
+    });
+  } else if (action === "sandbox_read_file") {
+    data = withDecodedFileContent(
+      await input.sandboxRequest({
+        type: "download_file",
+        sandboxId,
+        payload: {
+          path: requiredString(args.path, "path"),
+          maxBytes: numberValue2(args.maxBytes) ?? 512 * 1024
+        }
+      })
+    );
+  } else if (action === "sandbox_search_files") {
+    data = await input.sandboxRequest({
+      type: "search_files",
+      sandboxId,
+      payload: {
+        query: requiredString(args.query, "query"),
+        path: optionalString(args.path) || ".",
+        ...numberValue2(args.maxResults) === null ? {} : { maxResults: numberValue2(args.maxResults) }
+      }
+    });
+  } else if (action === "sandbox_upload_file") {
+    data = await input.sandboxRequest({
+      type: "upload_file",
+      sandboxId,
+      payload: {
+        path: requiredString(args.path, "path"),
+        contentsBase64: requiredString(args.contentsBase64, "contentsBase64")
+      }
+    });
+  } else if (action === "sandbox_write_file") {
+    data = await input.sandboxRequest({
+      type: "upload_file",
+      sandboxId,
+      payload: {
+        path: requiredString(args.path, "path"),
+        contents: stringValue5(args.content)
+      }
+    });
+  } else if (action === "sandbox_edit_file") {
+    data = await editRemoteSandboxFile({
+      sandboxId,
+      args,
+      sandboxRequest: input.sandboxRequest
+    });
+  } else if (action === "sandbox_delete_file") {
+    data = await input.sandboxRequest({
+      type: "delete_file",
+      sandboxId,
+      payload: {
+        path: requiredString(args.path, "path"),
+        recursive: args.recursive === true
+      }
+    });
+  } else if (action === "sandbox_mkdir") {
+    data = await input.sandboxRequest({
+      type: "mkdir",
+      sandboxId,
+      payload: {
+        path: requiredString(args.path, "path"),
+        recursive: args.recursive !== false
+      }
+    });
+  } else if (action === "sandbox_move_file") {
+    data = await input.sandboxRequest({
+      type: "move_file",
+      sandboxId,
+      payload: {
+        fromPath: requiredString(args.fromPath, "fromPath"),
+        toPath: requiredString(args.toPath, "toPath"),
+        overwrite: args.overwrite === true
+      }
+    });
+  } else if (action === "sandbox_exec") {
+    data = await input.sandboxRequest({
+      type: "exec",
+      sandboxId,
+      payload: {
+        command: requiredString(args.command, "command"),
+        timeoutSeconds: numberValue2(args.timeoutSeconds) ?? 120
+      }
+    });
+  } else if (action === "sandbox_open_port") {
+    data = await input.sandboxRequest({
+      type: "open_port",
+      sandboxId,
+      payload: {
+        port: requiredNumber(args.port, "port"),
+        label: optionalString(args.label) || "Work preview",
+        access: "private",
+        autoStart: true
+      }
+    });
+  } else {
+    data = await input.sandboxRequest({
+      type: "snapshot_create",
+      sandboxId,
+      payload: { name: requiredString(args.name, "name") }
+    });
+  }
+  return WorkspaceToolResultSchema.parse({
+    ok: true,
+    action,
+    output: `${action} completed in the attached Work sandbox.`,
+    data
+  });
+}
+async function editRemoteSandboxFile(input) {
+  const path37 = requiredString(input.args.path, "path");
+  const oldText = requiredString(input.args.oldText, "oldText");
+  const newText = stringValue5(input.args.newText);
+  const downloaded = asRecord5(
+    await input.sandboxRequest({
+      type: "download_file",
+      sandboxId: input.sandboxId,
+      payload: { path: path37, maxBytes: 1024 * 1024 }
+    })
+  );
+  const file = asRecord5(downloaded.file);
+  const content = optionalString(downloaded.contents) || optionalString(downloaded.content) || optionalString(file.contents) || optionalString(file.content) || decodeBase64(optionalString(file.contentsBase64));
+  if (!content.includes(oldText)) {
+    throw new Error(`Text to replace was not found in ${path37}.`);
+  }
+  if (input.args.replaceAll !== true && content.indexOf(oldText) !== content.lastIndexOf(oldText)) {
+    throw new Error(`Text to replace is not unique in ${path37}.`);
+  }
+  const nextContent = input.args.replaceAll === true ? content.split(oldText).join(newText) : content.replace(oldText, newText);
+  return input.sandboxRequest({
+    type: "upload_file",
+    sandboxId: input.sandboxId,
+    payload: { path: path37, contents: nextContent }
+  });
+}
+function withDecodedFileContent(value) {
+  const result = asRecord5(value);
+  const file = asRecord5(result.file);
+  const contentsBase64 = optionalString(file.contentsBase64);
+  if (!contentsBase64) return value;
+  return {
+    ...result,
+    file: {
+      ...file,
+      content: decodeBase64(contentsBase64)
+    }
+  };
+}
+function decodeBase64(value) {
+  if (!value) return "";
+  return Buffer2.from(value, "base64").toString("utf8");
+}
+function asRecord5(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function stringValue5(value) {
+  return typeof value === "string" ? value : "";
+}
+function optionalString(value) {
+  return stringValue5(value).trim();
+}
+function requiredString(value, name) {
+  const result = stringValue5(value);
+  if (!result.trim()) throw new Error(`${name} is required.`);
+  return result;
+}
+function numberValue2(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function requiredNumber(value, name) {
+  const result = numberValue2(value);
+  if (result === null) throw new Error(`${name} is required.`);
+  return result;
+}
+
 // ../server/src/runtime/app-server-workspace.ts
 function createAppServerWorkspace(input) {
   const workspaceDir = path19.resolve(input.workspaceDir);
@@ -16204,9 +19878,18 @@ function createAppServerWorkspace(input) {
     );
     try {
       if (request.action.startsWith("sandbox_")) {
-        throw new Error(
-          "Nested sandbox operations are not available inside the app-server placement."
-        );
+        const result2 = await executeAppServerSandboxTool({
+          session,
+          request,
+          sandboxRequest: input.sandboxRequest ?? sandboxRequestPayload
+        });
+        if (!result2) {
+          throw new Error(
+            `Sandbox action ${request.action} is not available in app-server placement.`
+          );
+        }
+        await recordResult(session, result2, options.turnId, startedAt);
+        return result2;
       }
       const { app, state } = await workspaceForSession(session);
       const result = await handleActiveWorkspaceToolAction({
@@ -17433,7 +21116,7 @@ function redactConnectedAppToolArguments(toolName, args) {
   return redacted && typeof redacted === "object" && !Array.isArray(redacted) ? redacted : {};
 }
 async function executeConnectedAppToolDefinition(input) {
-  const provider = normalizeConnectedAppProviderFamilyId(stringValue5(input.context.args.provider));
+  const provider = normalizeConnectedAppProviderFamilyId(stringValue6(input.context.args.provider));
   if (!provider) {
     return connectedAppToolFailure(input.context.callId, input.toolName, "Connected app provider is required.");
   }
@@ -17473,7 +21156,7 @@ async function executeConnectedAppToolDefinition(input) {
       }
     );
   }
-  if (input.operation === "write" && !stringValue5(input.context.args.explicitUserIntent)) {
+  if (input.operation === "write" && !stringValue6(input.context.args.explicitUserIntent)) {
     return connectedAppToolFailure(
       input.context.callId,
       input.toolName,
@@ -17565,7 +21248,7 @@ async function executeConnectedAppToolDefinition(input) {
 function inferredProviderOperationCapabilityIds(input) {
   const providerOperation = connectedAppProviderOperationById(
     input.provider,
-    stringValue5(input.args.operation)
+    stringValue6(input.args.operation)
   );
   if (!providerOperation || providerOperation.operation !== input.operation) return null;
   return providerOperation.capabilityIds;
@@ -17581,9 +21264,9 @@ function connectedAppProviderErrorSummary(data) {
   const record5 = data;
   const result = isRecord2(record5.result) ? record5.result : null;
   const metadata = isRecord2(record5.metadata) ? record5.metadata : null;
-  const httpStatus = numberValue2(metadata?.httpStatus) ?? numberValue2(result?.status);
-  const title = stringValue5(result?.title);
-  const detail = stringValue5(result?.detail);
+  const httpStatus = numberValue3(metadata?.httpStatus) ?? numberValue3(result?.status);
+  const title = stringValue6(result?.title);
+  const detail = stringValue6(result?.detail);
   if (!httpStatus && !title && !detail) return null;
   const statusText = httpStatus ? `Provider returned HTTP ${httpStatus}` : "Provider returned an error";
   const titleText = title ? ` ${title}` : "";
@@ -17661,10 +21344,10 @@ function dedupeContexts(contexts) {
   }
   return [...byProvider.values()];
 }
-function stringValue5(value) {
+function stringValue6(value) {
   return typeof value === "string" && value.trim() ? value.trim() : null;
 }
-function numberValue2(value) {
+function numberValue3(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : null;
 }
 function stringArray(value) {
@@ -18109,7 +21792,7 @@ function goalContextPreview(event2) {
 function subagentEventPreview(event2) {
   const run = subagentRunFromEvent(event2);
   if (!run) return eventPreview(event2);
-  const usage = asRecord4(run.metadata.usage);
+  const usage = asRecord6(run.metadata.usage);
   const report = run.report;
   return [
     `run: subagent-run:${run.id}`,
@@ -18162,8 +21845,8 @@ function isDurableResourceRef(value) {
   return /^(workspace:(?:file|dir):|sandbox:(?:file|dir):|git:|event:|message:|artifact:|goal-context:|session:|subagent-run:)/.test(value);
 }
 function subagentRunFromEvent(event2) {
-  const data = asRecord4(event2.data);
-  const parsed = SubagentRunSchema.safeParse(asRecord4(data?.run));
+  const data = asRecord6(event2.data);
+  const parsed = SubagentRunSchema.safeParse(asRecord6(data?.run));
   return parsed.success ? parsed.data : null;
 }
 function subagentRefsPreview(refs, label) {
@@ -18181,8 +21864,8 @@ function subagentDurableRef(ref) {
   return ref.id.startsWith("workspace:") || ref.id.startsWith("sandbox:") ? ref.id : `workspace:file:${ref.id}`;
 }
 function subagentUsagePreview(usage) {
-  const totalTokens = numberValue3(usage.totalTokens);
-  const requestCount = numberValue3(usage.requestCount);
+  const totalTokens = numberValue4(usage.totalTokens);
+  const requestCount = numberValue4(usage.requestCount);
   if (totalTokens <= 0 && requestCount <= 0) return null;
   return `usage: ${totalTokens} tokens across ${requestCount} ${requestCount === 1 ? "request" : "requests"}`;
 }
@@ -18202,10 +21885,10 @@ function extractFilePaths2(value) {
   }
   return [...paths].slice(0, 20);
 }
-function asRecord4(value) {
+function asRecord6(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
-function numberValue3(value) {
+function numberValue4(value) {
   return typeof value === "number" && Number.isFinite(value) ? Math.max(0, Math.floor(value)) : 0;
 }
 function truncate2(value, maxChars) {
@@ -18930,7 +22613,7 @@ function openInput(context) {
   return {
     ...baseInput(context),
     ...optionalTabId(context.args) ? { tabId: optionalTabId(context.args) } : {},
-    ...optionalString(context.args, "url", BROWSER_URL_MAX_LENGTH) ? { url: optionalString(context.args, "url", BROWSER_URL_MAX_LENGTH) } : {}
+    ...optionalString2(context.args, "url", BROWSER_URL_MAX_LENGTH) ? { url: optionalString2(context.args, "url", BROWSER_URL_MAX_LENGTH) } : {}
   };
 }
 function snapshotInput(context) {
@@ -19050,8 +22733,8 @@ function optionalTarget(args) {
   return refTarget ?? point;
 }
 function optionalRefTarget(args) {
-  const targetRef = optionalString(args, "targetRef", BROWSER_ID_MAX_LENGTH);
-  const snapshotId = optionalString(args, "snapshotId", BROWSER_ID_MAX_LENGTH);
+  const targetRef = optionalString2(args, "targetRef", BROWSER_ID_MAX_LENGTH);
+  const snapshotId = optionalString2(args, "snapshotId", BROWSER_ID_MAX_LENGTH);
   if (!targetRef && !snapshotId) return void 0;
   if (!targetRef || !snapshotId) throw new Error("targetRef requires snapshotId");
   return { kind: "ref", snapshotId, targetRef };
@@ -19114,7 +22797,7 @@ function targetParameters(input = {}) {
   };
 }
 function optionalTabId(args) {
-  return optionalString(args, "tabId", BROWSER_ID_MAX_LENGTH);
+  return optionalString2(args, "tabId", BROWSER_ID_MAX_LENGTH);
 }
 function stringArg2(args, key, maxLength) {
   const value = args[key];
@@ -19123,7 +22806,7 @@ function stringArg2(args, key, maxLength) {
   if (trimmed.length > maxLength) throw new Error(`${key} is too long`);
   return trimmed;
 }
-function optionalString(args, key, maxLength) {
+function optionalString2(args, key, maxLength) {
   const value = args[key];
   if (value === void 0 || value === null) return null;
   if (typeof value !== "string" || !value.trim()) throw new Error(`${key} must be a non-empty string`);
@@ -19174,7 +22857,7 @@ var NativeToolCallAccumulator = class {
     toolCalls.forEach((toolCall, ordinal) => {
       const record5 = toolCall;
       const index = typeof record5.index === "number" && Number.isInteger(record5.index) ? record5.index : null;
-      const id = stringValue6(toolCall.id);
+      const id = stringValue7(toolCall.id);
       const key = index !== null ? `index:${index}` : id ? `id:${id}` : `ordinal:${ordinal}`;
       const current = this.calls.get(key) ?? {
         key,
@@ -19185,10 +22868,10 @@ var NativeToolCallAccumulator = class {
         argumentsJson: ""
       };
       if (id) current.id = id;
-      const type = stringValue6(toolCall.type);
+      const type = stringValue7(toolCall.type);
       if (type) current.type = type;
       const fn = toolCall.function && typeof toolCall.function === "object" ? toolCall.function : {};
-      const nameChunk = stringValue6(fn.name);
+      const nameChunk = stringValue7(fn.name);
       if (nameChunk) current.name += nameChunk;
       if (typeof fn.arguments === "string") current.argumentsJson += fn.arguments;
       this.calls.set(key, current);
@@ -19290,7 +22973,7 @@ function completedToolCall(call, sequence) {
     hostedToolCall
   };
 }
-function stringValue6(value) {
+function stringValue7(value) {
   return typeof value === "string" && value.trim() ? value : null;
 }
 function replayableNativeToolArguments(argumentsJson) {
@@ -20040,7 +23723,7 @@ function createResourceModelToolDefinitions(deps) {
               scope,
               query: stringArg3(context.args, "query"),
               ...typeof context.args.limit === "number" ? { limit: context.args.limit } : {},
-              ...asRecord5(context.args.filters) ? { filters: asRecord5(context.args.filters) } : {}
+              ...asRecord7(context.args.filters) ? { filters: asRecord7(context.args.filters) } : {}
             }
           });
           return resourceSearchResultToModelToolResult(context.callId, result2);
@@ -20054,7 +23737,7 @@ function createResourceModelToolDefinitions(deps) {
               args: {
                 query: stringArg3(context.args, "query"),
                 ...typeof context.args.limit === "number" ? { maxResults: context.args.limit } : {},
-                ...typeof asRecord5(context.args.filters)?.path === "string" ? { path: asRecord5(context.args.filters)?.path } : {}
+                ...typeof asRecord7(context.args.filters)?.path === "string" ? { path: asRecord7(context.args.filters)?.path } : {}
               },
               source: "chat_action"
             },
@@ -20810,7 +24493,7 @@ function createOpenPondActionModelToolDefinitions(deps) {
     })
   })) : [];
   const directAgentActions = deps.actionCatalog.filter((action) => {
-    const implementation = asRecord5(action.implementation);
+    const implementation = asRecord7(action.implementation);
     const actionName = action.sourceActionId ?? action.name ?? action.id;
     return !CROSS_SYSTEM_TOOL_NAMES.includes(actionName) && (Boolean(action.agentId) || implementation?.type === "openpond-profile-action");
   });
@@ -20913,9 +24596,9 @@ function createOpenPondActionModelToolDefinitions(deps) {
           deps,
           resultToolName: "openpond_action_run",
           compactProfileResultForModel: true,
-          input: asRecord5(context.args.input) ?? {},
-          requestedProjectId: stringValue7(context.args.projectId) ?? void 0,
-          requestedAgentId: stringValue7(context.args.agentId) ?? void 0
+          input: asRecord7(context.args.input) ?? {},
+          requestedProjectId: stringValue8(context.args.projectId) ?? void 0,
+          requestedAgentId: stringValue8(context.args.agentId) ?? void 0
         });
       }
     }
@@ -20928,11 +24611,11 @@ function directOpenPondActionToolName(action) {
   return `agent_${slug}_${suffix}`;
 }
 function directOpenPondActionAliasName(action) {
-  const name = stringValue7(asRecord5(action.implementation)?.actionId) ?? action.sourceActionId ?? action.name ?? action.id;
+  const name = stringValue8(asRecord7(action.implementation)?.actionId) ?? action.sourceActionId ?? action.name ?? action.id;
   return /^[A-Za-z0-9_-]{1,64}$/.test(name) ? name : null;
 }
 function actionInputSchema(action) {
-  const schema = asRecord5(action.inputSchema);
+  const schema = asRecord7(action.inputSchema);
   if (schema?.type === "object") return structuredClone(schema);
   return {
     type: "object",
@@ -20942,7 +24625,7 @@ function actionInputSchema(action) {
 }
 async function executeScopedOpenPondAction(input) {
   const { action, context, deps, resultToolName } = input;
-  const implementation = asRecord5(action.implementation);
+  const implementation = asRecord7(action.implementation);
   if (implementation?.type === "openpond-profile-action") {
     const executionTarget = resolveWorkspaceExecutionTarget({ session: context.session });
     if (isSandboxExecutionTarget(executionTarget)) {
@@ -20959,8 +24642,8 @@ async function executeScopedOpenPondAction(input) {
         `Action ${action.id} is a profile action, but profile action execution is not configured.`
       );
     }
-    const profileActionId = stringValue7(implementation.actionId) ?? action.id;
-    const prompt = stringValue7(input.input.prompt) ?? stringValue7(input.input.message) ?? context.userPrompt;
+    const profileActionId = stringValue8(implementation.actionId) ?? action.id;
+    const prompt = stringValue8(input.input.prompt) ?? stringValue8(input.input.message) ?? context.userPrompt;
     const result2 = await deps.executeProfileAction({
       action: profileActionId,
       input: {
@@ -21000,7 +24683,7 @@ async function executeScopedOpenPondAction(input) {
     actionName: action.sourceActionId ?? action.name ?? action.id,
     input: input.input
   };
-  const allowedProjectId = stringValue7(implementation?.projectId);
+  const allowedProjectId = stringValue8(implementation?.projectId);
   if (input.requestedProjectId) {
     if (!allowedProjectId || input.requestedProjectId !== allowedProjectId) {
       return failedActionToolResult(
@@ -21013,7 +24696,7 @@ async function executeScopedOpenPondAction(input) {
   } else if (allowedProjectId) {
     payloadArgs.projectId = allowedProjectId;
   }
-  const allowedAgentId = action.agentId ?? stringValue7(implementation?.agentId);
+  const allowedAgentId = action.agentId ?? stringValue8(implementation?.agentId);
   if (input.requestedAgentId) {
     if (!allowedAgentId || input.requestedAgentId !== allowedAgentId) {
       return failedActionToolResult(
@@ -21041,8 +24724,8 @@ async function executeScopedOpenPondAction(input) {
   return workspaceToolResultToModelToolResult(context.callId, resultToolName, result);
 }
 function compactProfileActionResult(value) {
-  const execution = asRecord5(value);
-  const stdout = stringValue7(execution?.stdout);
+  const execution = asRecord7(value);
+  const stdout = stringValue8(execution?.stdout);
   if (!stdout) return value;
   let payload;
   try {
@@ -21050,13 +24733,13 @@ function compactProfileActionResult(value) {
   } catch {
     return value;
   }
-  const actionResult = asRecord5(payload)?.result ?? payload;
-  const actionResultRecord = asRecord5(actionResult);
-  const metadata = asRecord5(actionResultRecord?.metadata);
+  const actionResult = asRecord7(payload)?.result ?? payload;
+  const actionResultRecord = asRecord7(actionResult);
+  const metadata = asRecord7(actionResultRecord?.metadata);
   for (const key of ["snapshot", "decision", "submission", "receipt"]) {
     if (metadata && Object.hasOwn(metadata, key)) return metadata[key];
   }
-  const text = stringValue7(actionResultRecord?.text);
+  const text = stringValue8(actionResultRecord?.text);
   if (text) {
     try {
       return JSON.parse(text);
@@ -21315,26 +24998,26 @@ function sandboxResourceRefForExecutionTarget(ref, target) {
   return null;
 }
 function gitChangedFileRefs(value, sandboxMode = false) {
-  const record5 = asRecord5(value);
-  const status = asRecord5(record5?.status);
+  const record5 = asRecord7(value);
+  const status = asRecord7(record5?.status);
   const files = Array.isArray(record5?.files) ? record5.files : Array.isArray(status?.files) ? status.files : [];
-  return files.filter((item) => Boolean(item) && typeof item === "object" && !Array.isArray(item)).map((item) => stringValue7(item.path)).filter((item) => Boolean(item)).map((filePath) => `${sandboxMode ? "sandbox" : "workspace"}:file:${filePath}`);
+  return files.filter((item) => Boolean(item) && typeof item === "object" && !Array.isArray(item)).map((item) => stringValue8(item.path)).filter((item) => Boolean(item)).map((filePath) => `${sandboxMode ? "sandbox" : "workspace"}:file:${filePath}`);
 }
 function gitDiffText(value) {
-  const record5 = asRecord5(value);
-  return stringValue7(record5?.diff) ?? stringValue7(asRecord5(record5?.result)?.diff);
+  const record5 = asRecord7(value);
+  return stringValue8(record5?.diff) ?? stringValue8(asRecord7(record5?.result)?.diff);
 }
 function sandboxPathItems(value) {
   const records = nestedArraysForKeys(value, ["matches", "files", "entries"]);
   const items = [];
   for (const record5 of records) {
-    const path37 = stringValue7(record5.path) ?? stringValue7(record5.name);
+    const path37 = stringValue8(record5.path) ?? stringValue8(record5.name);
     if (!path37) continue;
     items.push({
       path: path37,
-      snippet: stringValue7(record5.text) ?? stringValue7(record5.snippet) ?? stringValue7(record5.content) ?? void 0,
+      snippet: stringValue8(record5.text) ?? stringValue8(record5.snippet) ?? stringValue8(record5.content) ?? void 0,
       line: typeof record5.line === "number" ? record5.line : null,
-      kind: stringValue7(record5.kind) ?? stringValue7(record5.type)
+      kind: stringValue8(record5.kind) ?? stringValue8(record5.type)
     });
   }
   return items;
@@ -21357,17 +25040,17 @@ function nestedArraysForKeys(value, keys) {
   return output;
 }
 function sandboxFileContent(value) {
-  const record5 = asRecord5(value);
+  const record5 = asRecord7(value);
   const file = sandboxFileRecord(value);
-  const encoded = stringValue7(file?.contentsBase64) ?? stringValue7(record5?.contentsBase64);
-  if (encoded && !sandboxFileMetadata(value, stringValue7(file?.path) ?? "").binary) {
+  const encoded = stringValue8(file?.contentsBase64) ?? stringValue8(record5?.contentsBase64);
+  if (encoded && !sandboxFileMetadata(value, stringValue8(file?.path) ?? "").binary) {
     try {
       return Buffer.from(encoded, "base64").toString("utf8");
     } catch {
       return null;
     }
   }
-  return stringValue7(record5?.content) ?? stringValue7(record5?.text) ?? stringValue7(record5?.contents) ?? stringValue7(file?.content) ?? stringValue7(file?.text);
+  return stringValue8(record5?.content) ?? stringValue8(record5?.text) ?? stringValue8(record5?.contents) ?? stringValue8(file?.content) ?? stringValue8(file?.text);
 }
 function contentTypeForResourcePath(value) {
   const lower = value.toLowerCase();
@@ -21377,13 +25060,13 @@ function contentTypeForResourcePath(value) {
   return null;
 }
 function sandboxFileRecord(value) {
-  const record5 = asRecord5(value);
-  return asRecord5(record5?.file) ?? asRecord5(asRecord5(record5?.result)?.file);
+  const record5 = asRecord7(value);
+  return asRecord7(record5?.file) ?? asRecord7(asRecord7(record5?.result)?.file);
 }
 function sandboxFileMetadata(value, resourcePath) {
   const file = sandboxFileRecord(value);
-  const contentType = stringValue7(file?.contentType) ?? stringValue7(file?.mimeType) ?? contentTypeForResourcePath(resourcePath);
-  const sizeBytes = numberValue4(file?.sizeBytes) ?? numberValue4(file?.size);
+  const contentType = stringValue8(file?.contentType) ?? stringValue8(file?.mimeType) ?? contentTypeForResourcePath(resourcePath);
+  const sizeBytes = numberValue5(file?.sizeBytes) ?? numberValue5(file?.size);
   const binary = file?.binary === true || file?.isBinary === true || (contentType ? isBinaryContentType(contentType) : isLikelyBinaryResourcePath(resourcePath));
   return { binary, contentType, ...sizeBytes !== null ? { sizeBytes } : {} };
 }
@@ -21458,7 +25141,7 @@ function actionCatalogText(action) {
   ].filter((value) => typeof value === "string" && value.trim().length > 0).join(" ").toLowerCase();
 }
 function actionCatalogItemForModel(action) {
-  const implementation = asRecord5(action.implementation);
+  const implementation = asRecord7(action.implementation);
   const directRunAllowed = implementation?.type !== "openpond-profile-action";
   return {
     actionId: action.id,
@@ -21468,8 +25151,8 @@ function actionCatalogItemForModel(action) {
     directRunAllowed,
     inputSchema: action.inputSchema ?? null,
     outputSchema: action.outputSchema ?? null,
-    agentId: action.agentId ?? stringValue7(implementation?.agentId),
-    projectId: stringValue7(implementation?.projectId),
+    agentId: action.agentId ?? stringValue8(implementation?.agentId),
+    projectId: stringValue8(implementation?.projectId),
     sourceActionId: action.sourceActionId ?? null
   };
 }
@@ -21489,13 +25172,13 @@ function failedActionToolResult(callId, name, message) {
     )
   };
 }
-function asRecord5(value) {
+function asRecord7(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
-function stringValue7(value) {
+function stringValue8(value) {
   return typeof value === "string" && value.trim() ? value.trim() : null;
 }
-function numberValue4(value) {
+function numberValue5(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : null;
 }
 
@@ -24040,7 +27723,7 @@ async function workInputBytes(input) {
   return bytes;
 }
 function workPath(rawArea, rawPath, allowedAreas = ["inputs", "work", "outputs"]) {
-  const area = requiredString(rawArea);
+  const area = requiredString2(rawArea);
   if (!allowedAreas.includes(area)) {
     throw new Error(`Unknown Work area: ${area}`);
   }
@@ -24059,7 +27742,7 @@ async function waitForWorkSandboxReady(readStatus, options = {}) {
   const timeoutMs = options.timeoutMs ?? WORK_SANDBOX_STARTUP_TIMEOUT_MS;
   const pollMs = options.pollMs ?? WORK_SANDBOX_STARTUP_POLL_MS;
   const now2 = options.now ?? Date.now;
-  const sleep3 = options.sleep ?? ((milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds)));
+  const sleep4 = options.sleep ?? ((milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds)));
   const startedAt = now2();
   let lastState = "";
   while (now2() - startedAt <= timeoutMs) {
@@ -24070,7 +27753,7 @@ async function waitForWorkSandboxReady(readStatus, options = {}) {
     if (TERMINAL_WORK_SANDBOX_STATES.has(lastState)) {
       throw new Error(`Work sandbox entered ${lastState} during startup.`);
     }
-    await sleep3(pollMs);
+    await sleep4(pollMs);
   }
   throw new Error(
     `Work sandbox did not become ready within ${timeoutMs}ms${lastState ? ` (last state: ${lastState})` : ""}.`
@@ -24080,7 +27763,7 @@ async function waitForWorkReceiptSettlement(readReceipts, options = {}) {
   const timeoutMs = options.timeoutMs ?? WORK_RECEIPT_SETTLEMENT_TIMEOUT_MS;
   const pollMs = options.pollMs ?? WORK_RECEIPT_SETTLEMENT_POLL_MS;
   const now2 = options.now ?? Date.now;
-  const sleep3 = options.sleep ?? ((milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds)));
+  const sleep4 = options.sleep ?? ((milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds)));
   const startedAt = now2();
   let lastResult = null;
   while (now2() - startedAt <= timeoutMs) {
@@ -24088,11 +27771,11 @@ async function waitForWorkReceiptSettlement(readReceipts, options = {}) {
     if (!lastResult.ok || receiptSettlementComplete(lastResult.data)) {
       return lastResult;
     }
-    await sleep3(pollMs);
+    await sleep4(pollMs);
   }
   return lastResult ?? readReceipts();
 }
-function requiredString(value) {
+function requiredString2(value) {
   if (typeof value !== "string" || !value.trim()) {
     throw new Error("A required string argument is missing.");
   }
@@ -24285,7 +27968,7 @@ function createWorkModelToolDefinitions(deps) {
         "work_list_files",
         "sandbox_list_files",
         (context) => ({
-          path: workPath(context.args.area, optionalString2(context.args.path)),
+          path: workPath(context.args.area, optionalString3(context.args.path)),
           recursive: typeof context.args.recursive === "boolean" ? context.args.recursive : true
         })
       )
@@ -24311,7 +27994,7 @@ function createWorkModelToolDefinitions(deps) {
         "work_read_file",
         "sandbox_read_file",
         (context) => ({
-          path: workPath(context.args.area, requiredString2(context.args.path)),
+          path: workPath(context.args.area, requiredString3(context.args.path)),
           maxBytes: typeof context.args.maxBytes === "number" ? Math.min(
             Math.max(Math.floor(context.args.maxBytes), 1),
             1e6
@@ -24339,11 +28022,11 @@ function createWorkModelToolDefinitions(deps) {
         "work_write_file",
         "sandbox_write_file",
         (context) => ({
-          path: workPath(context.args.area, requiredString2(context.args.path), [
+          path: workPath(context.args.area, requiredString3(context.args.path), [
             "work",
             "outputs"
           ]),
-          content: requiredString2(context.args.content, true),
+          content: requiredString3(context.args.content, true),
           autoPreserveSource: false
         })
       )
@@ -24370,12 +28053,12 @@ function createWorkModelToolDefinitions(deps) {
         "work_edit_file",
         "sandbox_edit_file",
         (context) => ({
-          path: workPath(context.args.area, requiredString2(context.args.path), [
+          path: workPath(context.args.area, requiredString3(context.args.path), [
             "work",
             "outputs"
           ]),
-          oldText: requiredString2(context.args.oldText),
-          newText: requiredString2(context.args.newText, true),
+          oldText: requiredString3(context.args.oldText),
+          newText: requiredString3(context.args.newText, true),
           replaceAll: context.args.replaceAll === true,
           autoPreserveSource: false
         })
@@ -24401,7 +28084,7 @@ function createWorkModelToolDefinitions(deps) {
         "work_delete_file",
         "sandbox_delete_file",
         (context) => ({
-          path: workPath(context.args.area, requiredString2(context.args.path), [
+          path: workPath(context.args.area, requiredString3(context.args.path), [
             "work",
             "outputs"
           ]),
@@ -24427,7 +28110,7 @@ function createWorkModelToolDefinitions(deps) {
         required: ["command"]
       },
       execute: withSandbox("work_exec", "sandbox_exec", (context) => ({
-        command: `cd /workspace/work && ${requiredString2(context.args.command)}`,
+        command: `cd /workspace/work && ${requiredString3(context.args.command)}`,
         timeoutSeconds: typeof context.args.timeoutSeconds === "number" ? Math.min(
           Math.max(Math.floor(context.args.timeoutSeconds), 1),
           3600
@@ -24452,7 +28135,7 @@ function createWorkModelToolDefinitions(deps) {
         "sandbox_open_port",
         (context) => ({
           port: context.args.port,
-          label: optionalString2(context.args.label) || "Work preview",
+          label: optionalString3(context.args.label) || "Work preview",
           access: "private",
           autoStart: true
         })
@@ -24473,7 +28156,7 @@ function createWorkModelToolDefinitions(deps) {
         "work_checkpoint",
         "sandbox_snapshot_create",
         (context) => ({
-          name: requiredString2(context.args.name)
+          name: requiredString3(context.args.name)
         })
       )
     },
@@ -24505,8 +28188,8 @@ function createWorkModelToolDefinitions(deps) {
         "work_prepare_agent",
         "sandbox_prepare_agent",
         (context) => ({
-          directory: requiredString2(context.args.directory),
-          template: requiredString2(context.args.template)
+          directory: requiredString3(context.args.directory),
+          template: requiredString3(context.args.template)
         })
       )
     },
@@ -24540,9 +28223,9 @@ function createWorkModelToolDefinitions(deps) {
         "work_save_agent_package",
         "sandbox_save_agent_package",
         (context) => ({
-          directory: requiredString2(context.args.directory),
-          agentId: optionalString2(context.args.agentId) || void 0,
-          title: optionalString2(context.args.title) || void 0
+          directory: requiredString3(context.args.directory),
+          agentId: optionalString3(context.args.agentId) || void 0,
+          title: optionalString3(context.args.title) || void 0
         })
       )
     },
@@ -24592,10 +28275,10 @@ function createWorkModelToolDefinitions(deps) {
         "work_save_output",
         "sandbox_save_output",
         (context) => ({
-          path: workPath("outputs", requiredString2(context.args.path), [
+          path: workPath("outputs", requiredString3(context.args.path), [
             "outputs"
           ]),
-          suggestedName: optionalString2(context.args.suggestedName) || void 0,
+          suggestedName: optionalString3(context.args.suggestedName) || void 0,
           validation: Array.isArray(context.args.validation) ? context.args.validation : []
         })
       )
@@ -24642,9 +28325,9 @@ function createWorkModelToolDefinitions(deps) {
         required: ["kind", "title", "resourceId", "url"]
       },
       execute: async (context) => {
-        const kind = requiredString2(context.args.kind);
-        const title = requiredString2(context.args.title);
-        const resourceId = requiredString2(context.args.resourceId);
+        const kind = requiredString3(context.args.kind);
+        const title = requiredString3(context.args.title);
+        const resourceId = requiredString3(context.args.resourceId);
         const url = validHttpUrl(context.args.url);
         const validation = Array.isArray(context.args.validation) ? context.args.validation : [];
         const identity = {
@@ -24664,10 +28347,10 @@ function createWorkModelToolDefinitions(deps) {
         } : {
           ...identity,
           kind: "external_resource",
-          provider: optionalString2(context.args.provider) || "external",
+          provider: optionalString3(context.args.provider) || "external",
           resourceId,
           url,
-          contentType: optionalString2(context.args.contentType) || null
+          contentType: optionalString3(context.args.contentType) || null
         };
         return {
           toolCallId: context.callId,
@@ -24790,17 +28473,17 @@ function workAreaProperty() {
     enum: ["inputs", "work", "outputs"]
   };
 }
-function requiredString2(value, allowEmpty = false) {
+function requiredString3(value, allowEmpty = false) {
   if (typeof value !== "string" || !allowEmpty && !value.trim()) {
     throw new Error("A required string argument is missing.");
   }
   return allowEmpty ? value : value.trim();
 }
-function optionalString2(value) {
+function optionalString3(value) {
   return typeof value === "string" ? value.trim() : "";
 }
 function validHttpUrl(value) {
-  const text = requiredString2(value);
+  const text = requiredString3(value);
   const url = new URL(text);
   if (url.protocol !== "http:" && url.protocol !== "https:") {
     throw new Error("Work output URLs must use HTTP or HTTPS.");
@@ -25819,7 +29502,7 @@ async function assertGeneratedSdkArtifacts(target, requireEvalPass = true) {
     );
   }
   const missingMetadata = actions.filter(
-    (action) => typeof action.id === "string" && (!stringValue8(action.label) || !stringValue8(action.description) || typeof action.timeoutSeconds !== "number")
+    (action) => typeof action.id === "string" && (!stringValue9(action.label) || !stringValue9(action.description) || typeof action.timeoutSeconds !== "number")
   );
   if (missingMetadata.length > 0) {
     throw new Error(
@@ -25829,7 +29512,7 @@ async function assertGeneratedSdkArtifacts(target, requireEvalPass = true) {
   const setupGate = buildOpenPondProfileSetupGate({
     actionCatalog: actions.filter((action) => typeof action.id === "string").map((action) => ({
       id: action.id,
-      name: stringValue8(action.name),
+      name: stringValue9(action.name),
       setupRequirements: recordArray(action.setupRequirements) ?? []
     })),
     actionId: target.defaultAction
@@ -25860,49 +29543,49 @@ function parseJsonOutput(stdout) {
     return null;
   }
 }
-function asRecord6(value) {
+function asRecord8(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
 function recordArray(value) {
   if (!Array.isArray(value)) return null;
   return value.filter(
-    (item) => Boolean(asRecord6(item))
+    (item) => Boolean(asRecord8(item))
   );
 }
 function traceRefFromCommandResult(value) {
-  const record5 = asRecord6(value);
-  const ref = stringValue8(record5?.traceArtifactRef);
+  const record5 = asRecord8(value);
+  const ref = stringValue9(record5?.traceArtifactRef);
   return ref?.startsWith(".openpond/") ? ref : null;
 }
 function summaryFromCommandResult(commandName, value) {
-  const record5 = asRecord6(value);
+  const record5 = asRecord8(value);
   if (!record5) return null;
   if (commandName === "inspect") {
     return {
       actionCount: Array.isArray(record5.actionCatalog) ? record5.actionCatalog.length : null,
-      defaultAction: asRecord6(record5.agent)?.defaultAction ?? null,
-      projectName: asRecord6(record5.project)?.name ?? null
+      defaultAction: asRecord8(record5.agent)?.defaultAction ?? null,
+      projectName: asRecord8(record5.project)?.name ?? null
     };
   }
   if (commandName === "validate") {
     return {
       status: record5.status ?? null,
-      errors: asRecord6(record5.summary)?.errors ?? null,
-      warnings: asRecord6(record5.summary)?.warnings ?? null
+      errors: asRecord8(record5.summary)?.errors ?? null,
+      warnings: asRecord8(record5.summary)?.warnings ?? null
     };
   }
   if (commandName === "eval") {
-    return asRecord6(record5.summary);
+    return asRecord8(record5.summary);
   }
   if (commandName === "direct-run") {
     return {
-      hasResult: Boolean(asRecord6(record5.result)),
-      resultKeys: Object.keys(asRecord6(record5.result) ?? {})
+      hasResult: Boolean(asRecord8(record5.result)),
+      resultKeys: Object.keys(asRecord8(record5.result) ?? {})
     };
   }
   return null;
 }
-function stringValue8(value) {
+function stringValue9(value) {
   return typeof value === "string" && value.trim() ? value.trim() : null;
 }
 
@@ -26127,7 +29810,7 @@ function agentCandidateId(runId) {
   return `agent_candidate_${runId}`;
 }
 function checkSummary(metadata) {
-  const evaluation = asRecord7(metadata?.eval);
+  const evaluation = asRecord9(metadata?.eval);
   const total = typeof evaluation?.total === "number" ? evaluation.total : null;
   return total === null ? "Agent SDK checks and deterministic Evals passed." : `${total} Agent SDK Eval${total === 1 ? "" : "s"} passed.`;
 }
@@ -26314,14 +29997,14 @@ async function applyPreparedHarnessSourceApplication(snapshot, target, env = pro
   );
   if (!existsSync2(manifestPath)) return false;
   const manifest = JSON.parse(await readFile3(manifestPath, "utf8"));
-  const root = asRecord7(manifest);
+  const root = asRecord9(manifest);
   if (root?.schema !== "openpond.harnessPreparedSource.v1") {
     throw new Error(
       `${HARNESS_PREPARED_SOURCE_MANIFEST} must use schema openpond.harnessPreparedSource.v1.`
     );
   }
-  const agents = asRecord7(root.agents);
-  const agent = asRecord7(agents?.[target.agentId]);
+  const agents = asRecord9(root.agents);
+  const agent = asRecord9(agents?.[target.agentId]);
   const operation = asHarnessPreparedSourceOperation(
     agent?.[snapshot.operation]
   );
@@ -26360,14 +30043,14 @@ async function applyPreparedHarnessSourceApplication(snapshot, target, env = pro
   return true;
 }
 function asHarnessPreparedSourceOperation(value) {
-  const operation = asRecord7(value);
+  const operation = asRecord9(value);
   if (!operation || typeof operation.source !== "string" || !operation.source.trim())
     return null;
   if (operation.registrations !== void 0 && !Array.isArray(operation.registrations)) {
     throw new Error("Prepared harness source registrations must be an array.");
   }
   const registrations = (operation.registrations ?? []).map((value2) => {
-    const registration = asRecord7(value2);
+    const registration = asRecord9(value2);
     if (!registration || typeof registration.source !== "string" || !registration.source.trim() || typeof registration.target !== "string" || !registration.target.trim()) {
       throw new Error(
         "Prepared harness source registrations require source and target paths."
@@ -26404,7 +30087,7 @@ async function waitForTimedOutSourceApplication(target) {
   const deadline = Date.now() + LOCAL_CREATE_TIMEOUT_RECOVERY_MS;
   while (Date.now() < deadline) {
     if (await localCreateSourceLayoutIsStable(target)) return true;
-    await sleep2(LOCAL_CREATE_TIMEOUT_RECOVERY_POLL_MS);
+    await sleep3(LOCAL_CREATE_TIMEOUT_RECOVERY_POLL_MS);
   }
   return false;
 }
@@ -26412,7 +30095,7 @@ async function localCreateSourceLayoutIsStable(target) {
   try {
     await assertLocalCreateSourceLayout(target);
     const before = await sourceLayoutFingerprint(target);
-    await sleep2(LOCAL_CREATE_TIMEOUT_RECOVERY_STABLE_MS);
+    await sleep3(LOCAL_CREATE_TIMEOUT_RECOVERY_STABLE_MS);
     await assertLocalCreateSourceLayout(target);
     const after = await sourceLayoutFingerprint(target);
     return before === after;
@@ -26435,7 +30118,7 @@ async function sourceLayoutFingerprint(target) {
   );
   return parts.join("\n---\n");
 }
-function sleep2(ms) {
+function sleep3(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 function localCreatePipelinePrompt(snapshot, target) {
@@ -26498,7 +30181,7 @@ function normalizeActionId(value) {
   const trimmed = value?.trim();
   return trimmed || null;
 }
-function asRecord7(value) {
+function asRecord9(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
 function sourceActionIdForAgent(actionId, agentId) {
@@ -27265,7 +30948,7 @@ async function executeAgentTasksetEvaluation(input) {
       task.id,
       0
     ]).slice(0, 24)}`;
-    const traceRef = stringValue9(parsed?.traceArtifactRef);
+    const traceRef = stringValue10(parsed?.traceArtifactRef);
     const attempt = TaskAttemptResultSchema.parse({
       schemaVersion: "openpond.taskAttempt.v1",
       id: attemptId,
@@ -27335,7 +31018,7 @@ function parseAgentRunPayload(stdout) {
 function recordValue(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
-function stringValue9(value) {
+function stringValue10(value) {
   return typeof value === "string" && value.trim() ? value.trim() : null;
 }
 
@@ -27348,17 +31031,17 @@ async function runNormalizedAgentEvaluation(input) {
     throwOnFailure: false
   });
   const payload = parseAgentEvalPayload(result.stdout);
-  const total = numberValue5(payload.summary?.total) ?? 0;
-  const passed = numberValue5(payload.summary?.passed) ?? 0;
-  const failed = numberValue5(payload.summary?.failed) ?? Math.max(0, total - passed);
+  const total = numberValue6(payload.summary?.total) ?? 0;
+  const passed = numberValue6(payload.summary?.passed) ?? 0;
+  const failed = numberValue6(payload.summary?.failed) ?? Math.max(0, total - passed);
   const publishGate = payload.publishGate?.status === "passed" ? "passed" : "failed";
   const results = Array.isArray(payload.results) ? payload.results : [];
-  const sdkEvalRefs = results.map((evaluation) => stringValue10(evaluation.name)).filter((value) => Boolean(value));
+  const sdkEvalRefs = results.map((evaluation) => stringValue11(evaluation.name)).filter((value) => Boolean(value));
   const artifactRefs = /* @__PURE__ */ new Set([
     path29.posix.join(input.sourceRef, ".openpond/eval-results.json")
   ]);
   for (const evaluation of results) {
-    const trace = stringValue10(evaluation.traceArtifactRef);
+    const trace = stringValue11(evaluation.traceArtifactRef);
     if (trace)
       artifactRefs.add(path29.posix.join(input.sourceRef, normalizeRef(trace)));
     for (const artifact of stringArray3(evaluation.artifacts)) {
@@ -27412,20 +31095,20 @@ async function runNormalizedAgentEvaluation(input) {
     summary: `${input.subject === "active" ? "Active" : input.subject === "candidate" ? "Candidate" : "Post-release"} Agent SDK and Taskset Evals: ${combinedPassed}/${combinedTotal} passed${combinedPublishGate === "failed" ? "; publish gate failed" : ""}.`,
     createdAt: timestamp,
     metadata: {
-      schemaVersion: stringValue10(payload.schemaVersion),
-      schema: stringValue10(payload.schema),
+      schemaVersion: stringValue11(payload.schemaVersion),
+      schema: stringValue11(payload.schema),
       project: {
-        name: stringValue10(payload.project?.name),
-        version: stringValue10(payload.project?.version)
+        name: stringValue11(payload.project?.name),
+        version: stringValue11(payload.project?.version)
       },
       source: {
-        configPath: stringValue10(payload.source?.configPath),
-        configHash: stringValue10(payload.source?.configHash)
+        configPath: stringValue11(payload.source?.configPath),
+        configHash: stringValue11(payload.source?.configHash)
       },
       publishGate: {
-        total: numberValue5(payload.publishGate?.total),
-        passed: numberValue5(payload.publishGate?.passed),
-        failed: numberValue5(payload.publishGate?.failed),
+        total: numberValue6(payload.publishGate?.total),
+        passed: numberValue6(payload.publishGate?.passed),
+        failed: numberValue6(payload.publishGate?.failed),
         blockingFailures: stringArray3(payload.publishGate?.blockingFailures)
       },
       command: {
@@ -27438,10 +31121,10 @@ async function runNormalizedAgentEvaluation(input) {
       executionContractHash: tasksetExecution?.executionContractHash ?? null,
       gradeRefs: tasksetExecution?.gradeRefs ?? [],
       results: results.map((evaluation) => ({
-        name: stringValue10(evaluation.name),
-        status: stringValue10(evaluation.status),
-        error: stringValue10(evaluation.error),
-        traceArtifactRef: stringValue10(evaluation.traceArtifactRef)
+        name: stringValue11(evaluation.name),
+        status: stringValue11(evaluation.status),
+        error: stringValue11(evaluation.error),
+        traceArtifactRef: stringValue11(evaluation.traceArtifactRef)
       }))
     }
   };
@@ -27480,14 +31163,14 @@ function parseAgentEvalPayload(stdout) {
 function normalizeRef(value) {
   return value.replace(/^\.\//, "").replaceAll("\\", "/");
 }
-function stringValue10(value) {
+function stringValue11(value) {
   return typeof value === "string" && value.trim() ? value.trim() : null;
 }
-function numberValue5(value) {
+function numberValue6(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : null;
 }
 function stringArray3(value) {
-  return Array.isArray(value) ? value.map(stringValue10).filter((item) => Boolean(item)) : [];
+  return Array.isArray(value) ? value.map(stringValue11).filter((item) => Boolean(item)) : [];
 }
 
 // ../server/src/runtime/create-pipeline/agent-improvement-git.ts
@@ -27710,13 +31393,13 @@ async function listPullRequestsForBranch(command, cwd, branch) {
 function normalizePullRequest(raw, openedAt = (/* @__PURE__ */ new Date()).toISOString(), updatedAt = (/* @__PURE__ */ new Date()).toISOString()) {
   const number = typeof raw.number === "number" ? raw.number : Number(raw.number);
   const stateValue = typeof raw.state === "string" ? raw.state.toLowerCase() : "";
-  const mergedAt = stringValue11(raw.mergedAt);
+  const mergedAt = stringValue12(raw.mergedAt);
   const state = mergedAt || stateValue === "merged" ? "merged" : stateValue === "open" ? "open" : "closed";
   const mergeCommitRecord = raw.mergeCommit && typeof raw.mergeCommit === "object" ? raw.mergeCommit : null;
-  const mergeCommit = stringValue11(mergeCommitRecord?.oid) ?? stringValue11(raw.mergeCommit);
-  const url = stringValue11(raw.url);
-  const baseBranch = stringValue11(raw.baseRefName);
-  const headBranch = stringValue11(raw.headRefName);
+  const mergeCommit = stringValue12(mergeCommitRecord?.oid) ?? stringValue12(raw.mergeCommit);
+  const url = stringValue12(raw.url);
+  const baseBranch = stringValue12(raw.baseRefName);
+  const headBranch = stringValue12(raw.headRefName);
   if (!Number.isInteger(number) || number <= 0 || !url || !baseBranch || !headBranch) {
     throw new Error("GitHub returned an incomplete pull request payload.");
   }
@@ -27768,7 +31451,7 @@ function assertCommand(result, message) {
   if (result.code === 0) return;
   throw new Error(result.stderr.trim() || result.stdout.trim() || message);
 }
-function stringValue11(value) {
+function stringValue12(value) {
   return typeof value === "string" && value.trim() ? value.trim() : null;
 }
 function defaultCommandRunner(command, args, cwd, env = {}) {
@@ -28340,9 +32023,9 @@ async function readAgentPackageOrigin(agentRootPath, manifestHash) {
     ".openpond",
     "agent-package-origin.json"
   );
-  const origin = await fs20.readFile(originPath, "utf8").then((raw) => asRecord8(JSON.parse(raw))).catch(() => ({}));
-  const versionId = stringValue12(origin.versionId);
-  const digest = stringValue12(origin.digest);
+  const origin = await fs20.readFile(originPath, "utf8").then((raw) => asRecord10(JSON.parse(raw))).catch(() => ({}));
+  const versionId = stringValue13(origin.versionId);
+  const digest = stringValue13(origin.digest);
   if (versionId && digest && /^[a-f0-9]{64}$/.test(digest) && versionId === `agent-${digest.slice(0, 20)}`) {
     return {
       versionId,
@@ -28358,10 +32041,10 @@ async function readAgentPackageOrigin(agentRootPath, manifestHash) {
     evalReceiptIds: []
   };
 }
-function asRecord8(value) {
+function asRecord10(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
-function stringValue12(value) {
+function stringValue13(value) {
   return typeof value === "string" && value.trim() ? value.trim() : null;
 }
 function stringArray4(value) {
@@ -29435,7 +33118,7 @@ function uniqueEvidence(run, evidence) {
 }
 async function verifyAppliedProfileCommit(input) {
   const command = input.command ?? (async (name, args, cwd, env) => {
-    const { runWorkspaceCommand } = await import("./workspaces-NGDIBOKQ.js");
+    const { runWorkspaceCommand } = await import("./workspaces-Y3GSQO3Y.js");
     return runWorkspaceCommand(name, args, cwd, env);
   });
   const result = await command("git", ["rev-parse", "HEAD"], input.repoPath);
@@ -36886,7 +40569,8 @@ async function createOpenPondAppServer(options = {}) {
     workspaceDir,
     logger,
     getSession,
-    appendRuntimeEvent
+    appendRuntimeEvent,
+    sandboxRequest: options.sandboxRequest
   });
   const upsertApproval = async (approval) => {
     await store.upsertApproval(approval);
@@ -37092,7 +40776,6 @@ export {
   createLocalHarnessImprovementRuntime,
   createLocalHarnessModelToolDefinitions,
   resolveWorkspaceExecutionTarget,
-  pipefailSandboxShellCommand,
   SELECT_PROJECT_MESSAGE,
   createOpenPondCommandAccessService,
   commandResultForModel,
@@ -37123,6 +40806,10 @@ export {
   getWorkspaceDeploymentSource,
   handleActiveWorkspaceToolAction,
   MUTATING_WORKSPACE_TOOL_ACTIONS,
+  resolveOpenPondSandboxClient,
+  sandboxRequestPayload,
+  listSandboxIntegrationConnections,
+  requestOpenPondPublicApi,
   isBundledAuthoringSkillName,
   loadBundledAuthoringSkills,
   readBundledAuthoringProfileSkill,