mini-coder 0.5.13 → 0.6.0

package/src/agent.ts

@@ -1,945 +1,272 @@
-/**
- * Core agent loop.
- *
- * Streams LLM responses, executes tool calls, appends messages to the
- * session history, and loops until the model stops or the user interrupts.
- * Uses pi-ai's {@link streamSimple} for model communication.
- *
- * @module
- */
-
-import type { Database } from "bun:sqlite";
-import type {
-  AssistantMessage,
-  AssistantMessageEvent,
-  Message,
-  Model,
-  ThinkingLevel,
-  Tool,
-  ToolCall,
-  ToolResultMessage,
-  UserMessage,
+import {
+  type AssistantMessage,
+  type Context,
+  type Message,
+  streamSimple,
+  type TextContent,
+  type ToolCall,
+  type ToolResultMessage,
 } from "@mariozechner/pi-ai";
-import { streamSimple } from "@mariozechner/pi-ai";
-import { appendMessage } from "./session.ts";
-import { getTodoItems, type ToolExecResult } from "./tools.ts";
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-/**
- * A tool execution handler.
- *
- * Called by the agent loop when the model invokes a tool. Arguments are
- * the JSON object parsed by pi-ai from the model's tool call.
- */
-/** Callback used by tool handlers to report progressive output updates. */
-export type ToolUpdateCallback = (result: ToolExecResult) => void;
-
-export type ToolHandler = (
-  args: Record<string, unknown>,
-  cwd: string,
-  signal?: AbortSignal,
-  onUpdate?: ToolUpdateCallback,
-) => Promise<ToolExecResult> | ToolExecResult;
-
-export type { ToolExecResult };
-
-/** Events emitted during the agent loop for UI updates. */
-export type AgentEvent =
-  | {
-      type: "text_delta";
-      delta: string;
-      content: AssistantMessage["content"];
-    }
-  | {
-      type: "thinking_delta";
-      delta: string;
-      content: AssistantMessage["content"];
-    }
-  | {
-      type: "toolcall_start";
-      toolCallId: string;
-      name: string;
-      args: Record<string, unknown>;
-      content: AssistantMessage["content"];
-    }
-  | {
-      type: "toolcall_delta";
-      toolCallId: string;
-      name: string;
-      args: Record<string, unknown>;
-      delta: string;
-      content: AssistantMessage["content"];
-    }
-  | {
-      type: "toolcall_end";
-      toolCallId: string;
-      name: string;
-      args: Record<string, unknown>;
-      content: AssistantMessage["content"];
-    }
-  | { type: "user_message"; message: UserMessage }
-  | { type: "assistant_message"; message: AssistantMessage }
-  | {
-      type: "tool_start";
-      toolCallId: string;
-      name: string;
-      args: Record<string, unknown>;
-    }
-  | {
-      type: "tool_delta";
-      toolCallId: string;
-      name: string;
-      result: ToolExecResult;
-    }
-  | {
-      type: "tool_end";
-      toolCallId: string;
-      name: string;
-      result: ToolExecResult;
-    }
-  | { type: "tool_result"; message: ToolResultMessage }
-  | { type: "done"; message: AssistantMessage }
-  | { type: "error"; message: AssistantMessage }
-  | { type: "aborted"; message: AssistantMessage };
-
-/** Options for the agent loop. */
-interface RunAgentOpts {
-  /** Open database handle. */
-  db: Database;
-  /** Current session ID. */
-  sessionId: string;
-  /** Turn number for this agent loop (all messages share this turn). */
-  turn: number;
-  /** The model to stream with. */
-  model: Model<string>;
-  /** The assembled system prompt. */
-  systemPrompt: string;
-  /** Tool definitions sent to the model. */
-  tools: Tool[];
-  /** Tool name → handler map for executing tool calls. */
-  toolHandlers: Map<string, ToolHandler>;
-  /** Current message history (mutated in-place as messages are appended). */
-  messages: Message[];
-  /** Working directory for tool execution. */
-  cwd: string;
-  /** API key for the provider. */
-  apiKey?: string;
-  /** Reasoning effort level (e.g. "low", "medium", "high", "xhigh"). */
-  effort?: ThinkingLevel;
-  /** Abort signal for interruption. */
-  signal?: AbortSignal;
-  /** Callback for UI events. */
-  onEvent?: (event: AgentEvent) => void;
-  /** Dequeue the next queued steering message, if one is waiting. */
-  takeQueuedUserMessage?: () => UserMessage | null;
-}
-
-/** Result of the agent loop. */
-interface AgentLoopResult {
-  /** The updated message history. */
-  messages: Message[];
-  /** How the loop ended. */
-  stopReason: "stop" | "length" | "error" | "aborted";
-}
-
-function cloneAssistantContent(
-  content: AssistantMessage["content"],
-): AssistantMessage["content"] {
-  return content.map((block) => {
-    if (block.type === "toolCall") {
-      return {
-        ...block,
-        arguments: structuredClone(block.arguments),
-      };
-    }
-    return { ...block };
-  });
-}
-
-interface MergedAssistantBlock {
-  block: AssistantMessage["content"][number];
-  partialStep: number;
-  finalStep: number;
-}
-
-function mergeAssistantBlocks(
-  partialBlock: AssistantMessage["content"][number] | undefined,
-  finalBlock: AssistantMessage["content"][number] | undefined,
-): MergedAssistantBlock | null {
-  if (!partialBlock && !finalBlock) {
-    return null;
-  }
-  if (!partialBlock && finalBlock) {
-    return { block: finalBlock, partialStep: 0, finalStep: 1 };
-  }
-  if (partialBlock && !finalBlock) {
-    return { block: partialBlock, partialStep: 1, finalStep: 0 };
-  }
-  if (!partialBlock || !finalBlock) {
-    return null;
-  }
-  if (partialBlock.type === finalBlock.type) {
-    const shouldPreservePartialThinking =
-      partialBlock.type === "thinking" &&
-      finalBlock.type === "thinking" &&
-      partialBlock.thinking &&
-      !finalBlock.thinking;
-    return {
-      block: shouldPreservePartialThinking ? partialBlock : finalBlock,
-      partialStep: 1,
-      finalStep: 1,
-    };
-  }
-  if (partialBlock.type === "thinking") {
-    return { block: partialBlock, partialStep: 1, finalStep: 0 };
-  }
-  return { block: finalBlock, partialStep: 1, finalStep: 1 };
-}
-
-/** Merge streamed partial assistant content into the final message content. */
-function mergeAssistantContent(
-  partialContent: AssistantMessage["content"],
-  finalContent: AssistantMessage["content"],
-): AssistantMessage["content"] {
-  if (partialContent.length === 0) return finalContent;
-  if (finalContent.length === 0) return partialContent;
-
-  const merged: AssistantMessage["content"] = [];
-  let partialIndex = 0;
-  let finalIndex = 0;
-
-  while (
-    partialIndex < partialContent.length ||
-    finalIndex < finalContent.length
-  ) {
-    const nextBlock = mergeAssistantBlocks(
-      partialContent[partialIndex],
-      finalContent[finalIndex],
-    );
-    if (!nextBlock) {
-      break;
+import { getApiKey } from "./oauth";
+import type {
+  AgentContex,
+  AgentEvent,
+  AgentToolEvent,
+  ToolAndRunner,
+} from "./types";
+
+// ### JetBrains Junie: Observation Masking
+// Published research found that **simply hiding old tool outputs** matched the quality of full LLM summarization with **zero extra compute**:
+// https://blog.jetbrains.com/research/2025/12/efficient-context-management/
+export function compactContext(messages: Message[]) {
+  // TODO: Preserve SKILL.md contents, and exclude them from compaction.
+  // Problem: How do we know? we need to check each message result againt it's arguments
+  // and then find if by chance it has a read skill command... This is a mess. We we.
+  // A better way would be to first add a read(path, lines, offset). And then we know
+  // which files are read using it, and can match by path if it's a SKILL.md ending.
+  const KEEP_OBSERVATIONS = 10;
+
+  const toolResultIndices: number[] = [];
+  for (let i = 0; i < messages.length; i++) {
+    if (messages[i].role !== "toolResult") continue;
+    const content = (messages[i] as ToolResultMessage).content;
+    if (
+      content.length === 1 &&
+      content[0].type === "text" &&
+      content[0].text.startsWith("Old environment output:")
+    ) {
+      continue;
     }
-    merged.push(nextBlock.block);
-    partialIndex += nextBlock.partialStep;
-    finalIndex += nextBlock.finalStep;
+    toolResultIndices.push(i);
   }
 
-  return merged;
-}
-
-/** Merge a final assistant message with the richest streamed partial content seen. */
-function mergeAssistantMessage(
-  partialMessage: AssistantMessage,
-  finalMessage: AssistantMessage,
-): AssistantMessage {
-  return {
-    ...finalMessage,
-    content: mergeAssistantContent(
-      partialMessage.content,
-      finalMessage.content,
-    ),
-  };
-}
-
-function toolErrorResult(name: string, error: unknown): ToolExecResult {
-  const message = error instanceof Error ? error.message : String(error);
-
-  return {
-    content: [{ type: "text", text: `Tool ${name} failed: ${message}` }],
-    isError: true,
-  };
-}
-
-function unknownToolResult(name: string): ToolExecResult {
-  return {
-    content: [{ type: "text", text: `Unknown tool: ${name}` }],
-    isError: true,
-  };
-}
-
-function buildAgentContext(
-  systemPrompt: string,
-  messages: Message[],
-  tools: Tool[],
-) {
-  return tools.length > 0
-    ? { systemPrompt, messages, tools }
-    : { systemPrompt, messages };
-}
-
-function buildStreamOptions(
-  apiKey: string | undefined,
-  effort: ThinkingLevel | undefined,
-  signal: AbortSignal | undefined,
-) {
-  return {
-    ...(apiKey ? { apiKey } : {}),
-    ...(effort ? { reasoning: effort } : {}),
-    ...(signal ? { signal } : {}),
-  };
-}
-
-interface StreamedToolCallEventPayload {
-  toolCallId: string;
-  name: string;
-  args: Record<string, unknown>;
-  content: AssistantMessage["content"];
-}
-
-function buildStreamedToolCallEventPayload(
-  partial: AssistantMessage,
-  contentIndex: number,
-  toolCall?: ToolCall,
-): StreamedToolCallEventPayload | null {
-  const block = toolCall ?? partial.content[contentIndex];
-  if (!block || block.type !== "toolCall") {
-    return null;
-  }
-
-  return {
-    toolCallId: block.id,
-    name: block.name,
-    args: structuredClone(block.arguments),
-    content: cloneAssistantContent(partial.content),
-  };
-}
-
-function handleAssistantStreamEvent(
-  event: AssistantMessageEvent,
-  onEvent: RunAgentOpts["onEvent"],
-): AssistantMessage | null {
-  switch (event.type) {
-    case "text_delta":
-      onEvent?.({
-        type: "text_delta",
-        delta: event.delta,
-        content: cloneAssistantContent(event.partial.content),
-      });
-      return null;
-    case "thinking_delta":
-      onEvent?.({
-        type: "thinking_delta",
-        delta: event.delta,
-        content: cloneAssistantContent(event.partial.content),
-      });
-      return null;
-    case "toolcall_start": {
-      const payload = buildStreamedToolCallEventPayload(
-        event.partial,
-        event.contentIndex,
-      );
-      if (payload) {
-        onEvent?.({
-          type: "toolcall_start",
-          ...payload,
-        });
+  if (toolResultIndices.length <= KEEP_OBSERVATIONS) return;
+
+  for (let i = 0; i < toolResultIndices.length - KEEP_OBSERVATIONS; i++) {
+    const idx = toolResultIndices[i];
+    const msg = messages[idx] as ToolResultMessage;
+    let lines = 0;
+    let images = 0;
+    for (const c of msg.content) {
+      if (c.type === "text") {
+        lines += c.text.split(/\r?\n/).length;
+      } else if (c.type === "image") {
+        images++;
       }
-      return null;
     }
-    case "toolcall_delta": {
-      const payload = buildStreamedToolCallEventPayload(
-        event.partial,
-        event.contentIndex,
-      );
-      if (payload) {
-        onEvent?.({
-          type: "toolcall_delta",
-          delta: event.delta,
-          ...payload,
-        });
-      }
-      return null;
-    }
-    case "toolcall_end": {
-      const payload = buildStreamedToolCallEventPayload(
-        event.partial,
-        event.contentIndex,
-        event.toolCall,
-      );
-      if (payload) {
-        onEvent?.({
-          type: "toolcall_end",
-          ...payload,
-        });
-      }
-      return null;
+    let text = `Old environment output: (${lines} lines omitted)`;
+    if (images > 0) {
+      text += ` (${images} image${images > 1 ? "s" : ""} omitted)`;
     }
-    case "done":
-      return event.message;
-    case "error":
-      return event.error;
-    case "start":
-    case "text_start":
-    case "text_end":
-    case "thinking_start":
-    case "thinking_end":
-      return null;
+    msg.content = [{ type: "text", text }];
   }
 }
 
-function buildIncompleteAssistantMessage(
-  opts: Pick<RunAgentOpts, "model" | "signal">,
-  partialAssistantMessage?: AssistantMessage,
-): AssistantMessage {
-  const stopReason = opts.signal?.aborted ? "aborted" : "error";
-  const errorMessage =
-    stopReason === "aborted"
-      ? "Request was aborted"
-      : "Stream ended without a final assistant message";
-
-  return {
-    role: "assistant",
-    content: partialAssistantMessage
-      ? cloneAssistantContent(partialAssistantMessage.content)
-      : [],
-    api: partialAssistantMessage?.api ?? opts.model.api,
-    provider: partialAssistantMessage?.provider ?? opts.model.provider,
-    model: partialAssistantMessage?.model ?? opts.model.id,
-    usage: partialAssistantMessage?.usage ?? {
-      input: 0,
-      output: 0,
-      cacheRead: 0,
-      cacheWrite: 0,
-      totalTokens: 0,
-      cost: {
-        input: 0,
-        output: 0,
-        cacheRead: 0,
-        cacheWrite: 0,
-        total: 0,
-      },
-    },
-    stopReason,
-    errorMessage,
-    timestamp: Date.now(),
+export async function* streamAgent(
+  agentCtx: AgentContex,
+): AsyncGenerator<AgentEvent> {
+  const llmCtx: Context = {
+    systemPrompt: agentCtx.systemPrompt,
+    tools: agentCtx.tools.map((t) => t.tool),
+    messages: agentCtx.messages,
   };
-}
 
-async function resolveStreamResultSoon(
-  streamResult: Promise<AssistantMessage>,
-): Promise<AssistantMessage | undefined> {
-  const pending = Symbol("pending");
-  const result = await Promise.race([
-    streamResult,
-    new Promise<typeof pending>((resolve) => {
-      setTimeout(() => resolve(pending), 0);
-    }),
-  ]);
-  return result === pending ? undefined : result;
-}
-
-async function streamAssistantMessage(
-  opts: Pick<
-    RunAgentOpts,
-    | "model"
-    | "systemPrompt"
-    | "tools"
-    | "messages"
-    | "apiKey"
-    | "effort"
-    | "signal"
-    | "onEvent"
-  >,
-): Promise<AssistantMessage> {
-  const eventStream = streamSimple(
-    opts.model,
-    buildAgentContext(opts.systemPrompt, opts.messages, opts.tools),
-    buildStreamOptions(opts.apiKey, opts.effort, opts.signal),
-  );
-  const streamResult = eventStream.result();
-  let settledStreamResult: AssistantMessage | undefined;
-  void streamResult.then((message) => {
-    settledStreamResult = message;
-  });
+  // Important for refreshing tokens.
+  const apiKey = await getApiKey(agentCtx.options);
 
-  let assistantMessage: AssistantMessage | undefined;
-  let partialAssistantMessage: AssistantMessage | undefined;
+  // Main agent loop, continues until llm sends a response other than toolCall or has no tool calls.
+  while (true) {
+    const s = streamSimple(agentCtx.options.model, llmCtx, {
+      reasoning: agentCtx.options.effort,
+      signal: agentCtx.signal,
+      apiKey,
+    });
 
-  for await (const event of eventStream) {
-    if ("partial" in event) {
-      partialAssistantMessage = event.partial;
+    let partial: AssistantMessage | null = null;
+    let added = false;
+
+    for await (const e of s) {
+      switch (e.type) {
+        case "start":
+          partial = e.partial;
+          llmCtx.messages.push(e.partial);
+          added = true;
+          yield { type: "message_start", partial };
+          break;
+
+        case "text_start":
+        case "text_delta":
+        case "text_end":
+        case "thinking_start":
+        case "thinking_delta":
+        case "thinking_end":
+        case "toolcall_start":
+        case "toolcall_delta":
+        case "toolcall_end":
+          if (partial) {
+            partial = e.partial;
+            llmCtx.messages[llmCtx.messages.length - 1] = partial;
+            yield { type: "message_update", partial };
+          }
+          break;
+
+        case "error": {
+          const finalMessage = await s.result();
+          if (added) {
+            llmCtx.messages[llmCtx.messages.length - 1] = finalMessage;
+          } else {
+            llmCtx.messages.push(finalMessage);
+            yield { type: "message_start", partial: { ...finalMessage } };
+          }
+
+          yield { type: "message_end", message: finalMessage };
+          return;
+        }
+      }
     }
 
-    assistantMessage =
-      handleAssistantStreamEvent(event, opts.onEvent) ?? assistantMessage;
-  }
-
-  // `end(result)` resolves the final result without emitting a terminal event.
-  // Some wrappers settle that promise on the next task, so give it one more
-  // turn before treating the stream as incomplete.
-  await Promise.resolve();
-  if (!assistantMessage && !settledStreamResult) {
-    settledStreamResult = await resolveStreamResultSoon(streamResult);
-  }
-
-  const finalAssistantMessage =
-    assistantMessage ??
-    settledStreamResult ??
-    buildIncompleteAssistantMessage(opts, partialAssistantMessage);
-  if (!partialAssistantMessage) {
-    return finalAssistantMessage;
-  }
-  return mergeAssistantMessage(partialAssistantMessage, finalAssistantMessage);
-}
-
-function appendUserMessage(
-  db: Database,
-  sessionId: string,
-  messages: Message[],
-  userMessage: UserMessage,
-  onEvent: RunAgentOpts["onEvent"],
-): number {
-  messages.push(userMessage);
-  const turn = appendMessage(db, sessionId, userMessage);
-  onEvent?.({ type: "user_message", message: userMessage });
-  return turn;
-}
-
-function appendAssistantMessage(
-  db: Database,
-  sessionId: string,
-  messages: Message[],
-  assistantMessage: AssistantMessage,
-  turn: number,
-  onEvent: RunAgentOpts["onEvent"],
-): void {
-  messages.push(assistantMessage);
-  appendMessage(db, sessionId, assistantMessage, turn);
-  onEvent?.({ type: "assistant_message", message: assistantMessage });
-}
-
-function resolveLoopStopReason(
-  assistantMessage: AssistantMessage,
-  messages: Message[],
-  onEvent: RunAgentOpts["onEvent"],
-): AgentLoopResult | null {
-  if (
-    assistantMessage.stopReason === "error" ||
-    assistantMessage.stopReason === "aborted"
-  ) {
-    const eventType =
-      assistantMessage.stopReason === "error" ? "error" : "aborted";
-    onEvent?.({ type: eventType, message: assistantMessage });
-    return { messages, stopReason: assistantMessage.stopReason };
-  }
-
-  return null;
-}
-
-function consumeQueuedUserMessage(
-  db: Database,
-  sessionId: string,
-  messages: Message[],
-  takeQueuedUserMessage: RunAgentOpts["takeQueuedUserMessage"],
-  onEvent: RunAgentOpts["onEvent"],
-): number | null {
-  const queuedUserMessage = takeQueuedUserMessage?.();
-  if (!queuedUserMessage) {
-    return null;
-  }
-
-  return appendUserMessage(db, sessionId, messages, queuedUserMessage, onEvent);
-}
-
-function getAssistantToolCalls(message: AssistantMessage): ToolCall[] {
-  return message.content.filter((content): content is ToolCall => {
-    return content.type === "toolCall";
-  });
-}
-
-async function executeToolCall(
-  toolCall: ToolCall,
-  opts: Pick<RunAgentOpts, "toolHandlers" | "cwd" | "signal" | "onEvent">,
-): Promise<ToolExecResult> {
-  const handler = opts.toolHandlers.get(toolCall.name);
-  if (!handler) {
-    return unknownToolResult(toolCall.name);
-  }
-
-  opts.onEvent?.({
-    type: "tool_start",
-    toolCallId: toolCall.id,
-    name: toolCall.name,
-    args: toolCall.arguments,
-  });
-
-  let result: ToolExecResult;
-  try {
-    if (opts.signal?.aborted) {
-      result = toolErrorResult(
-        toolCall.name,
-        new Error("This operation was aborted"),
-      );
+    const message = await s.result();
+    if (added) {
+      llmCtx.messages[llmCtx.messages.length - 1] = message;
     } else {
-      result = await handler(
-        toolCall.arguments,
-        opts.cwd,
-        opts.signal,
-        (partial) => {
-          opts.onEvent?.({
-            type: "tool_delta",
-            toolCallId: toolCall.id,
-            name: toolCall.name,
-            result: partial,
-          });
-        },
-      );
+      llmCtx.messages.push(message);
+      yield { type: "message_start", partial: { ...message } };
     }
-  } catch (error) {
-    result = toolErrorResult(toolCall.name, error);
-  }
-
-  opts.onEvent?.({
-    type: "tool_end",
-    toolCallId: toolCall.id,
-    name: toolCall.name,
-    result,
-  });
-  return result;
-}
+    yield { type: "message_end", message };
 
-function appendToolResultMessage(
-  db: Database,
-  sessionId: string,
-  messages: Message[],
-  toolCall: ToolCall,
-  result: ToolExecResult,
-  turn: number,
-  onEvent: RunAgentOpts["onEvent"],
-): void {
-  const toolResultMessage: ToolResultMessage = {
-    role: "toolResult",
-    toolCallId: toolCall.id,
-    toolName: toolCall.name,
-    content: result.content,
-    ...(result.details !== undefined ? { details: result.details } : {}),
-    isError: result.isError,
-    timestamp: Date.now(),
-  };
-
-  messages.push(toolResultMessage);
-  appendMessage(db, sessionId, toolResultMessage, turn);
-  onEvent?.({ type: "tool_result", message: toolResultMessage });
-}
+    const toolCalls = message.content.filter((c) => c.type === "toolCall");
 
-function getIncompleteTodos(messages: readonly Message[]) {
-  return getTodoItems(messages).filter((todo) => todo.status !== "completed");
-}
+    // Stop on errors or no tools to call.
+    if (message.stopReason !== "toolUse" || toolCalls.length === 0) {
+      break;
+    }
 
-function getTodoReminderSignature(
-  todos: ReturnType<typeof getIncompleteTodos>,
-): string {
-  return JSON.stringify(
-    [...todos].sort((left, right) => {
-      const contentOrder = left.content.localeCompare(right.content);
-      if (contentOrder !== 0) {
-        return contentOrder;
+    const seenToolIds = new Map<string, number>();
+    if (toolCalls.length > 0) {
+      const ts = toolRunner(toolCalls, agentCtx.tools, agentCtx.signal);
+
+      for await (const e of ts) {
+        if (e.type === "tool_update") {
+          // Update contex with update or add new.
+          const existing = seenToolIds.get(e.partial.toolCallId);
+          if (existing && existing >= 0) {
+            const m = llmCtx.messages[existing];
+            if (m.role === "toolResult") {
+              llmCtx.messages[existing] = {
+                ...m,
+                content: [...m.content, ...e.partial.content],
+                isError: e.partial.isError,
+              };
+            }
+
+            yield {
+              type: "tool_message_update",
+              partial: e.partial,
+            };
+          } else {
+            llmCtx.messages.push(e.partial);
+            seenToolIds.set(e.partial.toolCallId, llmCtx.messages.length - 1);
+
+            yield {
+              type: "tool_message_start",
+              partial: e.partial,
+            };
+          }
+        } else if (e.type === "tool_result") {
+          // Update context with full message and yield
+          const idx = llmCtx.messages.findIndex(
+            (m) =>
+              m.role === "toolResult" && m.toolCallId === e.message.toolCallId,
+          );
+          if (idx >= 0) {
+            llmCtx.messages[idx] = e.message;
+          } else {
+            llmCtx.messages.push(e.message);
+          }
+
+          yield {
+            type: "tool_message_end",
+            message: e.message,
+          };
+        }
       }
-      return left.status.localeCompare(right.status);
-    }),
-  );
-}
-
-function wrapSystemReminder(content: string): string {
-  return `<system_reminder>\n${content}\n</system_reminder>`;
-}
-
-function createTodoReminderMessage(
-  messages: readonly Message[],
-  remindedTodoSignatures: Set<string>,
-): UserMessage | null {
-  const incompleteTodos = getIncompleteTodos(messages);
-  if (incompleteTodos.length === 0) {
-    return null;
-  }
-
-  const signature = getTodoReminderSignature(incompleteTodos);
-  if (remindedTodoSignatures.has(signature)) {
-    return null;
-  }
-  remindedTodoSignatures.add(signature);
-
-  const lines = [
-    "You have pending todo items that must be completed before finishing the task:",
-    "",
-    ...incompleteTodos.map((todo) => {
-      const status = todo.status === "in_progress" ? "IN_PROGRESS" : "PENDING";
-      return `- [${status}] ${todo.content}`;
-    }),
-    "",
-    "Please complete all pending items before finishing.",
-  ];
-
-  return {
-    role: "user",
-    content: wrapSystemReminder(lines.join("\n")),
-    timestamp: Date.now(),
-  };
-}
-
-interface StoppedAssistantResolution {
-  /** Next turn number when a queued steering message was consumed. */
-  nextTurn: number | null;
-  /** Ephemeral context messages to include on the next model request. */
-  pendingContextMessages: Message[];
-  /** Final loop result when the turn should stop immediately. */
-  finalResult: AgentLoopResult | null;
-}
-
-function resolveStoppedAssistantMessage(
-  assistantMessage: AssistantMessage,
-  stopReason: "stop" | "length",
-  opts: Pick<
-    RunAgentOpts,
-    "db" | "sessionId" | "messages" | "takeQueuedUserMessage" | "onEvent"
-  >,
-  remindedTodoSignatures: Set<string>,
-): StoppedAssistantResolution {
-  const queuedTurn = consumeQueuedUserMessage(
-    opts.db,
-    opts.sessionId,
-    opts.messages,
-    opts.takeQueuedUserMessage,
-    opts.onEvent,
-  );
-  if (queuedTurn !== null) {
-    return {
-      nextTurn: queuedTurn,
-      pendingContextMessages: [],
-      finalResult: null,
-    };
-  }
-
-  const todoReminder = createTodoReminderMessage(
-    opts.messages,
-    remindedTodoSignatures,
-  );
-  if (todoReminder) {
-    return {
-      nextTurn: null,
-      pendingContextMessages: [todoReminder],
-      finalResult: null,
-    };
-  }
-
-  opts.onEvent?.({ type: "done", message: assistantMessage });
-  return {
-    nextTurn: null,
-    pendingContextMessages: [],
-    finalResult: {
-      messages: opts.messages,
-      stopReason,
-    },
-  };
-}
-
-async function executeAssistantToolCalls(
-  assistantMessage: AssistantMessage,
-  opts: Pick<
-    RunAgentOpts,
-    | "db"
-    | "sessionId"
-    | "messages"
-    | "toolHandlers"
-    | "cwd"
-    | "signal"
-    | "onEvent"
-    | "model"
-  >,
-  turn: number,
-): Promise<AgentLoopResult | null> {
-  for (const toolCall of getAssistantToolCalls(assistantMessage)) {
-    const result = await executeToolCall(toolCall, opts);
-    appendToolResultMessage(
-      opts.db,
-      opts.sessionId,
-      opts.messages,
-      toolCall,
-      result,
-      turn,
-      opts.onEvent,
-    );
-
-    if (opts.signal?.aborted) {
-      opts.onEvent?.({
-        type: "aborted",
-        message: buildIncompleteAssistantMessage(
-          { model: opts.model, signal: opts.signal },
-          assistantMessage,
-        ),
-      });
-      return { messages: opts.messages, stopReason: "aborted" };
     }
   }
-
-  return null;
-}
-
-interface AgentIterationOutcome {
-  /** Final loop result when the run should stop immediately. */
-  finalResult: AgentLoopResult | null;
-  /** Next turn number when a queued steering message starts a new turn. */
-  nextTurn: number;
-  /** Ephemeral context messages for the next model request. */
-  pendingContextMessages: Message[];
-}
-
-async function resolveAgentIteration(
-  assistantMessage: AssistantMessage,
-  currentTurn: number,
-  remindedTodoSignatures: Set<string>,
-  opts: Pick<
-    RunAgentOpts,
-    | "db"
-    | "sessionId"
-    | "messages"
-    | "toolHandlers"
-    | "cwd"
-    | "signal"
-    | "onEvent"
-    | "model"
-    | "takeQueuedUserMessage"
-  >,
-): Promise<AgentIterationOutcome> {
-  const stopResult = resolveLoopStopReason(
-    assistantMessage,
-    opts.messages,
-    opts.onEvent,
-  );
-  if (stopResult) {
-    return {
-      finalResult: stopResult,
-      nextTurn: currentTurn,
-      pendingContextMessages: [],
-    };
-  }
-
-  if (
-    assistantMessage.stopReason === "stop" ||
-    assistantMessage.stopReason === "length"
-  ) {
-    const stopResolution = resolveStoppedAssistantMessage(
-      assistantMessage,
-      assistantMessage.stopReason,
-      {
-        db: opts.db,
-        sessionId: opts.sessionId,
-        messages: opts.messages,
-        takeQueuedUserMessage: opts.takeQueuedUserMessage,
-        onEvent: opts.onEvent,
-      },
-      remindedTodoSignatures,
-    );
-    return {
-      finalResult: stopResolution.finalResult,
-      nextTurn: stopResolution.nextTurn ?? currentTurn,
-      pendingContextMessages: stopResolution.pendingContextMessages,
-    };
-  }
-
-  const toolStopResult = await executeAssistantToolCalls(
-    assistantMessage,
-    opts,
-    currentTurn,
-  );
-  if (toolStopResult) {
-    return {
-      finalResult: toolStopResult,
-      nextTurn: currentTurn,
-      pendingContextMessages: [],
-    };
-  }
-
-  const queuedTurn = consumeQueuedUserMessage(
-    opts.db,
-    opts.sessionId,
-    opts.messages,
-    opts.takeQueuedUserMessage,
-    opts.onEvent,
-  );
-  return {
-    finalResult: null,
-    nextTurn: queuedTurn ?? currentTurn,
-    pendingContextMessages: [],
-  };
 }
 
-// ---------------------------------------------------------------------------
-// Agent loop
-// ---------------------------------------------------------------------------
-
-/**
- * Run the agent loop for a single turn.
- *
- * Streams an LLM response, executes any tool calls, appends all messages
- * to the session (sharing the same turn number), and loops back when the
- * model requests tool use. Returns when the model stops, hits a length
- * limit, errors, or is aborted.
- *
- * @param opts - Agent loop options.
- * @returns The loop result with updated messages and stop reason.
- */
-export async function runAgentLoop(
-  opts: RunAgentOpts,
-): Promise<AgentLoopResult> {
-  const {
-    db,
-    sessionId,
-    turn,
-    model,
-    messages,
-    signal,
-    onEvent,
-    toolHandlers,
-    cwd,
-    takeQueuedUserMessage,
-  } = opts;
-  let currentTurn = turn;
-  let pendingContextMessages: Message[] = [];
-  const remindedTodoSignatures = new Set<string>();
-
-  while (true) {
-    const assistantMessage = await streamAssistantMessage({
-      ...opts,
-      messages:
-        pendingContextMessages.length > 0
-          ? [...messages, ...pendingContextMessages]
-          : messages,
-    });
-    pendingContextMessages = [];
-    appendAssistantMessage(
-      db,
-      sessionId,
-      messages,
-      assistantMessage,
-      currentTurn,
-      onEvent,
-    );
-
-    const iterationOutcome = await resolveAgentIteration(
-      assistantMessage,
-      currentTurn,
-      remindedTodoSignatures,
-      {
-        db,
-        sessionId,
-        messages,
-        toolHandlers,
-        cwd,
-        signal,
-        onEvent,
-        model,
-        takeQueuedUserMessage,
-      },
-    );
-    if (iterationOutcome.finalResult) {
-      return iterationOutcome.finalResult;
+// This should stay stateless, don't accumulate anything at this layer, just proxy
+// wrapped runners events.
+async function* toolRunner(
+  toolCalls: ToolCall[],
+  tools: ToolAndRunner[],
+  signal?: AbortSignal,
+): AsyncGenerator<AgentToolEvent> {
+  for (const call of toolCalls) {
+    const timestamp = Date.now();
+    const tool = tools.find((t) => t.tool.name === call.name);
+
+    if (!tool) {
+      yield {
+        type: "tool_result",
+        message: {
+          role: "toolResult",
+          toolCallId: call.id,
+          toolName: call.name,
+          content: [{ type: "text", text: "Error: Tool not found" }],
+          isError: true,
+          timestamp,
+        },
+      };
+      continue;
     }
 
-    currentTurn = iterationOutcome.nextTurn;
-    pendingContextMessages = iterationOutcome.pendingContextMessages;
+    try {
+      for await (const e of tool.runner(call.arguments, signal)) {
+        // yield deltas for output, full output on result.
+        const content: TextContent = { type: "text", text: e.text };
+
+        if (e.type === "output") {
+          // handle deltas
+          yield {
+            type: "tool_update",
+            partial: {
+              role: "toolResult",
+              toolCallId: call.id,
+              toolName: call.name,
+              content: [content],
+              isError: false,
+              timestamp,
+            },
+          };
+        } else if (e.type === "result") {
+          // handle final message
+          yield {
+            type: "tool_result",
+            message: {
+              role: "toolResult",
+              toolCallId: call.id,
+              toolName: call.name,
+              content: [content],
+              isError: false,
+              timestamp,
+            },
+          };
+        }
+      }
+    } catch (err) {
+      // We don't validate arguments, so it's better to show the errors.
+      const error = err instanceof Error ? err.message : "Unknown error";
+      yield {
+        type: "tool_result",
+        message: {
+          role: "toolResult",
+          toolCallId: call.id,
+          toolName: call.name,
+          content: [{ type: "text", text: `Error: ${error}` }],
+          isError: true,
+          timestamp,
+        },
+      };
+    }
   }
 }