fourmis-agents-sdk 0.3.1 → 0.4.1

package/dist/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;
   }
-  return tools;
+  if (tools.type === "preset") {
+    return PRESETS[tools.preset] ?? PRESETS.claude_code;
+  }
+  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,112 +2967,522 @@ async function collectFiles(dir, globPattern) {
   }
   return files;
 }
-// src/tools/index.ts
-var ALL_TOOLS = {
-  Bash: BashTool,
-  Read: ReadTool,
-  Write: WriteTool,
-  Edit: EditTool,
-  Glob: GlobTool,
-  Grep: GrepTool
-};
-function buildToolRegistry(toolNames, allowedTools, disallowedTools) {
-  const registry = new ToolRegistry;
-  for (const name of toolNames) {
-    if (disallowedTools?.includes(name))
-      continue;
-    const tool = ALL_TOOLS[name];
-    if (tool) {
-      registry.register(tool);
-    }
-  }
-  return registry;
-}
 
-// src/permissions.ts
-var SAFE_TOOLS = new Set(["Read", "Glob", "Grep"]);
-var EDIT_TOOLS = new Set(["Write", "Edit"]);
-var FS_COMMANDS = ["mkdir", "touch", "rm", "mv", "cp"];
-var DELEGATE_TOOLS = new Set(["Teammate", "Task", "TaskOutput", "TaskStop"]);
-function normalizeRules(rules) {
-  if (!rules)
-    return [];
-  return rules.map((r) => typeof r === "string" ? { toolName: r } : r);
-}
-function matchesRule(rules, toolName, input) {
-  for (const rule of rules) {
-    if (rule.toolName !== toolName)
-      continue;
-    if (!rule.ruleContent)
-      return true;
-    const inputStr = toolName === "Bash" ? String(input?.command ?? "") : JSON.stringify(input ?? {});
-    if (inputStr.includes(rule.ruleContent))
-      return true;
-  }
-  return false;
+// 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);
 }
-
-class PermissionManager {
-  mode;
-  canUseTool;
-  allowRules;
-  denyRules;
-  settingsManager;
-  constructor(mode = "default", canUseTool, permissions, settingsManager) {
-    this.mode = mode;
-    this.canUseTool = canUseTool;
-    this.allowRules = normalizeRules(permissions?.allow);
-    this.denyRules = normalizeRules(permissions?.deny);
-    this.settingsManager = settingsManager;
-  }
-  async check(toolName, input, options) {
-    if (this.mode === "bypassPermissions") {
-      return { behavior: "allow" };
-    }
-    if (matchesRule(this.denyRules, toolName, input)) {
-      return {
-        behavior: "deny",
-        message: `Tool "${toolName}" is denied by permissions config.`
-      };
-    }
-    if (this.mode === "plan") {
-      if (!SAFE_TOOLS.has(toolName)) {
-        return {
-          behavior: "deny",
-          message: `Tool "${toolName}" is not allowed in plan mode. Only read-only tools are available.`
-        };
+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 };
       }
-      return { behavior: "allow" };
-    }
-    if (this.mode === "delegate") {
-      if (!DELEGATE_TOOLS.has(toolName) && !SAFE_TOOLS.has(toolName)) {
+      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 {
-          behavior: "deny",
-          message: `Tool "${toolName}" is not allowed in delegate mode. Only Teammate, Task, and read-only tools are available.`
+          content: `Error: cell not found (id=${cell_id ?? "n/a"}, index=${String(cell_index ?? "n/a")})`,
+          isError: true
         };
       }
-      return { behavior: "allow" };
-    }
-    if (matchesRule(this.allowRules, toolName, input)) {
-      return { behavior: "allow" };
-    }
-    if (SAFE_TOOLS.has(toolName)) {
-      return { behavior: "allow" };
-    }
-    if (this.mode === "acceptEdits") {
-      if (EDIT_TOOLS.has(toolName)) {
-        return { behavior: "allow" };
-      }
-      if (toolName === "Bash") {
-        const cmd = String(input?.command ?? "").trimStart();
-        if (FS_COMMANDS.some((fc) => cmd.startsWith(fc + " ") || cmd === fc)) {
-          return { behavior: "allow" };
-        }
-      }
+      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 };
     }
