@giselles-ai/sandbox-agent 0.1.10 → 0.1.12

package/dist/index.d.ts

@@ -1,6 +1,29 @@
 import { z } from 'zod';
 import { Sandbox } from '@vercel/sandbox';
 
+type AgentType = "codex" | "gemini";
+declare class Agent {
+    private _type;
+    private _snapshotId;
+    private _pendingOps;
+    private constructor();
+    static create(type: AgentType, options: {
+        snapshotId: string;
+    }): Agent;
+    get type(): AgentType;
+    get snapshotId(): string;
+    get dirty(): boolean;
+    addFiles(files: Array<{
+        path: string;
+        content: Buffer;
+    }>): this;
+    runCommands(commands: Array<{
+        cmd: string;
+        args?: string[];
+    }>): this;
+    prepare(): Promise<void>;
+}
+
 type BaseChatRequest = {
     message: string;
     session_id?: string;
@@ -38,11 +61,18 @@ declare const codexRequestSchema: z.ZodObject<{
     message: z.ZodString;
     session_id: z.ZodOptional<z.ZodString>;
     sandbox_id: z.ZodOptional<z.ZodString>;
+    relay_session_id: z.ZodOptional<z.ZodString>;
+    relay_token: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 type CodexAgentRequest = z.infer<typeof codexRequestSchema>;
 type CodexAgentOptions = {
     snapshotId?: string;
     env?: Record<string, string>;
+    tools?: {
+        browser?: {
+            relayUrl?: string;
+        };
+    };
 };
 declare function createCodexAgent(options?: CodexAgentOptions): ChatAgent<CodexAgentRequest>;
 
@@ -71,4 +101,4 @@ type GeminiAgentOptions = {
 };
 declare function createGeminiAgent(options?: GeminiAgentOptions): ChatAgent<GeminiAgentRequest>;
 
-export { type BaseChatRequest, type ChatAgent, type ChatCommand, type RunChatInput, type StdoutMapper, createCodexAgent, createCodexStdoutMapper, createGeminiAgent, runChat };
+export { Agent, type BaseChatRequest, type ChatAgent, type ChatCommand, type RunChatInput, type StdoutMapper, createCodexAgent, createCodexStdoutMapper, createGeminiAgent, runChat };

package/dist/index.js

@@ -1,13 +1,92 @@
+// src/agent.ts
+import { Sandbox } from "@vercel/sandbox";
+var Agent = class _Agent {
+  _type;
+  _snapshotId;
+  _pendingOps = [];
+  constructor(type, snapshotId) {
+    this._type = type;
+    this._snapshotId = snapshotId;
+  }
+  static create(type, options) {
+    const trimmed = options.snapshotId.trim();
+    if (!trimmed) {
+      throw new Error("snapshotId is required.");
+    }
+    return new _Agent(type, trimmed);
+  }
+  get type() {
+    return this._type;
+  }
+  get snapshotId() {
+    return this._snapshotId;
+  }
+  get dirty() {
+    return this._pendingOps.length > 0;
+  }
+  addFiles(files) {
+    if (files.length === 0) {
+      return this;
+    }
+    this._pendingOps.push({
+      kind: "writeFiles",
+      files
+    });
+    return this;
+  }
+  runCommands(commands) {
+    for (const command of commands) {
+      this._pendingOps.push({
+        kind: "runCommand",
+        cmd: command.cmd,
+        args: command.args ?? []
+      });
+    }
+    return this;
+  }
+  async prepare() {
+    if (!this.dirty) {
+      return;
+    }
+    const ops = this._pendingOps;
+    const sandbox = await Sandbox.create({
+      source: { type: "snapshot", snapshotId: this._snapshotId }
+    });
+    console.log(
+      `[sandbox] created sandbox=${sandbox.sandboxId} from snapshot=${this._snapshotId}`
+    );
+    for (const op of ops) {
+      switch (op.kind) {
+        case "writeFiles":
+          await sandbox.writeFiles(op.files);
+          break;
+        case "runCommand":
+          await sandbox.runCommand(op.cmd, op.args);
+          break;
+      }
+    }
+    const snapshot = await sandbox.snapshot();
+    this._snapshotId = snapshot.snapshotId;
+    this._pendingOps = [];
+  }
+};
+
 // src/agents/codex-agent.ts
+import * as TOML from "@iarna/toml";
 import { z } from "zod";
 
 // src/agents/codex-mapper.ts
 function mapEvent(event) {
   const type = event.type;
+  if (type === "thread.started") {
+    return {
+      type: "init",
+      session_id: event.thread_id ?? void 0
+    };
+  }
   if (type === "session.created") {
     return {
       type: "init",
-      session_id: event.id ?? void 0,
       modelId: event.model ?? void 0
     };
   }
@@ -33,6 +112,18 @@ function mapEvent(event) {
       content: typeof event.message === "string" ? event.message : JSON.stringify(event)
     };
   }
+  if (type === "item.completed") {
+    const item = event.item;
+    if (item?.type === "agent_message" && typeof item.text === "string") {
+      return {
+        type: "message",
+        role: "assistant",
+        content: item.text,
+        delta: false
+      };
+    }
+    return null;
+  }
   if (type === "response.completed") {
     return null;
   }
@@ -84,10 +175,13 @@ function createCodexStdoutMapper() {
 }
 
 // src/agents/codex-agent.ts
+var CODEX_CONFIG_PATH = "/home/vercel-sandbox/.codex/config.toml";
 var codexRequestSchema = z.object({
   message: z.string().min(1),
   session_id: z.string().min(1).optional(),
-  sandbox_id: z.string().min(1).optional()
+  sandbox_id: z.string().min(1).optional(),
+  relay_session_id: z.string().min(1).optional(),
+  relay_token: z.string().min(1).optional()
 });
 function requiredEnv(env, name) {
   const value = env[name]?.trim();
@@ -96,34 +190,91 @@ function requiredEnv(env, name) {
   }
   return value;
 }
+async function patchCodexConfigTransportEnv(sandbox, bridgeTransportEnv) {
+  const buffer = await sandbox.readFileToBuffer({
+    path: CODEX_CONFIG_PATH
+  });
+  if (!buffer) {
+    throw new Error(
+      `Codex config not found in sandbox at ${CODEX_CONFIG_PATH}. Ensure the snapshot contains a pre-configured config.toml.`
+    );
+  }
+  const config = TOML.parse(
+    new TextDecoder().decode(buffer)
+  );
+  if (config.mcp_servers) {
+    for (const server of Object.values(config.mcp_servers)) {
+      server.env = { ...server.env, ...bridgeTransportEnv };
+    }
+  }
+  await sandbox.writeFiles([
+    {
+      path: CODEX_CONFIG_PATH,
+      content: Buffer.from(TOML.stringify(config))
+    }
+  ]);
+}
+function createCodexRequestSchema(browserEnabled) {
+  if (!browserEnabled) {
+    return codexRequestSchema;
+  }
+  return codexRequestSchema.superRefine((value, ctx) => {
+    if (!value.relay_session_id) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["relay_session_id"],
+        message: "relay_session_id is required when tools.browser is enabled."
+      });
+    }
+    if (!value.relay_token) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["relay_token"],
+        message: "relay_token is required when tools.browser is enabled."
+      });
+    }
+  });
+}
+function assertBrowserToolRelayCredentials(parsed) {
+  if (!parsed.relay_session_id || !parsed.relay_token) {
+    throw new Error("relay_session_id and relay_token are required.");
+  }
+}
 function createCodexAgent(options = {}) {
   const env = options.env ?? {};
   const snapshotId = options.snapshotId?.trim() || requiredEnv(env, "SANDBOX_SNAPSHOT_ID");
-  const apiKey = env.CODEX_API_KEY?.trim() || env.OPENAI_API_KEY?.trim();
-  if (!apiKey) {
-    throw new Error(
-      "Missing required environment variable: CODEX_API_KEY or OPENAI_API_KEY"
-    );
+  const apiKey = requiredEnv(env, "CODEX_API_KEY");
+  const browserToolEnabled = options.tools?.browser !== void 0;
+  const browserToolRelayUrl = options.tools?.browser?.relayUrl?.trim();
+  if (browserToolEnabled) {
+    requiredEnv(env, "BROWSER_TOOL_RELAY_URL");
+    requiredEnv(env, "BROWSER_TOOL_RELAY_SESSION_ID");
+    requiredEnv(env, "BROWSER_TOOL_RELAY_TOKEN");
+  }
+  if (browserToolEnabled && !browserToolRelayUrl) {
+    throw new Error("tools.browser.relayUrl is empty.");
   }
   return {
-    requestSchema: codexRequestSchema,
+    requestSchema: createCodexRequestSchema(browserToolEnabled),
     snapshotId,
     async prepareSandbox(_input) {
+      if (!browserToolEnabled) {
+        return;
+      }
+      requiredEnv(env, "VERCEL_OIDC_TOKEN");
+      assertBrowserToolRelayCredentials(_input.input);
+      await patchCodexConfigTransportEnv(_input.sandbox, env);
     },
     createCommand({ input }) {
-      const args = [
-        "exec",
-        "--json",
-        "--yolo",
-        "--skip-git-repo-check",
-        input.message
-      ];
+      const args = ["exec"];
+      if (input.session_id) {
+        args.push("resume", input.session_id);
+      }
+      args.push("--json", "--yolo", "--skip-git-repo-check", input.message);
       return {
         cmd: "codex",
         args,
-        env: {
-          OPENAI_API_KEY: apiKey
-        }
+        env: { CODEX_API_KEY: apiKey }
       };
     },
     createStdoutMapper() {
@@ -198,7 +349,7 @@ function createGeminiRequestSchema(browserEnabled) {
     }
   });
 }
-function assertBrowserToolRelayCredentials(parsed) {
+function assertBrowserToolRelayCredentials2(parsed) {
   if (!parsed.relay_session_id || !parsed.relay_token) {
     throw new Error("relay_session_id and relay_token are required.");
   }
@@ -224,7 +375,7 @@ function createGeminiAgent(options = {}) {
         return;
       }
       requiredEnv2(env, "VERCEL_OIDC_TOKEN");
-      assertBrowserToolRelayCredentials(input);
+      assertBrowserToolRelayCredentials2(input);
       await patchGeminiSettingsTransportEnv(sandbox, env);
     },
     createCommand({ input }) {
@@ -252,7 +403,7 @@ function createGeminiAgent(options = {}) {
 
 // src/chat-run.ts
 import { Writable } from "stream";
-import { Sandbox } from "@vercel/sandbox";
+import { Sandbox as Sandbox2 } from "@vercel/sandbox";
 function emitText(controller, text, encoder) {
   if (text.length === 0) {
     return;
@@ -306,19 +457,23 @@ function runChat(input) {
       const mapper = input.agent.createStdoutMapper?.();
       void (async () => {
         try {
-          const sandbox = parsed.sandbox_id ? await Sandbox.get({ sandboxId: parsed.sandbox_id }) : await (async () => {
+          const sandbox = parsed.sandbox_id ? await Sandbox2.get({ sandboxId: parsed.sandbox_id }) : await (async () => {
             const snapshotId = input.agent.snapshotId?.trim();
             if (!snapshotId) {
               throw new Error(
                 "Agent must provide snapshotId when sandbox_id is not provided."
               );
             }
-            return Sandbox.create({
+            const created = await Sandbox2.create({
               source: {
                 type: "snapshot",
                 snapshotId
               }
             });
+            console.log(
+              `[sandbox] created sandbox=${created.sandboxId} from snapshot=${snapshotId}`
+            );
+            return created;
           })();
           enqueueEvent({ type: "sandbox", sandbox_id: sandbox.sandboxId });
           await input.agent.prepareSandbox({
@@ -335,6 +490,7 @@ function runChat(input) {
             stdout: new Writable({
               write(chunk, _encoding, callback) {
                 const text = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+                console.log("[sandbox-agent] raw stdout:", text);
                 if (mapper) {
                   for (const line of mapper.push(text)) {
                     enqueueStdout(line);
@@ -382,6 +538,7 @@ function runChat(input) {
   );
 }
 export {
+  Agent,
   createCodexAgent,
   createCodexStdoutMapper,
   createGeminiAgent,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@giselles-ai/sandbox-agent",
-	"version": "0.1.10",
+	"version": "0.1.12",
 	"type": "module",
 	"sideEffects": false,
 	"license": "Apache-2.0",
@@ -28,6 +28,7 @@
 	},
 	"dependencies": {
 		"@vercel/sandbox": "1.6.0",
+		"@iarna/toml": "3.0.0",
 		"zod": "4.3.6"
 	},
 	"devDependencies": {