rivetkit 2.1.4 → 2.1.6-rc.1

package/dist/tsup/sandbox/index.js

@@ -0,0 +1,761 @@
+import {
+  buildTerminalWebSocketUrl,
+  connectTerminal,
+  deleteFile,
+  downloadFile,
+  followProcessLogs,
+  listFiles,
+  mkdirFs,
+  moveFile,
+  statFile,
+  uploadBatch,
+  uploadFile
+} from "../chunk-JRKPV5NJ.js";
+import {
+  actor
+} from "../chunk-UQZRMTM3.js";
+import "../chunk-YGYGANCA.js";
+import "../chunk-EONWXYMN.js";
+import {
+  db
+} from "../chunk-MLK3GY6P.js";
+import "../chunk-GFGRBYO2.js";
+import "../chunk-PQWI44WD.js";
+import "../chunk-LXUQ667X.js";
+import "../chunk-C22JYHVT.js";
+import "../chunk-VWYO36X4.js";
+import "../chunk-AKUJ5OTO.js";
+import "../chunk-424PT5DM.js";
+
+// src/sandbox/actor/index.ts
+import { SandboxAgent } from "sandbox-agent";
+
+// src/sandbox/config.ts
+import { z } from "zod/v4";
+var zFunction = () => z.custom((val) => typeof val === "function");
+var SandboxProviderSchema = z.object({
+  name: z.string(),
+  create: zFunction(),
+  destroy: zFunction(),
+  getUrl: zFunction().optional(),
+  getFetch: zFunction().optional(),
+  ensureServer: zFunction().optional()
+});
+var SandboxActorOptionsSchema = z.object({
+  // Log if the actor still thinks a turn is active but no new session event
+  // has arrived for this long.
+  warningAfterMs: z.number().nonnegative().default(3e4),
+  // Clear active-turn state after this timeout so a missing terminal event
+  // cannot keep the actor awake forever.
+  staleAfterMs: z.number().positive().default(5 * 6e4)
+}).strict().prefault(() => ({})).transform((value) => ({
+  ...value,
+  warningAfterMs: Math.min(value.warningAfterMs, value.staleAfterMs)
+}));
+var SandboxActorConfigSchema = z.object({
+  provider: SandboxProviderSchema.optional(),
+  createProvider: zFunction().optional(),
+  persistRawEvents: z.boolean().optional(),
+  destroyActor: z.boolean().default(false),
+  options: SandboxActorOptionsSchema,
+  onBeforeConnect: zFunction().optional(),
+  onSessionEvent: zFunction().optional(),
+  onPermissionRequest: zFunction().optional()
+}).strict().refine(
+  (data) => data.provider !== void 0 !== (data.createProvider !== void 0),
+  {
+    message: "Sandbox actor config must define exactly one of 'provider' or 'createProvider'"
+  }
+);
+
+// src/sandbox/session-persist-driver.ts
+function parseCursor(cursor) {
+  if (!cursor) {
+    return 0;
+  }
+  const value = Number(cursor);
+  if (!Number.isFinite(value) || value < 0) {
+    return 0;
+  }
+  return Math.floor(value);
+}
+function nextCursor(offset, limit, itemCount) {
+  if (itemCount < limit) {
+    return void 0;
+  }
+  return String(offset + itemCount);
+}
+var SqliteSessionPersistDriver = class {
+  #db;
+  #persistRawEvents;
+  constructor(db2, persistRawEvents) {
+    this.#db = db2;
+    this.#persistRawEvents = persistRawEvents;
+  }
+  async getSession(id) {
+    const rows = await this.#db.execute(
+      "SELECT record_json FROM sandbox_agent_sessions WHERE id = ? LIMIT 1",
+      id
+    );
+    const row = rows[0];
+    if (!row) {
+      return void 0;
+    }
+    return JSON.parse(row.record_json);
+  }
+  async listSessions(request = {}) {
+    const limit = request.limit ?? 50;
+    const offset = parseCursor(request.cursor);
+    const rows = await this.#db.execute(
+      `
+				SELECT record_json
+				FROM sandbox_agent_sessions
+				ORDER BY created_at DESC, id DESC
+				LIMIT ? OFFSET ?
+			`,
+      limit,
+      offset
+    );
+    return {
+      items: rows.map((row) => JSON.parse(row.record_json)),
+      nextCursor: nextCursor(offset, limit, rows.length)
+    };
+  }
+  async updateSession(session) {
+    await this.#db.execute(
+      `
+				INSERT INTO sandbox_agent_sessions (id, created_at, record_json)
+				VALUES (?, ?, ?)
+				ON CONFLICT(id) DO UPDATE SET
+					created_at = excluded.created_at,
+					record_json = excluded.record_json
+			`,
+      session.id,
+      session.createdAt,
+      JSON.stringify(session)
+    );
+  }
+  async listEvents(request) {
+    const limit = request.limit ?? 200;
+    const offset = parseCursor(request.cursor);
+    const rows = await this.#db.execute(
+      `
+				SELECT
+					id,
+					event_index,
+					session_id,
+					created_at,
+					connection_id,
+					sender,
+					payload_json
+				FROM sandbox_agent_events
+				WHERE session_id = ?
+				ORDER BY event_index ASC
+				LIMIT ? OFFSET ?
+			`,
+      request.sessionId,
+      limit,
+      offset
+    );
+    return {
+      items: rows.map((row) => ({
+        id: row.id,
+        eventIndex: row.event_index,
+        sessionId: row.session_id,
+        createdAt: row.created_at,
+        connectionId: row.connection_id,
+        sender: row.sender,
+        payload: JSON.parse(row.payload_json)
+      })),
+      nextCursor: nextCursor(offset, limit, rows.length)
+    };
+  }
+  async insertEvent(_sessionId, event) {
+    const payload = JSON.stringify(event.payload);
+    await this.#db.execute(
+      `
+				INSERT INTO sandbox_agent_events (
+					id,
+					session_id,
+					event_index,
+					created_at,
+					connection_id,
+					sender,
+					payload_json,
+					raw_payload_json
+				)
+				VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+				ON CONFLICT(session_id, event_index) DO UPDATE SET
+					id = excluded.id,
+					created_at = excluded.created_at,
+					connection_id = excluded.connection_id,
+					sender = excluded.sender,
+					payload_json = excluded.payload_json,
+					raw_payload_json = excluded.raw_payload_json
+			`,
+      event.id,
+      event.sessionId,
+      event.eventIndex,
+      event.createdAt,
+      event.connectionId,
+      event.sender,
+      payload,
+      this.#persistRawEvents ? payload : null
+    );
+  }
+};
+
+// src/sandbox/types.ts
+var SANDBOX_AGENT_HOOK_METHODS = [
+  "onSessionEvent",
+  "onPermissionRequest"
+];
+var SANDBOX_AGENT_ACTION_METHODS = [
+  "dispose",
+  "listSessions",
+  "getSession",
+  "getEvents",
+  "createSession",
+  "resumeSession",
+  "resumeOrCreateSession",
+  "destroySandbox",
+  "destroySession",
+  "setSessionMode",
+  "setSessionConfigOption",
+  "setSessionModel",
+  "setSessionThoughtLevel",
+  "getSessionConfigOptions",
+  "getSessionModes",
+  "rawSendSessionMethod",
+  "respondPermission",
+  "rawRespondPermission",
+  "getHealth",
+  "listAgents",
+  "getAgent",
+  "installAgent",
+  "listAcpServers",
+  "listFsEntries",
+  "readFsFile",
+  "writeFsFile",
+  "deleteFsEntry",
+  "mkdirFs",
+  "moveFs",
+  "statFs",
+  "uploadFsBatch",
+  "getMcpConfig",
+  "setMcpConfig",
+  "deleteMcpConfig",
+  "getSkillsConfig",
+  "setSkillsConfig",
+  "deleteSkillsConfig",
+  "getProcessConfig",
+  "setProcessConfig",
+  "createProcess",
+  "runProcess",
+  "listProcesses",
+  "getProcess",
+  "stopProcess",
+  "killProcess",
+  "deleteProcess",
+  "getProcessLogs",
+  "followProcessLogs",
+  "sendProcessInput",
+  "resizeProcessTerminal",
+  "buildProcessTerminalWebSocketUrl",
+  "connectProcessTerminalWebSocket",
+  "connectProcessTerminal"
+];
+
+// src/sandbox/actor/db.ts
+async function migrateSandboxTables(db2) {
+  await db2.execute(`
+		DROP TABLE IF EXISTS sandbox_actor_meta;
+		DROP TABLE IF EXISTS sandbox_actor_sessions;
+	`);
+  await db2.execute(`
+		CREATE TABLE IF NOT EXISTS sandbox_agent_sessions (
+			id TEXT PRIMARY KEY,
+			created_at INTEGER NOT NULL,
+			record_json TEXT NOT NULL
+		);
+
+		CREATE TABLE IF NOT EXISTS sandbox_agent_events (
+			id TEXT PRIMARY KEY,
+			session_id TEXT NOT NULL,
+			event_index INTEGER NOT NULL,
+			created_at INTEGER NOT NULL,
+			connection_id TEXT NOT NULL,
+			sender TEXT NOT NULL,
+			payload_json TEXT NOT NULL,
+			raw_payload_json TEXT,
+			UNIQUE(session_id, event_index)
+		);
+
+		CREATE INDEX IF NOT EXISTS sandbox_agent_sessions_created_at_idx
+			ON sandbox_agent_sessions (created_at DESC);
+
+		CREATE INDEX IF NOT EXISTS sandbox_agent_events_session_event_index_idx
+			ON sandbox_agent_events (session_id, event_index ASC);
+	`);
+}
+
+// src/sandbox/actor/session.ts
+function syncPreventSleep(c) {
+  c.setPreventSleep(
+    c.vars.activeHooks.size > 0 || c.vars.activeSessionIds.size > 0
+  );
+}
+function clearTimerMap(map, sessionId) {
+  const timeout = map.get(sessionId);
+  if (timeout) {
+    clearTimeout(timeout);
+    map.delete(sessionId);
+  }
+}
+function clearTimerMapAll(map) {
+  for (const timeout of map.values()) {
+    clearTimeout(timeout);
+  }
+  map.clear();
+}
+function clearSessionTimers(vars, sessionId) {
+  clearTimerMap(vars.warningTimeoutBySessionId, sessionId);
+  clearTimerMap(vars.staleTimeoutBySessionId, sessionId);
+}
+function clearAllSessionTimers(vars) {
+  clearTimerMapAll(vars.warningTimeoutBySessionId);
+  clearTimerMapAll(vars.staleTimeoutBySessionId);
+}
+function scheduleSessionTimers(c, options, sessionId) {
+  clearSessionTimers(c.vars, sessionId);
+  const lastEventAt = c.vars.lastEventAtBySessionId.get(sessionId);
+  if (lastEventAt === void 0) {
+    return;
+  }
+  const warningDelay = Math.max(
+    0,
+    options.warningAfterMs - (Date.now() - lastEventAt)
+  );
+  c.vars.warningTimeoutBySessionId.set(
+    sessionId,
+    setTimeout(() => {
+      if (!c.vars.activeSessionIds.has(sessionId)) {
+        return;
+      }
+      c.log.warn({
+        msg: "sandbox actor turn is still active without new session events",
+        sessionId,
+        idleMs: Date.now() - lastEventAt
+      });
+    }, warningDelay)
+  );
+  const staleDelay = Math.max(
+    0,
+    options.staleAfterMs - (Date.now() - lastEventAt)
+  );
+  c.vars.staleTimeoutBySessionId.set(
+    sessionId,
+    setTimeout(() => {
+      if (!c.vars.activeSessionIds.has(sessionId)) {
+        return;
+      }
+      c.log.warn({
+        msg: "sandbox actor cleared stale active turn state after inactivity timeout",
+        sessionId,
+        idleMs: Date.now() - lastEventAt
+      });
+      clearSessionActiveInMemory(c, sessionId);
+      syncPreventSleep(c);
+    }, staleDelay)
+  );
+}
+function markSessionActiveInMemory(c, options, sessionId, requestId) {
+  c.vars.activeSessionIds.add(sessionId);
+  if (requestId) {
+    const requestIds = c.vars.activePromptRequestIdsBySessionId.get(sessionId) ?? [];
+    if (!requestIds.includes(requestId)) {
+      requestIds.push(requestId);
+      c.vars.activePromptRequestIdsBySessionId.set(
+        sessionId,
+        requestIds
+      );
+    }
+  }
+  c.vars.lastEventAtBySessionId.set(sessionId, Date.now());
+  scheduleSessionTimers(c, options, sessionId);
+}
+function clearSessionActiveInMemory(c, sessionId, requestId) {
+  if (requestId) {
+    const remaining = (c.vars.activePromptRequestIdsBySessionId.get(sessionId) ?? []).filter(
+      (activeRequestId) => activeRequestId !== requestId
+    );
+    if (remaining.length > 0) {
+      c.vars.activePromptRequestIdsBySessionId.set(
+        sessionId,
+        remaining
+      );
+      return;
+    }
+  }
+  c.vars.activeSessionIds.delete(sessionId);
+  c.vars.activePromptRequestIdsBySessionId.delete(sessionId);
+  c.vars.lastEventAtBySessionId.delete(sessionId);
+  clearSessionTimers(c.vars, sessionId);
+}
+function addSubscribedSession(c, sessionId) {
+  if (c.state.subscribedSessionIds.includes(sessionId)) {
+    return;
+  }
+  c.state.subscribedSessionIds.push(sessionId);
+}
+function removeSubscribedSession(c, sessionId) {
+  clearSessionActiveInMemory(c, sessionId);
+  c.state.subscribedSessionIds = c.state.subscribedSessionIds.filter(
+    (id) => id !== sessionId
+  );
+  syncPreventSleep(c);
+}
+function clearAllActiveSessions(c) {
+  c.vars.activeSessionIds.clear();
+  c.vars.activePromptRequestIdsBySessionId.clear();
+  c.vars.lastEventAtBySessionId.clear();
+  clearAllSessionTimers(c.vars);
+  syncPreventSleep(c);
+}
+function runHook(c, sessionId, name, callback) {
+  const promise = Promise.resolve(callback()).catch((error) => {
+    c.log.error({
+      msg: `sandbox actor ${name} hook failed`,
+      sessionId,
+      error
+    });
+  }).finally(() => {
+    c.vars.activeHooks.delete(promise);
+    syncPreventSleep(c);
+  });
+  c.vars.activeHooks.add(promise);
+  syncPreventSleep(c);
+  c.waitUntil(promise);
+}
+function trackSessionTurnFromEvent(c, options, sessionId, event) {
+  const payload = event.payload;
+  const method = typeof (payload == null ? void 0 : payload.method) === "string" ? payload.method : null;
+  const rawId = payload == null ? void 0 : payload.id;
+  const id = typeof rawId === "string" ? rawId : typeof rawId === "number" ? String(rawId) : null;
+  if (event.sender === "client" && method === "session/prompt") {
+    markSessionActiveInMemory(
+      c,
+      options,
+      sessionId,
+      id ?? `session-prompt:${event.id}`
+    );
+    syncPreventSleep(c);
+    return;
+  }
+  if (!c.vars.activeSessionIds.has(sessionId)) {
+    return;
+  }
+  if (event.sender === "agent" && id) {
+    const requestIds = c.vars.activePromptRequestIdsBySessionId.get(sessionId) ?? [];
+    if (requestIds.length === 0 || requestIds.includes(id)) {
+      clearSessionActiveInMemory(c, sessionId, id);
+      syncPreventSleep(c);
+      return;
+    }
+  }
+  c.vars.lastEventAtBySessionId.set(sessionId, Date.now());
+  scheduleSessionTimers(c, options, sessionId);
+}
+function subscribeToSession(c, config, sessionId) {
+  if (c.vars.unsubscribeBySessionId.has(sessionId)) {
+    return;
+  }
+  const client = c.vars.sandboxAgentClient;
+  if (!client) {
+    return;
+  }
+  const options = config.options;
+  const event = client.onSessionEvent(sessionId, (sessionEvent) => {
+    trackSessionTurnFromEvent(c, options, sessionId, sessionEvent);
+    if (!config.onSessionEvent) {
+      return;
+    }
+    runHook(
+      c,
+      sessionId,
+      "onSessionEvent",
+      () => config.onSessionEvent(c, sessionId, sessionEvent)
+    );
+  });
+  const permission = client.onPermissionRequest(
+    sessionId,
+    (request) => {
+      markSessionActiveInMemory(c, options, sessionId);
+      syncPreventSleep(c);
+      if (!config.onPermissionRequest) {
+        return;
+      }
+      runHook(
+        c,
+        sessionId,
+        "onPermissionRequest",
+        () => config.onPermissionRequest(c, sessionId, request)
+      );
+    }
+  );
+  c.vars.unsubscribeBySessionId.set(sessionId, { event, permission });
+}
+
+// src/sandbox/actor/index.ts
+async function teardownAgentRuntime(vars) {
+  var _a, _b;
+  for (const subscription of vars.unsubscribeBySessionId.values()) {
+    (_a = subscription.event) == null ? void 0 : _a.call(subscription);
+    (_b = subscription.permission) == null ? void 0 : _b.call(subscription);
+  }
+  vars.unsubscribeBySessionId.clear();
+  clearAllSessionTimers(vars);
+  vars.activeHooks.clear();
+  if (vars.sandboxAgentClient) {
+    try {
+      await vars.sandboxAgentClient.dispose();
+    } finally {
+      vars.sandboxAgentClient = null;
+    }
+  }
+  vars.provider = null;
+}
+async function resolveProvider(c, config) {
+  if (c.vars.provider) {
+    return c.vars.provider;
+  }
+  const provider = config.provider !== void 0 ? config.provider : await config.createProvider(c);
+  if (c.state.providerName && c.state.providerName !== provider.name) {
+    throw new Error(
+      `sandbox actor provider mismatch: expected ${c.state.providerName}, received ${provider.name}`
+    );
+  }
+  if (!c.state.providerName) {
+    c.state.providerName = provider.name;
+  }
+  c.vars.provider = provider;
+  return provider;
+}
+async function ensureAgent(c, config, persistRawEvents) {
+  if (c.vars.sandboxAgentClient) {
+    return c.vars.sandboxAgentClient;
+  }
+  const provider = await resolveProvider(c, config);
+  c.vars.sandboxAgentClient = await SandboxAgent.start({
+    sandbox: provider,
+    sandboxId: c.state.sandboxId ?? void 0,
+    persist: new SqliteSessionPersistDriver(c.db, persistRawEvents)
+  });
+  if (!c.state.sandboxId && c.vars.sandboxAgentClient.sandboxId) {
+    c.state.sandboxId = c.vars.sandboxAgentClient.sandboxId;
+  }
+  for (const sessionId of c.state.subscribedSessionIds) {
+    subscribeToSession(c, config, sessionId);
+  }
+  return c.vars.sandboxAgentClient;
+}
+var READ_ONLY_ACTIONS = /* @__PURE__ */ new Set([
+  "listSessions",
+  "getSession",
+  "getEvents"
+]);
+var SESSION_RETURNING_ACTIONS = /* @__PURE__ */ new Set([
+  "createSession",
+  "resumeSession",
+  "resumeOrCreateSession",
+  "getSession"
+]);
+var SESSION_SENDING_ACTIONS = /* @__PURE__ */ new Set([
+  "rawSendSessionMethod",
+  "respondPermission",
+  "rawRespondPermission"
+]);
+function isSessionLike(value) {
+  return typeof value === "object" && value !== null && "id" in value && typeof value.id === "string";
+}
+function buildProxyActions(config) {
+  const actions = {};
+  for (const actionName of SANDBOX_AGENT_ACTION_METHODS) {
+    actions[actionName] = async (c, ...args) => {
+      var _a, _b;
+      if (c.state.sandboxDestroyed) {
+        if (READ_ONLY_ACTIONS.has(actionName)) {
+          const persist = new SqliteSessionPersistDriver(
+            c.db,
+            config.persistRawEvents ?? false
+          );
+          if (actionName === "listSessions") {
+            return persist.listSessions(args[0]);
+          }
+          if (actionName === "getSession") {
+            return persist.getSession(args[0]);
+          }
+          if (actionName === "getEvents") {
+            return persist.listEvents(args[0]);
+          }
+        }
+        throw new Error(
+          "sandbox has been destroyed; only read-only actions (listSessions, getSession, getEvents) are available"
+        );
+      }
+      const options = config.options;
+      if (SESSION_SENDING_ACTIONS.has(actionName) && typeof args[0] === "string") {
+        markSessionActiveInMemory(c, options, args[0]);
+        syncPreventSleep(c);
+      }
+      const agent = await ensureAgent(
+        c,
+        config,
+        config.persistRawEvents ?? false
+      );
+      const method = agent[actionName];
+      const result = await method.apply(agent, args);
+      if (actionName === "dispose") {
+        await teardownAgentRuntime(c.vars);
+        clearAllActiveSessions(c);
+      } else if (actionName === "destroySession" && isSessionLike(result)) {
+        const sub = c.vars.unsubscribeBySessionId.get(result.id);
+        (_a = sub == null ? void 0 : sub.event) == null ? void 0 : _a.call(sub);
+        (_b = sub == null ? void 0 : sub.permission) == null ? void 0 : _b.call(sub);
+        c.vars.unsubscribeBySessionId.delete(result.id);
+        removeSubscribedSession(c, result.id);
+      } else if (SESSION_RETURNING_ACTIONS.has(actionName) && isSessionLike(result)) {
+        addSubscribedSession(c, result.id);
+        subscribeToSession(c, config, result.id);
+      } else if (actionName === "listSessions" && result && typeof result === "object") {
+        const items = result.items;
+        if (Array.isArray(items)) {
+          for (const item of items) {
+            if (isSessionLike(item)) {
+              addSubscribedSession(c, item.id);
+              subscribeToSession(c, config, item.id);
+            }
+          }
+        }
+      }
+      return result;
+    };
+  }
+  return actions;
+}
+function sandboxActor(config) {
+  const parsedConfig = SandboxActorConfigSchema.parse(
+    config
+  );
+  return actor({
+    createState: async () => ({
+      sandboxId: null,
+      providerName: null,
+      subscribedSessionIds: [],
+      sandboxDestroyed: false
+    }),
+    createVars: () => ({
+      sandboxAgentClient: null,
+      provider: null,
+      activeSessionIds: /* @__PURE__ */ new Set(),
+      activePromptRequestIdsBySessionId: /* @__PURE__ */ new Map(),
+      lastEventAtBySessionId: /* @__PURE__ */ new Map(),
+      unsubscribeBySessionId: /* @__PURE__ */ new Map(),
+      activeHooks: /* @__PURE__ */ new Set(),
+      warningTimeoutBySessionId: /* @__PURE__ */ new Map(),
+      staleTimeoutBySessionId: /* @__PURE__ */ new Map()
+    }),
+    db: db({
+      onMigrate: migrateSandboxTables
+    }),
+    onSleep: async (c) => {
+      await teardownAgentRuntime(c.vars);
+    },
+    onDestroy: async (c) => {
+      const sandboxContext = c;
+      clearAllActiveSessions(sandboxContext);
+      await teardownAgentRuntime(sandboxContext.vars);
+      if (sandboxContext.state.sandboxId) {
+        try {
+          const provider = await resolveProvider(
+            sandboxContext,
+            parsedConfig
+          );
+          await provider.destroy(sandboxContext.state.sandboxId);
+        } finally {
+          sandboxContext.state.sandboxId = null;
+          sandboxContext.state.providerName = null;
+        }
+      }
+      sandboxContext.state.subscribedSessionIds = [];
+    },
+    onBeforeConnect: parsedConfig.onBeforeConnect,
+    actions: {
+      // Destroys the sandbox environment but keeps the actor alive so
+      // session transcripts remain accessible via read-only actions.
+      // If `destroyActor` is set in the config, the actor is also
+      // destroyed after the sandbox.
+      destroy: async (c) => {
+        if (c.state.sandboxDestroyed) {
+          return;
+        }
+        clearAllActiveSessions(c);
+        await teardownAgentRuntime(c.vars);
+        if (c.state.sandboxId) {
+          const provider = await resolveProvider(c, parsedConfig);
+          await provider.destroy(c.state.sandboxId);
+          c.state.sandboxId = null;
+        }
+        c.state.sandboxDestroyed = true;
+        if (parsedConfig.destroyActor) {
+          c.destroy();
+        }
+      },
+      getSandboxUrl: async (c) => {
+        if (c.state.sandboxDestroyed) {
+          throw new Error("sandbox has been destroyed");
+        }
+        const provider = await resolveProvider(c, parsedConfig);
+        if (!c.state.sandboxId) {
+          const agent = await ensureAgent(
+            c,
+            parsedConfig,
+            parsedConfig.persistRawEvents ?? false
+          );
+          if (!c.state.sandboxId && agent.sandboxId) {
+            c.state.sandboxId = agent.sandboxId;
+          }
+        }
+        if (!c.state.sandboxId) {
+          throw new Error("sandbox ID is not available");
+        }
+        if (!provider.getUrl) {
+          throw new Error(
+            `provider "${provider.name}" does not support getUrl; direct sandbox URL access is not available for this provider`
+          );
+        }
+        return { url: await provider.getUrl(c.state.sandboxId) };
+      },
+      ...buildProxyActions(parsedConfig)
+    }
+  });
+}
+export {
+  SANDBOX_AGENT_ACTION_METHODS,
+  SANDBOX_AGENT_HOOK_METHODS,
+  SandboxActorConfigSchema,
+  SandboxActorOptionsSchema,
+  buildTerminalWebSocketUrl,
+  connectTerminal,
+  deleteFile,
+  downloadFile,
+  followProcessLogs,
+  listFiles,
+  mkdirFs,
+  moveFile,
+  sandboxActor,
+  statFile,
+  uploadBatch,
+  uploadFile
+};
+//# sourceMappingURL=index.js.map