fourmis-agents-sdk 0.3.0 → 0.4.0

package/dist/agent-loop.d.ts

@@ -3,13 +3,13 @@
  *
  * AsyncGenerator that orchestrates:
  *   1. Call LLM via provider adapter
- *   2. Stream text deltas as AgentMessage events
+ *   2. Stream partial assistant deltas (optional)
  *   3. Collect tool calls
  *   4. Execute tools with permission checks
  *   5. Feed results back to LLM
  *   6. Repeat until done or limits reached
  */
-import type { AgentMessage } from "./types.js";
+import type { AgentMessage, OutputFormat, ThinkingConfig, Effort, SdkBeta, SdkPluginConfig } from "./types.js";
 import type { ProviderAdapter, NormalizedMessage, NormalizedContent } from "./providers/types.js";
 import type { ToolRegistry } from "./tools/registry.js";
 import type { PermissionManager } from "./permissions.js";
@@ -20,6 +20,16 @@ export type SessionLogger = (role: "user" | "assistant", content: NormalizedCont
 export type AgentLoopOptions = {
     provider: ProviderAdapter;
     model: string;
+    fallbackModel?: string;
+    modelState?: {
+        current: string;
+    };
+    maxThinkingTokensState?: {
+        current: number | undefined;
+    };
+    thinking?: ThinkingConfig;
+    effort?: Effort;
+    outputFormat?: OutputFormat;
     systemPrompt: string;
     tools: ToolRegistry;
     permissions: PermissionManager;
@@ -27,7 +37,7 @@ export type AgentLoopOptions = {
     sessionId: string;
     maxTurns: number;
     maxBudgetUsd: number;
-    includeStreamEvents: boolean;
+    includePartialMessages: boolean;
     signal: AbortSignal;
     env?: Record<string, string>;
     debug?: boolean;
@@ -37,6 +47,14 @@ export type AgentLoopOptions = {
     sessionLogger?: SessionLogger;
     /** Native memory tool for Anthropic provider (handled specially) */
     nativeMemoryTool?: NativeMemoryTool;
+    initMeta?: {
+        agents?: string[];
+        betas?: SdkBeta[];
+        slashCommands?: string[];
+        outputStyle?: string;
+        skills?: string[];
+        plugins?: SdkPluginConfig[];
+    };
 };
 export declare function agentLoop(prompt: string, options: AgentLoopOptions): AsyncGenerator<AgentMessage>;
 //# sourceMappingURL=agent-loop.d.ts.map

package/dist/agent-loop.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agent-loop.d.ts","sourceRoot":"","sources":["../src/agent-loop.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EACV,YAAY,EAGb,MAAM,YAAY,CAAC;AAEpB,OAAO,KAAK,EAAE,eAAe,EAAE,iBAAiB,EAAE,iBAAiB,EAAa,MAAM,sBAAsB,CAAC;AAC7G,OAAO,KAAK,EAAE,YAAY,EAAe,MAAM,qBAAqB,CAAC;AACrE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAC1D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAC9C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACxD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAG1D,MAAM,MAAM,aAAa,GAAG,CAC1B,IAAI,EAAE,MAAM,GAAG,WAAW,EAC1B,OAAO,EAAE,iBAAiB,EAAE,GAAG,MAAM,EACrC,UAAU,EAAE,MAAM,GAAG,IAAI,KACtB,MAAM,CAAC;AAEZ,MAAM,MAAM,gBAAgB,GAAG;IAC7B,QAAQ,EAAE,eAAe,CAAC;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE,YAAY,CAAC;IACpB,WAAW,EAAE,iBAAiB,CAAC;IAC/B,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,mBAAmB,EAAE,OAAO,CAAC;IAC7B,MAAM,EAAE,WAAW,CAAC;IACpB,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,KAAK,CAAC,EAAE,WAAW,CAAC;IACpB,SAAS,CAAC,EAAE,gBAAgB,CAAC;IAC7B,gBAAgB,CAAC,EAAE,iBAAiB,EAAE,CAAC;IACvC,aAAa,CAAC,EAAE,aAAa,CAAC;IAC9B,oEAAoE;IACpE,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;CACrC,CAAC;AAEF,wBAAuB,SAAS,CAC9B,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,gBAAgB,GACxB,cAAc,CAAC,YAAY,CAAC,CAkZ9B"}
+{"version":3,"file":"agent-loop.d.ts","sourceRoot":"","sources":["../src/agent-loop.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EACV,YAAY,EAMZ,YAAY,EACZ,cAAc,EACd,MAAM,EAEN,OAAO,EACP,eAAe,EAChB,MAAM,YAAY,CAAC;AAEpB,OAAO,KAAK,EAAE,eAAe,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAClG,OAAO,KAAK,EAAE,YAAY,EAAe,MAAM,qBAAqB,CAAC;AACrE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAC1D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAC9C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACxD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAG1D,MAAM,MAAM,aAAa,GAAG,CAC1B,IAAI,EAAE,MAAM,GAAG,WAAW,EAC1B,OAAO,EAAE,iBAAiB,EAAE,GAAG,MAAM,EACrC,UAAU,EAAE,MAAM,GAAG,IAAI,KACtB,MAAM,CAAC;AAEZ,MAAM,MAAM,gBAAgB,GAAG;IAC7B,QAAQ,EAAE,eAAe,CAAC;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,UAAU,CAAC,EAAE;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;IACjC,sBAAsB,CAAC,EAAE;QAAE,OAAO,EAAE,MAAM,GAAG,SAAS,CAAA;KAAE,CAAC;IACzD,QAAQ,CAAC,EAAE,cAAc,CAAC;IAC1B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,YAAY,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE,YAAY,CAAC;IACpB,WAAW,EAAE,iBAAiB,CAAC;IAC/B,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,sBAAsB,EAAE,OAAO,CAAC;IAChC,MAAM,EAAE,WAAW,CAAC;IACpB,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,KAAK,CAAC,EAAE,WAAW,CAAC;IACpB,SAAS,CAAC,EAAE,gBAAgB,CAAC;IAC7B,gBAAgB,CAAC,EAAE,iBAAiB,EAAE,CAAC;IACvC,aAAa,CAAC,EAAE,aAAa,CAAC;IAC9B,oEAAoE;IACpE,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;IACpC,QAAQ,CAAC,EAAE;QACT,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;QAClB,KAAK,CAAC,EAAE,OAAO,EAAE,CAAC;QAClB,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;QACzB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;QAClB,OAAO,CAAC,EAAE,eAAe,EAAE,CAAC;KAC7B,CAAC;CACH,CAAC;AA+DF,wBAAuB,SAAS,CAC9B,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,gBAAgB,GACxB,cAAc,CAAC,YAAY,CAAC,CAwjB9B"}

package/dist/agent-loop.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, {
@@ -104,10 +119,57 @@ function mergeUsage(a, b) {
 }
 
 // src/agent-loop.ts
+function makeModelUsageEntry() {
+  return {
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadInputTokens: 0,
+    cacheCreationInputTokens: 0,
+    totalCostUsd: 0
+  };
+}
+function makeErrorResult(params) {
+  return {
+    type: "result",
+    subtype: params.subtype,
+    duration_ms: Date.now() - params.startTime,
+    duration_api_ms: params.apiTimeMs,
+    is_error: true,
+    num_turns: params.turns,
+    stop_reason: null,
+    total_cost_usd: params.costUsd,
+    usage: params.usage,
+    modelUsage: params.modelUsage,
+    permission_denials: params.permissionDenials,
+    errors: params.errors,
+    uuid: uuid(),
+    session_id: params.sessionId
+  };
+}
+function extractStructuredJson(text) {
+  const trimmed = text.trim();
+  if (!trimmed) {
+    return { ok: false, error: "Empty result text; expected JSON output." };
+  }
+  const fenced = trimmed.match(/```(?:json)?\s*([\s\S]*?)\s*```/i);
+  const candidate = fenced ? fenced[1].trim() : trimmed;
+  try {
+    return { ok: true, value: JSON.parse(candidate) };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { ok: false, error: `Invalid JSON output: ${message}` };
+  }
+}
 async function* agentLoop(prompt, options) {
   const {
     provider,
     model,
+    fallbackModel,
+    modelState,
+    maxThinkingTokensState,
+    thinking,
+    effort,
+    outputFormat,
     systemPrompt,
     tools,
     permissions,
@@ -115,7 +177,7 @@ async function* agentLoop(prompt, options) {
     sessionId,
     maxTurns,
     maxBudgetUsd,
-    includeStreamEvents,
+    includePartialMessages,
     signal,
     env,
     debug,
@@ -123,14 +185,17 @@ async function* agentLoop(prompt, options) {
     mcpClient,
     previousMessages,
     sessionLogger,
-    nativeMemoryTool
+    nativeMemoryTool,
+    initMeta
   } = options;
+  const effectiveModelState = modelState ?? { current: model };
   const startTime = Date.now();
   let apiTimeMs = 0;
   let turns = 0;
   let totalUsage = emptyTokenUsage();
   let costUsd = 0;
   const modelUsage = {};
+  const permissionDenials = [];
   if (mcpClient) {
     await mcpClient.connectAll();
     for (const tool of mcpClient.getTools()) {
@@ -148,56 +213,135 @@ async function* agentLoop(prompt, options) {
     sessionLogger("user", prompt, null);
   }
   yield {
-    type: "init",
-    sessionId,
-    model,
-    provider: provider.name,
+    type: "system",
+    subtype: "init",
+    apiKeySource: "user",
+    claude_code_version: "fourmis-agent-sdk",
+    session_id: sessionId,
+    model: effectiveModelState.current,
     tools: tools.list(),
     cwd,
+    mcp_servers: (mcpClient?.status() ?? []).map((s) => ({ name: s.name, status: s.status })),
+    permissionMode: permissions.getMode(),
+    agents: initMeta?.agents,
+    betas: initMeta?.betas,
+    slash_commands: initMeta?.slashCommands ?? [],
+    output_style: initMeta?.outputStyle ?? "default",
+    skills: initMeta?.skills ?? [],
+    plugins: (initMeta?.plugins ?? []).map((p) => ({ name: p.path.split("/").pop() ?? p.path, path: p.path })),
     uuid: uuid()
   };
   if (hooks) {
-    await hooks.fire("SessionStart", { event: "SessionStart", session_id: sessionId }, undefined, { signal });
+    await hooks.fire("Setup", {
+      event: "Setup",
+      hook_event_name: "Setup",
+      trigger: "init",
+      session_id: sessionId,
+      cwd,
+      permission_mode: permissions.getMode()
+    }, undefined, { signal });
+  }
+  if (hooks) {
+    await hooks.fire("SessionStart", {
+      event: "SessionStart",
+      hook_event_name: "SessionStart",
+      session_id: sessionId,
+      source: "startup",
+      model: effectiveModelState.current,
+      cwd,
+      permission_mode: permissions.getMode()
+    }, undefined, { signal });
   }
   while (true) {
     if (signal.aborted) {
-      yield makeError("error_execution", ["Aborted"], turns, costUsd, sessionId, startTime);
+      yield makeErrorResult({
+        subtype: "error_during_execution",
+        errors: ["Aborted"],
+        turns,
+        costUsd,
+        sessionId,
+        startTime,
+        apiTimeMs,
+        usage: totalUsage,
+        modelUsage,
+        permissionDenials
+      });
       return;
     }
     if (turns >= maxTurns) {
-      yield makeError("error_max_turns", [`Reached maximum turns (${maxTurns})`], turns, costUsd, sessionId, startTime);
+      yield makeErrorResult({
+        subtype: "error_max_turns",
+        errors: [`Reached maximum turns (${maxTurns})`],
+        turns,
+        costUsd,
+        sessionId,
+        startTime,
+        apiTimeMs,
+        usage: totalUsage,
+        modelUsage,
+        permissionDenials
+      });
       return;
     }
     if (maxBudgetUsd > 0 && costUsd >= maxBudgetUsd) {
-      yield makeError("error_max_budget", [`Reached budget limit ($${maxBudgetUsd})`], turns, costUsd, sessionId, startTime);
+      yield makeErrorResult({
+        subtype: "error_max_budget_usd",
+        errors: [],
+        turns,
+        costUsd,
+        sessionId,
+        startTime,
+        apiTimeMs,
+        usage: totalUsage,
+        modelUsage,
+        permissionDenials
+      });
       return;
     }
+    const activeModel = effectiveModelState.current;
     const toolDefs = tools.getDefinitions();
     const apiStart = Date.now();
     let assistantTextParts = [];
-    let toolCalls = [];
+    const toolCalls = [];
     let turnUsage = emptyTokenUsage();
+    let turnStopReason = null;
     const nativeTools = nativeMemoryTool ? [nativeMemoryTool.definition] : undefined;
     try {
       const chunks = provider.chat({
-        model,
+        model: activeModel,
         messages,
         tools: toolDefs.length > 0 ? toolDefs : undefined,
         systemPrompt,
         signal,
-        nativeTools
+        nativeTools,
+        thinkingBudget: maxThinkingTokensState?.current,
+        thinking,
+        effort,
+        outputFormat
       });
       for await (const chunk of chunks) {
         switch (chunk.type) {
           case "text_delta":
             assistantTextParts.push(chunk.text);
-            if (includeStreamEvents) {
-              yield { type: "stream", subtype: "text_delta", text: chunk.text, uuid: uuid() };
+            if (includePartialMessages) {
+              yield {
+                type: "stream_event",
+                event: { type: "text_delta", text: chunk.text },
+                parent_tool_use_id: null,
+                uuid: uuid(),
+                session_id: sessionId
+              };
             }
             break;
           case "thinking_delta":
-            if (includeStreamEvents) {
-              yield { type: "stream", subtype: "thinking_delta", text: chunk.text, uuid: uuid() };
+            if (includePartialMessages) {
+              yield {
+                type: "stream_event",
+                event: { type: "thinking_delta", thinking: chunk.text },
+                parent_tool_use_id: null,
+                uuid: uuid(),
+                session_id: sessionId
+              };
             }
             break;
           case "tool_call":
@@ -207,33 +351,54 @@ async function* agentLoop(prompt, options) {
             turnUsage = mergeUsage(turnUsage, chunk.usage);
             break;
           case "done":
+            turnStopReason = chunk.stopReason ?? null;
             break;
         }
       }
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
-      yield makeError("error_execution", [`API error: ${message}`], turns, costUsd, sessionId, startTime);
+      if (fallbackModel && activeModel !== fallbackModel) {
+        effectiveModelState.current = fallbackModel;
+        yield {
+          type: "system",
+          subtype: "status",
+          status: null,
+          permissionMode: permissions.getMode(),
+          uuid: uuid(),
+          session_id: sessionId
+        };
+        continue;
+      }
+      yield makeErrorResult({
+        subtype: "error_during_execution",
+        errors: [`API error: ${message}`],
+        turns,
+        costUsd,
+        sessionId,
+        startTime,
+        apiTimeMs,
+        usage: totalUsage,
+        modelUsage,
+        permissionDenials
+      });
       return;
     }
     apiTimeMs += Date.now() - apiStart;
     turns++;
     totalUsage = mergeUsage(totalUsage, turnUsage);
-    const turnCost = provider.calculateCost(model, turnUsage);
+    const turnCost = provider.calculateCost(activeModel, turnUsage);
     costUsd += turnCost;
-    if (!modelUsage[model]) {
-      modelUsage[model] = {
-        inputTokens: 0,
-        outputTokens: 0,
-        cacheReadInputTokens: 0,
-        cacheCreationInputTokens: 0,
-        totalCostUsd: 0
-      };
+    if (!modelUsage[activeModel]) {
+      modelUsage[activeModel] = makeModelUsageEntry();
     }
-    modelUsage[model].inputTokens += turnUsage.inputTokens;
-    modelUsage[model].outputTokens += turnUsage.outputTokens;
-    modelUsage[model].cacheReadInputTokens += turnUsage.cacheReadInputTokens;
-    modelUsage[model].cacheCreationInputTokens += turnUsage.cacheCreationInputTokens;
-    modelUsage[model].totalCostUsd += turnCost;
+    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) {
@@ -251,28 +416,72 @@ async function* agentLoop(prompt, options) {
     if (sessionLogger) {
       sessionLogger("assistant", assistantContent, null);
     }
-    if (assistantText) {
-      yield { type: "text", text: assistantText, uuid: uuid() };
-    }
+    yield {
+      type: "assistant",
+      message: {
+        role: "assistant",
+        content: assistantContent
+      },
+      parent_tool_use_id: null,
+      uuid: uuid(),
+      session_id: sessionId
+    };
     if (toolCalls.length === 0) {
+      let structuredOutput;
+      if (outputFormat?.type === "json_schema") {
+        const parsed = extractStructuredJson(assistantText);
+        if (!parsed.ok) {
+          yield makeErrorResult({
+            subtype: "error_max_structured_output_retries",
+            errors: [parsed.error],
+            turns,
+            costUsd,
+            sessionId,
+            startTime,
+            apiTimeMs,
+            usage: totalUsage,
+            modelUsage,
+            permissionDenials
+          });
+          return;
+        }
+        structuredOutput = parsed.value;
+      }
       if (hooks) {
-        await hooks.fire("Stop", { event: "Stop", session_id: sessionId, text: assistantText || undefined }, undefined, { signal });
+        await hooks.fire("Stop", {
+          event: "Stop",
+          hook_event_name: "Stop",
+          session_id: sessionId,
+          text: assistantText || undefined,
+          stop_reason: turnStopReason ?? undefined
+        }, undefined, {
+          signal
+        });
       }
       if (hooks) {
-        await hooks.fire("SessionEnd", { event: "SessionEnd", session_id: sessionId }, undefined, { signal });
+        await hooks.fire("SessionEnd", {
+          event: "SessionEnd",
+          hook_event_name: "SessionEnd",
+          session_id: sessionId,
+          reason: "other"
+        }, undefined, { signal });
       }
       yield {
         type: "result",
         subtype: "success",
-        text: assistantText || null,
-        turns,
-        costUsd,
-        durationMs: Date.now() - startTime,
-        durationApiMs: apiTimeMs,
-        sessionId,
+        duration_ms: Date.now() - startTime,
+        duration_api_ms: apiTimeMs,
+        is_error: false,
+        num_turns: turns,
+        result: assistantText,
+        stop_reason: turnStopReason,
+        total_cost_usd: costUsd,
         usage: totalUsage,
         modelUsage,
-        uuid: uuid()
+        permission_denials: permissionDenials,
+        structured_output: structuredOutput,
+        uuid: uuid(),
+        session_id: sessionId
       };
       return;
     }
@@ -281,7 +490,13 @@ async function* agentLoop(prompt, options) {
       let hookDenied = false;
       let hookUpdatedInput;
       if (hooks) {
-        const hookResult = await hooks.fire("PreToolUse", { event: "PreToolUse", tool_name: call.name, tool_input: call.input, session_id: sessionId }, call.id, { signal });
+        const hookResult = await hooks.fire("PreToolUse", {
+          event: "PreToolUse",
+          hook_event_name: "PreToolUse",
+          tool_name: call.name,
+          tool_input: call.input,
+          session_id: sessionId
+        }, call.id, { signal });
         if (hookResult) {
           if (hookResult.permissionDecision === "deny") {
             hookDenied = true;
@@ -293,14 +508,6 @@ async function* agentLoop(prompt, options) {
       }
       if (hookDenied) {
         const denyContent = "Denied by hook";
-        yield {
-          type: "tool_result",
-          id: call.id,
-          name: call.name,
-          content: denyContent,
-          isError: true,
-          uuid: uuid()
-        };
         toolResults.push({
           type: "tool_result",
           tool_use_id: call.id,
@@ -316,14 +523,11 @@ async function* agentLoop(prompt, options) {
       const permResult = await permissions.check(call.name, inputAfterHook ?? {}, { signal, toolUseId: call.id });
       if (permResult.behavior === "deny") {
         const denyContent = `Permission denied: ${permResult.message}`;
-        yield {
-          type: "tool_result",
-          id: call.id,
-          name: call.name,
-          content: denyContent,
-          isError: true,
-          uuid: uuid()
-        };
+        permissionDenials.push({
+          tool_name: call.name,
+          tool_use_id: call.id,
+          tool_input: inputAfterHook ?? {}
+        });
         toolResults.push({
           type: "tool_result",
           tool_use_id: call.id,
@@ -336,13 +540,6 @@ async function* agentLoop(prompt, options) {
         continue;
       }
       const toolInput = permResult.behavior === "allow" && permResult.updatedInput ? permResult.updatedInput : inputAfterHook;
-      yield {
-        type: "tool_use",
-        id: call.id,
-        name: call.name,
-        input: toolInput,
-        uuid: uuid()
-      };
       let result;
       if (call.name === "memory" && nativeMemoryTool) {
         try {
@@ -361,28 +558,36 @@ async function* agentLoop(prompt, options) {
         };
         result = await tools.execute(call.name, toolInput, toolCtx);
       }
+      if (call.name === "ExitPlanMode") {
+        permissions.setMode("default");
+      }
       if (debug) {
         console.error(`[debug] Tool ${call.name}: ${result.isError ? "ERROR" : "OK"} (${result.content.length} chars)`);
       }
       if (hooks) {
         if (result.isError) {
-          await hooks.fire("PostToolUseFailure", { event: "PostToolUseFailure", tool_name: call.name, tool_result: result.content, tool_error: true, session_id: sessionId }, call.id, { signal });
+          await hooks.fire("PostToolUseFailure", {
+            event: "PostToolUseFailure",
+            hook_event_name: "PostToolUseFailure",
+            tool_name: call.name,
+            tool_result: result.content,
+            tool_error: true,
+            session_id: sessionId
+          }, call.id, { signal });
         } else {
-          const postResult = await hooks.fire("PostToolUse", { event: "PostToolUse", tool_name: call.name, tool_result: result.content, session_id: sessionId }, call.id, { signal });
+          const postResult = await hooks.fire("PostToolUse", {
+            event: "PostToolUse",
+            hook_event_name: "PostToolUse",
+            tool_name: call.name,
+            tool_result: result.content,
+            session_id: sessionId
+          }, call.id, { signal });
           if (postResult?.additionalContext) {
             result.content += `
 ${postResult.additionalContext}`;
           }
         }
       }
-      yield {
-        type: "tool_result",
-        id: call.id,
-        name: call.name,
-        content: result.content,
-        isError: result.isError,
-        uuid: uuid()
-      };
       toolResults.push({
         type: "tool_result",
         tool_use_id: call.id,
@@ -394,20 +599,19 @@ ${postResult.additionalContext}`;
     if (sessionLogger) {
       sessionLogger("user", toolResults, null);
     }
+    yield {
+      type: "user",
+      message: {
+        role: "user",
+        content: toolResults
+      },
+      parent_tool_use_id: null,
+      isSynthetic: true,
+      uuid: uuid(),
+      session_id: sessionId
+    };
   }
 }
-function makeError(subtype, errors, turns, costUsd, sessionId, startTime) {
-  return {
-    type: "result",
-    subtype,
-    errors,
-    turns,
-    costUsd,
-    durationMs: Date.now() - startTime,
-    sessionId,
-    uuid: uuid()
-  };
-}
 export {
   agentLoop
 };