@giselles-ai/agent 0.1.26 → 0.1.27

package/dist/index.js

@@ -4,9 +4,19 @@ import {
 } from "./chunk-JGH5DCA7.js";
 
 // src/define-agent.ts
+function createInternalArtifactPrompt() {
+  return `
+## Artifact Convention
+- Files intended for user review or download must be written under ./artifacts/.
+- Temporary files, logs, caches, and intermediate data should stay outside ./artifacts/.
+- Before finishing, inspect ./artifacts/ and mention only files that actually exist there.
+- Mention created artifact paths in the assistant response for fallback visibility.
+`.trim();
+}
 function defineAgent(config) {
   const catalogPrompt = config.catalog?.prompt({ mode: "inline" });
-  const agentMd = [config.agentMd, catalogPrompt].filter(Boolean).join("\n\n");
+  const internalPrompt = createInternalArtifactPrompt();
+  const agentMd = [config.agentMd, internalPrompt, catalogPrompt].filter(Boolean).join("\n\n");
   return {
     agentType: config.agentType ?? "gemini",
     agentMd: agentMd || void 0,

package/dist/server/index.js

@@ -1,8 +1,10 @@
 // src/agent-api.ts
+import { basename } from "path";
 import {
   createRelayHandler,
   createRelaySession
 } from "@giselles-ai/browser-tool/relay";
+import { Sandbox as Sandbox3 } from "@vercel/sandbox";
 
 // src/build.ts
 import { Sandbox } from "@vercel/sandbox";
@@ -606,6 +608,96 @@ function createAgent(options) {
 import { Writable } from "stream";
 import { Sandbox as Sandbox2 } from "@vercel/sandbox";
 var COMMAND_TIMEOUT_EXTENSION_MS = 5 * 60 * 1e3;
+var ARTIFACT_DIRS = ["./artifacts", "/vercel/sandbox/artifacts"];
+function getArtifactMimeType(path) {
+  const extension = path.split(".").pop()?.toLowerCase();
+  switch (extension) {
+    case "md":
+      return "text/markdown; charset=utf-8";
+    case "json":
+      return "application/json; charset=utf-8";
+    case "csv":
+      return "text/csv; charset=utf-8";
+    case "txt":
+      return "text/plain; charset=utf-8";
+    default:
+      return "application/octet-stream";
+  }
+}
+function getArtifactLabel(path) {
+  const pieces = path.split("/");
+  return pieces[pieces.length - 1] ?? path;
+}
+async function collectArtifacts(sandbox) {
+  const artifacts = [];
+  const seen = /* @__PURE__ */ new Set();
+  let discoveryFailed = false;
+  for (const artifactDir of ARTIFACT_DIRS) {
+    let output = "";
+    let discoveryStderr = "";
+    let exitCode = 0;
+    try {
+      const result = await sandbox.runCommand({
+        cmd: "find",
+        args: [artifactDir, "-type", "f", "-print"]
+      });
+      output = await result.stdout();
+      discoveryStderr = await result.stderr();
+      exitCode = typeof result.exitCode === "number" ? result.exitCode : 0;
+    } catch (error) {
+      discoveryFailed = true;
+      console.warn("[chat-run] artifact discovery failed for directory", {
+        directory: artifactDir,
+        error: error instanceof Error ? error.message : String(error),
+        stderr: discoveryStderr
+      });
+      continue;
+    }
+    if (exitCode !== 0 && !output.trim()) {
+      discoveryFailed = true;
+      console.warn(
+        "[chat-run] artifact discovery returned non-zero exit code",
+        {
+          directory: artifactDir,
+          exitCode,
+          stderr: discoveryStderr
+        }
+      );
+      continue;
+    }
+    if (!output.trim()) {
+      continue;
+    }
+    for (const line of output.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed) {
+        continue;
+      }
+      const [path, rawSize] = trimmed.split("	");
+      if (!path) {
+        continue;
+      }
+      const normalizedPath = path.startsWith("/vercel/sandbox/") ? `./${path.slice("/vercel/sandbox/".length)}` : path;
+      if (!normalizedPath.startsWith("./artifacts/") || seen.has(normalizedPath)) {
+        continue;
+      }
+      seen.add(normalizedPath);
+      const parsedSize = Number.parseInt(rawSize ?? "0", 10);
+      const size_bytes = Number.isNaN(parsedSize) ? 0 : parsedSize;
+      artifacts.push({
+        type: "artifact",
+        path: normalizedPath,
+        size_bytes,
+        mime_type: getArtifactMimeType(normalizedPath),
+        label: getArtifactLabel(normalizedPath)
+      });
+    }
+  }
+  if (discoveryFailed && artifacts.length === 0) {
+    return [];
+  }
+  return artifacts;
+}
 function emitText(controller, text, encoder) {
   if (text.length === 0) {
     return;
@@ -756,6 +848,10 @@ function runChat(input) {
             }),
             signal: abortController.signal
           });
+          const discoveredArtifacts = await collectArtifacts(sandbox);
+          for (const artifact of discoveredArtifacts) {
+            enqueueEvent(artifact);
+          }
           const snapshot = await sandbox.snapshot();
           enqueueEvent({
             type: "snapshot",
@@ -1480,6 +1576,70 @@ function resolveRelayUrl(basePath, request) {
   }
   return new URL(`${basePath}/relay`, request.url).toString();
 }
+function createArtifactError(status, path, message) {
+  return errorResponse(status, "FILE_ERROR", `${path}: ${message}`);
+}
+function getArtifactMimeType2(path) {
+  const extension = path.split(".").pop()?.toLowerCase();
+  switch (extension) {
+    case "md":
+      return "text/markdown; charset=utf-8";
+    case "json":
+      return "application/json; charset=utf-8";
+    case "csv":
+      return "text/csv; charset=utf-8";
+    case "txt":
+      return "text/plain; charset=utf-8";
+    default:
+      return "application/octet-stream";
+  }
+}
+async function resolveReadableSandbox(input) {
+  const createFromSnapshot = async (snapshotId) => Sandbox3.create({
+    source: {
+      type: "snapshot",
+      snapshotId
+    }
+  });
+  if (input.sandboxId) {
+    try {
+      const existing = await Sandbox3.get({ sandboxId: input.sandboxId });
+      if (existing.status === "running") {
+        return existing;
+      }
+      if (!input.snapshotId) {
+        throw new Error(
+          `Sandbox ${input.sandboxId} is ${existing.status}, not running`
+        );
+      }
+      console.log(
+        `[agent-api] sandbox=${input.sandboxId} status=${existing.status}, recreating from snapshot=${input.snapshotId}`
+      );
+      return createFromSnapshot(input.snapshotId);
+    } catch (error) {
+      if (!input.snapshotId) {
+        throw error;
+      }
+      console.log(
+        `[agent-api] sandbox=${input.sandboxId} expired, recreating from snapshot=${input.snapshotId}`
+      );
+      return createFromSnapshot(input.snapshotId);
+    }
+  }
+  if (!input.snapshotId) {
+    throw new Error("No sandbox_id or snapshot_id available for file read");
+  }
+  return createFromSnapshot(input.snapshotId);
+}
+function createDownloadHeaders(path, options) {
+  const filename = basename(path);
+  const mode = options.download === "1" ? "attachment" : "inline";
+  return {
+    "Content-Type": getArtifactMimeType2(path),
+    "Content-Disposition": `${mode}; filename="${filename}"`,
+    "Cache-Control": "private, no-store"
+  };
+}
 function createAgentApi(options) {
   const relay = createRelayHandler();
   const { basePath, agent: agentOptions } = options;
@@ -1521,6 +1681,45 @@ function createAgentApi(options) {
       return errorResponse(500, "INTERNAL_ERROR", message);
     }
   }
+  async function handleFiles(request) {
+    const url = new URL(request.url);
+    const chatId = url.searchParams.get("chat_id")?.trim();
+    const path = url.searchParams.get("path")?.trim();
+    const download = url.searchParams.get("download")?.trim();
+    if (!chatId || !path) {
+      return createArtifactError(400, "query", "chat_id and path are required");
+    }
+    if (!path.startsWith("./artifacts/") || path.includes("..")) {
+      return createArtifactError(400, "path", "path must be under ./artifacts");
+    }
+    const store = await getStore();
+    const chatState = await store.load(chatId);
+    if (!chatState) {
+      return createArtifactError(404, "chat_id", "chat session not found");
+    }
+    let sandbox;
+    try {
+      sandbox = await resolveReadableSandbox({
+        sandboxId: chatState.sandboxId,
+        snapshotId: chatState.snapshotId
+      });
+    } catch (error) {
+      return createArtifactError(
+        400,
+        "sandbox",
+        error instanceof Error ? error.message : "failed to resolve sandbox"
+      );
+    }
+    const fileBuffer = await sandbox.readFileToBuffer({
+      path
+    });
+    if (!fileBuffer) {
+      return createArtifactError(404, "path", "file not found");
+    }
+    return new Response(new Uint8Array(fileBuffer), {
+      headers: createDownloadHeaders(path, { download })
+    });
+  }
   async function handleRun(request) {
     try {
       const hookResult = await options.hooks?.chat?.before?.(request);
@@ -1579,6 +1778,7 @@ function createAgentApi(options) {
   function matchSubPath(request) {
     const url = new URL(request.url);
     const pathname = url.pathname;
+    const filesPath = `${basePath}/files`;
     if (pathname === authPath || pathname === `${authPath}/`) {
       return "auth";
     }
@@ -1588,6 +1788,9 @@ function createAgentApi(options) {
     if (pathname === buildPath || pathname === `${buildPath}/`) {
       return "build";
     }
+    if (pathname === filesPath || pathname === `${filesPath}/`) {
+      return "files";
+    }
     if (pathname === relayPrefix || pathname.startsWith(`${relayPrefix}/`)) {
       return "relay";
     }
@@ -1599,6 +1802,9 @@ function createAgentApi(options) {
       if (sub === "relay") {
         return relay.GET(request);
       }
+      if (sub === "files") {
+        return handleFiles(request);
+      }
       return errorResponse(404, "NOT_FOUND", "Not found.");
     },
     POST: async (request) => {
@@ -1622,6 +1828,9 @@ function createAgentApi(options) {
       if (sub === "relay") {
         return relay.OPTIONS(request);
       }
+      if (sub === "files") {
+        return new Response(null, { status: 204 });
+      }
       return new Response(null, { status: 204 });
     }
   };

package/package.json

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