-    if (this.canUseTool) {
-      const result = await this.canUseTool(toolName, input, options);
-      if (result.behavior === "allow" && result.updatedPermissions) {
+  }
+};
+
+// 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,
+  Read: ReadTool,
+  Write: WriteTool,
+  Edit: EditTool,
+  Glob: GlobTool,
+  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;
+  for (const name of toolNames) {
+    if (disallowedTools?.includes(name))
+      continue;
+    const tool = ALL_TOOLS[name];
+    if (tool) {
+      registry.register(tool);
+    }
+  }
+  return registry;
+}
+
+// src/permissions.ts
+var SAFE_TOOLS = new Set(["Read", "Glob", "Grep", "WebFetch", "WebSearch"]);
+var EDIT_TOOLS = new Set(["Write", "Edit", "NotebookEdit", "TodoWrite", "Config"]);
+var FS_COMMANDS = ["mkdir", "touch", "rm", "mv", "cp"];
+var DELEGATE_TOOLS = new Set(["Teammate", "Task", "TaskOutput", "TaskStop"]);
+function normalizeRules(rules) {
+  if (!rules)
+    return [];
+  return rules.map((r) => typeof r === "string" ? { toolName: r } : r);
+}
+function matchesRule(rules, toolName, input) {
+  for (const rule of rules) {
+    if (rule.toolName !== toolName)
+      continue;
+    if (!rule.ruleContent)
+      return true;
+    const inputStr = toolName === "Bash" ? String(input?.command ?? "") : JSON.stringify(input ?? {});
+    if (inputStr.includes(rule.ruleContent))
+      return true;
+  }
+  return false;
+}
+
+class PermissionManager {
+  mode;
+  canUseTool;
+  allowRules;
+  denyRules;
+  settingsManager;
+  constructor(mode = "default", canUseTool, permissions, settingsManager) {
+    this.mode = mode;
+    this.canUseTool = canUseTool;
+    this.allowRules = normalizeRules(permissions?.allow);
+    this.denyRules = normalizeRules(permissions?.deny);
+    this.settingsManager = settingsManager;
+  }
+  async check(toolName, input, options) {
+    if (this.mode === "bypassPermissions") {
+      return { behavior: "allow" };
+    }
+    if (matchesRule(this.denyRules, toolName, input)) {
+      return {
+        behavior: "deny",
+        message: `Tool "${toolName}" is denied by permissions config.`
+      };
+    }
+    if (this.mode === "plan") {
+      if (!SAFE_TOOLS.has(toolName)) {
+        return {
+          behavior: "deny",
+          message: `Tool "${toolName}" is not allowed in plan mode. Only read-only tools are available.`
+        };
+      }
+      return { behavior: "allow" };
+    }
+    if (this.mode === "delegate") {
+      if (!DELEGATE_TOOLS.has(toolName) && !SAFE_TOOLS.has(toolName)) {
+        return {
+          behavior: "deny",
+          message: `Tool "${toolName}" is not allowed in delegate mode. Only Teammate, Task, and read-only tools are available.`
+        };
+      }
+      return { behavior: "allow" };
+    }
+    if (matchesRule(this.allowRules, toolName, input)) {
+      return { behavior: "allow" };
+    }
+    if (SAFE_TOOLS.has(toolName)) {
+      return { behavior: "allow" };
+    }
+    if (this.mode === "acceptEdits") {
+      if (EDIT_TOOLS.has(toolName)) {
+        return { behavior: "allow" };
+      }
+      if (toolName === "Bash") {
+        const cmd = String(input?.command ?? "").trimStart();
+        if (FS_COMMANDS.some((fc) => cmd.startsWith(fc + " ") || cmd === fc)) {
+          return { behavior: "allow" };
+        }
+      }
+    }
+    if (this.canUseTool) {
+      const result = await this.canUseTool(toolName, input, {
+        ...options,
+        toolUseID: options.toolUseId,
+        agentID: options.agentId
+      });
+      if (result.behavior === "allow" && result.updatedPermissions) {
         this.applyPermissionUpdates(result.updatedPermissions);
       }
       return result;
@@ -2791,7 +3542,7 @@ class PermissionManager {
 
 // src/settings.ts
 import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
-import { dirname as dirname2, join as join3 } from "path";
+import { dirname as dirname4, join as join5 } from "path";
 import { homedir as homedir3 } from "os";
 
 class SettingsManager {
@@ -2869,7 +3620,7 @@ class SettingsManager {
       default:
         return;
     }
-    const dir = dirname2(path);
+    const dir = dirname4(path);
     if (!existsSync3(dir))
       mkdirSync2(dir, { recursive: true });
     writeFileSync3(path, JSON.stringify(data, null, 2) + `
@@ -2878,21 +3629,21 @@ class SettingsManager {
   sourceToPath(source) {
     switch (source) {
       case "user":
-        return join3(homedir3(), ".claude", "settings.json");
+        return join5(homedir3(), ".claude", "settings.json");
       case "project":
-        return join3(this.cwd, ".claude", "settings.json");
+        return join5(this.cwd, ".claude", "settings.json");
       case "local":
-        return join3(this.cwd, ".claude", "settings.local.json");
+        return join5(this.cwd, ".claude", "settings.local.json");
     }
   }
   destinationToPath(destination) {
     switch (destination) {
       case "userSettings":
-        return join3(homedir3(), ".claude", "settings.json");
+        return join5(homedir3(), ".claude", "settings.json");
       case "projectSettings":
-        return join3(this.cwd, ".claude", "settings.json");
+        return join5(this.cwd, ".claude", "settings.json");
       case "localSettings":
-        return join3(this.cwd, ".claude", "settings.local.json");
+        return join5(this.cwd, ".claude", "settings.local.json");
       default:
         return null;
     }
@@ -2953,9 +3704,10 @@ function stripFrontmatter(content) {
 // src/skills/skills.ts
 import { existsSync as existsSync4, readdirSync, readFileSync as readFileSync4, realpathSync, statSync } from "fs";
 import { homedir as homedir4 } from "os";
-import { basename, dirname as dirname3, isAbsolute, join as join4, resolve } from "path";
+import { basename, dirname as dirname5, isAbsolute, join as join6, resolve } from "path";
 var MAX_NAME_LENGTH = 64;
 var MAX_DESCRIPTION_LENGTH = 1024;
+var MAX_COMPATIBILITY_LENGTH = 500;
 var CONFIG_DIR_NAME = ".claude";
 function shouldIgnore(name) {
   return name.startsWith(".") || name === "node_modules";
@@ -2988,6 +3740,14 @@ function validateDescription(description) {
   }
   return errors;
 }
+function validateCompatibility(compatibility) {
+  if (!compatibility)
+    return [];
+  if (compatibility.length > MAX_COMPATIBILITY_LENGTH) {
+    return [`compatibility exceeds ${MAX_COMPATIBILITY_LENGTH} characters (${compatibility.length})`];
+  }
+  return [];
+}
 function loadSkillsFromDir(options) {
   return loadSkillsFromDirInternal(options.dir, options.source, true);
 }
@@ -3003,7 +3763,7 @@ function loadSkillsFromDirInternal(dir, source, includeRootFiles) {
       if (shouldIgnore(entry.name)) {
         continue;
       }
-      const fullPath = join4(dir, entry.name);
+      const fullPath = join6(dir, entry.name);
       let isDirectory = entry.isDirectory();
       let isFile = entry.isFile();
       if (entry.isSymbolicLink()) {
@@ -3041,7 +3801,7 @@ function loadSkillFromFile(filePath, source) {
   try {
     const rawContent = readFileSync4(filePath, "utf-8");
     const { frontmatter } = parseFrontmatter(rawContent);
-    const skillDir = dirname3(filePath);
+    const skillDir = dirname5(filePath);
     const parentDirName = basename(skillDir);
     const descErrors = validateDescription(frontmatter.description);
     for (const error of descErrors) {
@@ -3052,9 +3812,15 @@ function loadSkillFromFile(filePath, source) {
     for (const error of nameErrors) {
       diagnostics.push({ type: "warning", message: error, path: filePath });
     }
+    const compatErrors = validateCompatibility(frontmatter.compatibility);
+    for (const error of compatErrors) {
+      diagnostics.push({ type: "warning", message: error, path: filePath });
+    }
     if (!frontmatter.description || frontmatter.description.trim() === "") {
       return { skill: null, diagnostics };
     }
+    const allowedToolsRaw = frontmatter["allowed-tools"];
+    const allowedTools = allowedToolsRaw ? allowedToolsRaw.split(/\s+/).filter(Boolean) : undefined;
     return {
       skill: {
         name,
@@ -3062,7 +3828,11 @@ function loadSkillFromFile(filePath, source) {
         filePath,
         baseDir: skillDir,
         source,
-        disableModelInvocation: frontmatter["disable-model-invocation"] === true
+        disableModelInvocation: frontmatter["disable-model-invocation"] === true,
+        license: frontmatter.license,
+        compatibility: frontmatter.compatibility,
+        metadata: frontmatter.metadata,
+        allowedTools
       },
       diagnostics
     };
@@ -3077,9 +3847,9 @@ function normalizePath(input) {
   if (trimmed === "~")
     return homedir4();
   if (trimmed.startsWith("~/"))
-    return join4(homedir4(), trimmed.slice(2));
+    return join6(homedir4(), trimmed.slice(2));
   if (trimmed.startsWith("~"))
-    return join4(homedir4(), trimmed.slice(1));
+    return join6(homedir4(), trimmed.slice(1));
   return trimmed;
 }
 function resolveSkillPath(p, cwd) {
@@ -3123,7 +3893,7 @@ function loadSkills(options = {}) {
     }
   }
   if (includeDefaults) {
-    const userSkillsDir = join4(homedir4(), CONFIG_DIR_NAME, "skills");
+    const userSkillsDir = join6(homedir4(), CONFIG_DIR_NAME, "skills");
     const projectSkillsDir = resolve(cwd, CONFIG_DIR_NAME, "skills");
     addSkills(loadSkillsFromDirInternal(userSkillsDir, "user", true));
     addSkills(loadSkillsFromDirInternal(projectSkillsDir, "project", true));
@@ -3178,6 +3948,9 @@ function formatSkillsForPrompt(skills) {
     lines.push(`    <name>${escapeXml(skill.name)}</name>`);
     lines.push(`    <description>${escapeXml(skill.description)}</description>`);
     lines.push(`    <location>${escapeXml(skill.filePath)}</location>`);
+    if (skill.allowedTools?.length) {
+      lines.push(`    <allowed-tools>${escapeXml(skill.allowedTools.join(" "))}</allowed-tools>`);
+    }
     lines.push("  </skill>");
   }
   lines.push("</available_skills>");
@@ -3186,7 +3959,7 @@ function formatSkillsForPrompt(skills) {
 }
 // src/utils/system-prompt.ts
 import { readFileSync as readFileSync5 } from "fs";
-import { join as join5 } from "path";
+import { join as join7 } from "path";
 var CORE_IDENTITY = `You are an AI coding agent. You help users with software engineering tasks by reading, writing, and modifying code. You have access to tools that let you interact with the filesystem and execute commands.
 
 You are highly capable and can help users complete complex tasks that would otherwise be too difficult or time-consuming.`;
@@ -3250,11 +4023,18 @@ function buildSystemPrompt(context) {
     sections.push(`# Environment
 
 Working directory: ${context.cwd}`);
-    const instructions = readProjectInstructions(context.cwd);
-    if (instructions) {
-      sections.push(`# Project Instructions
+    if (context.additionalDirectories && context.additionalDirectories.length > 0) {
+      sections.push(`Additional allowed directories:
+${context.additionalDirectories.map((d) => `- ${d}`).join(`
+`)}`);
+    }
+    if (context.loadProjectInstructions) {
+      const instructions = readProjectInstructions(context.cwd);
+      if (instructions) {
+        sections.push(`# Project Instructions
 
 ${instructions}`);
+      }
     }
   }
   if (context.skills && context.skills.length > 0) {
@@ -3275,7 +4055,7 @@ ${skillsPrompt}`);
 function readProjectInstructions(cwd) {
   for (const name of ["CLAUDE.md", "AGENTS.md"]) {
     try {
-      const content = readFileSync5(join5(cwd, name), "utf-8").trim();
+      const content = readFileSync5(join7(cwd, name), "utf-8").trim();
       if (content)
         return content;
     } catch {}
@@ -3284,7 +4064,10 @@ function readProjectInstructions(cwd) {
 }
 
 // src/query.ts
-function createQuery(generator, abortController) {
+function unsupported(methodName) {
+  return Promise.reject(new Error(`Query.${methodName} is not supported in this runtime yet.`));
+}
+function createQuery(generator, abortController, controls) {
   const query = {
     next: generator.next.bind(generator),
     return: generator.return.bind(generator),
@@ -3295,6 +4078,71 @@ function createQuery(generator, abortController) {
     async interrupt() {
       abortController.abort();
     },
+    async setPermissionMode(mode) {
+      if (!controls?.setPermissionMode)
+        return unsupported("setPermissionMode");
+      await controls.setPermissionMode(mode);
+    },
+    async setModel(model) {
+      if (!controls?.setModel)
+        return unsupported("setModel");
+      await controls.setModel(model);
+    },
+    async setMaxThinkingTokens(maxThinkingTokens) {
+      if (!controls?.setMaxThinkingTokens)
+        return unsupported("setMaxThinkingTokens");
+      await controls.setMaxThinkingTokens(maxThinkingTokens);
+    },
+    async initializationResult() {
+      if (!controls?.initializationResult)
+        return unsupported("initializationResult");
+      return controls.initializationResult();
+    },
+    async supportedCommands() {
+      if (!controls?.supportedCommands)
+        return unsupported("supportedCommands");
+      return controls.supportedCommands();
+    },
+    async supportedModels() {
+      if (!controls?.supportedModels)
+        return unsupported("supportedModels");
+      return controls.supportedModels();
+    },
+    async mcpServerStatus() {
+      if (!controls?.mcpServerStatus)
+        return unsupported("mcpServerStatus");
+      return controls.mcpServerStatus();
+    },
+    async accountInfo() {
+      if (!controls?.accountInfo)
+        return unsupported("accountInfo");
+      return controls.accountInfo();
+    },
+    async rewindFiles(userMessageId, options) {
+      if (!controls?.rewindFiles)
+        return unsupported("rewindFiles");
+      return controls.rewindFiles(userMessageId, options);
+    },
+    async reconnectMcpServer(serverName) {
+      if (!controls?.reconnectMcpServer)
+        return unsupported("reconnectMcpServer");
+      await controls.reconnectMcpServer(serverName);
+    },
+    async toggleMcpServer(serverName, enabled) {
+      if (!controls?.toggleMcpServer)
+        return unsupported("toggleMcpServer");
+      await controls.toggleMcpServer(serverName, enabled);
+    },
+    async setMcpServers(servers) {
+      if (!controls?.setMcpServers)
+        return unsupported("setMcpServers");
+      return controls.setMcpServers(servers);
+    },
+    async streamInput(stream) {
+      if (!controls?.streamInput)
+        return unsupported("streamInput");
+      await controls.streamInput(stream);
+    },
     close() {
       abortController.abort();
       generator.return(undefined);
@@ -3316,7 +4164,10 @@ var HOOK_EVENTS = [
   "SubagentStart",
   "SubagentStop",
   "PreCompact",
-  "PermissionRequest"
+  "PermissionRequest",
+  "Setup",
+  "TeammateIdle",
+  "TaskCompleted"
 ];
 var TOOL_EVENTS = new Set(["PreToolUse", "PostToolUse", "PostToolUseFailure"]);
 
@@ -3348,9 +4199,31 @@ class HookManager {
         }
       }
       for (const callback of entry.hooks) {
-        const result = await callback(input, toolUseId, { signal });
+        const timeoutMs = typeof entry.timeout === "number" && entry.timeout > 0 ? Math.floor(entry.timeout * 1000) : null;
+        const invoke = callback(input, toolUseId, { signal });
+        const result = timeoutMs ? await Promise.race([
+          invoke,
+          new Promise((resolve2) => {
+            setTimeout(() => resolve2({}), timeoutMs);
+          })
+        ]) : await invoke;
         if (result) {
           hasOutput = true;
+          if (result.continue === false && !result.permissionDecision) {
+            merged.permissionDecision = "deny";
+          }
+          if (result.decision) {
+            if (result.decision.behavior === "deny") {
+              merged.permissionDecision = "deny";
+            } else {
+              if (!merged.permissionDecision) {
+                merged.permissionDecision = "allow";
+              }
+              if (result.decision.updatedInput !== undefined) {
+                merged.updatedInput = result.decision.updatedInput;
+              }
+            }
+          }
           if (result.permissionDecision) {
             if (!merged.permissionDecision || result.permissionDecision === "deny") {
               merged.permissionDecision = result.permissionDecision;
@@ -3380,14 +4253,29 @@ import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
 class McpClientManager {
   configs;
   servers = new Map;
+  disabled = new Set;
   constructor(configs) {
-    this.configs = configs;
+    this.configs = { ...configs };
   }
   async connectAll() {
     const entries = Object.entries(this.configs);
     await Promise.all(entries.map(([name, config]) => this.connectOne(name, config)));
   }
   async connectOne(name, config) {
+    if (this.disabled.has(name)) {
+      this.servers.set(name, {
+        name,
+        client: null,
+        tools: [],
+        status: {
+          name,
+          status: "disabled",
+          config: this.toStatusConfig(config),
+          scope: config.type === "sdk" ? "sdk" : "session"
+        }
+      });
+      return;
+    }
     try {
       const client = new Client({ name: `fourmis-${name}`, version: "1.0.0" });
       if (config.type === "sdk") {
@@ -3421,13 +4309,25 @@ class McpClientManager {
       const tools = (toolsResult.tools ?? []).map((t) => ({
         name: t.name,
         description: t.description,
-        inputSchema: t.inputSchema
+        inputSchema: t.inputSchema,
+        annotations: t.annotations ? {
+          readOnly: t.annotations.readOnly,
+          destructive: t.annotations.destructive,
+          openWorld: t.annotations.openWorld
+        } : undefined
       }));
       this.servers.set(name, {
         name,
         client,
         tools,
-        status: { name, status: "connected", tools }
+        status: {
+          name,
+          status: "connected",
+          tools,
+          serverInfo: { name, version: "1.0.0" },
+          config: this.toStatusConfig(config),
+          scope: config.type === "sdk" ? "sdk" : "session"
+        }
       });
     } catch (err) {
       const error = err instanceof Error ? err.message : String(err);
@@ -3435,17 +4335,31 @@ class McpClientManager {
         name,
         client: null,
         tools: [],
-        status: { name, status: "failed", error }
+        status: {
+          name,
+          status: "failed",
+          error,
+          config: this.toStatusConfig(config),
+          scope: config.type === "sdk" ? "sdk" : "session"
+        }
       });
     }
   }
+  toStatusConfig(config) {
+    if (config.type === "sdk") {
+      return { type: "sdk", name: config.name };
+    }
+    return config;
+  }
   getTools() {
     const result = [];
     for (const [serverName, server] of this.servers) {
       if (server.status.status !== "connected")
         continue;
       for (const tool of server.tools) {
-        const namespacedName = `mcp__${serverName}__${tool.name}`;
+        const config = this.configs[serverName];
+        const prefix = "toolPrefix" in config ? config.toolPrefix : serverName;
+        const namespacedName = prefix === "" ? tool.name : `${prefix}__${tool.name}`;
         result.push({
           name: namespacedName,
           description: tool.description ?? `MCP tool ${tool.name} from ${serverName}`,
@@ -3478,64 +4392,294 @@ class McpClientManager {
       return { content: `MCP tool error: ${message}`, isError: true };
     }
   }
-  async listResources(serverName) {
-    const result = [];
-    const serversToQuery = serverName ? [this.servers.get(serverName)].filter(Boolean) : [...this.servers.values()];
-    for (const server of serversToQuery) {
-      if (server.status.status !== "connected")
+  async listResources(serverName) {
+    const result = [];
+    const serversToQuery = serverName ? [this.servers.get(serverName)].filter(Boolean) : [...this.servers.values()];
+    for (const server of serversToQuery) {
+      if (server.status.status !== "connected")
+        continue;
+      try {
+        const resources = await server.client.listResources();
+        for (const r of resources.resources ?? []) {
+          result.push({
+            uri: r.uri,
+            name: r.name,
+            description: r.description,
+            mimeType: r.mimeType,
+            server: server.name
+          });
+        }
+      } catch {}
+    }
+    return result;
+  }
+  async readResource(serverName, uri) {
+    const server = this.servers.get(serverName);
+    if (!server || server.status.status !== "connected") {
+      throw new Error(`MCP server "${serverName}" is not connected`);
+    }
+    const result = await server.client.readResource({ uri });
+    const contents = result.contents ?? [];
+    return contents.map((c) => {
+      if ("text" in c)
+        return c.text;
+      if ("blob" in c)
+        return `[binary data: ${c.mimeType ?? "unknown"}]`;
+      return "";
+    }).join("");
+  }
+  status() {
+    const result = [];
+    for (const [name, config] of Object.entries(this.configs)) {
+      const server = this.servers.get(name);
+      if (server) {
+        result.push(server.status);
+      } else if (this.disabled.has(name)) {
+        result.push({
+          name,
+          status: "disabled",
+          config: this.toStatusConfig(config),
+          scope: config.type === "sdk" ? "sdk" : "session"
+        });
+      } else {
+        result.push({
+          name,
+          status: "pending",
+          config: this.toStatusConfig(config),
+          scope: config.type === "sdk" ? "sdk" : "session"
+        });
+      }
+    }
+    return result;
+  }
+  async reconnectServer(serverName) {
+    const config = this.configs[serverName];
+    if (!config) {
+      throw new Error(`MCP server "${serverName}" is not configured`);
+    }
+    await this.closeOne(serverName);
+    await this.connectOne(serverName, config);
+    const status = this.servers.get(serverName)?.status;
+    if (!status || status.status !== "connected") {
+      throw new Error(status?.error ?? `Failed to reconnect MCP server "${serverName}"`);
+    }
+  }
+  async toggleServer(serverName, enabled) {
+    const config = this.configs[serverName];
+    if (!config) {
+      throw new Error(`MCP server "${serverName}" is not configured`);
+    }
+    if (!enabled) {
+      this.disabled.add(serverName);
+      await this.closeOne(serverName);
+      this.servers.set(serverName, {
+        name: serverName,
+        client: null,
+        tools: [],
+        status: {
+          name: serverName,
+          status: "disabled",
+          config: this.toStatusConfig(config),
+          scope: config.type === "sdk" ? "sdk" : "session"
+        }
+      });
+      return;
+    }
+    this.disabled.delete(serverName);
+    await this.reconnectServer(serverName);
+  }
+  async setServers(servers) {
+    const prevNames = new Set(Object.keys(this.configs));
+    const nextNames = new Set(Object.keys(servers));
+    const added = [...nextNames].filter((n) => !prevNames.has(n));
+    const removed = [...prevNames].filter((n) => !nextNames.has(n));
+    const errors = {};
+    for (const name of removed) {
+      await this.closeOne(name);
+      delete this.configs[name];
+      this.disabled.delete(name);
+      this.servers.delete(name);
+    }
+    for (const [name, config] of Object.entries(servers)) {
+      const prev = this.configs[name];
+      this.configs[name] = config;
+      if (this.disabled.has(name))
+        continue;
+      if (!prev || JSON.stringify(this.toStatusConfig(prev)) !== JSON.stringify(this.toStatusConfig(config))) {
+        await this.closeOne(name);
+        await this.connectOne(name, config);
+      }
+      const status = this.servers.get(name)?.status;
+      if (!status || status.status === "failed") {
+        errors[name] = status?.error ?? "Failed to connect";
+      }
+    }
+    return { added, removed, errors };
+  }
+  async closeOne(serverName) {
+    const existing = this.servers.get(serverName);
+    if (existing?.client) {
+      try {
+        await existing.client.close();
+      } catch {}
+    }
+  }
+  async closeAll() {
+    for (const [name] of this.servers) {
+      await this.closeOne(name);
+    }
+    this.servers.clear();
+  }
+}
+
+// src/utils/session-store.ts
+import { readFileSync as readFileSync6, appendFileSync, mkdirSync as mkdirSync3, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
+import { join as join8 } from "path";
+import { homedir as homedir5 } 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 join8(homedir5(), ".claude", "projects", sanitizeCwd(cwd));
+}
+function ensureDir(dir) {
+  mkdirSync3(dir, { recursive: true });
+}
+function logMessage(dir, sessionId, entry) {
+  ensureDir(dir);
+  const filePath = join8(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 = readdirSync2(dir).filter((f) => f.endsWith(".jsonl")).map((f) => {
+      const filePath = join8(dir, f);
+      try {
+        return { name: f, mtime: statSync2(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 = join8(dir, `${sessionId}.jsonl`);
+  let lines;
+  try {
+    lines = readFileSync6(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;
-      try {
-        const resources = await server.client.listResources();
-        for (const r of resources.resources ?? []) {
-          result.push({
-            uri: r.uri,
-            name: r.name,
-            description: r.description,
-            mimeType: r.mimeType,
-            server: server.name
+      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)}`
           });
         }
-      } catch {}
-    }
-    return result;
-  }
-  async readResource(serverName, uri) {
-    const server = this.servers.get(serverName);
-    if (!server || server.status.status !== "connected") {
-      throw new Error(`MCP server "${serverName}" is not connected`);
-    }
-    const result = await server.client.readResource({ uri });
-    const contents = result.contents ?? [];
-    return contents.map((c) => {
-      if ("text" in c)
-        return c.text;
-      if ("blob" in c)
-        return `[binary data: ${c.mimeType ?? "unknown"}]`;
-      return "";
-    }).join("");
-  }
-  status() {
-    const result = [];
-    for (const [name] of Object.entries(this.configs)) {
-      const server = this.servers.get(name);
-      if (server) {
-        result.push(server.status);
+        content = normalizedBlocks;
       } else {
-        result.push({ name, status: "pending" });
+        continue;
       }
-    }
-    return result;
-  }
-  async closeAll() {
-    for (const [, server] of this.servers) {
-      if (server.client) {
-        try {
-          await server.client.close();
-        } catch {}
+      messages.push({ role, content });
+      if (resumeSessionAt && entry.uuid === resumeSessionAt) {
+        reachedResumePoint = true;
       }
-    }
-    this.servers.clear();
+    } catch {}
   }
