@giselles-ai/sandbox-agent 0.1.11 → 0.1.13

package/dist/index.d.ts

@@ -1,6 +1,30 @@
 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;
+    setAgentMd(content: string | Buffer): this;
+    runCommands(commands: Array<{
+        cmd: string;
+        args?: string[];
+    }>): this;
+    prepare(): Promise<void>;
+}
+
 type BaseChatRequest = {
     message: string;
     session_id?: string;
@@ -78,4 +102,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,3 +1,87 @@
+// 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;
+  }
+  setAgentMd(content) {
+    const buffer = typeof content === "string" ? Buffer.from(content) : content;
+    console.log(`[agent] setAgentMd called, content length=${buffer.length}`);
+    return this.addFiles([
+      { path: "/home/vercel-sandbox/AGENTS.md", content: buffer }
+    ]);
+  }
+  runCommands(commands) {
+    for (const command of commands) {
+      this._pendingOps.push({
+        kind: "runCommand",
+        cmd: command.cmd,
+        args: command.args ?? []
+      });
+    }
+    return this;
+  }
+  async prepare() {
+    console.log(
+      `[agent] prepare called, dirty=${this.dirty}, pendingOps=${this._pendingOps.length}`
+    );
+    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();
+    console.log(`[agent] prepare done, new snapshotId=${snapshot.snapshotId}`);
+    this._snapshotId = snapshot.snapshotId;
+    this._pendingOps = [];
+  }
+};
+
 // src/agents/codex-agent.ts
 import * as TOML from "@iarna/toml";
 import { z } from "zod";
@@ -39,6 +123,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;
   }
@@ -158,18 +254,11 @@ function assertBrowserToolRelayCredentials(parsed) {
 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.");
@@ -181,9 +270,13 @@ function createCodexAgent(options = {}) {
       if (!browserToolEnabled) {
         return;
       }
-      requiredEnv(env, "VERCEL_OIDC_TOKEN");
       assertBrowserToolRelayCredentials(_input.input);
-      await patchCodexConfigTransportEnv(_input.sandbox, env);
+      const patchEnv = {
+        ...env,
+        BROWSER_TOOL_RELAY_SESSION_ID: _input.input.relay_session_id,
+        BROWSER_TOOL_RELAY_TOKEN: _input.input.relay_token
+      };
+      await patchCodexConfigTransportEnv(_input.sandbox, patchEnv);
     },
     createCommand({ input }) {
       const args = ["exec"];
@@ -194,9 +287,7 @@ function createCodexAgent(options = {}) {
       return {
         cmd: "codex",
         args,
-        env: {
-          OPENAI_API_KEY: apiKey
-        }
+        env: { CODEX_API_KEY: apiKey }
       };
     },
     createStdoutMapper() {
@@ -283,8 +374,6 @@ function createGeminiAgent(options = {}) {
   const browserToolRelayUrl = options.tools?.browser?.relayUrl?.trim();
   if (browserToolEnabled) {
     requiredEnv2(env, "BROWSER_TOOL_RELAY_URL");
-    requiredEnv2(env, "BROWSER_TOOL_RELAY_SESSION_ID");
-    requiredEnv2(env, "BROWSER_TOOL_RELAY_TOKEN");
   }
   if (browserToolEnabled && !browserToolRelayUrl) {
     throw new Error("tools.browser.relayUrl is empty.");
@@ -296,9 +385,13 @@ function createGeminiAgent(options = {}) {
       if (!browserToolEnabled) {
         return;
       }
-      requiredEnv2(env, "VERCEL_OIDC_TOKEN");
       assertBrowserToolRelayCredentials2(input);
-      await patchGeminiSettingsTransportEnv(sandbox, env);
+      const patchEnv = {
+        ...env,
+        BROWSER_TOOL_RELAY_SESSION_ID: input.relay_session_id,
+        BROWSER_TOOL_RELAY_TOKEN: input.relay_token
+      };
+      await patchGeminiSettingsTransportEnv(sandbox, patchEnv);
     },
     createCommand({ input }) {
       const args = [
@@ -325,7 +418,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;
@@ -379,19 +472,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({
@@ -408,6 +505,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);
@@ -455,6 +553,7 @@ function runChat(input) {
   );
 }
 export {
+  Agent,
   createCodexAgent,
   createCodexStdoutMapper,
   createGeminiAgent,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@giselles-ai/sandbox-agent",
-	"version": "0.1.11",
+	"version": "0.1.13",
 	"type": "module",
 	"sideEffects": false,
 	"license": "Apache-2.0",