fourmis-agents-sdk 0.3.1 → 0.4.0

package/dist/api.js

@@ -1,5 +1,20 @@
 // @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
@@ -12,76 +27,6 @@ var __export = (target, all) => {
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = import.meta.require;
 
-// src/tools/mcp-resources.ts
-var exports_mcp_resources = {};
-__export(exports_mcp_resources, {
-  createReadMcpResourceTool: () => createReadMcpResourceTool,
-  createListMcpResourcesTool: () => createListMcpResourcesTool
-});
-function createListMcpResourcesTool(mcpClient) {
-  return {
-    name: "mcp__list_resources",
-    description: "List available resources from MCP servers.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        server: {
-          type: "string",
-          description: "Optional server name to filter by. If omitted, lists resources from all servers."
-        }
-      }
-    },
-    async execute(input) {
-      const { server } = input ?? {};
-      try {
-        const resources = await mcpClient.listResources(server);
-        if (resources.length === 0) {
-          return { content: "No resources available." };
-        }
-        const lines = resources.map((r) => `[${r.server}] ${r.uri} - ${r.name}${r.description ? `: ${r.description}` : ""}`);
-        return { content: lines.join(`
-`) };
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        return { content: `Error listing resources: ${message}`, isError: true };
-      }
-    }
-  };
-}
-function createReadMcpResourceTool(mcpClient) {
-  return {
-    name: "mcp__read_resource",
-    description: "Read a specific resource from an MCP server by URI.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        server: {
-          type: "string",
-          description: "The MCP server name that hosts the resource."
-        },
-        uri: {
-          type: "string",
-          description: "The resource URI to read."
-        }
-      },
-      required: ["server", "uri"]
-    },
-    async execute(input) {
-      const { server, uri } = input;
-      if (!server || !uri) {
-        return { content: "Both 'server' and 'uri' are required.", isError: true };
-      }
-      try {
-        const content = await mcpClient.readResource(server, uri);
-        return { content };
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        return { content: `Error reading resource: ${message}`, isError: true };
-      }
-    }
-  };
-}
-
 // src/auth/openai-oauth.ts
 var exports_openai_oauth = {};
 __export(exports_openai_oauth, {
@@ -95,25 +40,25 @@ __export(exports_openai_oauth, {
   decodeJwtPayload: () => decodeJwtPayload
 });
 import { randomBytes, createHash } from "crypto";
-import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
-import { join } from "path";
-import { homedir } from "os";
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
 function getHome() {
-  return process.env.HOME ?? homedir();
+  return process.env.HOME ?? homedir2();
 }
 function tokenDir() {
-  return join(getHome(), ".fourmis");
+  return join2(getHome(), ".fourmis");
 }
 function tokenPath() {
-  return join(tokenDir(), "openai-auth.json");
+  return join2(tokenDir(), "openai-auth.json");
 }
 function codexFallbackPath() {
-  return join(getHome(), ".codex", "auth.json");
+  return join2(getHome(), ".codex", "auth.json");
 }
 function loadTokens() {
   for (const p of [tokenPath(), codexFallbackPath()]) {
     try {
-      const raw = readFileSync(p, "utf-8");
+      const raw = readFileSync2(p, "utf-8");
       const data = JSON.parse(raw);
       if (data.access_token && data.account_id) {
         return data;
@@ -124,10 +69,10 @@ function loadTokens() {
 }
 function saveTokens(tokens) {
   const dir = tokenDir();
-  if (!existsSync(dir)) {
-    mkdirSync(dir, { recursive: true });
+  if (!existsSync2(dir)) {
+    mkdirSync2(dir, { recursive: true });
   }
-  writeFileSync(tokenPath(), JSON.stringify(tokens, null, 2), { mode: 384 });
+  writeFileSync2(tokenPath(), JSON.stringify(tokens, null, 2), { mode: 384 });
 }
 function generateCodeVerifier() {
   return randomBytes(64).toString("base64url");
@@ -377,19 +322,19 @@ __export(exports_gemini_oauth, {
   isLoggedIn: () => isLoggedIn2,
   getValidToken: () => getValidToken2
 });
-import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync2 } from "fs";
-import { join as join2 } from "path";
-import { homedir as homedir2 } from "os";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, existsSync as existsSync3 } from "fs";
+import { join as join3 } from "path";
+import { homedir as homedir3 } from "os";
 function getHome2() {
-  return process.env.HOME ?? homedir2();
+  return process.env.HOME ?? homedir3();
 }
 function tokenPath2() {
-  return join2(getHome2(), ".gemini", "oauth_creds.json");
+  return join3(getHome2(), ".gemini", "oauth_creds.json");
 }
 function loadTokens2() {
   const p = tokenPath2();
   try {
-    const raw = readFileSync2(p, "utf-8");
+    const raw = readFileSync3(p, "utf-8");
     const data = JSON.parse(raw);
     if (data.access_token && data.refresh_token) {
       return data;
@@ -402,12 +347,12 @@ function loadTokensSync2() {
 }
 function saveTokens2(tokens) {
   const p = tokenPath2();
-  const dir = join2(getHome2(), ".gemini");
-  if (!existsSync2(dir)) {
-    const { mkdirSync: mkdirSync2 } = __require("fs");
-    mkdirSync2(dir, { recursive: true });
+  const dir = join3(getHome2(), ".gemini");
+  if (!existsSync3(dir)) {
+    const { mkdirSync: mkdirSync3 } = __require("fs");
+    mkdirSync3(dir, { recursive: true });
   }
-  writeFileSync2(p, JSON.stringify(tokens, null, 2), { mode: 384 });
+  writeFileSync3(p, JSON.stringify(tokens, null, 2), { mode: 384 });
 }
 async function refreshAccessToken2(refreshToken) {
   const res = await fetch(GOOGLE_TOKEN_URL, {
@@ -461,330 +406,366 @@ var init_gemini_oauth = __esm(() => {
   GEMINI_CLIENT_SECRET = process.env.GEMINI_OAUTH_CLIENT_SECRET ?? ["GOCSPX", "4uHgMPm", "1o7Sk", "geV6Cu5clXFsxl"].join("-");
 });
 
-// src/types.ts
-function uuid() {
-  return crypto.randomUUID();
-}
-function emptyTokenUsage() {
+// src/tools/mcp-resources.ts
+var exports_mcp_resources = {};
+__export(exports_mcp_resources, {
+  createReadMcpResourceTool: () => createReadMcpResourceTool,
+  createListMcpResourcesTool: () => createListMcpResourcesTool
+});
+function createListMcpResourcesTool(mcpClient) {
   return {
-    inputTokens: 0,
-    outputTokens: 0,
-    cacheReadInputTokens: 0,
-    cacheCreationInputTokens: 0
+    name: "mcp__list_resources",
+    description: "List available resources from MCP servers.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        server: {
+          type: "string",
+          description: "Optional server name to filter by. If omitted, lists resources from all servers."
+        }
+      }
+    },
+    async execute(input) {
+      const { server } = input ?? {};
+      try {
+        const resources = await mcpClient.listResources(server);
+        if (resources.length === 0) {
+          return { content: "No resources available." };
+        }
+        const lines = resources.map((r) => `[${r.server}] ${r.uri} - ${r.name}${r.description ? `: ${r.description}` : ""}`);
+        return { content: lines.join(`
+`) };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { content: `Error listing resources: ${message}`, isError: true };
+      }
+    }
   };
 }
-function mergeUsage(a, b) {
+function createReadMcpResourceTool(mcpClient) {
   return {
-    inputTokens: a.inputTokens + b.inputTokens,
-    outputTokens: a.outputTokens + b.outputTokens,
-    cacheReadInputTokens: a.cacheReadInputTokens + b.cacheReadInputTokens,
-    cacheCreationInputTokens: a.cacheCreationInputTokens + b.cacheCreationInputTokens
+    name: "mcp__read_resource",
+    description: "Read a specific resource from an MCP server by URI.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        server: {
+          type: "string",
+          description: "The MCP server name that hosts the resource."
+        },
+        uri: {
+          type: "string",
+          description: "The resource URI to read."
+        }
+      },
+      required: ["server", "uri"]
+    },
+    async execute(input) {
+      const { server, uri } = input;
+      if (!server || !uri) {
+        return { content: "Both 'server' and 'uri' are required.", isError: true };
+      }
+      try {
+        const content = await mcpClient.readResource(server, uri);
+        return { content };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { content: `Error reading resource: ${message}`, isError: true };
+      }
+    }
   };
 }
 
-// src/agent-loop.ts
-async function* agentLoop(prompt, options) {
-  const {
-    provider,
-    model,
-    systemPrompt,
-    tools,
-    permissions,
-    cwd,
-    sessionId,
-    maxTurns,
-    maxBudgetUsd,
-    includeStreamEvents,
-    signal,
-    env,
-    debug,
-    hooks,
-    mcpClient,
-    previousMessages,
-    sessionLogger,
-    nativeMemoryTool
-  } = options;
-  const startTime = Date.now();
-  let apiTimeMs = 0;
-  let turns = 0;
-  let totalUsage = emptyTokenUsage();
-  let costUsd = 0;
-  const modelUsage = {};
-  if (mcpClient) {
-    await mcpClient.connectAll();
-    for (const tool of mcpClient.getTools()) {
-      tools.register(tool);
-    }
-    const { createListMcpResourcesTool: createListMcpResourcesTool2, createReadMcpResourceTool: createReadMcpResourceTool2 } = await Promise.resolve().then(() => exports_mcp_resources);
-    tools.register(createListMcpResourcesTool2(mcpClient));
-    tools.register(createReadMcpResourceTool2(mcpClient));
-  }
-  const messages = [
-    ...previousMessages ?? [],
-    { role: "user", content: prompt }
-  ];
-  if (sessionLogger) {
-    sessionLogger("user", prompt, null);
+// 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;
   }
-  yield {
-    type: "init",
-    sessionId,
-    model,
-    provider: provider.name,
-    tools: tools.list(),
-    cwd,
-    uuid: uuid()
-  };
-  if (hooks) {
-    await hooks.fire("SessionStart", { event: "SessionStart", session_id: sessionId }, undefined, { signal });
+  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;
   }
-  while (true) {
-    if (signal.aborted) {
-      yield makeError("error_execution", ["Aborted"], turns, costUsd, sessionId, startTime);
-      return;
+  async check(toolName, input, options) {
+    if (this.mode === "bypassPermissions") {
+      return { behavior: "allow" };
     }
-    if (turns >= maxTurns) {
-      yield makeError("error_max_turns", [`Reached maximum turns (${maxTurns})`], turns, costUsd, sessionId, startTime);
-      return;
+    if (matchesRule(this.denyRules, toolName, input)) {
+      return {
+        behavior: "deny",
+        message: `Tool "${toolName}" is denied by permissions config.`
+      };
     }
-    if (maxBudgetUsd > 0 && costUsd >= maxBudgetUsd) {
-      yield makeError("error_max_budget", [`Reached budget limit ($${maxBudgetUsd})`], turns, costUsd, sessionId, startTime);
-      return;
+    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" };
     }
-    const toolDefs = tools.getDefinitions();
-    const apiStart = Date.now();
-    let assistantTextParts = [];
-    let toolCalls = [];
-    let turnUsage = emptyTokenUsage();
-    const nativeTools = nativeMemoryTool ? [nativeMemoryTool.definition] : undefined;
-    try {
-      const chunks = provider.chat({
-        model,
-        messages,
-        tools: toolDefs.length > 0 ? toolDefs : undefined,
-        systemPrompt,
-        signal,
-        nativeTools
-      });
-      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() };
-            }
-            break;
-          case "thinking_delta":
-            if (includeStreamEvents) {
-              yield { type: "stream", subtype: "thinking_delta", text: chunk.text, uuid: uuid() };
-            }
-            break;
-          case "tool_call":
-            toolCalls.push({ id: chunk.id, name: chunk.name, input: chunk.input });
-            break;
-          case "usage":
-            turnUsage = mergeUsage(turnUsage, chunk.usage);
-            break;
-          case "done":
-            break;
-        }
+    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.`
+        };
       }
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      yield makeError("error_execution", [`API error: ${message}`], turns, costUsd, sessionId, startTime);
-      return;
+      return { behavior: "allow" };
     }
-    apiTimeMs += Date.now() - apiStart;
-    turns++;
-    totalUsage = mergeUsage(totalUsage, turnUsage);
-    const turnCost = provider.calculateCost(model, turnUsage);
-    costUsd += turnCost;
-    if (!modelUsage[model]) {
-      modelUsage[model] = {
-        inputTokens: 0,
-        outputTokens: 0,
-        cacheReadInputTokens: 0,
-        cacheCreationInputTokens: 0,
-        totalCostUsd: 0
-      };
+    if (matchesRule(this.allowRules, toolName, input)) {
+      return { behavior: "allow" };
     }
-    modelUsage[model].inputTokens += turnUsage.inputTokens;
-    modelUsage[model].outputTokens += turnUsage.outputTokens;
-    modelUsage[model].cacheReadInputTokens += turnUsage.cacheReadInputTokens;
-    modelUsage[model].cacheCreationInputTokens += turnUsage.cacheCreationInputTokens;
-    modelUsage[model].totalCostUsd += turnCost;
-    const assistantText = assistantTextParts.join("");
-    const assistantContent = [];
-    if (assistantText) {
-      assistantContent.push({ type: "text", text: assistantText });
+    if (SAFE_TOOLS.has(toolName)) {
+      return { behavior: "allow" };
     }
-    for (const call of toolCalls) {
-      assistantContent.push({
-        type: "tool_use",
-        id: call.id,
-        name: call.name,
-        input: call.input
-      });
+    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" };
+        }
+      }
     }
-    messages.push({ role: "assistant", content: assistantContent });
-    if (sessionLogger) {
-      sessionLogger("assistant", assistantContent, null);
+    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;
     }
-    if (assistantText) {
-      yield { type: "text", text: assistantText, uuid: uuid() };
+    if (this.mode === "dontAsk") {
+      return {
+        behavior: "deny",
+        message: `Tool "${toolName}" requires approval. In dontAsk mode, tools must be pre-approved via permissions config.`
+      };
     }
-    if (toolCalls.length === 0) {
-      if (hooks) {
-        await hooks.fire("Stop", { event: "Stop", session_id: sessionId, text: assistantText || undefined }, undefined, { signal });
+    return { behavior: "allow" };
+  }
+  applyPermissionUpdates(updates) {
+    for (const update of updates) {
+      if (this.settingsManager && update.destination !== "session" && update.destination !== "cliArg") {
+        this.settingsManager.persistUpdate(update);
       }
-      if (hooks) {
-        await hooks.fire("SessionEnd", { event: "SessionEnd", session_id: sessionId }, undefined, { signal });
+      switch (update.type) {
+        case "addRules":
+          for (const rule of update.rules) {
+            if (update.behavior === "allow") {
+              this.allowRules.push(rule);
+            } else if (update.behavior === "deny") {
+              this.denyRules.push(rule);
+            }
+          }
+          break;
+        case "removeRules":
+          for (const rule of update.rules) {
+            if (update.behavior === "allow") {
+              this.allowRules = this.allowRules.filter((r) => !(r.toolName === rule.toolName && r.ruleContent === rule.ruleContent));
+            } else if (update.behavior === "deny") {
+              this.denyRules = this.denyRules.filter((r) => !(r.toolName === rule.toolName && r.ruleContent === rule.ruleContent));
+            }
+          }
+          break;
+        case "replaceRules":
+          if (update.behavior === "allow") {
+            this.allowRules = [...update.rules];
+          } else if (update.behavior === "deny") {
+            this.denyRules = [...update.rules];
+          }
+          break;
+        case "setMode":
+          this.mode = update.mode;
+          break;
       }
-      yield {
-        type: "result",
-        subtype: "success",
-        text: assistantText || null,
-        turns,
-        costUsd,
-        durationMs: Date.now() - startTime,
-        durationApiMs: apiTimeMs,
-        sessionId,
-        usage: totalUsage,
-        modelUsage,
-        uuid: uuid()
-      };
-      return;
     }
-    const toolResults = [];
-    for (const call of toolCalls) {
-      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 });
-        if (hookResult) {
-          if (hookResult.permissionDecision === "deny") {
-            hookDenied = true;
-          }
-          if (hookResult.updatedInput !== undefined) {
-            hookUpdatedInput = hookResult.updatedInput;
+  }
+  setMode(mode) {
+    this.mode = mode;
+  }
+  getMode() {
+    return this.mode;
+  }
+}
+
+// src/settings.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+import { homedir } from "os";
+
+class SettingsManager {
+  cwd;
+  constructor(cwd) {
+    this.cwd = cwd;
+  }
+  loadPermissions(sources) {
+    const allAllow = [];
+    const allDeny = [];
+    for (const source of sources) {
+      const path = this.sourceToPath(source);
+      const data = this.readJson(path);
+      if (!data?.permissions)
+        continue;
+      const perms = data.permissions;
+      if (Array.isArray(perms.allow)) {
+        for (const rule of perms.allow) {
+          if (typeof rule === "string") {
+            allAllow.push(this.parseRule(rule));
           }
         }
       }
-      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,
-          content: denyContent,
-          is_error: true
-        });
-        if (hooks) {
-          await hooks.fire("PostToolUseFailure", { event: "PostToolUseFailure", tool_name: call.name, tool_result: denyContent, tool_error: true, session_id: sessionId }, call.id, { signal });
+      if (Array.isArray(perms.deny)) {
+        for (const rule of perms.deny) {
+          if (typeof rule === "string") {
+            allDeny.push(this.parseRule(rule));
+          }
         }
-        continue;
       }
-      const inputAfterHook = hookUpdatedInput !== undefined ? hookUpdatedInput : call.input;
-      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()
-        };
-        toolResults.push({
-          type: "tool_result",
-          tool_use_id: call.id,
-          content: denyContent,
-          is_error: true
-        });
-        if (hooks) {
-          await hooks.fire("PostToolUseFailure", { event: "PostToolUseFailure", tool_name: call.name, tool_result: denyContent, tool_error: true, session_id: sessionId }, call.id, { signal });
-        }
-        continue;
+    }
+    const result = {};
+    if (allAllow.length > 0)
+      result.allow = allAllow;
+    if (allDeny.length > 0)
+      result.deny = allDeny;
+    return result;
+  }
+  persistUpdate(update) {
+    const path = this.destinationToPath(update.destination);
+    if (!path)
+      return;
+    const data = this.readJson(path) ?? {};
+    if (!data.permissions)
+      data.permissions = {};
+    const perms = data.permissions;
+    switch (update.type) {
+      case "addRules": {
+        const key = update.behavior;
+        const existing = Array.isArray(perms[key]) ? perms[key] : [];
+        const newRules = update.rules.map((r) => this.serializeRule(r));
+        const set = new Set(existing);
+        for (const rule of newRules)
+          set.add(rule);
+        perms[key] = [...set];
+        break;
       }
-      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 {
-          const content = await nativeMemoryTool.execute(toolInput);
-          result = { content, isError: content.startsWith("Error:") };
-        } catch (err) {
-          const message = err instanceof Error ? err.message : String(err);
-          result = { content: `Error: ${message}`, isError: true };
-        }
-      } else {
-        const toolCtx = {
-          cwd,
-          signal,
-          sessionId,
-          env
-        };
-        result = await tools.execute(call.name, toolInput, toolCtx);
+      case "removeRules": {
+        const key = update.behavior;
+        if (!Array.isArray(perms[key]))
+          break;
+        const toRemove = new Set(update.rules.map((r) => this.serializeRule(r)));
+        perms[key] = perms[key].filter((r) => !toRemove.has(r));
+        break;
       }
-      if (debug) {
-        console.error(`[debug] Tool ${call.name}: ${result.isError ? "ERROR" : "OK"} (${result.content.length} chars)`);
+      case "replaceRules": {
+        const key = update.behavior;
+        perms[key] = update.rules.map((r) => this.serializeRule(r));
+        break;
       }
-      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 });
-        } else {
-          const postResult = await hooks.fire("PostToolUse", { event: "PostToolUse", tool_name: call.name, tool_result: result.content, session_id: sessionId }, call.id, { signal });
-          if (postResult?.additionalContext) {
-            result.content += `
-${postResult.additionalContext}`;
-          }
-        }
+      case "setMode": {
+        perms.defaultMode = update.mode;
+        break;
       }
-      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,
-        content: result.content,
-        is_error: result.isError
-      });
+      default:
+        return;
     }
-    messages.push({ role: "user", content: toolResults });
-    if (sessionLogger) {
-      sessionLogger("user", toolResults, null);
+    const dir = dirname(path);
+    if (!existsSync(dir))
+      mkdirSync(dir, { recursive: true });
+    writeFileSync(path, JSON.stringify(data, null, 2) + `
+`);
+  }
+  sourceToPath(source) {
+    switch (source) {
+      case "user":
+        return join(homedir(), ".claude", "settings.json");
+      case "project":
+        return join(this.cwd, ".claude", "settings.json");
+      case "local":
+        return join(this.cwd, ".claude", "settings.local.json");
+    }
+  }
+  destinationToPath(destination) {
+    switch (destination) {
+      case "userSettings":
+        return join(homedir(), ".claude", "settings.json");
+      case "projectSettings":
+        return join(this.cwd, ".claude", "settings.json");
+      case "localSettings":
+        return join(this.cwd, ".claude", "settings.local.json");
+      default:
+        return null;
+    }
+  }
+  readJson(path) {
+    try {
+      const content = readFileSync(path, "utf-8");
+      return JSON.parse(content);
+    } catch {
+      return null;
     }
   }
+  parseRule(s) {
+    const match = s.match(/^([^(]+)\((.+)\)$/);
+    if (match)
+      return { toolName: match[1], ruleContent: match[2] };
+    return { toolName: s };
+  }
+  serializeRule(rule) {
+    return rule.ruleContent ? `${rule.toolName}(${rule.ruleContent})` : rule.toolName;
+  }
+}
+
+// src/types.ts
+function uuid() {
+  return crypto.randomUUID();
 }
-function makeError(subtype, errors, turns, costUsd, sessionId, startTime) {
+function emptyTokenUsage() {
   return {
-    type: "result",
-    subtype,
-    errors,
-    turns,
-    costUsd,
-    durationMs: Date.now() - startTime,
-    sessionId,
-    uuid: uuid()
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadInputTokens: 0,
+    cacheCreationInputTokens: 0
+  };
+}
+function mergeUsage(a, b) {
+  return {
+    inputTokens: a.inputTokens + b.inputTokens,
+    outputTokens: a.outputTokens + b.outputTokens,
+    cacheReadInputTokens: a.cacheReadInputTokens + b.cacheReadInputTokens,
+    cacheCreationInputTokens: a.cacheCreationInputTokens + b.cacheCreationInputTokens
   };
 }
 
@@ -1043,6 +1024,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 +1186,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;
     }
@@ -2086,6 +2106,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 +2149,34 @@ class ToolRegistry {
 // src/tools/presets.ts
 var PRESETS = {
   coding: ["Bash", "Read", "Write", "Edit", "Glob", "Grep"],
+  claude_code: [
+    "Bash",
+    "Read",
+    "Write",
+    "Edit",
+    "Glob",
+    "Grep",
+    "NotebookEdit",
+    "WebFetch",
+    "WebSearch",
+    "TodoWrite",
+    "Config",
+    "AskUserQuestion",
+    "ExitPlanMode"
+  ],
   readonly: ["Read", "Glob", "Grep"],
   minimal: ["Read", "Write", "Edit", "Glob", "Grep"]
 };
 function resolveToolNames(tools) {
   if (!tools)
-    return PRESETS.coding;
-  if (typeof tools === "string") {
-    return PRESETS[tools] ?? [tools];
+    return PRESETS.claude_code;
+  if (Array.isArray(tools)) {
+    return tools;
+  }
+  if (tools.type === "preset") {
+    return PRESETS[tools.preset] ?? PRESETS.claude_code;
   }
-  return tools;
+  throw new Error("Invalid tools option. Expected string[] or { type: 'preset', preset: 'claude_code' }.");
 }
 
 // src/tools/bash.ts
@@ -2152,17 +2200,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 +2283,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 +2316,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 +2337,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(`
 `);
@@ -2270,7 +2374,7 @@ function resolvePath(filePath, cwd) {
 
 // src/tools/write.ts
 import { mkdir } from "fs/promises";
-import { dirname } from "path";
+import { dirname as dirname2 } from "path";
 var WriteTool = {
   name: "Write",
   description: "Writes content to a file. Creates parent directories if needed. " + "Overwrites existing files.",
@@ -2298,7 +2402,7 @@ var WriteTool = {
     }
     const resolvedPath = file_path.startsWith("/") ? file_path : `${ctx.cwd}/${file_path}`;
     try {
-      const dir = dirname(resolvedPath);
+      const dir = dirname2(resolvedPath);
       await mkdir(dir, { recursive: true });
       await Bun.write(resolvedPath, content);
       const lines = content.split(`
@@ -2593,327 +2697,465 @@ async function runJsGrep(opts, searchPath, mode, ctx) {
       totalCount += matchedLines.length;
       const relativePath = filePath.startsWith(ctx.cwd) ? filePath.slice(ctx.cwd.length + 1) : filePath;
       if (mode === "files_with_matches") {
-        results.push(relativePath);
-      } else if (mode === "count") {
-        results.push(`${relativePath}:${matchedLines.length}`);
-      } else {
-        for (const { num, line } of matchedLines) {
-          results.push(`${relativePath}:${num}:${line}`);
-        }
-      }
-    } catch {}
-    if (opts.head_limit && results.length >= opts.head_limit) {
-      break;
-    }
-  }
-  let output = results.join(`
-`);
-  if (opts.head_limit) {
-    const entries = output.split(`
-`).slice(0, opts.head_limit);
-    output = entries.join(`
-`);
-  }
-  return { content: output || "No matches found." };
-}
-async function collectFiles(dir, globPattern) {
-  const { Glob: Glob2 } = await Promise.resolve(globalThis.Bun);
-  const pattern = globPattern ?? "**/*";
-  const glob = new Glob2(pattern);
-  const files = [];
-  for await (const path of glob.scan({ cwd: dir, dot: false, onlyFiles: true })) {
-    files.push(`${dir}/${path}`);
-  }
-  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;
-}
-
-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);
-      if (result.behavior === "allow" && result.updatedPermissions) {
-        this.applyPermissionUpdates(result.updatedPermissions);
-      }
-      return result;
-    }
-    if (this.mode === "dontAsk") {
-      return {
-        behavior: "deny",
-        message: `Tool "${toolName}" requires approval. In dontAsk mode, tools must be pre-approved via permissions config.`
-      };
-    }
-    return { behavior: "allow" };
-  }
-  applyPermissionUpdates(updates) {
-    for (const update of updates) {
-      if (this.settingsManager && update.destination !== "session" && update.destination !== "cliArg") {
-        this.settingsManager.persistUpdate(update);
-      }
-      switch (update.type) {
-        case "addRules":
-          for (const rule of update.rules) {
-            if (update.behavior === "allow") {
-              this.allowRules.push(rule);
-            } else if (update.behavior === "deny") {
-              this.denyRules.push(rule);
-            }
-          }
-          break;
-        case "removeRules":
-          for (const rule of update.rules) {
-            if (update.behavior === "allow") {
-              this.allowRules = this.allowRules.filter((r) => !(r.toolName === rule.toolName && r.ruleContent === rule.ruleContent));
-            } else if (update.behavior === "deny") {
-              this.denyRules = this.denyRules.filter((r) => !(r.toolName === rule.toolName && r.ruleContent === rule.ruleContent));
-            }
-          }
-          break;
-        case "replaceRules":
-          if (update.behavior === "allow") {
-            this.allowRules = [...update.rules];
-          } else if (update.behavior === "deny") {
-            this.denyRules = [...update.rules];
-          }
-          break;
-        case "setMode":
-          this.mode = update.mode;
-          break;
+        results.push(relativePath);
+      } else if (mode === "count") {
+        results.push(`${relativePath}:${matchedLines.length}`);
+      } else {
+        for (const { num, line } of matchedLines) {
+          results.push(`${relativePath}:${num}:${line}`);
+        }
       }
+    } catch {}
+    if (opts.head_limit && results.length >= opts.head_limit) {
+      break;
     }
   }
-  setMode(mode) {
-    this.mode = mode;
+  let output = results.join(`
+`);
+  if (opts.head_limit) {
+    const entries = output.split(`
+`).slice(0, opts.head_limit);
+    output = entries.join(`
+`);
   }
-  getMode() {
-    return this.mode;
+  return { content: output || "No matches found." };
+}
+async function collectFiles(dir, globPattern) {
+  const { Glob: Glob2 } = await Promise.resolve(globalThis.Bun);
+  const pattern = globPattern ?? "**/*";
+  const glob = new Glob2(pattern);
+  const files = [];
+  for await (const path of glob.scan({ cwd: dir, dot: false, onlyFiles: true })) {
+    files.push(`${dir}/${path}`);
   }
+  return files;
 }
 
-// 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 { homedir as homedir3 } from "os";
-
-class SettingsManager {
-  cwd;
-  constructor(cwd) {
-    this.cwd = cwd;
+// src/tools/notebook-edit.ts
+import { readFile, writeFile } from "fs/promises";
+function toSourceLines(text) {
+  const lines = text.split(`
+`);
+  return lines.map((line, idx) => idx < lines.length - 1 ? `${line}
+` : line);
+}
+var NotebookEditTool = {
+  name: "NotebookEdit",
+  description: "Edit a specific Jupyter notebook cell by id or index.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      notebook_path: { type: "string", description: "Path to .ipynb file." },
+      cell_id: { type: "string", description: "Cell id to edit." },
+      cell_index: { type: "number", description: "Cell index to edit if id is not provided." },
+      new_source: { type: "string", description: "New cell source content." }
+    },
+    required: ["notebook_path", "new_source"]
+  },
+  async execute(input, ctx) {
+    const {
+      notebook_path,
+      cell_id,
+      cell_index,
+      new_source
+    } = input ?? {};
+    if (!notebook_path)
+      return { content: "Error: notebook_path is required", isError: true };
+    if (new_source === undefined)
+      return { content: "Error: new_source is required", isError: true };
+    const filePath = notebook_path.startsWith("/") ? notebook_path : `${ctx.cwd}/${notebook_path}`;
+    try {
+      const raw = await readFile(filePath, "utf-8");
+      const notebook = JSON.parse(raw);
+      if (!Array.isArray(notebook.cells)) {
+        return { content: "Error: notebook has no cells array", isError: true };
+      }
+      let targetIndex = -1;
+      if (cell_id) {
+        targetIndex = notebook.cells.findIndex((c) => c.id === cell_id);
+      } else if (typeof cell_index === "number") {
+        targetIndex = cell_index;
+      } else {
+        targetIndex = 0;
+      }
+      if (targetIndex < 0 || targetIndex >= notebook.cells.length) {
+        return {
+          content: `Error: cell not found (id=${cell_id ?? "n/a"}, index=${String(cell_index ?? "n/a")})`,
+          isError: true
+        };
+      }
+      const cell = notebook.cells[targetIndex];
+      cell.source = toSourceLines(new_source);
+      await writeFile(filePath, JSON.stringify(notebook, null, 2) + `
+`, "utf-8");
+      return {
+        content: `Updated notebook cell ${targetIndex} in ${filePath}`
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { content: `Error editing notebook: ${message}`, isError: true };
+    }
   }
-  loadPermissions(sources) {
-    const allAllow = [];
-    const allDeny = [];
-    for (const source of sources) {
-      const path = this.sourceToPath(source);
-      const data = this.readJson(path);
-      if (!data?.permissions)
-        continue;
-      const perms = data.permissions;
-      if (Array.isArray(perms.allow)) {
-        for (const rule of perms.allow) {
-          if (typeof rule === "string") {
-            allAllow.push(this.parseRule(rule));
-          }
-        }
+};
+
+// 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)."
       }
-      if (Array.isArray(perms.deny)) {
-        for (const rule of perms.deny) {
-          if (typeof rule === "string") {
-            allDeny.push(this.parseRule(rule));
-          }
+    },
+    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);
     }
-    const result = {};
-    if (allAllow.length > 0)
-      result.allow = allAllow;
-    if (allDeny.length > 0)
-      result.deny = allDeny;
-    return result;
   }
-  persistUpdate(update) {
-    const path = this.destinationToPath(update.destination);
-    if (!path)
-      return;
-    const data = this.readJson(path) ?? {};
-    if (!data.permissions)
-      data.permissions = {};
-    const perms = data.permissions;
-    switch (update.type) {
-      case "addRules": {
-        const key = update.behavior;
-        const existing = Array.isArray(perms[key]) ? perms[key] : [];
-        const newRules = update.rules.map((r) => this.serializeRule(r));
-        const set = new Set(existing);
-        for (const rule of newRules)
-          set.add(rule);
-        perms[key] = [...set];
-        break;
+};
+
+// 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)."
       }
-      case "removeRules": {
-        const key = update.behavior;
-        if (!Array.isArray(perms[key]))
-          break;
-        const toRemove = new Set(update.rules.map((r) => this.serializeRule(r)));
-        perms[key] = perms[key].filter((r) => !toRemove.has(r));
-        break;
+    },
+    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
+        };
       }
-      case "replaceRules": {
-        const key = update.behavior;
-        perms[key] = update.rules.map((r) => this.serializeRule(r));
-        break;
+      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." };
       }
-      case "setMode": {
-        perms.defaultMode = update.mode;
-        break;
+      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}`);
       }
-      default:
-        return;
+      return { content: lines.join(`
+`) };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { content: `Error searching web: ${message}`, isError: true };
     }
-    const dir = dirname2(path);
-    if (!existsSync3(dir))
-      mkdirSync2(dir, { recursive: true });
-    writeFileSync3(path, JSON.stringify(data, null, 2) + `
-`);
   }
-  sourceToPath(source) {
-    switch (source) {
-      case "user":
-        return join3(homedir3(), ".claude", "settings.json");
-      case "project":
-        return join3(this.cwd, ".claude", "settings.json");
-      case "local":
-        return join3(this.cwd, ".claude", "settings.local.json");
+};
+
+// 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
+    };
   }
-  destinationToPath(destination) {
-    switch (destination) {
-      case "userSettings":
-        return join3(homedir3(), ".claude", "settings.json");
-      case "projectSettings":
-        return join3(this.cwd, ".claude", "settings.json");
-      case "localSettings":
-        return join3(this.cwd, ".claude", "settings.local.json");
-      default:
-        return null;
+};
+
+// src/tools/todo-write.ts
+import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
+import { dirname as dirname3, join as join4 } 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 = join4(ctx.cwd, ".claude", "todos.json");
+    try {
+      await mkdir2(dirname3(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 };
     }
   }
-  readJson(path) {
+};
+
+// src/tools/config.ts
+import { mkdir as mkdir3, readFile as readFile2, writeFile as writeFile3 } from "fs/promises";
+import { join as join5, dirname as dirname4 } from "path";
+function scopePath(cwd, scope) {
+  if (scope === "project")
+    return join5(cwd, ".claude", "settings.json");
+  return join5(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 content = readFileSync3(path, "utf-8");
-      return JSON.parse(content);
+      const raw = await readFile2(filePath, "utf-8");
+      data = JSON.parse(raw);
     } catch {
-      return null;
+      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(dirname4(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);
     }
   }
-  parseRule(s) {
-    const match = s.match(/^([^(]+)\((.+)\)$/);
-    if (match)
-      return { toolName: match[1], ruleContent: match[2] };
-    return { toolName: s };
-  }
-  serializeRule(rule) {
-    return rule.ruleContent ? `${rule.toolName}(${rule.ruleContent})` : rule.toolName;
-  }
+  return registry;
 }
 
 // src/skills/frontmatter.ts
@@ -2953,9 +3195,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 +3231,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 +3254,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 +3292,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 +3303,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 +3319,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 +3338,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 +3384,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 +3439,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 +3450,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,41 +3514,546 @@ 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) {
+    const skillsPrompt = formatSkillsForPrompt(context.skills);
+    if (skillsPrompt) {
+      sections.push(`# Skills
+
+${skillsPrompt}`);
+    }
+  }
+  if (context.customPrompt) {
+    sections.push(context.customPrompt);
+  }
+  return sections.join(`
+
+`);
+}
+function readProjectInstructions(cwd) {
+  for (const name of ["CLAUDE.md", "AGENTS.md"]) {
+    try {
+      const content = readFileSync5(join7(cwd, name), "utf-8").trim();
+      if (content)
+        return content;
+    } catch {}
+  }
+  return null;
+}
+
+// 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,
+    cwd,
+    sessionId,
+    maxTurns,
+    maxBudgetUsd,
+    includePartialMessages,
+    signal,
+    env,
+    debug,
+    hooks,
+    mcpClient,
+    previousMessages,
+    sessionLogger,
+    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()) {
+      tools.register(tool);
+    }
+    const { createListMcpResourcesTool: createListMcpResourcesTool2, createReadMcpResourceTool: createReadMcpResourceTool2 } = await Promise.resolve().then(() => exports_mcp_resources);
+    tools.register(createListMcpResourcesTool2(mcpClient));
+    tools.register(createReadMcpResourceTool2(mcpClient));
+  }
+  const messages = [
+    ...previousMessages ?? [],
+    { role: "user", content: prompt }
+  ];
+  if (sessionLogger) {
+    sessionLogger("user", prompt, null);
+  }
+  yield {
+    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("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 makeErrorResult({
+        subtype: "error_during_execution",
+        errors: ["Aborted"],
+        turns,
+        costUsd,
+        sessionId,
+        startTime,
+        apiTimeMs,
+        usage: totalUsage,
+        modelUsage,
+        permissionDenials
+      });
+      return;
+    }
+    if (turns >= maxTurns) {
+      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 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 = [];
+    const toolCalls = [];
+    let turnUsage = emptyTokenUsage();
+    let turnStopReason = null;
+    const nativeTools = nativeMemoryTool ? [nativeMemoryTool.definition] : undefined;
+    try {
+      const chunks = provider.chat({
+        model: activeModel,
+        messages,
+        tools: toolDefs.length > 0 ? toolDefs : undefined,
+        systemPrompt,
+        signal,
+        nativeTools,
+        thinkingBudget: maxThinkingTokensState?.current,
+        thinking,
+        effort,
+        outputFormat
+      });
+      for await (const chunk of chunks) {
+        switch (chunk.type) {
+          case "text_delta":
+            assistantTextParts.push(chunk.text);
+            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 (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":
+            toolCalls.push({ id: chunk.id, name: chunk.name, input: chunk.input });
+            break;
+          case "usage":
+            turnUsage = mergeUsage(turnUsage, chunk.usage);
+            break;
+          case "done":
+            turnStopReason = chunk.stopReason ?? null;
+            break;
+        }
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      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(activeModel, turnUsage);
+    costUsd += 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) {
+      assistantContent.push({ type: "text", text: assistantText });
+    }
+    for (const call of toolCalls) {
+      assistantContent.push({
+        type: "tool_use",
+        id: call.id,
+        name: call.name,
+        input: call.input
+      });
+    }
+    messages.push({ role: "assistant", content: assistantContent });
+    if (sessionLogger) {
+      sessionLogger("assistant", assistantContent, null);
+    }
+    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",
+          hook_event_name: "Stop",
+          session_id: sessionId,
+          text: assistantText || undefined,
+          stop_reason: turnStopReason ?? undefined
+        }, undefined, {
+          signal
+        });
+      }
+      if (hooks) {
+        await hooks.fire("SessionEnd", {
+          event: "SessionEnd",
+          hook_event_name: "SessionEnd",
+          session_id: sessionId,
+          reason: "other"
+        }, undefined, { signal });
+      }
+      yield {
+        type: "result",
+        subtype: "success",
+        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,
+        permission_denials: permissionDenials,
+        structured_output: structuredOutput,
+        uuid: uuid(),
+        session_id: sessionId
+      };
+      return;
+    }
+    const toolResults = [];
+    for (const call of toolCalls) {
+      let hookDenied = false;
+      let hookUpdatedInput;
+      if (hooks) {
+        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;
+          }
+          if (hookResult.updatedInput !== undefined) {
+            hookUpdatedInput = hookResult.updatedInput;
+          }
+        }
+      }
+      if (hookDenied) {
+        const denyContent = "Denied by hook";
+        toolResults.push({
+          type: "tool_result",
+          tool_use_id: call.id,
+          content: denyContent,
+          is_error: true
+        });
+        if (hooks) {
+          await hooks.fire("PostToolUseFailure", { event: "PostToolUseFailure", tool_name: call.name, tool_result: denyContent, tool_error: true, session_id: sessionId }, call.id, { signal });
+        }
+        continue;
+      }
+      const inputAfterHook = hookUpdatedInput !== undefined ? hookUpdatedInput : call.input;
+      const permResult = await permissions.check(call.name, inputAfterHook ?? {}, { signal, toolUseId: call.id });
+      if (permResult.behavior === "deny") {
+        const denyContent = `Permission denied: ${permResult.message}`;
+        permissionDenials.push({
+          tool_name: call.name,
+          tool_use_id: call.id,
+          tool_input: inputAfterHook ?? {}
+        });
+        toolResults.push({
+          type: "tool_result",
+          tool_use_id: call.id,
+          content: denyContent,
+          is_error: true
+        });
+        if (hooks) {
+          await hooks.fire("PostToolUseFailure", { event: "PostToolUseFailure", tool_name: call.name, tool_result: denyContent, tool_error: true, session_id: sessionId }, call.id, { signal });
+        }
+        continue;
+      }
+      const toolInput = permResult.behavior === "allow" && permResult.updatedInput ? permResult.updatedInput : inputAfterHook;
+      let result;
+      if (call.name === "memory" && nativeMemoryTool) {
+        try {
+          const content = await nativeMemoryTool.execute(toolInput);
+          result = { content, isError: content.startsWith("Error:") };
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          result = { content: `Error: ${message}`, isError: true };
+        }
+      } else {
+        const toolCtx = {
+          cwd,
+          signal,
+          sessionId,
+          env
+        };
+        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",
+            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",
+            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}`;
+          }
+        }
+      }
+      toolResults.push({
+        type: "tool_result",
+        tool_use_id: call.id,
+        content: result.content,
+        is_error: result.isError
+      });
     }
-  }
-  if (context.skills && context.skills.length > 0) {
-    const skillsPrompt = formatSkillsForPrompt(context.skills);
-    if (skillsPrompt) {
-      sections.push(`# Skills
-
-${skillsPrompt}`);
+    messages.push({ role: "user", content: toolResults });
+    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
+    };
   }
-  if (context.customPrompt) {
-    sections.push(context.customPrompt);
-  }
-  return sections.join(`
-
-`);
-}
-function readProjectInstructions(cwd) {
-  for (const name of ["CLAUDE.md", "AGENTS.md"]) {
-    try {
-      const content = readFileSync5(join5(cwd, name), "utf-8").trim();
-      if (content)
-        return content;
-    } catch {}
-  }
-  return null;
 }
 
 // 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 +4064,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 +4150,10 @@ var HOOK_EVENTS = [
   "SubagentStart",
   "SubagentStop",
   "PreCompact",
-  "PermissionRequest"
+  "PermissionRequest",
+  "Setup",
+  "TeammateIdle",
+  "TaskCompleted"
 ];
 var TOOL_EVENTS = new Set(["PreToolUse", "PostToolUse", "PostToolUseFailure"]);
 
@@ -3348,9 +4185,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 +4239,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 +4295,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,10 +4321,22 @@ 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) {
@@ -3478,64 +4376,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 +4686,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 +4702,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 +4744,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 +4798,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 +4973,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 +5021,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 +5064,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 +5075,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 +5088,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 +5111,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 +5131,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 +5140,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 +5162,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 +5273,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 +5324,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 +5385,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 +5394,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 +5439,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 +5452,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 +5460,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);
 }
 export {
   query