+  return messages;
 }
 
 // src/agents/tools.ts
@@ -3558,6 +4702,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."
@@ -3565,16 +4718,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) {
@@ -3588,28 +4760,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,
@@ -3617,18 +4814,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.";
@@ -3787,112 +4989,9 @@ class TaskManager {
   }
 }
 
-// src/utils/session-store.ts
-import { readFileSync as readFileSync6, appendFileSync, mkdirSync as mkdirSync3, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
-import { join as join6 } from "path";
-import { homedir as homedir5 } from "os";
-function sanitizeCwd(cwd) {
-  return cwd.replace(/[/.]/g, "-");
-}
-function sessionsDir(cwd) {
-  return join6(homedir5(), ".claude", "projects", sanitizeCwd(cwd));
-}
-function ensureDir(dir) {
-  mkdirSync3(dir, { recursive: true });
-}
-function logMessage(dir, sessionId, entry) {
-  ensureDir(dir);
-  const filePath = join6(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 = readdirSync2(dir).filter((f) => f.endsWith(".jsonl")).map((f) => {
-      const filePath = join6(dir, f);
-      try {
-        return { name: f, mtime: statSync2(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) {
-  const dir = sessionsDir(cwd);
-  const filePath = join6(dir, `${sessionId}.jsonl`);
-  let lines;
-  try {
-    lines = readFileSync6(filePath, "utf-8").trim().split(`
-`).filter(Boolean);
-  } catch {
-    return [];
-  }
-  const messages = [];
-  for (const line of lines) {
-    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)) {
-        content = message.content.filter((c) => c.type === "text" || c.type === "tool_use" || c.type === "tool_result").map((c) => c);
-      } else {
-        continue;
-      }
-      messages.push({ role, content });
-    } catch {}
-  }
-  return messages;
-}
-
 // src/memory/memory-handler.ts
-import { readdir, stat, readFile, writeFile, rm, rename, mkdir as mkdir2 } from "fs/promises";
-import { join as join7, resolve as resolve2, relative as relative2 } from "path";
+import { readdir, stat, readFile as readFile3, writeFile as writeFile4, rm, rename, mkdir as mkdir4 } from "fs/promises";
+import { join as join9, resolve as resolve2, relative as relative2 } from "path";
 import { existsSync as existsSync5 } from "fs";
 function createMemoryHandler(memoryDir) {
   const absMemoryDir = resolve2(memoryDir);
@@ -3938,7 +5037,7 @@ function createMemoryHandler(memoryDir) {
       for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
         if (entry.name.startsWith(".") || entry.name === "node_modules")
           continue;
-        const entryPath = join7(dirPath, entry.name);
+        const entryPath = join9(dirPath, entry.name);
         const entryStat = await stat(entryPath);
         lines.push(`${formatSize(entryStat.size)}	${toLogicalPath(entryPath)}`);
         if (entry.isDirectory()) {
@@ -3981,7 +5080,7 @@ function createMemoryHandler(memoryDir) {
 ${lines.join(`
 `)}`;
     }
-    const content = await readFile(absPath, "utf-8");
+    const content = await readFile3(absPath, "utf-8");
     const formatted = formatFileContent(content, cmd.view_range);
     return `Here's the content of ${cmd.path} with line numbers:
 ${formatted}`;
@@ -3992,8 +5091,8 @@ ${formatted}`;
       return `Error: File ${cmd.path} already exists`;
     }
     const parentDir = resolve2(absPath, "..");
-    await mkdir2(parentDir, { recursive: true });
-    await writeFile(absPath, cmd.file_text, "utf-8");
+    await mkdir4(parentDir, { recursive: true });
+    await writeFile4(absPath, cmd.file_text, "utf-8");
     return `File created successfully at: ${cmd.path}`;
   }
   async function handleStrReplace(cmd) {
@@ -4005,7 +5104,7 @@ ${formatted}`;
     if (s.isDirectory()) {
       return `Error: The path ${cmd.path} does not exist. Please provide a valid path.`;
     }
-    const content = await readFile(absPath, "utf-8");
+    const content = await readFile3(absPath, "utf-8");
     const lines = content.split(`
 `);
     const matchingLines = [];
@@ -4028,7 +5127,7 @@ ${formatted}`;
       return `No replacement was performed. Multiple occurrences of old_str \`${cmd.old_str}\` in lines: ${matchingLines.join(", ")}. Please ensure it is unique`;
     }
     const newContent = content.replace(cmd.old_str, cmd.new_str);
-    await writeFile(absPath, newContent, "utf-8");
+    await writeFile4(absPath, newContent, "utf-8");
     const newLines = newContent.split(`
 `);
     const replaceLine = matchingLines[0];
@@ -4048,7 +5147,7 @@ ${snippet}`;
     if (s.isDirectory()) {
       return `Error: The path ${cmd.path} does not exist`;
     }
-    const content = await readFile(absPath, "utf-8");
+    const content = await readFile3(absPath, "utf-8");
     const lines = content.split(`
 `);
     if (cmd.insert_line < 0 || cmd.insert_line > lines.length) {
@@ -4057,7 +5156,7 @@ ${snippet}`;
     const insertLines = cmd.insert_text.split(`
 `);
     lines.splice(cmd.insert_line, 0, ...insertLines);
-    await writeFile(absPath, lines.join(`
+    await writeFile4(absPath, lines.join(`
 `), "utf-8");
     return `The file ${cmd.path} has been edited.`;
   }
@@ -4079,13 +5178,13 @@ ${snippet}`;
       return `Error: The destination ${cmd.new_path} already exists`;
     }
     const parentDir = resolve2(newAbs, "..");
-    await mkdir2(parentDir, { recursive: true });
+    await mkdir4(parentDir, { recursive: true });
     await rename(oldAbs, newAbs);
     return `Successfully renamed ${cmd.old_path} to ${cmd.new_path}`;
   }
   async function execute(cmd) {
     if (!existsSync5(absMemoryDir)) {
-      await mkdir2(absMemoryDir, { recursive: true });
+      await mkdir4(absMemoryDir, { recursive: true });
     }
     switch (cmd.command) {
       case "view":
@@ -4190,19 +5289,41 @@ function createMemoryTool(config) {
     }
   };
 }
-
 // src/api.ts
 var DEFAULT_MODEL = "claude-sonnet-4-5-20250929";
 var DEFAULT_MAX_TURNS = 10;
 var DEFAULT_MAX_BUDGET_USD = 5;
 function query(params) {
-  const { prompt, options = {} } = params;
+  const { options = {} } = params;
+  const prompt = params.prompt;
+  if (typeof prompt !== "string") {
+    throw new Error("query({ prompt: AsyncIterable }) is not supported in single-prompt mode yet. Use Query.streamInput() in a streaming session.");
+  }
   const providerName = options.provider ?? "anthropic";
   const provider = getProvider(providerName, {
     apiKey: options.apiKey,
     baseUrl: options.baseUrl
   });
   const model = options.model ?? DEFAULT_MODEL;
+  const fallbackModel = options.fallbackModel;
+  const modelState = { current: model };
+  const resolvedThinkingBudget = (() => {
+    if (options.thinking) {
+      switch (options.thinking.type) {
+        case "disabled":
+          return 0;
+        case "enabled":
+          return options.thinking.budgetTokens;
+        case "adaptive":
+          return;
+      }
+    }
+    return options.maxThinkingTokens;
+  })();
+  const maxThinkingTokensState = { current: resolvedThinkingBudget };
+  if (options.permissionMode === "bypassPermissions" && options.allowDangerouslySkipPermissions !== true) {
+    throw new Error('permissionMode "bypassPermissions" requires allowDangerouslySkipPermissions: true');
+  }
   const toolNames = resolveToolNames(options.tools);
   const registry = buildToolRegistry(toolNames, undefined, options.disallowedTools);
   let skills = [];
@@ -4219,12 +5340,22 @@ function query(params) {
       }
     }
   }
-  const systemPrompt = options.systemPrompt ?? buildSystemPrompt({
-    tools: registry.list(),
-    cwd: options.cwd,
-    customPrompt: options.appendSystemPrompt,
-    skills
-  });
+  const systemPrompt = (() => {
+    if (typeof options.systemPrompt === "string") {
+      return options.systemPrompt;
+    }
+    const appendedPrompt = typeof options.systemPrompt === "object" ? [options.systemPrompt.append, options.appendSystemPrompt].filter(Boolean).join(`
+
+`) : options.appendSystemPrompt;
+    return buildSystemPrompt({
+      tools: registry.list(),
+      cwd: options.cwd,
+      additionalDirectories: options.additionalDirectories,
+      loadProjectInstructions: Array.isArray(options.settingSources) && options.settingSources.includes("project"),
+      customPrompt: appendedPrompt,
+      skills
+    });
+  })();
   let settingsManager;
   let mergedPermissions = options.permissions;
   if (options.settingSources && options.settingSources.length > 0) {
@@ -4270,7 +5401,7 @@ function query(params) {
       }
     }
   } else if (options.resume) {
-    previousMessages = loadSessionMessages(cwd, options.resume);
+    previousMessages = loadSessionMessages(cwd, options.resume, options.resumeSessionAt);
     if (options.forkSession) {
       sessionId = uuid();
     } else {
@@ -4279,18 +5410,28 @@ function query(params) {
   }
   const persistSession = options.persistSession !== false;
   const sessionLogger = persistSession ? createSessionLogger(cwd, sessionId, model) : undefined;
-  const abortController = new AbortController;
+  const abortController = options.abortController ?? new AbortController;
   if (options.signal) {
     options.signal.addEventListener("abort", () => abortController.abort(), { once: true });
   }
   const hookManager = options.hooks ? new HookManager(options.hooks) : undefined;
   const mcpClient = options.mcpServers && Object.keys(options.mcpServers).length > 0 ? new McpClientManager(options.mcpServers) : undefined;
+  const syncMcpTools = () => {
+    if (!mcpClient)
+      return;
+    registry.clearByPrefix("mcp__");
+    for (const tool of mcpClient.getTools()) {
+      registry.register(tool);
+    }
+    registry.register(createListMcpResourcesTool(mcpClient));
+    registry.register(createReadMcpResourceTool(mcpClient));
+  };
   if (options.agents && Object.keys(options.agents).length > 0) {
     const taskManager = new TaskManager;
     const agentCtx = {
       agents: options.agents,
       parentProvider: provider,
-      parentModel: model,
+      parentModel: modelState.current,
       parentPermissions: permissions,
       parentHooks: hookManager,
       parentCwd: cwd,
@@ -4314,6 +5455,12 @@ function query(params) {
   const generator = agentLoop(prompt, {
     provider,
     model,
+    modelState,
+    maxThinkingTokensState,
+    fallbackModel,
+    thinking: options.thinking,
+    effort: options.effort,
+    outputFormat: options.outputFormat,
     systemPrompt,
     tools: registry,
     permissions,
@@ -4321,7 +5468,7 @@ function query(params) {
     sessionId,
     maxTurns: options.maxTurns ?? DEFAULT_MAX_TURNS,
     maxBudgetUsd: options.maxBudgetUsd ?? DEFAULT_MAX_BUDGET_USD,
-    includeStreamEvents: options.includeStreamEvents ?? false,
+    includePartialMessages: options.includePartialMessages ?? false,
     signal: abortController.signal,
     env: options.env,
     debug: options.debug,
@@ -4329,9 +5476,95 @@ function query(params) {
     mcpClient,
     previousMessages,
     sessionLogger,
-    nativeMemoryTool
+    nativeMemoryTool,
+    initMeta: {
+      betas: options.betas,
+      outputStyle: "default",
+      slashCommands: skills.map((s) => `/${s.name}`),
+      skills: skills.map((s) => s.name),
+      plugins: options.plugins,
+      agents: options.agents ? Object.keys(options.agents) : undefined
+    }
   });
-  return createQuery(generator, abortController);
+  const controls = {
+    async setPermissionMode(mode) {
+      permissions.setMode(mode);
+    },
+    async setModel(nextModel) {
+      modelState.current = nextModel ?? model;
+    },
+    async setMaxThinkingTokens(maxThinkingTokens) {
+      maxThinkingTokensState.current = maxThinkingTokens ?? undefined;
+    },
+    async initializationResult() {
+      const models = provider.listModels ? await provider.listModels() : [];
+      return {
+        commands: skills.map((s) => ({
+          name: s.name,
+          description: s.description,
+          argumentHint: ""
+        })),
+        output_style: "default",
+        available_output_styles: ["default"],
+        models,
+        account: {}
+      };
+    },
+    async supportedCommands() {
+      return skills.map((s) => ({
+        name: s.name,
+        description: s.description,
+        argumentHint: ""
+      }));
+    },
+    async supportedModels() {
+      return provider.listModels ? await provider.listModels() : [];
+    },
+    async mcpServerStatus() {
+      return mcpClient ? mcpClient.status() : [];
+    },
+    async accountInfo() {
+      return {
+        tokenSource: options.apiKey ? "api-key" : "runtime",
+        apiKeySource: options.apiKey ? "explicit" : "env_or_oauth"
+      };
+    },
+    async rewindFiles(_userMessageId, _options) {
+      if (!options.enableFileCheckpointing) {
+        return {
+          canRewind: false,
+          error: "File checkpointing is disabled. Set enableFileCheckpointing: true."
+        };
+      }
+      return {
+        canRewind: false,
+        error: "File checkpoint rewind is not implemented in fourmis-agent-sdk yet."
+      };
+    },
+    async reconnectMcpServer(serverName) {
+      if (!mcpClient)
+        throw new Error("No MCP servers are configured for this query.");
+      await mcpClient.reconnectServer(serverName);
+      syncMcpTools();
+    },
+    async toggleMcpServer(serverName, enabled) {
+      if (!mcpClient)
+        throw new Error("No MCP servers are configured for this query.");
+      await mcpClient.toggleServer(serverName, enabled);
+      syncMcpTools();
+    },
+    async setMcpServers(servers) {
+      if (!mcpClient)
+        throw new Error("No MCP client is available for this query.");
+      const result = await mcpClient.setServers(servers);
+      syncMcpTools();
+      return result;
+    },
+    async streamInput() {
+      throw new Error("Query.streamInput is not implemented for single-prompt query mode.");
+    }
+  };
+  return createQuery(generator, abortController, controls);
 }
 
 // src/mcp/server.ts
@@ -4373,16 +5606,23 @@ export {
   createMemoryHandler,
   createMcpServer,
   WriteTool,
+  WebSearchTool,
+  WebFetchTool,
   ToolRegistry,
+  TodoWriteTool,
   TaskManager,
   SettingsManager,
   ReadTool,
   PRESETS,
+  NotebookEditTool,
   McpClientManager,
   HookManager,
   HOOK_EVENTS,
   GrepTool,
   GlobTool,
+  ExitPlanModeTool,
   EditTool,
-  BashTool
+  ConfigTool,
+  BashTool,
+  AskUserQuestionTool
 };