fourmis-agents-sdk 0.3.1 → 0.4.1

package/dist/agents/index.js

@@ -483,10 +483,57 @@ function mergeUsage(a, b) {
 }
 
 // src/agent-loop.ts
+function makeModelUsageEntry() {
+  return {
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadInputTokens: 0,
+    cacheCreationInputTokens: 0,
+    totalCostUsd: 0
+  };
+}
+function makeErrorResult(params) {
+  return {
+    type: "result",
+    subtype: params.subtype,
+    duration_ms: Date.now() - params.startTime,
+    duration_api_ms: params.apiTimeMs,
+    is_error: true,
+    num_turns: params.turns,
+    stop_reason: null,
+    total_cost_usd: params.costUsd,
+    usage: params.usage,
+    modelUsage: params.modelUsage,
+    permission_denials: params.permissionDenials,
+    errors: params.errors,
+    uuid: uuid(),
+    session_id: params.sessionId
+  };
+}
+function extractStructuredJson(text) {
+  const trimmed = text.trim();
+  if (!trimmed) {
+    return { ok: false, error: "Empty result text; expected JSON output." };
+  }
+  const fenced = trimmed.match(/```(?:json)?\s*([\s\S]*?)\s*```/i);
+  const candidate = fenced ? fenced[1].trim() : trimmed;
+  try {
+    return { ok: true, value: JSON.parse(candidate) };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { ok: false, error: `Invalid JSON output: ${message}` };
+  }
+}
 async function* agentLoop(prompt, options) {
   const {
     provider,
     model,
+    fallbackModel,
+    modelState,
+    maxThinkingTokensState,
+    thinking,
+    effort,
+    outputFormat,
     systemPrompt,
     tools,
     permissions,
@@ -494,7 +541,7 @@ async function* agentLoop(prompt, options) {
     sessionId,
     maxTurns,
     maxBudgetUsd,
-    includeStreamEvents,
+    includePartialMessages,
     signal,
     env,
     debug,
@@ -502,14 +549,17 @@ async function* agentLoop(prompt, options) {
     mcpClient,
     previousMessages,
     sessionLogger,
-    nativeMemoryTool
+    nativeMemoryTool,
+    initMeta
   } = options;
+  const effectiveModelState = modelState ?? { current: model };
   const startTime = Date.now();
   let apiTimeMs = 0;
   let turns = 0;
   let totalUsage = emptyTokenUsage();
   let costUsd = 0;
   const modelUsage = {};
+  const permissionDenials = [];
   if (mcpClient) {
     await mcpClient.connectAll();
     for (const tool of mcpClient.getTools()) {
@@ -527,56 +577,135 @@ async function* agentLoop(prompt, options) {
     sessionLogger("user", prompt, null);
   }
   yield {
-    type: "init",
-    sessionId,
-    model,
-    provider: provider.name,
+    type: "system",
+    subtype: "init",
+    apiKeySource: "user",
+    claude_code_version: "fourmis-agent-sdk",
+    session_id: sessionId,
+    model: effectiveModelState.current,
     tools: tools.list(),
     cwd,
+    mcp_servers: (mcpClient?.status() ?? []).map((s) => ({ name: s.name, status: s.status })),
+    permissionMode: permissions.getMode(),
+    agents: initMeta?.agents,
+    betas: initMeta?.betas,
+    slash_commands: initMeta?.slashCommands ?? [],
+    output_style: initMeta?.outputStyle ?? "default",
+    skills: initMeta?.skills ?? [],
+    plugins: (initMeta?.plugins ?? []).map((p) => ({ name: p.path.split("/").pop() ?? p.path, path: p.path })),
     uuid: uuid()
   };
   if (hooks) {
-    await hooks.fire("SessionStart", { event: "SessionStart", session_id: sessionId }, undefined, { signal });
+    await hooks.fire("Setup", {
+      event: "Setup",
+      hook_event_name: "Setup",
+      trigger: "init",
+      session_id: sessionId,
+      cwd,
+      permission_mode: permissions.getMode()
+    }, undefined, { signal });
+  }
+  if (hooks) {
+    await hooks.fire("SessionStart", {
+      event: "SessionStart",
+      hook_event_name: "SessionStart",
+      session_id: sessionId,
+      source: "startup",
+      model: effectiveModelState.current,
+      cwd,
+      permission_mode: permissions.getMode()
+    }, undefined, { signal });
   }
   while (true) {
     if (signal.aborted) {
-      yield makeError("error_execution", ["Aborted"], turns, costUsd, sessionId, startTime);
+      yield makeErrorResult({
+        subtype: "error_during_execution",
+        errors: ["Aborted"],
+        turns,
+        costUsd,
+        sessionId,
+        startTime,
+        apiTimeMs,
+        usage: totalUsage,
+        modelUsage,
+        permissionDenials
+      });
       return;
     }
     if (turns >= maxTurns) {
-      yield makeError("error_max_turns", [`Reached maximum turns (${maxTurns})`], turns, costUsd, sessionId, startTime);
+      yield makeErrorResult({
+        subtype: "error_max_turns",
+        errors: [`Reached maximum turns (${maxTurns})`],
+        turns,
+        costUsd,
+        sessionId,
+        startTime,
+        apiTimeMs,
+        usage: totalUsage,
+        modelUsage,
+        permissionDenials
+      });
       return;
     }
     if (maxBudgetUsd > 0 && costUsd >= maxBudgetUsd) {
-      yield makeError("error_max_budget", [`Reached budget limit ($${maxBudgetUsd})`], turns, costUsd, sessionId, startTime);
+      yield makeErrorResult({
+        subtype: "error_max_budget_usd",
+        errors: [],
+        turns,
+        costUsd,
+        sessionId,
+        startTime,
+        apiTimeMs,
+        usage: totalUsage,
+        modelUsage,
+        permissionDenials
+      });
       return;
     }
+    const activeModel = effectiveModelState.current;
     const toolDefs = tools.getDefinitions();
     const apiStart = Date.now();
     let assistantTextParts = [];
-    let toolCalls = [];
+    const toolCalls = [];
     let turnUsage = emptyTokenUsage();
+    let turnStopReason = null;
     const nativeTools = nativeMemoryTool ? [nativeMemoryTool.definition] : undefined;
     try {
       const chunks = provider.chat({
-        model,
+        model: activeModel,
         messages,
         tools: toolDefs.length > 0 ? toolDefs : undefined,
         systemPrompt,
         signal,
-        nativeTools
+        nativeTools,
+        thinkingBudget: maxThinkingTokensState?.current,
+        thinking,
+        effort,
+        outputFormat
       });
       for await (const chunk of chunks) {
         switch (chunk.type) {
           case "text_delta":
             assistantTextParts.push(chunk.text);
-            if (includeStreamEvents) {
-              yield { type: "stream", subtype: "text_delta", text: chunk.text, uuid: uuid() };
+            if (includePartialMessages) {
+              yield {
+                type: "stream_event",
+                event: { type: "text_delta", text: chunk.text },
+                parent_tool_use_id: null,
+                uuid: uuid(),
+                session_id: sessionId
+              };
             }
             break;
           case "thinking_delta":
-            if (includeStreamEvents) {
-              yield { type: "stream", subtype: "thinking_delta", text: chunk.text, uuid: uuid() };
+            if (includePartialMessages) {
+              yield {
+                type: "stream_event",
+                event: { type: "thinking_delta", thinking: chunk.text },
+                parent_tool_use_id: null,
+                uuid: uuid(),
+                session_id: sessionId
+              };
             }
             break;
           case "tool_call":
@@ -586,33 +715,54 @@ async function* agentLoop(prompt, options) {
             turnUsage = mergeUsage(turnUsage, chunk.usage);
             break;
           case "done":
+            turnStopReason = chunk.stopReason ?? null;
             break;
         }
       }
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
-      yield makeError("error_execution", [`API error: ${message}`], turns, costUsd, sessionId, startTime);
+      if (fallbackModel && activeModel !== fallbackModel) {
+        effectiveModelState.current = fallbackModel;
+        yield {
+          type: "system",
+          subtype: "status",
+          status: null,
+          permissionMode: permissions.getMode(),
+          uuid: uuid(),
+          session_id: sessionId
+        };
+        continue;
+      }
+      yield makeErrorResult({
+        subtype: "error_during_execution",
+        errors: [`API error: ${message}`],
+        turns,
+        costUsd,
+        sessionId,
+        startTime,
+        apiTimeMs,
+        usage: totalUsage,
+        modelUsage,
+        permissionDenials
+      });
       return;
     }
     apiTimeMs += Date.now() - apiStart;
     turns++;
     totalUsage = mergeUsage(totalUsage, turnUsage);
-    const turnCost = provider.calculateCost(model, turnUsage);
+    const turnCost = provider.calculateCost(activeModel, turnUsage);
     costUsd += turnCost;
-    if (!modelUsage[model]) {
-      modelUsage[model] = {
-        inputTokens: 0,
-        outputTokens: 0,
-        cacheReadInputTokens: 0,
-        cacheCreationInputTokens: 0,
-        totalCostUsd: 0
-      };
-    }
-    modelUsage[model].inputTokens += turnUsage.inputTokens;
-    modelUsage[model].outputTokens += turnUsage.outputTokens;
-    modelUsage[model].cacheReadInputTokens += turnUsage.cacheReadInputTokens;
-    modelUsage[model].cacheCreationInputTokens += turnUsage.cacheCreationInputTokens;
-    modelUsage[model].totalCostUsd += turnCost;
+    if (!modelUsage[activeModel]) {
+      modelUsage[activeModel] = makeModelUsageEntry();
+    }
+    modelUsage[activeModel].inputTokens += turnUsage.inputTokens;
+    modelUsage[activeModel].outputTokens += turnUsage.outputTokens;
+    modelUsage[activeModel].cacheReadInputTokens += turnUsage.cacheReadInputTokens;
+    modelUsage[activeModel].cacheCreationInputTokens += turnUsage.cacheCreationInputTokens;
+    modelUsage[activeModel].totalCostUsd += turnCost;
+    modelUsage[activeModel].webSearchRequests = (modelUsage[activeModel].webSearchRequests ?? 0) + (turnUsage.webSearchRequests ?? 0);
+    modelUsage[activeModel].costUSD = modelUsage[activeModel].totalCostUsd;
+    modelUsage[activeModel].contextWindow = provider.getContextWindow(activeModel);
     const assistantText = assistantTextParts.join("");
     const assistantContent = [];
     if (assistantText) {
@@ -630,28 +780,72 @@ async function* agentLoop(prompt, options) {
     if (sessionLogger) {
       sessionLogger("assistant", assistantContent, null);
     }
-    if (assistantText) {
-      yield { type: "text", text: assistantText, uuid: uuid() };
-    }
+    yield {
+      type: "assistant",
+      message: {
+        role: "assistant",
+        content: assistantContent
+      },
+      parent_tool_use_id: null,
+      uuid: uuid(),
+      session_id: sessionId
+    };
     if (toolCalls.length === 0) {
+      let structuredOutput;
+      if (outputFormat?.type === "json_schema") {
+        const parsed = extractStructuredJson(assistantText);
+        if (!parsed.ok) {
+          yield makeErrorResult({
+            subtype: "error_max_structured_output_retries",
+            errors: [parsed.error],
+            turns,
+            costUsd,
+            sessionId,
+            startTime,
+            apiTimeMs,
+            usage: totalUsage,
+            modelUsage,
+            permissionDenials
+          });
+          return;
+        }
+        structuredOutput = parsed.value;
+      }
       if (hooks) {
-        await hooks.fire("Stop", { event: "Stop", session_id: sessionId, text: assistantText || undefined }, undefined, { signal });
+        await hooks.fire("Stop", {
+          event: "Stop",
+          hook_event_name: "Stop",
+          session_id: sessionId,
+          text: assistantText || undefined,
+          stop_reason: turnStopReason ?? undefined
+        }, undefined, {
+          signal
+        });
       }
       if (hooks) {
-        await hooks.fire("SessionEnd", { event: "SessionEnd", session_id: sessionId }, undefined, { signal });
+        await hooks.fire("SessionEnd", {
+          event: "SessionEnd",
+          hook_event_name: "SessionEnd",
+          session_id: sessionId,
+          reason: "other"
+        }, undefined, { signal });
       }
       yield {
         type: "result",
         subtype: "success",
-        text: assistantText || null,
-        turns,
-        costUsd,
-        durationMs: Date.now() - startTime,
-        durationApiMs: apiTimeMs,
-        sessionId,
+        duration_ms: Date.now() - startTime,
+        duration_api_ms: apiTimeMs,
+        is_error: false,
+        num_turns: turns,
+        result: assistantText,
+        stop_reason: turnStopReason,
+        total_cost_usd: costUsd,
         usage: totalUsage,
         modelUsage,
-        uuid: uuid()
+        permission_denials: permissionDenials,
+        structured_output: structuredOutput,
+        uuid: uuid(),
+        session_id: sessionId
       };
       return;
     }
@@ -660,7 +854,13 @@ async function* agentLoop(prompt, options) {
       let hookDenied = false;
       let hookUpdatedInput;
       if (hooks) {
-        const hookResult = await hooks.fire("PreToolUse", { event: "PreToolUse", tool_name: call.name, tool_input: call.input, session_id: sessionId }, call.id, { signal });
+        const hookResult = await hooks.fire("PreToolUse", {
+          event: "PreToolUse",
+          hook_event_name: "PreToolUse",
+          tool_name: call.name,
+          tool_input: call.input,
+          session_id: sessionId
+        }, call.id, { signal });
         if (hookResult) {
           if (hookResult.permissionDecision === "deny") {
             hookDenied = true;
@@ -672,14 +872,6 @@ async function* agentLoop(prompt, options) {
       }
       if (hookDenied) {
         const denyContent = "Denied by hook";
-        yield {
-          type: "tool_result",
-          id: call.id,
-          name: call.name,
-          content: denyContent,
-          isError: true,
-          uuid: uuid()
-        };
         toolResults.push({
           type: "tool_result",
           tool_use_id: call.id,
@@ -695,14 +887,11 @@ async function* agentLoop(prompt, options) {
       const permResult = await permissions.check(call.name, inputAfterHook ?? {}, { signal, toolUseId: call.id });
       if (permResult.behavior === "deny") {
         const denyContent = `Permission denied: ${permResult.message}`;
-        yield {
-          type: "tool_result",
-          id: call.id,
-          name: call.name,
-          content: denyContent,
-          isError: true,
-          uuid: uuid()
-        };
+        permissionDenials.push({
+          tool_name: call.name,
+          tool_use_id: call.id,
+          tool_input: inputAfterHook ?? {}
+        });
         toolResults.push({
           type: "tool_result",
           tool_use_id: call.id,
@@ -715,13 +904,6 @@ async function* agentLoop(prompt, options) {
         continue;
       }
       const toolInput = permResult.behavior === "allow" && permResult.updatedInput ? permResult.updatedInput : inputAfterHook;
-      yield {
-        type: "tool_use",
-        id: call.id,
-        name: call.name,
-        input: toolInput,
-        uuid: uuid()
-      };
       let result;
       if (call.name === "memory" && nativeMemoryTool) {
         try {
@@ -740,28 +922,36 @@ async function* agentLoop(prompt, options) {
         };
         result = await tools.execute(call.name, toolInput, toolCtx);
       }
+      if (call.name === "ExitPlanMode") {
+        permissions.setMode("default");
+      }
       if (debug) {
         console.error(`[debug] Tool ${call.name}: ${result.isError ? "ERROR" : "OK"} (${result.content.length} chars)`);
       }
       if (hooks) {
         if (result.isError) {
-          await hooks.fire("PostToolUseFailure", { event: "PostToolUseFailure", tool_name: call.name, tool_result: result.content, tool_error: true, session_id: sessionId }, call.id, { signal });
+          await hooks.fire("PostToolUseFailure", {
+            event: "PostToolUseFailure",
+            hook_event_name: "PostToolUseFailure",
+            tool_name: call.name,
+            tool_result: result.content,
+            tool_error: true,
+            session_id: sessionId
+          }, call.id, { signal });
         } else {
-          const postResult = await hooks.fire("PostToolUse", { event: "PostToolUse", tool_name: call.name, tool_result: result.content, session_id: sessionId }, call.id, { signal });
+          const postResult = await hooks.fire("PostToolUse", {
+            event: "PostToolUse",
+            hook_event_name: "PostToolUse",
+            tool_name: call.name,
+            tool_result: result.content,
+            session_id: sessionId
+          }, call.id, { signal });
           if (postResult?.additionalContext) {
             result.content += `
 ${postResult.additionalContext}`;
           }
         }
       }
-      yield {
-        type: "tool_result",
-        id: call.id,
-        name: call.name,
-        content: result.content,
-        isError: result.isError,
-        uuid: uuid()
-      };
       toolResults.push({
         type: "tool_result",
         tool_use_id: call.id,
@@ -773,20 +963,19 @@ ${postResult.additionalContext}`;
     if (sessionLogger) {
       sessionLogger("user", toolResults, null);
     }
+    yield {
+      type: "user",
+      message: {
+        role: "user",
+        content: toolResults
+      },
+      parent_tool_use_id: null,
+      isSynthetic: true,
+      uuid: uuid(),
+      session_id: sessionId
+    };
   }
 }
-function makeError(subtype, errors, turns, costUsd, sessionId, startTime) {
-  return {
-    type: "result",
-    subtype,
-    errors,
-    turns,
-    costUsd,
-    durationMs: Date.now() - startTime,
-    sessionId,
-    uuid: uuid()
-  };
-}
 
 // src/utils/cost.ts
 var ANTHROPIC_PRICING = {
@@ -1043,6 +1232,44 @@ class AnthropicAdapter {
       max_tokens: maxTokens,
       stream: true
     };
+    if (request.thinking) {
+      switch (request.thinking.type) {
+        case "adaptive":
+          params.thinking = { type: "adaptive" };
+          break;
+        case "disabled":
+          params.thinking = { type: "disabled" };
+          break;
+        case "enabled":
+          params.thinking = {
+            type: "enabled",
+            budget_tokens: request.thinking.budgetTokens
+          };
+          break;
+      }
+    } else if (request.thinkingBudget !== undefined) {
+      if (request.thinkingBudget <= 0) {
+        params.thinking = { type: "disabled" };
+      } else {
+        params.thinking = {
+          type: "enabled",
+          budget_tokens: Math.max(1024, request.thinkingBudget)
+        };
+      }
+    }
+    const outputConfig = {};
+    if (request.effort) {
+      outputConfig.effort = request.effort;
+    }
+    if (request.outputFormat?.type === "json_schema") {
+      outputConfig.format = {
+        type: "json_schema",
+        schema: request.outputFormat.schema
+      };
+    }
+    if (Object.keys(outputConfig).length > 0) {
+      params.output_config = outputConfig;
+    }
     if (this.oauthMode) {
       const systemBlocks = [
         { type: "text", text: "You are Claude Code, Anthropic's official CLI for Claude." }
@@ -1167,11 +1394,12 @@ class AnthropicAdapter {
     switch (feature) {
       case "streaming":
       case "tool_calling":
-      case "image_input":
-      case "pdf_input":
       case "thinking":
       case "structured_output":
         return true;
+      case "image_input":
+      case "pdf_input":
+        return false;
       default:
         return false;
     }
@@ -1242,6 +1470,22 @@ var CODEX_MODELS = new Set([
   "gpt-5-codex",
   "gpt-5-codex-mini"
 ]);
+var OPENAI_MAX_TOOL_NAME = 64;
+function sanitizeToolName(name) {
+  const clean = name.replace(/[^a-zA-Z0-9_-]/g, "_");
+  if (clean.length <= OPENAI_MAX_TOOL_NAME)
+    return clean;
+  const hash = simpleHash(name);
+  return clean.slice(0, OPENAI_MAX_TOOL_NAME - 7) + "_" + hash;
+}
+function simpleHash(s) {
+  let h = 2166136261;
+  for (let i = 0;i < s.length; i++) {
+    h ^= s.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return (h >>> 0).toString(16).padStart(8, "0").slice(0, 6);
+}
 
 class OpenAIAdapter {
   name = "openai";
@@ -1249,6 +1493,7 @@ class OpenAIAdapter {
   codexMode;
   accountId;
   currentAccessToken;
+  toolNameMap = new Map;
   constructor(options) {
     const key = options?.apiKey ?? process.env.OPENAI_API_KEY;
     if (key) {
@@ -1281,6 +1526,15 @@ class OpenAIAdapter {
     }
   }
   async* chat(request) {
+    this.toolNameMap.clear();
+    if (request.tools) {
+      for (const tool of request.tools) {
+        const sanitized = sanitizeToolName(tool.name);
+        if (sanitized !== tool.name) {
+          this.toolNameMap.set(sanitized, tool.name);
+        }
+      }
+    }
     if (this.codexMode) {
       yield* this.chatResponses(request);
     } else {
@@ -1382,7 +1636,7 @@ class OpenAIAdapter {
       yield {
         type: "tool_call",
         id: buf.id,
-        name: buf.name,
+        name: this.resolveToolName(buf.name),
         input
       };
     }
@@ -1426,7 +1680,7 @@ class OpenAIAdapter {
             yield {
               type: "tool_call",
               id: item.call_id,
-              name: item.name,
+              name: this.resolveToolName(item.name),
               input: parsedInput
             };
           }
@@ -1493,7 +1747,7 @@ class OpenAIAdapter {
               id: block.id,
               type: "function",
               function: {
-                name: block.name,
+                name: sanitizeToolName(block.name),
                 arguments: JSON.stringify(block.input)
               }
             });
@@ -1558,7 +1812,7 @@ class OpenAIAdapter {
           result.push({
             type: "function_call",
             call_id: tu.id,
-            name: tu.name,
+            name: sanitizeToolName(tu.name),
             arguments: JSON.stringify(tu.input)
           });
         }
@@ -1590,7 +1844,7 @@ class OpenAIAdapter {
     return tools.map((tool) => ({
       type: "function",
       function: {
-        name: tool.name,
+        name: sanitizeToolName(tool.name),
         description: tool.description,
         parameters: tool.inputSchema
       }
@@ -1599,12 +1853,15 @@ class OpenAIAdapter {
   convertToolsForResponses(tools) {
     return tools.map((tool) => ({
       type: "function",
-      name: tool.name,
+      name: sanitizeToolName(tool.name),
       description: tool.description,
       parameters: tool.inputSchema,
       strict: false
     }));
   }
+  resolveToolName(name) {
+    return this.toolNameMap.get(name) ?? name;
+  }
   mapStopReason(reason) {
     switch (reason) {
       case "stop":
@@ -2086,6 +2343,16 @@ class ToolRegistry {
   register(tool) {
     this.tools.set(tool.name, tool);
   }
+  unregister(name) {
+    this.tools.delete(name);
+  }
+  clearByPrefix(prefix) {
+    for (const name of this.tools.keys()) {
+      if (name.startsWith(prefix)) {
+        this.tools.delete(name);
+      }
+    }
+  }
   get(name) {
     return this.tools.get(name);
   }
@@ -2119,16 +2386,34 @@ class ToolRegistry {
 // src/tools/presets.ts
 var PRESETS = {
   coding: ["Bash", "Read", "Write", "Edit", "Glob", "Grep"],
+  claude_code: [
+    "Bash",
+    "Read",
+    "Write",
+    "Edit",
+    "Glob",
+    "Grep",
+    "NotebookEdit",
+    "WebFetch",
+    "WebSearch",
+    "TodoWrite",
+    "Config",
+    "AskUserQuestion",
+    "ExitPlanMode"
+  ],
   readonly: ["Read", "Glob", "Grep"],
   minimal: ["Read", "Write", "Edit", "Glob", "Grep"]
 };
 function resolveToolNames(tools) {
   if (!tools)
-    return PRESETS.coding;
-  if (typeof tools === "string") {
-    return PRESETS[tools] ?? [tools];
+    return PRESETS.claude_code;
+  if (Array.isArray(tools)) {
+    return tools;
+  }
+  if (tools.type === "preset") {
+    return PRESETS[tools.preset] ?? PRESETS.claude_code;
   }
-  return tools;
+  throw new Error("Invalid tools option. Expected string[] or { type: 'preset', preset: 'claude_code' }.");
 }
 
 // src/tools/bash.ts
@@ -2152,17 +2437,58 @@ var BashTool = {
       timeout: {
         type: "number",
         description: "Timeout in milliseconds (max 600000)"
+      },
+      run_in_background: {
+        type: "boolean",
+        description: "Run command asynchronously and return immediately."
+      },
+      dangerouslyDisableSandbox: {
+        type: "boolean",
+        description: "If true, explicitly request unsandboxed execution."
+      },
+      _simulatedSedEdit: {
+        type: "object",
+        properties: {
+          filePath: { type: "string" },
+          newContent: { type: "string" }
+        },
+        description: "Internal field for precomputed edit previews."
       }
     },
     required: ["command"]
   },
   async execute(input, ctx) {
-    const { command, timeout: timeoutMs, description } = input;
+    const {
+      command,
+      timeout: timeoutMs,
+      run_in_background,
+      description,
+      dangerouslyDisableSandbox,
+      _simulatedSedEdit
+    } = input;
     if (!command || typeof command !== "string") {
       return { content: "Error: command is required", isError: true };
     }
     const timeout = Math.min(timeoutMs ?? DEFAULT_TIMEOUT, MAX_TIMEOUT);
     try {
+      if (run_in_background) {
+        const proc2 = Bun.spawn(["bash", "-c", command], {
+          cwd: ctx.cwd,
+          stdout: "ignore",
+          stderr: "ignore",
+          stdin: "ignore",
+          env: { ...process.env, ...ctx.env }
+        });
+        return {
+          content: `Background command started (pid ${proc2.pid ?? "unknown"}).`,
+          metadata: {
+            pid: proc2.pid ?? null,
+            run_in_background: true,
+            dangerouslyDisableSandbox: dangerouslyDisableSandbox === true,
+            hasSimulatedSedEdit: !!_simulatedSedEdit
+          }
+        };
+      }
       const proc = Bun.spawn(["bash", "-c", command], {
         cwd: ctx.cwd,
         stdout: "pipe",
@@ -2194,7 +2520,11 @@ var BashTool = {
       return {
         content: output,
         isError: exitCode !== 0 ? true : undefined,
-        metadata: { exitCode }
+        metadata: {
+          exitCode,
+          dangerouslyDisableSandbox: dangerouslyDisableSandbox === true,
+          hasSimulatedSedEdit: !!_simulatedSedEdit
+        }
       };
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
@@ -2223,12 +2553,17 @@ var ReadTool = {
       limit: {
         type: "number",
         description: "Number of lines to read"
+      },
+      pages: {
+        type: "array",
+        items: { type: "number" },
+        description: "Optional PDF page numbers (1-based)."
       }
     },
     required: ["file_path"]
   },
   async execute(input, ctx) {
-    const { file_path, offset, limit } = input;
+    const { file_path, offset, limit, pages } = input;
     if (!file_path) {
       return { content: "Error: file_path is required", isError: true };
     }
@@ -2239,6 +2574,12 @@ var ReadTool = {
       if (!exists) {
         return { content: `Error: File not found: ${resolvedPath}`, isError: true };
       }
+      if (Array.isArray(pages) && pages.length > 0 && resolvedPath.toLowerCase().endsWith(".pdf")) {
+        return {
+          content: "Error: PDF page extraction is not implemented in this runtime.",
+          isError: true
+        };
+      }
       const text = await file.text();
       const lines = text.split(`
 `);
@@ -2626,6 +2967,405 @@ async function collectFiles(dir, globPattern) {
   }
   return files;
 }
+
+// src/tools/notebook-edit.ts
+import { readFile, writeFile } from "fs/promises";
+function toSourceLines(text) {
+  const lines = text.split(`
+`);
+  return lines.map((line, idx) => idx < lines.length - 1 ? `${line}
+` : line);
+}
+var NotebookEditTool = {
+  name: "NotebookEdit",
+  description: "Edit a specific Jupyter notebook cell by id or index.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      notebook_path: { type: "string", description: "Path to .ipynb file." },
+      cell_id: { type: "string", description: "Cell id to edit." },
+      cell_index: { type: "number", description: "Cell index to edit if id is not provided." },
+      new_source: { type: "string", description: "New cell source content." }
+    },
+    required: ["notebook_path", "new_source"]
+  },
+  async execute(input, ctx) {
+    const {
+      notebook_path,
+      cell_id,
+      cell_index,
+      new_source
+    } = input ?? {};
+    if (!notebook_path)
+      return { content: "Error: notebook_path is required", isError: true };
+    if (new_source === undefined)
+      return { content: "Error: new_source is required", isError: true };
+    const filePath = notebook_path.startsWith("/") ? notebook_path : `${ctx.cwd}/${notebook_path}`;
+    try {
+      const raw = await readFile(filePath, "utf-8");
+      const notebook = JSON.parse(raw);
+      if (!Array.isArray(notebook.cells)) {
+        return { content: "Error: notebook has no cells array", isError: true };
+      }
+      let targetIndex = -1;
+      if (cell_id) {
+        targetIndex = notebook.cells.findIndex((c) => c.id === cell_id);
+      } else if (typeof cell_index === "number") {
+        targetIndex = cell_index;
+      } else {
+        targetIndex = 0;
+      }
+      if (targetIndex < 0 || targetIndex >= notebook.cells.length) {
+        return {
+          content: `Error: cell not found (id=${cell_id ?? "n/a"}, index=${String(cell_index ?? "n/a")})`,
+          isError: true
+        };
+      }
+      const cell = notebook.cells[targetIndex];
+      cell.source = toSourceLines(new_source);
+      await writeFile(filePath, JSON.stringify(notebook, null, 2) + `
+`, "utf-8");
+      return {
+        content: `Updated notebook cell ${targetIndex} in ${filePath}`
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { content: `Error editing notebook: ${message}`, isError: true };
+    }
+  }
+};
+
+// src/tools/web-fetch.ts
+var DEFAULT_TIMEOUT_MS = 20000;
+var MAX_OUTPUT = 80000;
+var WebFetchTool = {
+  name: "WebFetch",
+  description: "Fetches a URL and returns response text.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      url: {
+        type: "string",
+        description: "The URL to fetch."
+      },
+      prompt: {
+        type: "string",
+        description: "Optional fetch intent/instructions."
+      },
+      timeout_ms: {
+        type: "number",
+        description: "Timeout in milliseconds (default 20000)."
+      },
+      max_length: {
+        type: "number",
+        description: "Maximum output length (default 80000)."
+      }
+    },
+    required: ["url"]
+  },
+  async execute(input) {
+    const { url, timeout_ms, max_length } = input ?? {};
+    if (!url)
+      return { content: "Error: url is required", isError: true };
+    const timeout = Math.max(1000, timeout_ms ?? DEFAULT_TIMEOUT_MS);
+    const outLimit = Math.max(1000, max_length ?? MAX_OUTPUT);
+    const controller = new AbortController;
+    const timer = setTimeout(() => controller.abort(), timeout);
+    try {
+      const res = await fetch(url, {
+        method: "GET",
+        signal: controller.signal,
+        headers: {
+          "user-agent": "fourmis-agent-sdk/1.0"
+        }
+      });
+      const contentType = res.headers.get("content-type") ?? "unknown";
+      let body = await res.text();
+      if (body.length > outLimit) {
+        body = body.slice(0, outLimit) + `
+... (truncated)`;
+      }
+      return {
+        content: [
+          `Status: ${res.status} ${res.statusText}`,
+          `Content-Type: ${contentType}`,
+          "",
+          body
+        ].join(`
+`),
+        isError: res.ok ? undefined : true
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { content: `Error fetching URL: ${message}`, isError: true };
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+};
+
+// src/tools/web-search.ts
+var SEARCH_ENDPOINT = "https://duckduckgo.com/html/";
+function stripTags(input) {
+  return input.replace(/<[^>]+>/g, "").replace(/&amp;/g, "&").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&lt;/g, "<").replace(/&gt;/g, ">").trim();
+}
+var WebSearchTool = {
+  name: "WebSearch",
+  description: "Searches the web and returns top result links.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      query: {
+        type: "string",
+        description: "Search query."
+      },
+      max_results: {
+        type: "number",
+        description: "Maximum results to return (default 5)."
+      }
+    },
+    required: ["query"]
+  },
+  async execute(input) {
+    const { query, max_results } = input ?? {};
+    if (!query) {
+      return { content: "Error: query is required", isError: true };
+    }
+    const limit = Math.max(1, Math.min(20, max_results ?? 5));
+    try {
+      const url = `${SEARCH_ENDPOINT}?q=${encodeURIComponent(query)}`;
+      const res = await fetch(url, {
+        headers: {
+          "user-agent": "fourmis-agent-sdk/1.0"
+        }
+      });
+      if (!res.ok) {
+        return {
+          content: `Error searching web: ${res.status} ${res.statusText}`,
+          isError: true
+        };
+      }
+      const html = await res.text();
+      const matches = [...html.matchAll(/<a[^>]*class="result__a"[^>]*href="([^"]+)"[^>]*>([\s\S]*?)<\/a>/g)];
+      if (matches.length === 0) {
+        return { content: "No search results found." };
+      }
+      const lines = [];
+      for (let i = 0;i < Math.min(limit, matches.length); i++) {
+        const href = stripTags(matches[i][1]);
+        const title = stripTags(matches[i][2]);
+        lines.push(`${i + 1}. ${title}
+   ${href}`);
+      }
+      return { content: lines.join(`
+`) };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { content: `Error searching web: ${message}`, isError: true };
+    }
+  }
+};
+
+// src/tools/ask-user-question.ts
+var AskUserQuestionTool = {
+  name: "AskUserQuestion",
+  description: "Ask the user a clarifying question and wait for their response.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      question: {
+        type: "string",
+        description: "Question to ask the user."
+      },
+      options: {
+        type: "array",
+        items: { type: "string" },
+        description: "Optional fixed choices."
+      }
+    },
+    required: ["question"]
+  },
+  async execute(input) {
+    const { question, options } = input ?? {};
+    if (!question) {
+      return { content: "Error: question is required", isError: true };
+    }
+    const choices = Array.isArray(options) && options.length > 0 ? ` Choices: ${options.join(" | ")}` : "";
+    return {
+      content: `User interaction is not available in this runtime. Unanswered question: ${question}.${choices}`,
+      isError: true
+    };
+  }
+};
+
+// src/tools/todo-write.ts
+import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
+import { dirname as dirname2, join as join3 } from "path";
+var TodoWriteTool = {
+  name: "TodoWrite",
+  description: "Write/update task todo items for the current session.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      todos: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            content: { type: "string" },
+            status: { type: "string", enum: ["pending", "in_progress", "completed"] },
+            activeForm: { type: "string" }
+          },
+          required: ["content", "status"]
+        }
+      }
+    },
+    required: ["todos"]
+  },
+  async execute(input, ctx) {
+    const { todos } = input ?? {};
+    if (!Array.isArray(todos)) {
+      return { content: "Error: todos must be an array", isError: true };
+    }
+    for (const todo of todos) {
+      if (!todo?.content || !todo?.status) {
+        return { content: "Error: each todo requires content and status", isError: true };
+      }
+    }
+    const filePath = join3(ctx.cwd, ".claude", "todos.json");
+    try {
+      await mkdir2(dirname2(filePath), { recursive: true });
+      const payload = {
+        updatedAt: new Date().toISOString(),
+        todos
+      };
+      await writeFile2(filePath, JSON.stringify(payload, null, 2) + `
+`, "utf-8");
+      return {
+        content: `Saved ${todos.length} todo item(s) to ${filePath}`
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { content: `Error writing todos: ${message}`, isError: true };
+    }
+  }
+};
+
+// src/tools/config.ts
+import { mkdir as mkdir3, readFile as readFile2, writeFile as writeFile3 } from "fs/promises";
+import { join as join4, dirname as dirname3 } from "path";
+function scopePath(cwd, scope) {
+  if (scope === "project")
+    return join4(cwd, ".claude", "settings.json");
+  return join4(cwd, ".claude", "settings.local.json");
+}
+function setByPath(obj, keyPath, value) {
+  const keys = keyPath.split(".").filter(Boolean);
+  if (keys.length === 0)
+    return;
+  let current = obj;
+  for (let i = 0;i < keys.length - 1; i++) {
+    const key = keys[i];
+    const next = current[key];
+    if (!next || typeof next !== "object" || Array.isArray(next)) {
+      current[key] = {};
+    }
+    current = current[key];
+  }
+  current[keys[keys.length - 1]] = value;
+}
+function getByPath(obj, keyPath) {
+  const keys = keyPath.split(".").filter(Boolean);
+  let current = obj;
+  for (const key of keys) {
+    if (!current || typeof current !== "object" || Array.isArray(current))
+      return;
+    current = current[key];
+  }
+  return current;
+}
+var ConfigTool = {
+  name: "Config",
+  description: "Read or update .claude settings values.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      action: {
+        type: "string",
+        enum: ["get", "set", "list"]
+      },
+      key: {
+        type: "string",
+        description: "Dot-path key (for get/set)."
+      },
+      value: {
+        description: "Value for set action."
+      },
+      scope: {
+        type: "string",
+        enum: ["local", "project"]
+      }
+    },
+    required: ["action"]
+  },
+  async execute(input, ctx) {
+    const {
+      action,
+      key,
+      value,
+      scope = "local"
+    } = input ?? {};
+    if (!action) {
+      return { content: "Error: action is required", isError: true };
+    }
+    const filePath = scopePath(ctx.cwd, scope);
+    let data = {};
+    try {
+      const raw = await readFile2(filePath, "utf-8");
+      data = JSON.parse(raw);
+    } catch {
+      data = {};
+    }
+    if (action === "list") {
+      return { content: JSON.stringify(data, null, 2) };
+    }
+    if (!key) {
+      return { content: "Error: key is required for get/set", isError: true };
+    }
+    if (action === "get") {
+      const out = getByPath(data, key);
+      return { content: out === undefined ? "undefined" : JSON.stringify(out, null, 2) };
+    }
+    setByPath(data, key, value);
+    try {
+      await mkdir3(dirname3(filePath), { recursive: true });
+      await writeFile3(filePath, JSON.stringify(data, null, 2) + `
+`, "utf-8");
+      return { content: `Updated ${key} in ${filePath}` };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { content: `Error writing config: ${message}`, isError: true };
+    }
+  }
+};
+
+// src/tools/exit-plan-mode.ts
+var ExitPlanModeTool = {
+  name: "ExitPlanMode",
+  description: "Exit plan mode and resume normal execution permissions.",
+  inputSchema: {
+    type: "object",
+    properties: {}
+  },
+  async execute() {
+    return {
+      content: "Exiting plan mode.",
+      metadata: {
+        setPermissionMode: "default"
+      }
+    };
+  }
+};
 // src/tools/index.ts
 var ALL_TOOLS = {
   Bash: BashTool,
@@ -2633,7 +3373,14 @@ var ALL_TOOLS = {
   Write: WriteTool,
   Edit: EditTool,
   Glob: GlobTool,
-  Grep: GrepTool
+  Grep: GrepTool,
+  NotebookEdit: NotebookEditTool,
+  WebFetch: WebFetchTool,
+  WebSearch: WebSearchTool,
+  AskUserQuestion: AskUserQuestionTool,
+  TodoWrite: TodoWriteTool,
+  Config: ConfigTool,
+  ExitPlanMode: ExitPlanModeTool
 };
 function buildToolRegistry(toolNames, allowedTools, disallowedTools) {
   const registry = new ToolRegistry;
@@ -2648,6 +3395,156 @@ function buildToolRegistry(toolNames, allowedTools, disallowedTools) {
   return registry;
 }
 
+// src/utils/session-store.ts
+import { readFileSync as readFileSync3, appendFileSync, mkdirSync as mkdirSync2, readdirSync, statSync } from "fs";
+import { join as join5 } from "path";
+import { homedir as homedir3 } from "os";
+function safeStringify(value) {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function sanitizeCwd(cwd) {
+  return cwd.replace(/[/.]/g, "-");
+}
+function sessionsDir(cwd) {
+  return join5(homedir3(), ".claude", "projects", sanitizeCwd(cwd));
+}
+function ensureDir(dir) {
+  mkdirSync2(dir, { recursive: true });
+}
+function logMessage(dir, sessionId, entry) {
+  ensureDir(dir);
+  const filePath = join5(dir, `${sessionId}.jsonl`);
+  appendFileSync(filePath, JSON.stringify(entry) + `
+`);
+}
+function createSessionLogger(cwd, sessionId, model) {
+  const dir = sessionsDir(cwd);
+  let lastUuid = null;
+  return (role, content, parentUuid) => {
+    const entryUuid = uuid();
+    let normalizedContent = content;
+    if (role === "user" && typeof content === "string") {
+      normalizedContent = [{ type: "text", text: content }];
+    }
+    const entry = {
+      type: role,
+      uuid: entryUuid,
+      parentUuid: parentUuid ?? lastUuid,
+      sessionId,
+      timestamp: new Date().toISOString(),
+      cwd,
+      isSidechain: false,
+      userType: "external",
+      message: {
+        role,
+        content: normalizedContent,
+        ...role === "assistant" && model ? { model } : {}
+      },
+      ...role === "user" ? { permissionMode: "default" } : {}
+    };
+    logMessage(dir, sessionId, entry);
+    lastUuid = entryUuid;
+    return entryUuid;
+  };
+}
+function findLatestSession(cwd) {
+  const dir = sessionsDir(cwd);
+  try {
+    const files = readdirSync(dir).filter((f) => f.endsWith(".jsonl")).map((f) => {
+      const filePath = join5(dir, f);
+      try {
+        return { name: f, mtime: statSync(filePath).mtimeMs };
+      } catch {
+        return null;
+      }
+    }).filter((f) => f !== null).sort((a, b) => b.mtime - a.mtime);
+    if (files.length === 0)
+      return null;
+    return files[0].name.replace(/\.jsonl$/, "");
+  } catch {
+    return null;
+  }
+}
+function loadSessionMessages(cwd, sessionId, resumeSessionAt) {
+  const dir = sessionsDir(cwd);
+  const filePath = join5(dir, `${sessionId}.jsonl`);
+  let lines;
+  try {
+    lines = readFileSync3(filePath, "utf-8").trim().split(`
+`).filter(Boolean);
+  } catch {
+    return [];
+  }
+  const messages = [];
+  let reachedResumePoint = false;
+  for (const line of lines) {
+    if (resumeSessionAt && reachedResumePoint)
+      break;
+    try {
+      const entry = JSON.parse(line);
+      if (entry.type !== "user" && entry.type !== "assistant")
+        continue;
+      if (entry.isMeta === true)
+        continue;
+      const message = entry.message;
+      if (!message)
+        continue;
+      const role = entry.type === "user" ? "user" : "assistant";
+      let content;
+      if (typeof message.content === "string") {
+        content = message.content;
+      } else if (Array.isArray(message.content)) {
+        const normalizedBlocks = [];
+        for (const c of message.content) {
+          if (!c || typeof c !== "object")
+            continue;
+          const block = c;
+          if (typeof block.type !== "string")
+            continue;
+          if (block.type === "text" && typeof block.text === "string") {
+            normalizedBlocks.push({ type: "text", text: block.text });
+            continue;
+          }
+          if (block.type === "tool_use" && typeof block.id === "string" && typeof block.name === "string") {
+            normalizedBlocks.push({
+              type: "tool_use",
+              id: block.id,
+              name: block.name,
+              input: block.input ?? {}
+            });
+            continue;
+          }
+          if (block.type === "tool_result" && typeof block.tool_use_id === "string") {
+            normalizedBlocks.push({
+              type: "tool_result",
+              tool_use_id: block.tool_use_id,
+              content: typeof block.content === "string" ? block.content : safeStringify(block.content),
+              is_error: typeof block.is_error === "boolean" ? block.is_error : undefined
+            });
+            continue;
+          }
+          normalizedBlocks.push({
+            type: "text",
+            text: `[session:${block.type}] ${safeStringify(block)}`
+          });
+        }
+        content = normalizedBlocks;
+      } else {
+        continue;
+      }
+      messages.push({ role, content });
+      if (resumeSessionAt && entry.uuid === resumeSessionAt) {
+        reachedResumePoint = true;
+      }
+    } catch {}
+  }
+  return messages;
+}
+
 // src/agents/tools.ts
 function createTaskTool(ctx) {
   return {
@@ -2668,6 +3565,15 @@ function createTaskTool(ctx) {
           type: "string",
           description: "The type of agent to use. Must match a registered agent definition."
         },
+        model: {
+          type: "string",
+          enum: ["sonnet", "opus", "haiku"],
+          description: "Optional model family hint for this subagent."
+        },
+        resume: {
+          type: "string",
+          description: "Optional session ID to resume this subagent from."
+        },
         run_in_background: {
           type: "boolean",
           description: "If true, run the task in the background and return a task ID."
@@ -2675,16 +3581,35 @@ function createTaskTool(ctx) {
         max_turns: {
           type: "number",
           description: "Maximum number of turns for the subagent."
+        },
+        name: {
+          type: "string",
+          description: "Optional display name for the spawned subagent."
+        },
+        team_name: {
+          type: "string",
+          description: "Optional team name context for this subagent."
+        },
+        mode: {
+          type: "string",
+          enum: ["acceptEdits", "bypassPermissions", "default", "delegate", "dontAsk", "plan"],
+          description: "Permission mode hint for the spawned subagent."
         }
       },
-      required: ["prompt", "subagent_type"]
+      required: ["description", "prompt", "subagent_type"]
     },
     async execute(input, toolCtx) {
       const {
+        description,
         prompt,
         subagent_type,
+        model: requestedModel,
+        resume,
         run_in_background,
-        max_turns
+        max_turns,
+        name,
+        team_name,
+        mode
       } = input;
       const agentDef = ctx.agents[subagent_type];
       if (!agentDef) {
@@ -2698,28 +3623,53 @@ function createTaskTool(ctx) {
         await ctx.parentHooks.fire("SubagentStart", { event: "SubagentStart", agent_type: subagent_type, session_id: toolCtx.sessionId }, undefined, { signal: toolCtx.signal });
       }
       const provider = agentDef.provider ? getProvider(agentDef.provider) : ctx.parentProvider;
-      const model = agentDef.model ?? ctx.parentModel;
-      let subTools;
-      if (agentDef.tools) {
-        subTools = buildToolRegistry(agentDef.tools);
-      } else {
-        subTools = buildToolRegistry(resolveToolNames("coding"));
-      }
+      const modelAliases = {
+        sonnet: "claude-sonnet-4-5-20250929",
+        opus: "claude-opus-4-5-20251101",
+        haiku: "claude-haiku-4-5-20251001"
+      };
+      const model = requestedModel ? modelAliases[requestedModel] : agentDef.model ?? ctx.parentModel;
+      const baseTools = agentDef.tools ?? resolveToolNames({ type: "preset", preset: "claude_code" });
+      const subTools = buildToolRegistry(baseTools, undefined, agentDef.disallowedTools);
       const maxTurns = max_turns ?? agentDef.maxTurns ?? 10;
-      const sessionId = uuid();
+      const sessionId = resume ?? uuid();
+      const previousMessages = resume ? loadSessionMessages(ctx.parentCwd, resume) : undefined;
       const abortController = new AbortController;
       if (toolCtx.signal) {
         toolCtx.signal.addEventListener("abort", () => abortController.abort(), { once: true });
       }
-      const systemPrompt = `${agentDef.prompt}
+      const systemPromptParts = [
+        agentDef.prompt,
+        `You are a subagent of type "${subagent_type}". ${agentDef.description}`,
+        `Task summary: ${description}`
+      ];
+      if (agentDef.criticalSystemReminder_EXPERIMENTAL) {
+        systemPromptParts.push(`Critical reminder: ${agentDef.criticalSystemReminder_EXPERIMENTAL}`);
+      }
+      if (agentDef.skills && agentDef.skills.length > 0) {
+        systemPromptParts.push(`Available skills:
+${agentDef.skills.map((s) => `- ${s}`).join(`
+`)}`);
+      }
+      if (name) {
+        systemPromptParts.push(`Subagent name: ${name}`);
+      }
+      if (team_name) {
+        systemPromptParts.push(`Team context: ${team_name}`);
+      }
+      if (mode) {
+        systemPromptParts.push(`Permission mode hint: ${mode}`);
+      }
+      const systemPrompt = systemPromptParts.join(`
 
-You are a subagent of type "${subagent_type}". ${agentDef.description}`;
+`);
       const runAgent = async () => {
         const messages = [];
         let resultText = "";
         for await (const msg of agentLoop(prompt, {
           provider,
           model,
+          modelState: { current: model },
           systemPrompt,
           tools: subTools,
           permissions: ctx.parentPermissions,
@@ -2727,18 +3677,23 @@ You are a subagent of type "${subagent_type}". ${agentDef.description}`;
           sessionId,
           maxTurns,
           maxBudgetUsd: 5,
-          includeStreamEvents: false,
+          includePartialMessages: false,
           signal: abortController.signal,
           env: ctx.parentEnv,
           debug: ctx.parentDebug,
-          hooks: ctx.parentHooks
+          hooks: ctx.parentHooks,
+          previousMessages
         })) {
           messages.push(msg);
-          if (msg.type === "text") {
-            resultText += msg.text;
+          if (msg.type === "assistant") {
+            for (const block of msg.message.content) {
+              if (block.type === "text") {
+                resultText += block.text;
+              }
+            }
           }
           if (msg.type === "result" && msg.subtype === "success") {
-            resultText = msg.text ?? resultText;
+            resultText = msg.result || resultText;
           }
         }
         return resultText || "Subagent completed with no text output.";