openpond-sdk 0.0.1

package/dist/index.js

@@ -0,0 +1,2635 @@
+// ../cloud/src/sandbox/client-handles.ts
+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)
+  };
+}
+
+// ../cloud/src/sandbox/runtime-handle.ts
+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();
+}
+
+// ../cloud/src/sandbox/smoke.ts
+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 expectedRuntimeDriver = options.expectedRuntimeDriver ?? "remote-firecracker";
+    if (sandbox.runtimeDriver !== expectedRuntimeDriver) {
+      throw new Error(
+        `expected ${expectedRuntimeDriver}, got ${sandbox.runtimeDriver}`
+      );
+    }
+    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));
+}
+
+// ../cloud/src/sandbox/async-request-options.ts
+function asyncRequestHeaders(options = {}) {
+  return options.async || options.respondAsync ? { Prefer: "respond-async" } : void 0;
+}
+
+// ../cloud/src/api/vercel-protection.ts
+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;
+  }
+}
+
+// ../cloud/src/api/core.ts
+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 {
+  constructor(timeoutMs, requestUrl) {
+    super(`API request timed out after ${timeoutMs}ms: ${requestUrl}`);
+    this.timeoutMs = timeoutMs;
+    this.requestUrl = requestUrl;
+    this.name = "ApiTimeoutError";
+  }
+  timeoutMs;
+  requestUrl;
+  code = "OPENPOND_API_TIMEOUT";
+};
+var ApiResponseTooLargeError = class extends Error {
+  constructor(maximumBytes, requestUrl) {
+    super(`API response exceeded ${maximumBytes} bytes: ${requestUrl}`);
+    this.maximumBytes = maximumBytes;
+    this.requestUrl = requestUrl;
+    this.name = "ApiResponseTooLargeError";
+  }
+  maximumBytes;
+  requestUrl;
+  code = "OPENPOND_API_RESPONSE_TOO_LARGE";
+};
+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 message = typeof payload.message === "string" ? payload.message : typeof payload.error === "string" ? payload.error : "";
+    throw new Error(`${label} failed: ${response.status}${message ? ` ${message}` : ""}`);
+  }
+  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;
+}
+
+// ../cloud/src/urls.ts
+var DEFAULT_OPENPOND_WEB_BASE_URL = "https://openpond.ai";
+var DEFAULT_OPENPOND_API_BASE_URL = "https://api.openpond.ai";
+var DEFAULT_OPENPOND_OPCHAT_API_BASE_URL = "https://api.openpond.ai/opchat/v1";
+
+// ../cloud/src/sandbox/stream.ts
+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;
+  }
+}
+
+// ../cloud/src/sandbox/url.ts
+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.startsWith("api") && hostname.endsWith(".openpond.ai");
+}
+
+// ../cloud/src/sandbox/sandbox-instance-client.ts
+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");
+  }
+};
+
+// ../cloud/src/sandbox/client.ts
+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);
+}
+
+// ../cloud/src/hosted-chat.ts
+import { randomUUID } from "node:crypto";
+function normalizeApiBaseUrl(value) {
+  const trimmed = normalizeOptionalOpChatApiBaseUrl(value);
+  if (!trimmed) throw new Error("apiBaseUrl is required");
+  return trimmed;
+}
+function trimTrailingSlashes(value) {
+  return value.replace(/\/+$/, "");
+}
+function normalizeOptionalOpChatApiBaseUrl(value) {
+  let trimmed = trimTrailingSlashes(value?.trim() ?? "");
+  if (!trimmed) return null;
+  trimmed = trimmed.replace(/\/chat\/completions$/i, "").replace(/\/models(?:\/[^/]+)?$/i, "");
+  if (trimmed.endsWith("/opchat/v1")) return trimmed;
+  if (trimmed.endsWith("/opchat")) return `${trimmed}/v1`;
+  if (trimmed.endsWith("/v1")) {
+    trimmed = trimmed.slice(0, -"/v1".length);
+  }
+  return `${trimTrailingSlashes(trimmed)}/opchat/v1`;
+}
+function resolveOpChatApiBaseUrl(options = {}) {
+  const runtimeEnv = options.env ?? (typeof process !== "undefined" ? process.env : {});
+  const explicit = normalizeOptionalOpChatApiBaseUrl(options.opChatApiBaseUrl) ?? normalizeOptionalOpChatApiBaseUrl(runtimeEnv.OPENPOND_OPCHAT_API_URL);
+  if (explicit) return explicit;
+  const migrationInput = normalizeOptionalOpChatApiBaseUrl(options.chatApiBaseUrl) ?? normalizeOptionalOpChatApiBaseUrl(runtimeEnv.OPENPOND_CHAT_API_URL) ?? normalizeOptionalOpChatApiBaseUrl(runtimeEnv.OPENPOND_GATEWAY_URL);
+  if (migrationInput) return migrationInput;
+  const apiBase = normalizeOptionalOpChatApiBaseUrl(options.apiBaseUrl) ?? normalizeOptionalOpChatApiBaseUrl(runtimeEnv.OPENPOND_API_URL);
+  return apiBase ?? DEFAULT_OPENPOND_OPCHAT_API_BASE_URL;
+}
+function requireToken(value) {
+  const trimmed = value.trim();
+  if (!trimmed) throw new Error("OpenPond API key is required");
+  return trimmed;
+}
+function hostedHeaders(requestUrl, token, accept, requestId) {
+  const headers = new Headers();
+  headers.set("Authorization", `Bearer ${requireToken(token)}`);
+  headers.set("Content-Type", "application/json");
+  headers.set("Accept", accept);
+  headers.set("x-openpond-client", "openpond-code");
+  headers.set("x-openpond-request-id", requestId || randomUUID());
+  return withVercelProtectionBypass(requestUrl, headers);
+}
+async function readError(response) {
+  const text = await response.text().catch(() => "");
+  if (!text) return response.statusText || `HTTP ${response.status}`;
+  try {
+    const payload = JSON.parse(text);
+    const error = typeof payload.error === "string" ? payload.error : payload.error && typeof payload.error === "object" && !Array.isArray(payload.error) ? payload.error : null;
+    const code = typeof payload.code === "string" ? payload.code : error && typeof error !== "string" && typeof error.code === "string" ? error.code : null;
+    const message = typeof payload.message === "string" ? payload.message : error && typeof error !== "string" && typeof error.message === "string" ? error.message : null;
+    const label = typeof error === "string" ? error : error && typeof error.type === "string" ? error.type : null;
+    return [code, label, message].filter(Boolean).join(": ") || text;
+  } catch {
+    return text;
+  }
+}
+function buildHostedChatBody(options, stream) {
+  const body = {
+    model: options.model,
+    messages: options.messages,
+    stream
+  };
+  if (typeof options.temperature === "number") {
+    body.temperature = options.temperature;
+  }
+  if (typeof options.maxTokens === "number") {
+    body.max_tokens = options.maxTokens;
+  }
+  if (options.tools) {
+    body.tools = options.tools;
+  }
+  const toolChoice = options.toolChoice ?? options.tool_choice;
+  if (toolChoice !== void 0) {
+    body.tool_choice = toolChoice;
+  }
+  if (options.metadata) {
+    body.metadata = options.metadata;
+  }
+  return body;
+}
+async function listOpChatModels(options) {
+  const apiBaseUrl = normalizeApiBaseUrl(options.apiBaseUrl);
+  const requestUrl = `${apiBaseUrl}/models`;
+  const response = await fetch(requestUrl, {
+    method: "GET",
+    headers: hostedHeaders(requestUrl, options.token, "application/json"),
+    signal: options.signal
+  });
+  if (!response.ok) {
+    throw new Error(
+      `Hosted model list failed: ${response.status} ${await readError(
+        response
+      )}`
+    );
+  }
+  return await response.json();
+}
+async function getOpChatModel(options) {
+  const apiBaseUrl = normalizeApiBaseUrl(options.apiBaseUrl);
+  const requestUrl = `${apiBaseUrl}/models/${encodeURIComponent(options.model)}`;
+  const response = await fetch(
+    requestUrl,
+    {
+      method: "GET",
+      headers: hostedHeaders(requestUrl, options.token, "application/json"),
+      signal: options.signal
+    }
+  );
+  if (!response.ok) {
+    throw new Error(
+      `Hosted model lookup failed: ${response.status} ${await readError(
+        response
+      )}`
+    );
+  }
+  return await response.json();
+}
+async function listOpChatProviders(options) {
+  const apiBaseUrl = normalizeApiBaseUrl(options.apiBaseUrl);
+  const requestUrl = `${apiBaseUrl}/providers`;
+  const response = await fetch(requestUrl, {
+    method: "GET",
+    headers: hostedHeaders(requestUrl, options.token, "application/json"),
+    signal: options.signal
+  });
+  if (!response.ok) {
+    throw new Error(
+      `Hosted provider list failed: ${response.status} ${await readError(
+        response
+      )}`
+    );
+  }
+  return await response.json();
+}
+async function getOpChatProvider(options) {
+  const apiBaseUrl = normalizeApiBaseUrl(options.apiBaseUrl);
+  const requestUrl = `${apiBaseUrl}/providers/${encodeURIComponent(options.provider)}`;
+  const response = await fetch(
+    requestUrl,
+    {
+      method: "GET",
+      headers: hostedHeaders(requestUrl, options.token, "application/json"),
+      signal: options.signal
+    }
+  );
+  if (!response.ok) {
+    throw new Error(
+      `Hosted provider lookup failed: ${response.status} ${await readError(
+        response
+      )}`
+    );
+  }
+  return await response.json();
+}
+async function sendHostedChatTurn(options) {
+  const apiBaseUrl = normalizeApiBaseUrl(options.apiBaseUrl);
+  const requestUrl = `${apiBaseUrl}/chat/completions`;
+  const response = await fetch(requestUrl, {
+    method: "POST",
+    headers: hostedHeaders(
+      requestUrl,
+      options.token,
+      "application/json",
+      options.requestId
+    ),
+    body: JSON.stringify(buildHostedChatBody(options, false)),
+    signal: options.signal
+  });
+  if (!response.ok) {
+    throw new Error(
+      `Hosted chat failed: ${response.status} ${await readError(response)}`
+    );
+  }
+  return await response.json();
+}
+async function* parseOpenAISSE(stream, signal) {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  const readAbortError = () => signal?.reason instanceof Error ? signal.reason : new Error("hosted_chat_aborted");
+  try {
+    while (true) {
+      if (signal?.aborted) throw readAbortError();
+      const result = await reader.read();
+      if (result.done) break;
+      buffer += decoder.decode(result.value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith("data:")) continue;
+        const data = trimmed.slice(5).trim();
+        if (!data) continue;
+        if (data === "[DONE]") return;
+        yield JSON.parse(data);
+      }
+    }
+  } finally {
+    try {
+      reader.releaseLock();
+    } catch {
+    }
+  }
+}
+async function* streamHostedChatTurn(options) {
+  const apiBaseUrl = normalizeApiBaseUrl(options.apiBaseUrl);
+  const requestUrl = `${apiBaseUrl}/chat/completions`;
+  const response = await fetch(requestUrl, {
+    method: "POST",
+    headers: hostedHeaders(
+      requestUrl,
+      options.token,
+      "text/event-stream",
+      options.requestId
+    ),
+    body: JSON.stringify(buildHostedChatBody(options, true)),
+    signal: options.signal
+  });
+  if (!response.ok || !response.body) {
+    throw new Error(
+      `Hosted chat stream failed: ${response.status} ${await readError(
+        response
+      )}`
+    );
+  }
+  for await (const raw of parseOpenAISSE(response.body, options.signal)) {
+    const chunk = raw;
+    if (chunk.error) {
+      throw new Error(chunk.error.message || "Hosted chat stream error");
+    }
+    if (chunk.usage) {
+      yield { type: "usage", usage: chunk.usage, raw };
+    }
+    const choice = chunk.choices?.[0];
+    if (!choice) continue;
+    const content = choice.delta?.content;
+    if (content) {
+      yield { type: "text_delta", text: content, raw };
+    }
+    const reasoning = choice.delta?.reasoning_content;
+    if (reasoning) {
+      yield { type: "reasoning_delta", text: reasoning, raw };
+    }
+    const toolCalls = choice.delta?.tool_calls;
+    if (Array.isArray(toolCalls) && toolCalls.length > 0) {
+      yield { type: "tool_call_delta", toolCalls, raw };
+    }
+    if (choice.finish_reason !== void 0 && choice.finish_reason !== null) {
+      yield { type: "finish", finishReason: choice.finish_reason, raw };
+    }
+  }
+}
+
+// src/work.ts
+var DEFAULT_MODEL = "openpond-chat";
+var DEFAULT_MAX_STEPS = 24;
+var MAX_TOOL_OUTPUT_CHARS = 4e4;
+var OpenPondNonExecutingSandboxError = class extends Error {
+  constructor(sandboxId) {
+    super(
+      `Sandbox ${sandboxId} accepted a command without executing it. A real remote runner is required for OpenPond Work.`
+    );
+    this.sandboxId = sandboxId;
+    this.name = "OpenPondNonExecutingSandboxError";
+  }
+  sandboxId;
+  code = "OPENPOND_NON_EXECUTING_SANDBOX";
+};
+var OpenPondWorkClient = class {
+  #apiKey;
+  #apiBaseUrl;
+  #chatApiBaseUrl;
+  #sandboxes;
+  constructor(input) {
+    this.#apiKey = input.apiKey;
+    this.#apiBaseUrl = input.apiBaseUrl;
+    this.#chatApiBaseUrl = input.chatApiBaseUrl;
+    this.#sandboxes = input.sandboxes;
+  }
+  async run(input) {
+    const prompt = input.prompt.trim();
+    if (!prompt) throw new Error("Work prompt is required");
+    input.signal?.throwIfAborted();
+    const emit = async (event) => input.onEvent?.(event);
+    await emit({ type: "status", message: "Preparing sandbox" });
+    const sandbox = await this.#resolveSandbox(input);
+    if (sandbox.runtimeDriver === "simulated-firecracker" && !input.allowSimulated) {
+      if (!input.sandboxId) {
+        await this.#sandboxes.delete(sandbox.id, { async: true }).catch(() => void 0);
+      }
+      throw new Error(
+        "OpenPond Work requires a remote-firecracker sandbox, but this environment returned the non-executing simulated-firecracker driver."
+      );
+    }
+    await emit({
+      type: "sandbox",
+      sandboxId: sandbox.id,
+      state: sandbox.state,
+      runtimeDriver: sandbox.runtimeDriver
+    });
+    const messages = [
+      { role: "system", content: systemPrompt(sandbox.id) },
+      ...(input.history ?? []).map((message) => ({ ...message })),
+      { role: "user", content: prompt }
+    ];
+    const maxSteps = boundedInteger(input.maxSteps, 1, 100, DEFAULT_MAX_STEPS);
+    let finalText = "";
+    for (let step = 1; step <= maxSteps; step += 1) {
+      input.signal?.throwIfAborted();
+      await emit({ type: "status", message: `Thinking \xB7 step ${step}` });
+      const completion = await sendHostedChatTurn({
+        apiBaseUrl: this.#chatApiBaseUrl,
+        token: this.#apiKey,
+        model: input.model?.trim() || DEFAULT_MODEL,
+        messages,
+        tools: WORK_TOOLS,
+        toolChoice: "auto",
+        signal: input.signal,
+        metadata: {
+          source: "openpond-sdk-work",
+          sandboxId: sandbox.id,
+          apiBaseUrl: this.#apiBaseUrl,
+          ...input.metadata
+        }
+      });
+      const choice = completion.choices?.[0];
+      const assistantText = choice?.message?.content?.trim() ?? "";
+      const toolCalls = choice?.message?.tool_calls ?? [];
+      messages.push({
+        role: "assistant",
+        content: assistantText || null,
+        ...toolCalls.length > 0 ? { tool_calls: toolCalls } : {}
+      });
+      if (assistantText) {
+        finalText = assistantText;
+        await emit({ type: "assistant", text: assistantText });
+      }
+      if (toolCalls.length === 0) {
+        const result = { sandboxId: sandbox.id, text: finalText, steps: step };
+        await emit({ type: "done", ...result });
+        return result;
+      }
+      for (const [index, toolCall] of toolCalls.entries()) {
+        const result = await this.#executeTool(
+          sandbox.id,
+          toolCall,
+          index,
+          input.timeoutSeconds,
+          emit
+        );
+        messages.push(result);
+      }
+    }
+    throw new Error(`Work did not finish within ${maxSteps} steps`);
+  }
+  async deleteSandbox(sandboxId) {
+    const sandbox = await this.#sandboxes.get(sandboxId);
+    if (sandbox.state === "deleted") return;
+    await this.#sandboxes.delete(sandboxId, { async: true });
+  }
+  async #resolveSandbox(input) {
+    if (input.sandboxId) {
+      const existing = await this.#sandboxes.get(input.sandboxId);
+      if (existing.state === "stopped") {
+        await this.#sandboxes.start(existing.id, { async: true });
+      } else if (existing.state === "deleted" || existing.state === "error") {
+        throw new Error(`Cannot resume sandbox ${existing.id} in state ${existing.state}`);
+      }
+      const ready = await this.#waitUntilRunning(existing.id, input.signal);
+      return ready;
+    }
+    const budgetUsd = input.budgetUsd?.trim() || "1.00";
+    const created = await this.#sandboxes.create(
+      {
+        ...input.repo?.trim() ? { repo: input.repo.trim() } : {},
+        runtimeProfileId: "openpond-work-v1",
+        resources: { cpu: 2, memoryGb: 4, diskGb: 16 },
+        budget: { maxUsd: budgetUsd },
+        quotas: {
+          maxSpendUsd: budgetUsd,
+          maxDurationSeconds: 3600,
+          idleTimeoutSeconds: 900,
+          maxCommands: 200,
+          maxOpenPorts: 4
+        },
+        metadata: { source: "openpond-sdk-work", ...input.metadata }
+      },
+      { async: true }
+    );
+    return this.#waitUntilRunning(created.id, input.signal);
+  }
+  async #waitUntilRunning(sandboxId, signal) {
+    const deadline = Date.now() + 12 * 6e4;
+    let sandbox = await this.#sandboxes.get(sandboxId);
+    while (Date.now() < deadline) {
+      signal?.throwIfAborted();
+      if (sandbox.state === "running") return sandbox;
+      if (sandbox.state === "error" || sandbox.state === "deleted") {
+        throw new Error(
+          `Sandbox ${sandbox.id} entered ${sandbox.state}${sandbox.logs.length ? `: ${sandbox.logs.join("\n")}` : ""}`
+        );
+      }
+      await sleep2(2e3, signal);
+      sandbox = await this.#sandboxes.get(sandboxId);
+    }
+    throw new Error(`Sandbox ${sandboxId} did not become ready before timeout`);
+  }
+  async #executeTool(sandboxId, toolCall, index, timeoutSeconds, emit) {
+    const toolCallId = toolCall.id || `work_tool_${index}`;
+    const name = toolCall.function?.name;
+    if (name !== "run_command") {
+      return toolMessage(toolCallId, { error: `Unknown tool: ${name ?? "missing"}` });
+    }
+    let args;
+    try {
+      args = JSON.parse(toolCall.function?.arguments || "{}");
+    } catch (error) {
+      return toolMessage(toolCallId, { error: `Invalid tool arguments: ${errorMessage(error)}` });
+    }
+    const command = typeof args.command === "string" ? args.command.trim() : "";
+    if (!command) return toolMessage(toolCallId, { error: "command is required" });
+    await emit({ type: "tool", toolCallId, command, status: "started" });
+    try {
+      const response = await this.#sandboxes.exec(sandboxId, {
+        command,
+        timeoutSeconds: boundedInteger(timeoutSeconds, 1, 900, 180)
+      });
+      const output = truncate(response.command.output, MAX_TOOL_OUTPUT_CHARS);
+      if (isNonExecutingSandboxOutput(output)) {
+        await emit({
+          type: "tool",
+          toolCallId,
+          command,
+          status: "failed",
+          output: "Staging accepted the command but did not execute it.",
+          exitCode: response.command.exitCode
+        });
+        await this.#sandboxes.delete(sandboxId, { async: true }).catch(() => void 0);
+        throw new OpenPondNonExecutingSandboxError(sandboxId);
+      }
+      const status = response.command.status === "succeeded" ? "succeeded" : "failed";
+      await emit({
+        type: "tool",
+        toolCallId,
+        command,
+        status,
+        output,
+        exitCode: response.command.exitCode
+      });
+      return toolMessage(toolCallId, {
+        status: response.command.status,
+        exitCode: response.command.exitCode,
+        output
+      });
+    } catch (error) {
+      if (error instanceof OpenPondNonExecutingSandboxError) throw error;
+      const output = errorMessage(error);
+      await emit({ type: "tool", toolCallId, command, status: "failed", output });
+      return toolMessage(toolCallId, { status: "failed", error: output });
+    }
+  }
+};
+var WORK_TOOLS = [
+  {
+    type: "function",
+    function: {
+      name: "run_command",
+      description: "Run a shell command inside the persistent OpenPond sandbox. Use standard shell tools to inspect, edit, build, and test files. Commands start in the repository workspace.",
+      parameters: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          command: { type: "string", description: "Shell command to execute." }
+        },
+        required: ["command"]
+      }
+    }
+  }
+];
+function systemPrompt(sandboxId) {
+  return [
+    "You are OpenPond Work, a careful coding agent operating in a persistent Linux sandbox.",
+    `The active sandbox is ${sandboxId}.`,
+    "Use run_command to inspect the workspace, edit files, and validate your work.",
+    "Do the requested work completely. Preserve existing user changes and avoid destructive commands.",
+    "Keep the user informed with concise prose, but call tools whenever verification or file changes are needed.",
+    "Before finishing, run relevant tests and summarize the concrete result."
+  ].join("\n");
+}
+function toolMessage(toolCallId, payload) {
+  return { role: "tool", tool_call_id: toolCallId, content: JSON.stringify(payload) };
+}
+function boundedInteger(value, minimum, maximum, fallback) {
+  if (!Number.isFinite(value)) return fallback;
+  return Math.min(maximum, Math.max(minimum, Math.floor(value)));
+}
+function truncate(value, maximum) {
+  if (value.length <= maximum) return value;
+  return `${value.slice(0, maximum)}
+\u2026 output truncated by openpond-sdk`;
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function isNonExecutingSandboxOutput(output) {
+  const normalized = output.toLowerCase();
+  return normalized.includes("command accepted by simulated-firecracker driver") || normalized.includes("no host command was executed");
+}
+function sleep2(milliseconds, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(signal.reason);
+      return;
+    }
+    const timer = setTimeout(resolve, milliseconds);
+    timer.unref?.();
+    signal?.addEventListener(
+      "abort",
+      () => {
+        clearTimeout(timer);
+        reject(signal.reason);
+      },
+      { once: true }
+    );
+  });
+}
+
+// ../cloud/src/sandbox/types/runtime-profiles.ts
+var SANDBOX_RUNTIME_PROFILE_IDS = [
+  "openpond-generic-firecracker-v1",
+  "openpond-work-v1",
+  "openpond-coding-core-v1",
+  "openpond-agent-harness-v1"
+];
+
+// src/index.ts
+var OpenPondClient = class {
+  sandboxes;
+  work;
+  constructor(options) {
+    const apiKey = options.apiKey.trim();
+    if (!apiKey) throw new Error("OpenPond API key is required");
+    const apiBaseUrl = options.baseUrl?.trim() || "https://api.openpond.ai";
+    this.sandboxes = createOpenPondSandboxClient({
+      apiKey,
+      baseUrl: apiBaseUrl,
+      sandboxApiUrl: options.sandboxApiUrl
+    });
+    this.work = new OpenPondWorkClient({
+      apiKey,
+      apiBaseUrl,
+      chatApiBaseUrl: options.chatApiUrl?.trim() || resolveOpChatApiBaseUrl({ apiBaseUrl, env: {} }),
+      sandboxes: this.sandboxes
+    });
+  }
+};
+function createOpenPondClient(options) {
+  return new OpenPondClient(options);
+}
+export {
+  OpenPondClient,
+  OpenPondNonExecutingSandboxError,
+  OpenPondSandboxClient,
+  OpenPondWorkClient,
+  SANDBOX_RUNTIME_PROFILE_IDS,
+  createOpenPondClient,
+  createOpenPondSandboxClient,
+  getOpChatModel,
+  getOpChatProvider,
+  listOpChatModels,
+  listOpChatProviders,
+  normalizeSandboxApiUrl,
+  resolveOpChatApiBaseUrl,
+  sendHostedChatTurn,
+  streamHostedChatTurn
+};
+//# sourceMappingURL=index.js.map