@giselles-ai/sandbox-agent 0.1.8 → 0.1.10

package/dist/index.d.ts

@@ -11,6 +11,10 @@ type ChatCommand = {
     args: string[];
     env?: Record<string, string>;
 };
+type StdoutMapper = {
+    push(chunk: string): string[];
+    flush(): string[];
+};
 type ChatAgent<TRequest extends BaseChatRequest> = {
     requestSchema: z.ZodType<TRequest>;
     snapshotId?: string;
@@ -21,6 +25,7 @@ type ChatAgent<TRequest extends BaseChatRequest> = {
     createCommand(input: {
         input: TRequest;
     }): ChatCommand;
+    createStdoutMapper?: () => StdoutMapper;
 };
 type RunChatInput<TRequest extends BaseChatRequest> = {
     agent: ChatAgent<TRequest>;
@@ -29,6 +34,24 @@ type RunChatInput<TRequest extends BaseChatRequest> = {
 };
 declare function runChat<TRequest extends BaseChatRequest>(input: RunChatInput<TRequest>): Promise<Response>;
 
+declare const codexRequestSchema: z.ZodObject<{
+    message: z.ZodString;
+    session_id: z.ZodOptional<z.ZodString>;
+    sandbox_id: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type CodexAgentRequest = z.infer<typeof codexRequestSchema>;
+type CodexAgentOptions = {
+    snapshotId?: string;
+    env?: Record<string, string>;
+};
+declare function createCodexAgent(options?: CodexAgentOptions): ChatAgent<CodexAgentRequest>;
+
+type CodexStdoutMapper = {
+    push(chunk: string): string[];
+    flush(): string[];
+};
+declare function createCodexStdoutMapper(): CodexStdoutMapper;
+
 declare const geminiRequestSchema: z.ZodObject<{
     message: z.ZodString;
     session_id: z.ZodOptional<z.ZodString>;
@@ -48,4 +71,4 @@ type GeminiAgentOptions = {
 };
 declare function createGeminiAgent(options?: GeminiAgentOptions): ChatAgent<GeminiAgentRequest>;
 
-export { type BaseChatRequest, type ChatAgent, type ChatCommand, type RunChatInput, createGeminiAgent, runChat };
+export { type BaseChatRequest, type ChatAgent, type ChatCommand, type RunChatInput, type StdoutMapper, createCodexAgent, createCodexStdoutMapper, createGeminiAgent, runChat };

package/dist/index.js

@@ -1,12 +1,93 @@
-// src/agents/gemini-agent.ts
+// src/agents/codex-agent.ts
 import { z } from "zod";
-var GEMINI_SETTINGS_PATH = "/home/vercel-sandbox/.gemini/settings.json";
-var geminiRequestSchema = z.object({
+
+// src/agents/codex-mapper.ts
+function mapEvent(event) {
+  const type = event.type;
+  if (type === "session.created") {
+    return {
+      type: "init",
+      session_id: event.id ?? void 0,
+      modelId: event.model ?? void 0
+    };
+  }
+  if (type === "message.output_text.delta") {
+    return {
+      type: "message",
+      role: "assistant",
+      content: event.delta ?? "",
+      delta: true
+    };
+  }
+  if (type === "message.output_text.done") {
+    return {
+      type: "message",
+      role: "assistant",
+      content: event.text ?? "",
+      delta: false
+    };
+  }
+  if (type === "error") {
+    return {
+      type: "stderr",
+      content: typeof event.message === "string" ? event.message : JSON.stringify(event)
+    };
+  }
+  if (type === "response.completed") {
+    return null;
+  }
+  return null;
+}
+function processLines(text) {
+  const lines = text.split("\n");
+  const completeLines = lines.slice(0, -1);
+  const output = [];
+  for (const line of completeLines) {
+    const trimmedLine = line.trim();
+    if (trimmedLine.length === 0) {
+      continue;
+    }
+    try {
+      const event = JSON.parse(trimmedLine);
+      const mapped = mapEvent(event);
+      if (!mapped) {
+        continue;
+      }
+      output.push(`${JSON.stringify(mapped)}
+`);
+    } catch {
+    }
+  }
+  return output;
+}
+function createCodexStdoutMapper() {
+  let buffer = "";
+  return {
+    push(chunk) {
+      buffer += chunk;
+      const combined = buffer;
+      const lines = combined.split("\n");
+      buffer = lines.pop() ?? "";
+      return processLines(`${lines.join("\n")}
+`);
+    },
+    flush() {
+      if (buffer.trim().length === 0) {
+        return [];
+      }
+      const remaining = buffer;
+      buffer = "";
+      return processLines(`${remaining}
+`);
+    }
+  };
+}
+
+// src/agents/codex-agent.ts
+var codexRequestSchema = z.object({
   message: z.string().min(1),
   session_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()
+  sandbox_id: z.string().min(1).optional()
 });
 function requiredEnv(env, name) {
   const value = env[name]?.trim();
@@ -15,6 +96,59 @@ function requiredEnv(env, name) {
   }
   return value;
 }
+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"
+    );
+  }
+  return {
+    requestSchema: codexRequestSchema,
+    snapshotId,
+    async prepareSandbox(_input) {
+    },
+    createCommand({ input }) {
+      const args = [
+        "exec",
+        "--json",
+        "--yolo",
+        "--skip-git-repo-check",
+        input.message
+      ];
+      return {
+        cmd: "codex",
+        args,
+        env: {
+          OPENAI_API_KEY: apiKey
+        }
+      };
+    },
+    createStdoutMapper() {
+      return createCodexStdoutMapper();
+    }
+  };
+}
+
+// src/agents/gemini-agent.ts
+import { z as z2 } from "zod";
+var GEMINI_SETTINGS_PATH = "/home/vercel-sandbox/.gemini/settings.json";
+var geminiRequestSchema = z2.object({
+  message: z2.string().min(1),
+  session_id: z2.string().min(1).optional(),
+  sandbox_id: z2.string().min(1).optional(),
+  relay_session_id: z2.string().min(1).optional(),
+  relay_token: z2.string().min(1).optional()
+});
+function requiredEnv2(env, name) {
+  const value = env[name]?.trim();
+  if (!value) {
+    throw new Error(`Missing required environment variable: ${name}`);
+  }
+  return value;
+}
 async function patchGeminiSettingsTransportEnv(sandbox, bridgeTransportEnv) {
   const buffer = await sandbox.readFileToBuffer({
     path: GEMINI_SETTINGS_PATH
@@ -71,13 +205,13 @@ function assertBrowserToolRelayCredentials(parsed) {
 }
 function createGeminiAgent(options = {}) {
   const env = options.env ?? {};
-  const snapshotId = options.snapshotId?.trim() || requiredEnv(env, "SANDBOX_SNAPSHOT_ID");
+  const snapshotId = options.snapshotId?.trim() || requiredEnv2(env, "SANDBOX_SNAPSHOT_ID");
   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");
+    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.");
@@ -89,7 +223,7 @@ function createGeminiAgent(options = {}) {
       if (!browserToolEnabled) {
         return;
       }
-      requiredEnv(env, "VERCEL_OIDC_TOKEN");
+      requiredEnv2(env, "VERCEL_OIDC_TOKEN");
       assertBrowserToolRelayCredentials(input);
       await patchGeminiSettingsTransportEnv(sandbox, env);
     },
@@ -109,7 +243,7 @@ function createGeminiAgent(options = {}) {
         cmd: "gemini",
         args,
         env: {
-          GEMINI_API_KEY: requiredEnv(env, "GEMINI_API_KEY")
+          GEMINI_API_KEY: requiredEnv2(env, "GEMINI_API_KEY")
         }
       };
     }
@@ -169,6 +303,7 @@ function runChat(input) {
         }
         emitText(controller, text, encoder);
       };
+      const mapper = input.agent.createStdoutMapper?.();
       void (async () => {
         try {
           const sandbox = parsed.sandbox_id ? await Sandbox.get({ sandboxId: parsed.sandbox_id }) : await (async () => {
@@ -200,7 +335,13 @@ function runChat(input) {
             stdout: new Writable({
               write(chunk, _encoding, callback) {
                 const text = typeof chunk === "string" ? chunk : chunk.toString("utf8");
-                enqueueStdout(text);
+                if (mapper) {
+                  for (const line of mapper.push(text)) {
+                    enqueueStdout(line);
+                  }
+                } else {
+                  enqueueStdout(text);
+                }
                 callback();
               }
             }),
@@ -220,6 +361,11 @@ function runChat(input) {
           const message = error instanceof Error ? error.message : String(error);
           enqueueEvent({ type: "stderr", content: `[error] ${message}` });
         } finally {
+          if (mapper) {
+            for (const line of mapper.flush()) {
+              enqueueStdout(line);
+            }
+          }
           input.signal.removeEventListener("abort", onAbort);
           close();
         }
@@ -236,6 +382,8 @@ function runChat(input) {
   );
 }
 export {
+  createCodexAgent,
+  createCodexStdoutMapper,
   createGeminiAgent,
   runChat
 };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@giselles-ai/sandbox-agent",
-	"version": "0.1.8",
+	"version": "0.1.10",
 	"type": "module",
 	"sideEffects": false,
 	"license": "Apache-2.0",
@@ -17,11 +17,6 @@
 			"types": "./dist/index.d.ts",
 			"import": "./dist/index.js",
 			"default": "./dist/index.js"
-		},
-		"./react": {
-			"types": "./dist/react/index.d.ts",
-			"import": "./dist/react/index.js",
-			"default": "./dist/react/index.js"
 		}
 	},
 	"scripts": {
@@ -35,10 +30,6 @@
 		"@vercel/sandbox": "1.6.0",
 		"zod": "4.3.6"
 	},
-	"peerDependencies": {
-		"react": ">=19.0.0",
-		"react-dom": ">=19.0.0"
-	},
 	"devDependencies": {
 		"@google/gemini-cli-core": "0.29.5",
 		"@types/node": "25.3.0",

package/dist/react/index.d.ts

@@ -1,48 +0,0 @@
-type AgentMessage = {
-    id: string;
-    role: "user" | "assistant";
-    content: string;
-};
-type StreamEvent = {
-    type?: string;
-    [key: string]: unknown;
-};
-type ToolEvent = {
-    id: string;
-    toolId: string;
-    toolName: string;
-    status?: "success" | "error";
-    parameters?: unknown;
-    output?: unknown;
-};
-type RelayStatus = "idle" | "connecting" | "connected" | "error";
-type AgentStatus = RelayStatus | "running";
-type AgentToolContext = {
-    sendRelayResponse: (payload: Record<string, unknown>) => Promise<void>;
-    setError: (message: string) => void;
-    addWarnings: (warnings: string[]) => void;
-};
-type AgentToolHandler = {
-    handleRelayRequest: (event: StreamEvent, context: AgentToolContext) => Promise<boolean>;
-};
-type UseAgentOptions = {
-    endpoint: string;
-    tools?: Record<string, AgentToolHandler>;
-};
-type AgentHookState = {
-    status: AgentStatus;
-    messages: AgentMessage[];
-    tools: ToolEvent[];
-    warnings: string[];
-    stderrLogs: string[];
-    sandboxId: string | null;
-    geminiSessionId: string | null;
-    error: string | null;
-    sendMessage: (input: {
-        message: string;
-        document?: string;
-    }) => Promise<void>;
-};
-declare function useAgent({ endpoint, tools }: UseAgentOptions): AgentHookState;
-
-export { type AgentHookState, type AgentMessage, type AgentStatus, type AgentToolContext, type AgentToolHandler, type ToolEvent, type UseAgentOptions, useAgent };

package/dist/react/index.js

@@ -1,520 +0,0 @@
-// src/react/use-agent.ts
-import { useCallback, useEffect, useMemo, useRef, useState } from "react";
-var LOG_PREFIX = "[agent-relay-client]";
-function isRecord(value) {
-  return Boolean(value) && typeof value === "object";
-}
-function asString(value) {
-  return typeof value === "string" ? value : null;
-}
-function asNumber(value) {
-  return typeof value === "number" && Number.isFinite(value) ? value : null;
-}
-function extractWarnings(value) {
-  if (!isRecord(value) || !Array.isArray(value.warnings)) {
-    return [];
-  }
-  return value.warnings.filter(
-    (warning) => typeof warning === "string"
-  );
-}
-function extractJsonObjects(buffer) {
-  const objects = [];
-  let depth = 0;
-  let inString = false;
-  let escaped = false;
-  let startIndex = -1;
-  for (let index = 0; index < buffer.length; index += 1) {
-    const char = buffer[index];
-    if (escaped) {
-      escaped = false;
-      continue;
-    }
-    if (char === "\\") {
-      escaped = true;
-      continue;
-    }
-    if (char === '"') {
-      inString = !inString;
-      continue;
-    }
-    if (inString) {
-      continue;
-    }
-    if (char === "{") {
-      if (depth === 0) {
-        startIndex = index;
-      }
-      depth += 1;
-      continue;
-    }
-    if (char === "}") {
-      depth -= 1;
-      if (depth === 0 && startIndex >= 0) {
-        objects.push(buffer.slice(startIndex, index + 1));
-        startIndex = -1;
-      }
-    }
-  }
-  if (depth > 0 && startIndex >= 0) {
-    return {
-      objects,
-      rest: buffer.slice(startIndex)
-    };
-  }
-  return {
-    objects,
-    rest: ""
-  };
-}
-function dedupeStringArray(next) {
-  const nextSet = new Set(next);
-  return Array.from(nextSet);
-}
-function normalizeTools(tools) {
-  if (!tools) {
-    return [];
-  }
-  return Object.values(tools);
-}
-function useAgent({ endpoint, tools }) {
-  const [relayStatus, setRelayStatus] = useState("idle");
-  const [running, setRunning] = useState(false);
-  const [messages, setMessages] = useState([]);
-  const [toolEvents, setToolEvents] = useState([]);
-  const [warnings, setWarnings] = useState([]);
-  const [stderrLogs, setStderrLogs] = useState([]);
-  const [sandboxId, setSandboxId] = useState(null);
-  const [geminiSessionId, setGeminiSessionId] = useState(null);
-  const [error, setError] = useState(null);
-  const [toolEventHandlers] = useMemo(() => [normalizeTools(tools)], [tools]);
-  const normalizedEndpoint = useMemo(
-    () => endpoint.replace(/\/+$/, ""),
-    [endpoint]
-  );
-  const eventSourceRef = useRef(null);
-  const reconnectTimerRef = useRef(null);
-  const mountedRef = useRef(true);
-  const sessionRef = useRef(null);
-  const messagesAssistantId = useRef(null);
-  const assistantBufferRef = useRef("");
-  const cleanupRelay = useCallback(() => {
-    if (eventSourceRef.current) {
-      eventSourceRef.current.close();
-      eventSourceRef.current = null;
-    }
-    if (reconnectTimerRef.current) {
-      clearTimeout(reconnectTimerRef.current);
-      reconnectTimerRef.current = null;
-    }
-  }, []);
-  const handleRelayResponse = useCallback(
-    async (payload) => {
-      const currentSession = sessionRef.current;
-      if (!currentSession) {
-        console.warn(`${LOG_PREFIX} respond.skip.no-session`, {
-          payloadType: payload.type
-        });
-        return;
-      }
-      const requestId = typeof payload.requestId === "string" ? payload.requestId : void 0;
-      const responseType = typeof payload.type === "string" ? payload.type : void 0;
-      console.info(`${LOG_PREFIX} respond.out`, {
-        sessionId: currentSession.sessionId,
-        requestId,
-        responseType
-      });
-      const relayBase = currentSession.relayUrl ?? normalizedEndpoint;
-      const response = await fetch(relayBase, {
-        method: "POST",
-        headers: {
-          "content-type": "application/json"
-        },
-        body: JSON.stringify({
-          type: "relay.respond",
-          sessionId: currentSession.sessionId,
-          token: currentSession.token,
-          response: payload
-        })
-      });
-      console.info(`${LOG_PREFIX} respond.result`, {
-        sessionId: currentSession.sessionId,
-        requestId,
-        status: response.status,
-        ok: response.ok
-      });
-    },
-    [normalizedEndpoint]
-  );
-  const addWarnings = useCallback((next) => {
-    if (next.length === 0) {
-      return;
-    }
-    setWarnings((current) => dedupeStringArray([...current, ...next]));
-  }, []);
-  const handleRelayEvent = useCallback(
-    async (event) => {
-      if (!isRecord(event) || typeof event.type !== "string") {
-        return;
-      }
-      if (event.type === "ready") {
-        return;
-      }
-      const requestId = asString(event.requestId);
-      if (!requestId) {
-        return;
-      }
-      if (event.type === "error_response") {
-        const message = asString(event.message);
-        if (message) {
-          setError(message);
-        }
-        return;
-      }
-      if (event.type === "snapshot_request" || event.type === "execute_request") {
-        const handlerContext = {
-          sendRelayResponse: handleRelayResponse,
-          setError,
-          addWarnings
-        };
-        for (const handler of toolEventHandlers) {
-          try {
-            const handled = await handler.handleRelayRequest(
-              event,
-              handlerContext
-            );
-            if (handled) {
-              return;
-            }
-          } catch (error2) {
-            const message = error2 instanceof Error ? error2.message : "Relay execution failed.";
-            setError(message);
-            setRelayStatus("error");
-            await handleRelayResponse({
-              type: "error_response",
-              requestId,
-              message
-            });
-            return;
-          }
-        }
-        await handleRelayResponse({
-          type: "error_response",
-          requestId,
-          message: `Unsupported relay request type: ${event.type}`
-        });
-        return;
-      }
-      await handleRelayResponse({
-        type: "error_response",
-        requestId,
-        message: `Unsupported relay request type: ${event.type}`
-      });
-    },
-    [addWarnings, handleRelayResponse, toolEventHandlers]
-  );
-  const connect = useCallback(() => {
-    const currentSession = sessionRef.current;
-    if (!currentSession) {
-      return;
-    }
-    cleanupRelay();
-    setRelayStatus("connecting");
-    const relayBase = currentSession.relayUrl ?? normalizedEndpoint;
-    const source = new EventSource(
-      `${relayBase}?type=relay.events&sessionId=${encodeURIComponent(currentSession.sessionId)}&token=${encodeURIComponent(currentSession.token)}`
-    );
-    console.info(`${LOG_PREFIX} sse.connect`, {
-      sessionId: currentSession.sessionId
-    });
-    eventSourceRef.current = source;
-    source.onopen = () => {
-      if (!mountedRef.current) {
-        return;
-      }
-      setRelayStatus("connected");
-      console.info(`${LOG_PREFIX} sse.open`, {
-        sessionId: currentSession.sessionId
-      });
-    };
-    source.onmessage = (message) => {
-      console.info(`${LOG_PREFIX} sse.message.raw`, {
-        sessionId: currentSession.sessionId,
-        data: message.data
-      });
-      try {
-        const payload = JSON.parse(message.data);
-        console.info(`${LOG_PREFIX} sse.message.parsed`, {
-          sessionId: currentSession.sessionId,
-          type: typeof payload === "object" && payload && "type" in payload && typeof payload.type === "string" ? payload.type : "unknown"
-        });
-        void handleRelayEvent(payload);
-      } catch (error2) {
-        console.error(`${LOG_PREFIX} sse.message.parse_error`, {
-          sessionId: currentSession.sessionId,
-          error: error2 instanceof Error ? error2.message : String(error2),
-          data: message.data
-        });
-      }
-    };
-    source.onerror = () => {
-      if (!mountedRef.current) {
-        return;
-      }
-      setRelayStatus("connecting");
-      console.warn(`${LOG_PREFIX} sse.error`, {
-        sessionId: currentSession.sessionId
-      });
-      if (!reconnectTimerRef.current) {
-        reconnectTimerRef.current = setTimeout(() => {
-          reconnectTimerRef.current = null;
-          connect();
-        }, 1500);
-      }
-    };
-  }, [cleanupRelay, handleRelayEvent, normalizedEndpoint]);
-  useEffect(() => {
-    mountedRef.current = true;
-    return () => {
-      mountedRef.current = false;
-      cleanupRelay();
-    };
-  }, [cleanupRelay]);
-  const handleStreamEvent = useCallback(
-    (event) => {
-      if (typeof event.type !== "string") {
-        return;
-      }
-      if (event.type === "relay.session") {
-        const sessionId = asString(event.sessionId);
-        const token = asString(event.token);
-        const relayUrl = asString(event.relayUrl);
-        const expiresAt = asNumber(event.expiresAt) ?? Date.now() + 10 * 60 * 1e3;
-        if (!sessionId || !token) {
-          return;
-        }
-        sessionRef.current = {
-          sessionId,
-          token,
-          expiresAt,
-          relayUrl
-        };
-        console.info(`${LOG_PREFIX} stream.relay_session`, {
-          sessionId
-        });
-        connect();
-        return;
-      }
-      if (event.type === "sandbox") {
-        const nextSandboxId = asString(event.sandbox_id);
-        if (nextSandboxId) {
-          setSandboxId(nextSandboxId);
-        }
-        return;
-      }
-      if (event.type === "init") {
-        const nextSessionId = asString(event.session_id);
-        if (nextSessionId) {
-          setGeminiSessionId(nextSessionId);
-        }
-        return;
-      }
-      if (event.type === "stderr") {
-        const text = asString(event.content);
-        if (text) {
-          setStderrLogs((current) => [...current, text]);
-        }
-        return;
-      }
-      if (event.type === "message") {
-        const role = asString(event.role);
-        const content = asString(event.content) ?? "";
-        const isDelta = Boolean(event.delta);
-        if (role === "assistant") {
-          if (isDelta) {
-            const currentId = messagesAssistantId.current;
-            if (!currentId) {
-              const nextId = crypto.randomUUID();
-              messagesAssistantId.current = nextId;
-              assistantBufferRef.current = content;
-              setMessages((current) => [
-                ...current,
-                { id: nextId, role: "assistant", content }
-              ]);
-              return;
-            }
-            const merged = `${assistantBufferRef.current}${content}`;
-            assistantBufferRef.current = merged;
-            setMessages(
-              (current) => current.map(
-                (message) => message.id === currentId ? { ...message, content: merged } : message
-              )
-            );
-            return;
-          }
-          if (content.trim().length > 0) {
-            const nextId = crypto.randomUUID();
-            messagesAssistantId.current = nextId;
-            assistantBufferRef.current = content;
-            setMessages((current) => [
-              ...current,
-              { id: nextId, role: "assistant", content }
-            ]);
-          }
-          return;
-        }
-        if (role === "user" && content.trim().length > 0) {
-          setMessages((current) => {
-            const last = current[current.length - 1];
-            if (last && last.role === "user" && last.content === content) {
-              return current;
-            }
-            return [
-              ...current,
-              { id: crypto.randomUUID(), role: "user", content }
-            ];
-          });
-        }
-        return;
-      }
-      if (event.type === "tool_use") {
-        const toolId = asString(event.tool_id) ?? crypto.randomUUID();
-        const toolName = asString(event.tool_name) ?? "tool";
-        setToolEvents((current) => [
-          ...current,
-          {
-            id: crypto.randomUUID(),
-            toolId,
-            toolName,
-            parameters: event.parameters
-          }
-        ]);
-        return;
-      }
-      if (event.type === "tool_result") {
-        const toolId = asString(event.tool_id);
-        if (!toolId) {
-          return;
-        }
-        const status2 = asString(event.status);
-        const nextStatus = status2 === "success" || status2 === "error" ? status2 : void 0;
-        setToolEvents(
-          (current) => current.map(
-            (tool) => tool.toolId === toolId ? {
-              ...tool,
-              status: nextStatus,
-              output: event.output
-            } : tool
-          )
-        );
-        const parsedWarnings = extractWarnings(event.output);
-        if (parsedWarnings.length > 0) {
-          setWarnings(
-            (current) => dedupeStringArray([...current, ...parsedWarnings])
-          );
-        }
-      }
-    },
-    [connect]
-  );
-  const sendMessage = useCallback(
-    async ({ message, document }) => {
-      const trimmedMessage = message.trim();
-      if (!trimmedMessage || running) {
-        return;
-      }
-      cleanupRelay();
-      sessionRef.current = null;
-      setRelayStatus("idle");
-      setError(null);
-      setRunning(true);
-      assistantBufferRef.current = "";
-      messagesAssistantId.current = null;
-      setMessages((current) => [
-        ...current,
-        { id: crypto.randomUUID(), role: "user", content: trimmedMessage }
-      ]);
-      try {
-        console.info(`${LOG_PREFIX} run.start`, {
-          messageLength: trimmedMessage.length,
-          hasDocument: Boolean(document?.trim())
-        });
-        const response = await fetch(normalizedEndpoint, {
-          method: "POST",
-          headers: {
-            "content-type": "application/json"
-          },
-          body: JSON.stringify({
-            type: "agent.run",
-            message: trimmedMessage,
-            document: document?.trim() ? document.trim() : void 0,
-            session_id: geminiSessionId ?? void 0,
-            sandbox_id: sandboxId ?? void 0
-          })
-        });
-        if (!response.ok || !response.body) {
-          throw new Error(`Failed to start stream (${response.status}).`);
-        }
-        console.info(`${LOG_PREFIX} run.stream.open`, {
-          status: response.status
-        });
-        const reader = response.body.getReader();
-        const decoder = new TextDecoder();
-        let buffer = "";
-        while (true) {
-          const { done, value } = await reader.read();
-          if (done) {
-            break;
-          }
-          buffer += decoder.decode(value, { stream: true });
-          const parsed = extractJsonObjects(buffer);
-          buffer = parsed.rest;
-          for (const objectText of parsed.objects) {
-            try {
-              const parsedEvent = JSON.parse(objectText);
-              handleStreamEvent(parsedEvent);
-            } catch {
-            }
-          }
-        }
-        if (buffer.trim().length > 0) {
-          try {
-            const parsedEvent = JSON.parse(buffer);
-            handleStreamEvent(parsedEvent);
-          } catch {
-          }
-        }
-      } catch (sendError) {
-        const messageText = sendError instanceof Error ? sendError.message : "Failed to send message.";
-        setError(messageText);
-        setRelayStatus("error");
-        throw sendError;
-      } finally {
-        setRunning(false);
-      }
-    },
-    [
-      cleanupRelay,
-      geminiSessionId,
-      handleStreamEvent,
-      normalizedEndpoint,
-      running,
-      sandboxId
-    ]
-  );
-  const status = running ? "running" : relayStatus;
-  return {
-    status,
-    messages,
-    tools: toolEvents,
-    warnings,
-    stderrLogs,
-    sandboxId,
-    geminiSessionId,
-    error,
-    sendMessage
-  };
-}
-export {
-  useAgent
-};