@stablekernel/opencode-cursor 0.1.0 → 0.3.0

package/dist/provider/index.js

@@ -1,9 +1,10 @@
 import {
   acquireAgent,
+  getSessionRecord,
   resolveControls,
   resolveCursorApiKey,
   streamAgentTurn
-} from "../chunk-D4YQ7ZEM.js";
+} from "../chunk-BTI2NHEE.js";
 
 // src/provider/index.ts
 import { NoSuchModelError } from "@ai-sdk/provider";
@@ -12,6 +13,19 @@ import { NoSuchModelError } from "@ai-sdk/provider";
 import { LoadAPIKeyError } from "@ai-sdk/provider";
 
 // src/provider/message-map.ts
+var TOOL_RESULT_CAP = 2e3;
+var TOOL_ARGS_CAP = 500;
+function stringify(value) {
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value ?? null);
+  } catch {
+    return String(value);
+  }
+}
+function truncate(text, cap) {
+  return text.length > cap ? `${text.slice(0, cap)}\u2026[+${text.length - cap} chars]` : text;
+}
 function promptToCursorMessage(prompt) {
   const lines = [];
   const images = [];
@@ -40,9 +54,16 @@ ${text.join("\n")}`);
         const text = [];
         for (const part of message.content) {
           if (part.type === "text") text.push(part.text);
-          else if (part.type === "reasoning") text.push(`(thinking) ${part.text}`);
-          else if (part.type === "tool-call") text.push(`[called ${part.toolName}(${part.input})]`);
-          else if (part.type === "tool-result") text.push(`[result of ${part.toolName}]`);
+          else if (part.type === "reasoning")
+            text.push(`(thinking) ${part.text}`);
+          else if (part.type === "tool-call")
+            text.push(
+              `[called ${part.toolName}(${truncate(stringify(part.input), TOOL_ARGS_CAP)})]`
+            );
+          else if (part.type === "tool-result")
+            text.push(
+              `[result of ${part.toolName}: ${truncate(stringify(part.output), TOOL_RESULT_CAP)}]`
+            );
         }
         lines.push(`# Assistant
 ${text.join("\n")}`);
@@ -51,8 +72,10 @@ ${text.join("\n")}`);
       case "tool": {
         for (const part of message.content) {
           if (part.type === "tool-result") {
-            lines.push(`# Tool result (${part.toolName})
-${JSON.stringify(part.output)}`);
+            lines.push(
+              `# Tool result (${part.toolName})
+${truncate(stringify(part.output), TOOL_RESULT_CAP)}`
+            );
           }
         }
         break;
@@ -111,31 +134,366 @@ function safeJsonString(input) {
 function blockToolName(name) {
   return `cursor_${name.replace(/[^A-Za-z0-9_-]/g, "_")}`;
 }
-function toolCallObj(id, name, input) {
+function nativeToolCall(id, toolName, input) {
   return {
     type: "tool-call",
     toolCallId: id,
-    toolName: blockToolName(name),
+    toolName,
     input: safeJsonString(input),
     providerExecuted: true,
     dynamic: true
   };
 }
-function toolResultObj(id, name, result, isError) {
+function nativeToolResult(id, toolName, result, isError) {
   return {
     type: "tool-result",
     toolCallId: id,
-    toolName: blockToolName(name),
+    toolName,
     result: result ?? null,
     isError,
     providerExecuted: true,
     dynamic: true
   };
 }
+function toolCallObj(id, name, input) {
+  return nativeToolCall(id, blockToolName(name), input);
+}
+function toolResultObj(id, name, result, isError) {
+  return nativeToolResult(id, blockToolName(name), result, isError);
+}
 var EDIT_TOOL_NAME = "edit";
 function isRecord(v) {
   return typeof v === "object" && v !== null;
 }
+function strField(v, key) {
+  return isRecord(v) && typeof v[key] === "string" ? v[key] : void 0;
+}
+function numField(v, key) {
+  return isRecord(v) && typeof v[key] === "number" ? v[key] : void 0;
+}
+function successValue(result) {
+  return isRecord(result) && result["status"] === "success" ? result["value"] : void 0;
+}
+function flattenMcpContent(value) {
+  if (!isRecord(value) || !Array.isArray(value["content"])) return null;
+  const parts = value["content"].flatMap((item) => {
+    const text = isRecord(item) ? strField(item["text"], "text") : void 0;
+    if (text !== void 0) return [text];
+    if (isRecord(item) && isRecord(item["image"])) return ["[image]"];
+    return [];
+  });
+  return parts.join("\n");
+}
+function mcpFold(result) {
+  const text = flattenMcpContent(successValue(result));
+  if (text === null) return null;
+  return { title: "", metadata: {}, output: text };
+}
+function mcpInputArgs(args) {
+  return isRecord(args) ? args["args"] : void 0;
+}
+function webSearchProvider(args) {
+  const id = (strField(args, "providerIdentifier") ?? "").toLowerCase();
+  if (id.includes("exa")) return "exa";
+  if (id.includes("parallel")) return "parallel";
+  return void 0;
+}
+function isWebSearchName(name) {
+  return /web[_-]?search/i.test(name);
+}
+var WEBSEARCH_ADAPTER = {
+  tool: "websearch",
+  input: (args) => {
+    const query = strField(mcpInputArgs(args), "query");
+    return query !== void 0 ? { query } : {};
+  },
+  result: (value, args) => {
+    const provider = webSearchProvider(args);
+    return {
+      title: "",
+      metadata: provider ? { provider } : {},
+      output: flattenMcpContent(value) ?? ""
+    };
+  }
+};
+function resolveAdapter(name, _input) {
+  const exact = NATIVE_ADAPTERS[name];
+  if (exact) return exact;
+  if (isWebSearchName(name)) return WEBSEARCH_ADAPTER;
+  return void 0;
+}
+function mapTodoStatus(status) {
+  if (status === "inProgress") return "in_progress";
+  return typeof status === "string" ? status : "pending";
+}
+function mapTodos(args) {
+  const todos = isRecord(args) && Array.isArray(args["todos"]) ? args["todos"] : [];
+  return todos.flatMap(
+    (t) => isRecord(t) && typeof t["content"] === "string" ? [
+      {
+        content: t["content"],
+        status: mapTodoStatus(t["status"])
+      }
+    ] : []
+  );
+}
+var NATIVE_ADAPTERS = {
+  // Cursor `shell` → opencode `bash` (console renderer).
+  shell: {
+    tool: "bash",
+    input: (args) => ({ command: strField(args, "command") ?? "" }),
+    result: (value, args) => {
+      if (!isRecord(value)) return null;
+      const command = strField(args, "command") ?? "";
+      const stdout = strField(value, "stdout") ?? "";
+      const stderr = strField(value, "stderr") ?? "";
+      const exit = numField(value, "exitCode");
+      const body = [stdout, stderr].filter((s) => s.length > 0).join("\n");
+      const output = exit !== void 0 && exit !== 0 ? `${body}${body ? "\n" : ""}(exit ${exit})` : body;
+      return {
+        title: command,
+        metadata: { command, output, exit: exit ?? 0 },
+        output
+      };
+    }
+  },
+  // Cursor `read` → opencode `read`.
+  read: {
+    tool: "read",
+    input: (args) => ({ filePath: strField(args, "path") ?? "" }),
+    result: (value, args) => {
+      const content = strField(value, "content");
+      if (content === void 0) return null;
+      const filePath = strField(args, "path") ?? "";
+      const totalLines = numField(value, "totalLines");
+      return {
+        title: filePath,
+        metadata: {
+          preview: content.split("\n").slice(0, 20).join("\n"),
+          loaded: [],
+          ...totalLines !== void 0 ? { totalLines } : {}
+        },
+        output: content
+      };
+    }
+  },
+  // Cursor `write` → opencode `write` (renders input.content as the new file).
+  write: {
+    tool: "write",
+    input: (args) => ({
+      filePath: strField(args, "path") ?? "",
+      content: strField(args, "fileText") ?? ""
+    }),
+    result: (value, args) => {
+      const filePath = strField(args, "path") ?? "";
+      const lines = numField(value, "linesCreated");
+      const output = lines !== void 0 ? `Wrote ${lines} line${lines === 1 ? "" : "s"}.` : "Wrote file successfully.";
+      return {
+        title: filePath,
+        metadata: { diagnostics: {}, filepath: filePath, exists: false },
+        output
+      };
+    }
+  },
+  // Cursor `glob` → opencode `glob`.
+  glob: {
+    tool: "glob",
+    input: (args) => {
+      const pattern = strField(args, "globPattern") ?? "";
+      const dir = strField(args, "targetDirectory");
+      return dir ? { pattern, path: dir } : { pattern };
+    },
+    result: (value) => {
+      if (!isRecord(value) || !Array.isArray(value["files"])) return null;
+      const files = value["files"].filter(
+        (f) => typeof f === "string"
+      );
+      const truncated = value["clientTruncated"] === true || value["ripgrepTruncated"] === true;
+      return {
+        title: "",
+        metadata: { count: files.length, truncated },
+        output: files.length > 0 ? files.join("\n") : "No files found"
+      };
+    }
+  },
+  // Cursor `grep` → opencode `grep` (flatten matches into ripgrep-style text).
+  grep: {
+    tool: "grep",
+    input: (args) => {
+      const out = {
+        pattern: strField(args, "pattern") ?? ""
+      };
+      const p = strField(args, "path");
+      if (p) out["path"] = p;
+      const g = strField(args, "glob");
+      if (g) out["include"] = g;
+      return out;
+    },
+    result: (value) => {
+      if (!isRecord(value)) return null;
+      const unions = [];
+      const ws = value["workspaceResults"];
+      if (isRecord(ws)) unions.push(...Object.values(ws));
+      if (value["activeEditorResult"] !== void 0)
+        unions.push(value["activeEditorResult"]);
+      const lines = [];
+      let total = 0;
+      let current = "";
+      for (const u of unions) {
+        if (!isRecord(u)) continue;
+        const output = u["output"];
+        if (u["type"] === "content" && isRecord(output) && Array.isArray(output["matches"])) {
+          for (const m of output["matches"]) {
+            if (!isRecord(m)) continue;
+            const file = strField(m, "file") ?? "";
+            const line = numField(m, "lineNumber");
+            const text = strField(m, "line") ?? "";
+            if (current !== file) {
+              if (current) lines.push("");
+              current = file;
+              lines.push(`${file}:`);
+            }
+            lines.push(
+              line !== void 0 ? `  Line ${line}: ${text}` : `  ${text}`
+            );
+            total++;
+          }
+        } else if (u["type"] === "files" && isRecord(output) && Array.isArray(output["files"])) {
+          for (const f of output["files"]) {
+            if (typeof f === "string") {
+              lines.push(f);
+              total++;
+            }
+          }
+        }
+      }
+      return {
+        title: "",
+        metadata: { matches: total, truncated: false },
+        output: total > 0 ? [
+          `Found ${total} match${total === 1 ? "" : "es"}`,
+          "",
+          ...lines
+        ].join("\n") : "No matches found"
+      };
+    }
+  },
+  // Cursor `ls` → opencode `list` (flatten the directory tree into paths).
+  ls: {
+    tool: "list",
+    input: (args) => ({ path: strField(args, "path") ?? "" }),
+    result: (value) => {
+      if (!isRecord(value)) return null;
+      const root = value["directoryTreeRoot"];
+      if (!isRecord(root)) return null;
+      const out = [];
+      const walk = (node) => {
+        const base = strField(node, "absPath") ?? "";
+        const files = Array.isArray(node["childrenFiles"]) ? node["childrenFiles"] : [];
+        for (const f of files) {
+          const name = strField(f, "name");
+          if (name) out.push(`${base}/${name}`);
+        }
+        const dirs = Array.isArray(node["childrenDirs"]) ? node["childrenDirs"] : [];
+        for (const d of dirs) {
+          if (!isRecord(d)) continue;
+          out.push(`${strField(d, "absPath") ?? ""}/`);
+          walk(d);
+        }
+      };
+      walk(root);
+      return {
+        title: strField(root, "absPath") ?? "",
+        metadata: {},
+        output: out.length > 0 ? out.join("\n") : "(empty)"
+      };
+    }
+  },
+  // Cursor `updateTodos` → opencode `todowrite` (todo checklist renderer).
+  updateTodos: {
+    tool: "todowrite",
+    input: (args) => ({ todos: mapTodos(args) }),
+    result: (_value, args) => {
+      const todos = mapTodos(args);
+      const done = todos.filter((t) => t.status === "completed").length;
+      return {
+        title: `${done}/${todos.length}`,
+        metadata: { todos },
+        output: `Updated ${todos.length} todo${todos.length === 1 ? "" : "s"}.`
+      };
+    }
+  },
+  // Cursor `task` (subagent) → opencode `task` (agent card: name + description).
+  // Non-clickable here — the subagent ran inside Cursor, not as an opencode
+  // child session — but the native card reads far better than raw JSON.
+  task: {
+    tool: "task",
+    input: (args) => {
+      const description = strField(args, "description") ?? "";
+      const sub = isRecord(args) ? args["subagentType"] : void 0;
+      const subagent = strField(sub, "name") ?? strField(sub, "kind") ?? void 0;
+      return subagent ? { description, subagent_type: subagent } : { description };
+    },
+    result: (value, args) => {
+      const description = strField(args, "description") ?? "";
+      const suffix = strField(value, "resultSuffix");
+      const background = isRecord(value) && value["isBackground"] === true;
+      return {
+        title: description,
+        metadata: background ? { background: true } : {},
+        output: suffix ?? "Subagent task completed."
+      };
+    }
+  },
+  // Cursor `readLints` has no opencode counterpart — format-only: render the
+  // diagnostics as a readable list instead of dumping the nested JSON.
+  readLints: {
+    input: (args) => {
+      const paths = isRecord(args) && Array.isArray(args["paths"]) ? args["paths"] : [];
+      return { paths };
+    },
+    result: (value) => {
+      const files = isRecord(value) && Array.isArray(value["fileDiagnostics"]) ? value["fileDiagnostics"] : [];
+      const lines = [];
+      let total = 0;
+      for (const file of files) {
+        if (!isRecord(file)) continue;
+        const diags = Array.isArray(file["diagnostics"]) ? file["diagnostics"] : [];
+        if (diags.length === 0) continue;
+        lines.push(`${strField(file, "path") ?? ""}`);
+        for (const d of diags) {
+          if (!isRecord(d)) continue;
+          const severity = strField(d, "severity") ?? "info";
+          const start = isRecord(d["range"]) ? d["range"]["start"] : void 0;
+          const line = numField(start, "line");
+          const char = numField(start, "character");
+          const loc = line !== void 0 ? ` L${line + 1}${char !== void 0 ? `:${char + 1}` : ""}` : "";
+          lines.push(`  ${severity}${loc}: ${strField(d, "message") ?? ""}`);
+          total++;
+        }
+      }
+      return {
+        title: total > 0 ? `${total} problem${total === 1 ? "" : "s"}` : "No problems",
+        metadata: { count: total },
+        output: total > 0 ? lines.join("\n") : "No problems found."
+      };
+    }
+  },
+  // Cursor `delete` has no opencode counterpart — format-only: a one-line
+  // confirmation instead of `{"fileSize":N}`.
+  delete: {
+    input: (args) => ({ path: strField(args, "path") ?? "" }),
+    result: (value, args) => {
+      const path = strField(args, "path") ?? "";
+      const size = numField(value, "fileSize");
+      return {
+        title: path,
+        metadata: {},
+        output: size !== void 0 ? `Deleted ${path} (${size} bytes).` : `Deleted ${path}.`
+      };
+    }
+  }
+};
 function editFilePath(input) {
   return isRecord(input) && typeof input["path"] === "string" ? input["path"] : "";
 }
@@ -189,15 +547,22 @@ function editResultFields(id, filePath, diff, result) {
   };
 }
 function newBlockToolState() {
-  return { openToolCalls: /* @__PURE__ */ new Map(), pendingEdits: /* @__PURE__ */ new Map() };
+  return { open: /* @__PURE__ */ new Map(), pendingEdits: /* @__PURE__ */ new Map() };
 }
 function blockToolCallParts(id, name, input, state) {
   if (name === EDIT_TOOL_NAME) {
     state.pendingEdits.set(id, editFilePath(input));
     return [];
   }
-  state.openToolCalls.set(id, name);
-  return [toolCallObj(id, name, input)];
+  const adapter = resolveAdapter(name, input);
+  if (adapter) {
+    const toolName2 = adapter.tool ?? blockToolName(name);
+    state.open.set(id, { toolName: toolName2, adapter, args: input });
+    return [nativeToolCall(id, toolName2, adapter.input(input))];
+  }
+  const toolName = blockToolName(name);
+  state.open.set(id, { toolName, args: input });
+  return [nativeToolCall(id, toolName, input)];
 }
 function blockToolResultParts(id, name, result, isError, state) {
   if (state.pendingEdits.has(id)) {
@@ -215,15 +580,28 @@ function blockToolResultParts(id, name, result, isError, state) {
       toolResultObj(id, EDIT_TOOL_NAME, result, isError)
     ];
   }
-  state.openToolCalls.delete(id);
-  return [toolResultObj(id, name, result, isError)];
+  const open = state.open.get(id);
+  state.open.delete(id);
+  const toolName = open?.toolName ?? blockToolName(name);
+  if (open?.adapter && !isError) {
+    const value = successValue(result);
+    if (value !== void 0) {
+      const folded = open.adapter.result(value, open.args);
+      if (folded) return [nativeToolResult(id, toolName, folded, false)];
+    }
+  }
+  if (!isError) {
+    const folded = mcpFold(result);
+    if (folded) return [nativeToolResult(id, toolName, folded, false)];
+  }
+  return [nativeToolResult(id, toolName, result, isError)];
 }
 function blockDanglingParts(state) {
   const parts = [];
-  for (const [id, name] of state.openToolCalls) {
-    parts.push(toolResultObj(id, name, DANGLING_TOOL_RESULT, true));
+  for (const [id, open] of state.open) {
+    parts.push(nativeToolResult(id, open.toolName, DANGLING_TOOL_RESULT, true));
   }
-  state.openToolCalls.clear();
+  state.open.clear();
   for (const [id, filePath] of state.pendingEdits) {
     parts.push(toolCallObj(id, EDIT_TOOL_NAME, { path: filePath }));
     parts.push(toolResultObj(id, EDIT_TOOL_NAME, DANGLING_TOOL_RESULT, true));
@@ -336,12 +714,17 @@ function cursorEventsToStream(events, toolDisplay = "blocks") {
               break;
             case "tool-call":
               if (toolDisplay === "blocks") {
-                for (const part of blockToolCallParts(
+                const parts = blockToolCallParts(
                   event.id,
                   event.name,
                   event.input,
                   toolState
-                )) {
+                );
+                if (parts.length > 0) {
+                  closeText();
+                  closeReasoning();
+                }
+                for (const part of parts) {
                   controller.enqueue(part);
                 }
               } else {
@@ -352,13 +735,18 @@ ${formatToolCall(event.name, event.input)}
               break;
             case "tool-result":
               if (toolDisplay === "blocks") {
-                for (const part of blockToolResultParts(
+                const parts = blockToolResultParts(
                   event.id,
                   event.name,
                   event.result,
                   event.isError,
                   toolState
-                )) {
+                );
+                if (parts.length > 0) {
+                  closeText();
+                  closeReasoning();
+                }
+                for (const part of parts) {
                   controller.enqueue(part);
                 }
               } else if (event.isError) {
@@ -473,6 +861,55 @@ ${formatToolCall(event.name, event.input)}
   return { content, finishReason, usage };
 }
 
+// src/provider/transcript-fingerprint.ts
+import { createHash } from "crypto";
+function sha(input) {
+  return createHash("sha256").update(input).digest("hex");
+}
+function mcpServersFingerprint(servers) {
+  if (!servers) return "";
+  const keys = Object.keys(servers).sort();
+  if (keys.length === 0) return "";
+  return sha(JSON.stringify(keys.map((k) => [k, servers[k]])));
+}
+function userMessageKey(message) {
+  const parts = [];
+  for (const part of message.content) {
+    if (part.type === "text") parts.push(`t:${part.text}`);
+    else if (part.type === "file") parts.push(`f:${part.mediaType}`);
+  }
+  return parts.join("\n");
+}
+function fingerprint(prompt) {
+  const systemParts = [];
+  const userHashes = [];
+  for (const message of prompt) {
+    if (message.role === "system") systemParts.push(message.content);
+    else if (message.role === "user")
+      userHashes.push(sha(userMessageKey(message)));
+  }
+  return { systemHash: sha(systemParts.join("\n")), userHashes };
+}
+function isStrictPrefix(prefix, full) {
+  if (prefix.length >= full.length) return false;
+  for (let i = 0; i < prefix.length; i++) {
+    if (prefix[i] !== full[i]) return false;
+  }
+  return true;
+}
+function classifyTurn(prev, prompt) {
+  const fp = fingerprint(prompt);
+  if (!prev) return { kind: "new", fingerprint: fp };
+  if (prev.systemHash !== fp.systemHash)
+    return { kind: "side-call", fingerprint: fp };
+  const lastIsUser = prompt[prompt.length - 1]?.role === "user";
+  const exactlyOneNew = fp.userHashes.length === prev.userHashes.length + 1;
+  if (lastIsUser && exactlyOneNew && isStrictPrefix(prev.userHashes, fp.userHashes)) {
+    return { kind: "continuation", fingerprint: fp };
+  }
+  return { kind: "divergence", fingerprint: fp };
+}
+
 // src/provider/language-model.ts
 var CursorLanguageModel = class {
   constructor(modelId, config) {
@@ -503,8 +940,46 @@ var CursorLanguageModel = class {
       providerOptions
     );
     const sessionID = typeof providerOptions?.["sessionID"] === "string" ? providerOptions["sessionID"] : void 0;
-    const useSession = this.config.session === true && Boolean(sessionID);
+    const dynamicMcp = providerOptions?.["mcpServers"];
+    const mcpServers = dynamicMcp ?? this.config.mcpServers;
+    const mcpHash = mcpServersFingerprint(mcpServers);
+    const sessionEnabled = (this.config.session ?? "auto") !== false;
     const explicitAgentId = typeof providerOptions?.["agentId"] === "string" ? providerOptions["agentId"] : void 0;
+    const ephemeral = providerOptions?.["ephemeral"] === true;
+    const usePool = sessionEnabled && Boolean(sessionID) && !explicitAgentId;
+    let resumeAgentId = explicitAgentId;
+    let poolKey;
+    let record;
+    if (usePool) {
+      const classification = ephemeral ? {
+        kind: "side-call",
+        fingerprint: fingerprint(options.prompt)
+      } : classifyTurn(getSessionRecord(sessionID), options.prompt);
+      switch (classification.kind) {
+        case "continuation": {
+          const prev = getSessionRecord(sessionID);
+          if (prev?.mcpHash === mcpHash) {
+            resumeAgentId = prev?.agentId;
+          }
+          poolKey = sessionID;
+          record = { ...classification.fingerprint, mcpHash };
+          break;
+        }
+        case "new":
+        case "divergence":
+          poolKey = sessionID;
+          record = { ...classification.fingerprint, mcpHash };
+          break;
+        case "side-call":
+          break;
+      }
+      if (process.env["OPENCODE_CURSOR_DEBUG"] === "1") {
+        const label = classification.kind === "continuation" ? "resume" : `fresh:${classification.kind}`;
+        console.error(
+          `[cursor:debug] turn classification=${label} session=${sessionID}`
+        );
+      }
+    }
     const acquired = await acquireAgent({
       apiKey: this.requireApiKey(),
       modelSelection,
@@ -512,12 +987,12 @@ var CursorLanguageModel = class {
       cwd: this.config.cwd,
       ...this.config.settingSources ? { settingSources: this.config.settingSources } : {},
       ...this.config.sandbox !== void 0 ? { sandbox: this.config.sandbox } : {},
-      ...this.config.mcpServers ? { mcpServers: this.config.mcpServers } : {},
+      ...mcpServers ? { mcpServers } : {},
       ...this.config.agents ? { agents: this.config.agents } : {},
-      ...useSession ? { name: `opencode/${sessionID.slice(-8)}` } : {},
-      ...explicitAgentId ? { agentId: explicitAgentId } : {},
-      sessionID,
-      session: useSession
+      ...poolKey ? { name: `opencode/${sessionID.slice(-8)}` } : {},
+      ...resumeAgentId ? { resumeAgentId } : {},
+      ...poolKey ? { poolKey } : {},
+      ...record ? { record } : {}
     });
     const message = acquired.resumed ? latestUserMessage(options.prompt) ?? promptToCursorMessage(options.prompt) : promptToCursorMessage(options.prompt);
     try {
@@ -559,7 +1034,7 @@ function createCursor(options = {}) {
     ...options.settingSources ? { settingSources: options.settingSources } : {},
     ...options.sandbox !== void 0 ? { sandbox: options.sandbox } : {},
     ...options.agents ? { agents: options.agents } : {},
-    ...options.session !== void 0 ? { session: options.session } : {},
+    session: options.session ?? "auto",
     toolDisplay: options.toolDisplay ?? "blocks"
   };
   const notImplemented = (kind, modelId) => {