@giselles-ai/agent 0.1.24 → 0.1.26

package/dist/{chunk-TAQV6ZOB.js → chunk-JGH5DCA7.js}

@@ -7,7 +7,13 @@ function computeConfigHash(config) {
     files: (config.files ?? []).map((f) => ({
       path: f.path,
       content: f.content
-    }))
+    })),
+    setup: config.setup?.script ?? null,
+    env: config.env ? Object.fromEntries(
+      Object.entries(config.env).sort(
+        ([a], [b]) => a < b ? -1 : a > b ? 1 : 0
+      )
+    ) : null
   });
   return createHash("sha256").update(payload).digest("hex").slice(0, 16);
 }
@@ -50,7 +56,9 @@ async function requestBuild(agent, options) {
   const requestBody = {
     config_hash: configHash,
     agent_type: agent.agentType ?? "gemini",
-    files
+    files,
+    setup_script: agent.setup?.script ?? null,
+    env: agent.env ?? null
   };
   const requestHeaders = {
     "content-type": "application/json",

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { A as AgentConfig, D as DefinedAgent } from './types-Cto-uejG.js';
-export { a as AgentFile } from './types-Cto-uejG.js';
+import { A as AgentConfig, D as DefinedAgent } from './types-Co_KfALw.js';
+export { a as AgentFile, b as AgentSetup, U as UICatalog } from './types-Co_KfALw.js';
 
 declare function defineAgent(config: AgentConfig): DefinedAgent;
 

package/dist/index.js

@@ -1,14 +1,23 @@
 import {
   computeConfigHash,
   requestBuild
-} from "./chunk-TAQV6ZOB.js";
+} from "./chunk-JGH5DCA7.js";
 
 // src/define-agent.ts
 function defineAgent(config) {
+  const catalogPrompt = config.catalog?.prompt({ mode: "inline" });
+  const agentMd = [config.agentMd, catalogPrompt].filter(Boolean).join("\n\n");
   return {
     agentType: config.agentType ?? "gemini",
-    agentMd: config.agentMd,
+    agentMd: agentMd || void 0,
+    catalog: config.catalog,
     files: config.files ?? [],
+    env: config.env ? Object.fromEntries(
+      Object.entries(config.env).filter(
+        (entry) => entry[1] != null
+      )
+    ) : {},
+    setup: config.setup,
     get snapshotId() {
       const id = process.env?.GISELLE_AGENT_SNAPSHOT_ID;
       if (!id) {

package/dist/next/index.d.ts

@@ -1,5 +1,5 @@
 import { NextConfig } from 'next';
-import { A as AgentConfig } from '../types-Cto-uejG.js';
+import { A as AgentConfig } from '../types-Co_KfALw.js';
 
 type GiselleAgentPluginOptions = {
     /** Base URL for the agent API. Default: process.env.GISELLE_AGENT_BASE_URL ?? "https://studio.giselles.ai/agent-api" */

package/dist/next/index.js

@@ -1,9 +1,9 @@
 import {
+  computeConfigHash,
   requestBuild
-} from "../chunk-TAQV6ZOB.js";
+} from "../chunk-JGH5DCA7.js";
 
 // src/next/with-giselle-agent.ts
-import crypto from "crypto";
 import fs from "fs";
 import { createRequire } from "module";
 import path from "path";
@@ -18,12 +18,7 @@ function resolveBaseUrl(options) {
   return (options?.baseUrl ?? process.env.GISELLE_AGENT_BASE_URL ?? "https://studio.giselles.ai/agent-api").replace(/\/+$/, "");
 }
 function getSnapshotFile(agent) {
-  const key = {
-    agentType: agent.agentType,
-    agentMd: agent.agentMd,
-    files: agent.files
-  };
-  const hash = crypto.createHash("sha256").update(JSON.stringify(key)).digest("hex").slice(0, 16);
+  const hash = computeConfigHash(agent);
   return path.join(process.cwd(), ".next", "giselle", hash);
 }
 function hasRunRecently() {

package/dist/server/index.d.ts

@@ -147,6 +147,7 @@ declare const cloudChatRunRequestSchema: z.ZodObject<{
         gemini: "gemini";
     }>;
     snapshot_id: z.ZodString;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     tool_results: z.ZodOptional<z.ZodArray<z.ZodObject<{
         toolCallId: z.ZodString;
         toolName: z.ZodEnum<{

package/dist/server/index.js

@@ -51,6 +51,8 @@ function parseBuildRequest(body) {
   const configHash = record.config_hash;
   const agentType = record.agent_type;
   const files = record.files;
+  const setupScript = record.setup_script;
+  const rawEnv = record.env;
   if (typeof configHash !== "string" || !configHash.trim()) {
     return null;
   }
@@ -61,6 +63,8 @@ function parseBuildRequest(body) {
     return null;
   }
   const parsedFiles = [];
+  let parsedSetupScript = null;
+  let parsedEnv = null;
   for (const file of files) {
     if (!file || typeof file !== "object" || Array.isArray(file)) {
       return null;
@@ -74,10 +78,30 @@ function parseBuildRequest(body) {
       content: recordFile.content
     });
   }
+  if (setupScript !== void 0 && setupScript !== null) {
+    if (typeof setupScript !== "string") {
+      return null;
+    }
+    parsedSetupScript = setupScript;
+  }
+  if (rawEnv !== void 0 && rawEnv !== null) {
+    if (typeof rawEnv !== "object" || Array.isArray(rawEnv)) {
+      return null;
+    }
+    const envRecord = rawEnv;
+    for (const value of Object.values(envRecord)) {
+      if (typeof value !== "string") {
+        return null;
+      }
+    }
+    parsedEnv = envRecord;
+  }
   return {
     config_hash: configHash.trim(),
     agent_type: agentType,
-    files: parsedFiles
+    files: parsedFiles,
+    setup_script: parsedSetupScript,
+    env: parsedEnv
   };
 }
 async function buildAgent(input) {
@@ -123,6 +147,21 @@ async function buildAgent(input) {
       }))
     );
   }
+  if (parsed.setup_script) {
+    console.log("[agent-build] running setup script...");
+    const result = await sandbox.runCommand({
+      cmd: "bash",
+      args: ["-lc", parsed.setup_script],
+      ...parsed.env ? { env: parsed.env } : {}
+    });
+    if (result.exitCode !== 0) {
+      const stderr = typeof result.stderr === "string" ? result.stderr : "";
+      throw new Error(
+        `Setup script failed (exit ${result.exitCode}): ${stderr}`
+      );
+    }
+    console.log("[agent-build] setup script completed");
+  }
   const snapshot = await sandbox.snapshot();
   console.log(`[agent-build] snapshot created: ${snapshot.snapshotId}`);
   await cache.set(cacheKey, snapshot.snapshotId);
@@ -359,7 +398,12 @@ function createCodexAgent(options = {}) {
       return {
         cmd: "codex",
         args,
-        env: { CODEX_API_KEY: apiKey }
+        env: Object.fromEntries(
+          Object.entries({
+            ...env,
+            CODEX_API_KEY: apiKey
+          }).filter((e) => e[1] != null)
+        )
       };
     },
     createStdoutMapper() {
@@ -493,17 +537,28 @@ function createGeminiAgent(options = {}) {
         "--output-format",
         "stream-json",
         "--approval-mode",
-        "yolo"
+        "yolo",
+        "--sandbox",
+        "false"
       ];
       if (input.session_id) {
         args.push("--resume", input.session_id);
       }
+      console.info("[gemini-agent] createCommand", {
+        hasSessionId: Boolean(input.session_id),
+        hasSandboxId: Boolean(input.sandbox_id),
+        hasSnapshotId: Boolean(input.snapshot_id),
+        argCount: args.length
+      });
       return {
         cmd: "gemini",
         args,
-        env: {
-          GEMINI_API_KEY: requiredEnv2(env, "GEMINI_API_KEY")
-        }
+        env: Object.fromEntries(
+          Object.entries({
+            ...env,
+            GEMINI_API_KEY: requiredEnv2(env, "GEMINI_API_KEY")
+          }).filter((e) => e[1] != null)
+        )
       };
     }
   };
@@ -550,6 +605,7 @@ function createAgent(options) {
 // src/chat-run.ts
 import { Writable } from "stream";
 import { Sandbox as Sandbox2 } from "@vercel/sandbox";
+var COMMAND_TIMEOUT_EXTENSION_MS = 5 * 60 * 1e3;
 function emitText(controller, text, encoder) {
   if (text.length === 0) {
     return;
@@ -619,7 +675,21 @@ function runChat(input) {
           const sandbox = await (async () => {
             if (parsed.sandbox_id) {
               try {
-                return await Sandbox2.get({ sandboxId: parsed.sandbox_id });
+                const existing = await Sandbox2.get({
+                  sandboxId: parsed.sandbox_id
+                });
+                if (existing.status !== "running") {
+                  if (!snapshotId) {
+                    throw new Error(
+                      `Sandbox ${parsed.sandbox_id} is ${existing.status}, not running`
+                    );
+                  }
+                  console.log(
+                    `[sandbox] sandbox=${parsed.sandbox_id} status=${existing.status}, recreating from snapshot=${snapshotId}`
+                  );
+                  return createFromSnapshot(snapshotId);
+                }
+                return existing;
               } catch (error) {
                 if (!snapshotId) {
                   throw error;
@@ -645,6 +715,16 @@ function runChat(input) {
           const command = input.agent.createCommand({
             input: parsed
           });
+          console.info("[chat-run] starting sandbox command", {
+            sandboxId: sandbox.sandboxId,
+            cmd: command.cmd,
+            args: command.args,
+            envKeys: Object.keys(command.env ?? {}).sort(),
+            hasSessionId: typeof parsed.session_id === "string" && parsed.session_id.length > 0,
+            hasSandboxId: typeof parsed.sandbox_id === "string" && parsed.sandbox_id.length > 0,
+            hasSnapshotId: typeof parsed.snapshot_id === "string" && parsed.snapshot_id.length > 0
+          });
+          await sandbox.extendTimeout(COMMAND_TIMEOUT_EXTENSION_MS);
           await sandbox.runCommand({
             cmd: command.cmd,
             args: command.args,
@@ -666,6 +746,10 @@ function runChat(input) {
             stderr: new Writable({
               write(chunk, _encoding, callback) {
                 const text = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+                console.error("[chat-run] sandbox stderr", {
+                  sandboxId: sandbox.sandboxId,
+                  content: text
+                });
                 enqueueEvent({ type: "stderr", content: text });
                 callback();
               }
@@ -822,6 +906,7 @@ var cloudChatRunRequestSchema = z3.object({
   message: z3.string().min(1),
   agent_type: z3.enum(["gemini", "codex"]),
   snapshot_id: z3.string().min(1),
+  env: z3.record(z3.string(), z3.string()).optional(),
   tool_results: z3.array(
     z3.object({
       toolCallId: z3.string().min(1),
@@ -921,8 +1006,12 @@ function injectRelayUrl(agent, relayUrl) {
     }
   };
 }
+function usesBrowserTool(agent) {
+  return isCreateAgentOptions2(agent) && agent.tools?.browser !== void 0;
+}
 async function runCloudChat(input) {
-  const agentParam = injectRelayUrl(input.agent, input.relayUrl);
+  const browserToolEnabled = usesBrowserTool(input.agent);
+  const agentParam = browserToolEnabled ? injectRelayUrl(input.agent, input.relayUrl) : input.agent;
   const agent = resolveAgent(agentParam);
   const now = input.now?.() ?? Date.now();
   const createRelaySub = input.createRelayRequestSubscription ?? createRelayRequestSubscription;
@@ -944,23 +1033,29 @@ async function runCloudChat(input) {
       sendResponse
     });
   }
-  const relaySession = await input.createRelaySession();
-  const relaySubscription = await createRelaySub({
-    sessionId: relaySession.sessionId,
-    token: relaySession.token
-  });
-  console.info("[cloud-chat] relay subscription ready", {
-    chatId: input.chatId,
-    relaySessionId: relaySession.sessionId
-  });
   const runtimeInput = {
     ...input.request,
     ...existing?.agentSessionId ? { session_id: existing.agentSessionId } : {},
     ...existing?.sandboxId ? { sandbox_id: existing.sandboxId } : {},
-    ...existing?.snapshotId ? { snapshot_id: existing.snapshotId } : {},
-    relay_session_id: relaySession.sessionId,
-    relay_token: relaySession.token
+    ...existing?.snapshotId ? { snapshot_id: existing.snapshotId } : {}
   };
+  let relaySession;
+  let relaySubscription = null;
+  if (browserToolEnabled) {
+    relaySession = await input.createRelaySession();
+    relaySubscription = await createRelaySub({
+      sessionId: relaySession.sessionId,
+      token: relaySession.token
+    });
+    console.info("[cloud-chat] relay subscription ready", {
+      chatId: input.chatId,
+      relaySessionId: relaySession.sessionId
+    });
+    Object.assign(runtimeInput, {
+      relay_session_id: relaySession.sessionId,
+      relay_token: relaySession.token
+    });
+  }
   let response;
   try {
     response = await (input.runChatImpl ?? runChat)({
@@ -969,7 +1064,7 @@ async function runCloudChat(input) {
       input: runtimeInput
     });
   } catch (error) {
-    await relaySubscription.close().catch(() => void 0);
+    await relaySubscription?.close().catch(() => void 0);
     throw error;
   }
   const managed = createManagedCloudResponseFromReader({
@@ -984,7 +1079,7 @@ async function runCloudChat(input) {
     relaySubscription,
     relaySession,
     relayUrl: input.relayUrl,
-    includeRelaySessionPrelude: true,
+    includeRelaySessionPrelude: browserToolEnabled,
     initialBuffer: "",
     initialTextBlockOpen: false
   });
@@ -1446,12 +1541,17 @@ function createAgentApi(options) {
           chat_id: parsed.data.chat_id,
           agent_type: parsed.data.agent_type,
           snapshot_id: parsed.data.snapshot_id,
+          env: parsed.data.env,
           tool_results: parsed.data.tool_results
         },
         agent: {
           ...agentOptions,
           type: parsed.data.agent_type,
-          snapshotId: parsed.data.snapshot_id
+          snapshotId: parsed.data.snapshot_id,
+          env: {
+            ...parsed.data.env,
+            ...agentOptions.env
+          }
         },
         signal: request.signal,
         store: await getStore(),

package/dist/types-Co_KfALw.d.ts

@@ -0,0 +1,43 @@
+/** Minimal interface for a json-render catalog. */
+type UICatalog = {
+    prompt(options?: {
+        mode?: "inline" | "standalone";
+        customRules?: string[];
+    }): string;
+};
+type AgentFile = {
+    path: string;
+    content: string;
+};
+type AgentSetup = {
+    /** Shell script to run inside the sandbox during build. Executed as `bash -lc`. */
+    script: string;
+};
+type AgentConfig = {
+    /** Agent type. Defaults to "gemini". */
+    agentType?: "gemini" | "codex";
+    /** Content for AGENTS.md in the sandbox. */
+    agentMd?: string;
+    /** Optional json-render catalog for generative UI. */
+    catalog?: UICatalog;
+    /** Environment variables passed to the sandbox at build and run time. */
+    env?: Record<string, string | undefined>;
+    /** Additional files to write into the sandbox. */
+    files?: AgentFile[];
+    /** Setup configuration for the sandbox build phase. */
+    setup?: AgentSetup;
+};
+type DefinedAgent = {
+    readonly agentType: "gemini" | "codex";
+    readonly agentMd?: string;
+    readonly catalog?: UICatalog;
+    readonly files: AgentFile[];
+    /** Setup configuration. Undefined when no setup is configured. */
+    readonly setup?: AgentSetup;
+    /** Environment variables. */
+    readonly env: Record<string, string>;
+    /** Snapshot ID resolved from env at runtime. Throws if not set. */
+    readonly snapshotId: string;
+};
+
+export type { AgentConfig as A, DefinedAgent as D, UICatalog as U, AgentFile as a, AgentSetup as b };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@giselles-ai/agent",
-	"version": "0.1.24",
+	"version": "0.1.26",
 	"type": "module",
 	"sideEffects": false,
 	"license": "Apache-2.0",
@@ -37,8 +37,9 @@
 		"format": "pnpm exec biome check --write ."
 	},
 	"dependencies": {
-		"@giselles-ai/browser-tool": "0.1.24",
-		"@vercel/sandbox": "1.6.0",
+		"@giselles-ai/browser-tool": "0.1.26",
+		"@json-render/core": "0.13.0",
+		"@vercel/sandbox": "1.8.1",
 		"@iarna/toml": "3.0.0",
 		"zod": "4.3.6"
 	},

package/dist/types-Cto-uejG.d.ts

@@ -1,21 +0,0 @@
-type AgentFile = {
-    path: string;
-    content: string;
-};
-type AgentConfig = {
-    /** Agent type. Defaults to "gemini". */
-    agentType?: "gemini" | "codex";
-    /** Content for AGENTS.md in the sandbox. */
-    agentMd?: string;
-    /** Additional files to write into the sandbox. */
-    files?: AgentFile[];
-};
-type DefinedAgent = {
-    readonly agentType: "gemini" | "codex";
-    readonly agentMd?: string;
-    readonly files: AgentFile[];
-    /** Snapshot ID resolved from env at runtime. Throws if not set. */
-    readonly snapshotId: string;
-};
-
-export type { AgentConfig as A, DefinedAgent as D, AgentFile as a };