openpond 0.0.38 → 0.0.39

package/dist/chunks/chunk-KHNHUA2H.js

@@ -0,0 +1,1737 @@
+import { createRequire as __openpondCreateRequire } from "node:module"; var require = __openpondCreateRequire(import.meta.url);
+
+// ../../packages/cloud/dist/api/vercel-protection.js
+var VERCEL_PROTECTION_BYPASS_HEADER = "x-vercel-protection-bypass";
+function withVercelProtectionBypass(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;
+  }
+}
+
+// ../../packages/cloud/dist/api/core.js
+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 apiFetch(baseUrl, token, requestPath, options = {}) {
+  const { timeoutMs = DEFAULT_API_TIMEOUT_MS, maxResponseBytes = DEFAULT_API_RESPONSE_BYTES, ...init } = options;
+  const requestUrl = `${baseUrl}${requestPath}`;
+  const headers = withVercelProtectionBypass(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;
+}
+
+// ../../packages/cloud/dist/urls.js
+var DEFAULT_OPENPOND_WEB_BASE_URL = "https://openpond.ai";
+var DEFAULT_OPENPOND_API_BASE_URL = "https://api.openpond.ai";
+
+// ../../packages/cloud/dist/sandbox/url.js
+function normalizeSandboxApiUrl(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_URL}/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");
+}
+
+// ../../packages/cloud/dist/sandbox/client-handles.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)
+  };
+}
+
+// ../../packages/cloud/dist/sandbox/runtime-handle.js
+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 (path, contents) => client.uploadFile((await resume()).id, path, contents),
+      read: async (path) => client.downloadFile((await resume()).id, path),
+      readResponse: async (input) => client.downloadFileResponse((await resume()).id, input),
+      list: async (input = {}) => client.listFiles((await resume()).id, input),
+      delete: async (path, input = {}) => client.deleteFile((await resume()).id, path, input),
+      search: async (input) => client.searchFiles((await resume()).id, input),
+      stat: async (path) => client.statFile((await resume()).id, path),
+      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();
+}
+
+// ../../packages/cloud/dist/sandbox/smoke.js
+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 sleep(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 sleep(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 sleep(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 sleep(pollMs);
+    latest = await client.get(sandboxId);
+  }
+  throw new Error(`snapshot did not reach ready state before timeout: ${snapshotId}`);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// ../../packages/cloud/dist/sandbox/async-request-options.js
+function asyncRequestHeaders(options = {}) {
+  return options.async || options.respondAsync ? { Prefer: "respond-async" } : void 0;
+}
+
+// ../../packages/cloud/dist/sandbox/stream.js
+async function streamSandboxEventOutput(params) {
+  const response = await apiFetch(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 event = buffered.slice(0, separatorIndex);
+        buffered = buffered.slice(separatorIndex + 2);
+        const output = parseProcessOutputEvent(event);
+        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(event) {
+  if (!event.includes("event: output")) {
+    return null;
+  }
+  const dataLines = event.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;
+  }
+}
+
+// ../../packages/cloud/dist/sandbox/sandbox-instance-client.js
+var OpenPondSandboxInstanceClient = class {
+  apiKey;
+  apiRootUrl;
+  sandboxApiUrl;
+  constructor(options) {
+    this.apiKey = options.apiKey;
+    this.sandboxApiUrl = normalizeSandboxApiUrl(options.sandboxApiUrl ?? options.baseUrl ?? DEFAULT_OPENPOND_API_BASE_URL);
+    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, path, contents) {
+    return this.uploadFileBase64(sandboxId, path, Buffer.from(contents, "utf-8").toString("base64"));
+  }
+  uploadFileBase64(sandboxId, path, contentsBase64) {
+    return this.request(`/${encodeURIComponent(sandboxId)}/files`, {
+      method: "POST",
+      body: JSON.stringify({
+        path,
+        contentsBase64
+      })
+    });
+  }
+  async downloadFile(sandboxId, path) {
+    const payload = await this.downloadFileResponse(sandboxId, path);
+    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, path, input = {}) {
+    const query = new URLSearchParams({ path });
+    if (input.recursive !== void 0)
+      query.set("recursive", String(input.recursive));
+    return this.request(`/${encodeURIComponent(sandboxId)}/files?${query.toString()}`, {
+      method: "DELETE"
+    });
+  }
+  statFile(sandboxId, path) {
+    const query = new URLSearchParams({ stat: "1", path });
+    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(path, init = {}) {
+    const response = await apiFetch(this.sandboxApiUrl, this.apiKey, path, init);
+    return readApiJson(response, "Sandbox request");
+  }
+  async requestApiRoot(path, init = {}) {
+    const response = await apiFetch(this.apiRootUrl, this.apiKey, path, init);
+    return readApiJson(response, "OpenPond API request");
+  }
+};
+
+// ../../packages/cloud/dist/sandbox/client.js
+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 createOpenPondSandboxClient(options) {
+  return new OpenPondSandboxClient(options);
+}
+
+export {
+  withVercelProtectionBypass,
+  apiFetch,
+  DEFAULT_OPENPOND_WEB_BASE_URL,
+  DEFAULT_OPENPOND_API_BASE_URL,
+  normalizeSandboxApiUrl,
+  createOpenPondSandboxClient
+};