mini-coder 0.7.4 → 0.8.0

package/src/agent.ts

@@ -1,302 +1,209 @@
-import type {
-  AssistantMessage,
-  Context,
-  ImageContent,
-  Message,
-  TextContent,
-  ToolCall,
-  ToolResultMessage,
+import {
+  type Api,
+  type AssistantMessage,
+  type JsonObject,
+  type Message,
+  type Model,
+  type ModelThinkingLevel,
+  type Models,
+  type Tool,
+  type ToolCall,
+  type ToolResultMessage,
+  type UserMessage,
 } from "@earendil-works/pi-ai";
-import { createAppModels } from "./models.ts";
-import { estimateTokens } from "./shared";
-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[]) {
-  const KEEP_OBSERVATIONS = 10;
-
-  const skillReadToolCallIds = new Set<string>();
-  for (const message of messages) {
-    if (message.role !== "assistant") continue;
+import type { Session } from "./session.ts";
+import { acceptsImages, executeTool, type ToolDetails, type ToolResult } from "./tools/index.ts";
+
+export type Phase = "preparing" | "waitingModel" | "streaming" | "runningTool" | "pausing" | "idle";
+
+export type AgentEvent =
+  | { type: "phase"; phase: Phase; detail?: string }
+  | { type: "text"; delta: string }
+  | { type: "reasoning"; delta: string }
+  | { type: "toolCallStart"; name: string }
+  | { type: "toolCall"; name: string; arguments: JsonObject }
+  | { type: "toolOutput"; chunk: string }
+  | { type: "toolResult"; name: string; text: string; isError: boolean }
+  | { type: "message"; message: AssistantMessage }
+  | { type: "error"; message: string }
+  | { type: "cancelled" }
+  | { type: "complete" };
+
+interface Interaction {
+  isPauseRequested(): boolean;
+  clearPause(): void;
+  requestSteering(): Promise<string>;
+}
 
-    for (const content of message.content) {
-      if (content.type !== "toolCall") continue;
-      if (content.name !== "read") continue;
+export const NO_INTERACTION: Interaction = {
+  isPauseRequested: () => false,
+  clearPause: () => {},
+  requestSteering: async () => "",
+};
+
+/** What one turn needs, shared by both projections: the TUI and `--print`. */
+export interface AgentOptions {
+  models: Models;
+  model: Model<Api>;
+  systemPrompt: string;
+  tools: Tool[];
+  thinkingEffort: ModelThinkingLevel;
+  session: Session;
+}
 
-      const path = content.arguments.path;
-      if (typeof path === "string" && path.endsWith("SKILL.md")) {
-        skillReadToolCallIds.add(content.id);
-      }
-    }
-  }
+interface AgentRun extends AgentOptions {
+  messages: Message[];
+  signal: AbortSignal;
+  interaction: Interaction;
+  onEvent: (event: AgentEvent) => void;
+}
 
-  const toolResultIndices: number[] = [];
-  for (let i = 0; i < messages.length; i++) {
-    if (messages[i].role !== "toolResult") continue;
+export async function runAgentTurn(run: AgentRun): Promise<void> {
+  const { messages, session, signal, interaction, onEvent } = run;
 
-    const message = messages[i] as ToolResultMessage;
-    if (skillReadToolCallIds.has(message.toolCallId)) continue;
+  /** Appends a user message the model reads at the next step boundary. */
+  const steer = (content: string): void => {
+    if (content === "") return;
+    const message: UserMessage = { role: "user", content, timestamp: Date.now() };
+    messages.push(message);
+    session.appendMessage(message);
+  };
 
-    const content = message.content;
-    if (
-      content.length === 1 &&
-      content[0].type === "text" &&
-      content[0].text.startsWith("Old environment output:")
-    ) {
-      continue;
+  /**
+   * Returns the steering typed while paused, or ""; the caller decides where
+   * it lands, because a user message between an assistant turn and its tool
+   * results is rejected by the provider. Null once the turn has been aborted;
+   * every step boundary is a cancellation point.
+   */
+  const pauseStep = async (): Promise<string | null> => {
+    if (signal.aborted) return null;
+    if (interaction.isPauseRequested()) {
+      interaction.clearPause();
+      onEvent({ type: "phase", phase: "pausing" });
+      const steering = await interaction.requestSteering();
+      onEvent({ type: "phase", phase: "idle" });
+      if (signal.aborted) return null;
+      return steering;
     }
-    toolResultIndices.push(i);
-  }
-
-  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++;
-      }
-    }
-    let text = `Old environment output: (${lines} lines omitted)`;
-    if (images > 0) {
-      text += ` (${images} image${images > 1 ? "s" : ""} omitted)`;
-    }
-    msg.content = [{ type: "text", text }];
-  }
-}
-
-export async function* streamAgent(
-  agentCtx: AgentContex,
-): AsyncGenerator<AgentEvent> {
-  const llmCtx: Context = {
-    systemPrompt: agentCtx.systemPrompt,
-    tools: agentCtx.tools.map((t) => t.tool),
-    messages: agentCtx.messages,
+    return "";
   };
 
-  const models = createAppModels(agentCtx.options.customProviders);
-
-  // Main agent loop, continues until llm sends a response other than toolCall or has no tool calls.
-  while (true) {
-    const estimate = estimateTokens(JSON.stringify(llmCtx));
-    // 80k is the agreed uppon threshold to the DUMB ZONE
-    if (estimate > 80000) compactContext(llmCtx.messages);
-
-    const s = models.streamSimple(agentCtx.options.model, llmCtx, {
-      reasoning: agentCtx.options.effort,
-      signal: agentCtx.signal,
+  for (;;) {
+    const steering = await pauseStep();
+    if (steering === null) {
+      onEvent({ type: "cancelled" });
+      return;
+    }
+    steer(steering);
+
+    onEvent({ type: "phase", phase: "preparing" });
+    session.appendRequest({
+      provider: run.model.provider,
+      model: run.model.id,
+      api: run.model.api,
+      thinkingEffort: run.thinkingEffort,
+      systemPrompt: run.systemPrompt,
+      tools: run.tools,
     });
 
-    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 (!finalMessage) throw new Error(e.error.errorMessage);
-
-          if (added) {
-            llmCtx.messages[llmCtx.messages.length - 1] = finalMessage;
-          } else {
-            llmCtx.messages.push(finalMessage);
-            yield { type: "message_start", partial: { ...finalMessage } };
-          }
+    onEvent({ type: "phase", phase: "waitingModel" });
+    const context = { systemPrompt: run.systemPrompt, tools: run.tools, messages };
+    let stream;
+    try {
+      stream = run.models.streamSimple(run.model, context, {
+        reasoning: run.thinkingEffort === "off" ? undefined : run.thinkingEffort,
+        signal,
+        sessionId: session.id ?? undefined,
+      });
+    } catch (error) {
+      onEvent({ type: "error", message: (error as Error).message });
+      return;
+    }
 
-          yield { type: "message_end", message: finalMessage };
-          return;
+    onEvent({ type: "phase", phase: "streaming" });
+    try {
+      for await (const event of stream) {
+        if (event.type === "text_delta") onEvent({ type: "text", delta: event.delta });
+        else if (event.type === "thinking_delta") onEvent({ type: "reasoning", delta: event.delta });
+        // The tool's name is known as soon as the call starts being written.
+        else if (event.type === "toolcall_start") {
+          const block = event.partial.content[event.contentIndex];
+          if (block.type === "toolCall") onEvent({ type: "toolCallStart", name: block.name });
+        } else if (event.type === "toolcall_end") {
+          onEvent({
+            type: "toolCall",
+            name: event.toolCall.name,
+            arguments: event.toolCall.arguments,
+          });
         }
       }
+    } catch (error) {
+      onEvent({ type: "error", message: (error as Error).message });
+      return;
     }
 
-    const message = await s.result();
-    if (!message) throw new Error("Stream finished without a message");
-
-    if (added) {
-      llmCtx.messages[llmCtx.messages.length - 1] = message;
-    } else {
-      llmCtx.messages.push(message);
-      yield { type: "message_start", partial: { ...message } };
-    }
-    yield { type: "message_end", message };
-
-    const toolCalls = message.content.filter(
-      (c): c is ToolCall => c.type === "toolCall",
-    );
+    const assistant = await stream.result();
+    messages.push(assistant);
+    session.appendMessage(assistant);
+    onEvent({ type: "message", message: assistant });
 
-    // Stop on errors or no tools to call.
-    if (message.stopReason !== "toolUse" || toolCalls.length === 0) {
-      break;
+    if (assistant.stopReason === "aborted") {
+      onEvent({ type: "cancelled" });
+      return;
     }
-
-    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,
-          };
-        }
-      }
+    if (assistant.stopReason === "error") {
+      onEvent({ type: "error", message: assistant.errorMessage ?? "provider error" });
+      return;
     }
-  }
-}
-
-// 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;
+    const toolCalls = assistant.content.filter((block): block is ToolCall => block.type === "toolCall");
+    if (toolCalls.length === 0) {
+      onEvent({ type: "complete" });
+      return;
     }
 
-    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, and check for images
-          let img: ImageContent | null = null;
-          if (e.image) {
-            img = { ...e.image, type: "image" };
-          }
-
-          yield {
-            type: "tool_result",
-            message: {
-              role: "toolResult",
-              toolCallId: call.id,
-              toolName: call.name,
-              content: img ? [content, img] : [content],
-              isError: false,
-              timestamp,
-            },
-          };
+    // Steering is held until every result of this assistant turn has landed:
+    // the provider rejects a user message between an assistant turn and its
+    // tool results.
+    const held: string[] = [];
+    for (const call of toolCalls) {
+      const steering = await pauseStep();
+      if (steering === null) {
+        onEvent({ type: "cancelled" });
+        return;
+      }
+      if (steering !== "") held.push(steering);
+      onEvent({ type: "phase", phase: "runningTool", detail: call.name });
+
+      const tool = run.tools.find((candidate) => candidate.name === call.name);
+      let result: ToolResult;
+      if (tool === undefined) {
+        result = { text: `unknown tool: ${call.name}`, isError: true };
+      } else {
+        try {
+          result = await executeTool(call, {
+            signal,
+            supportsImages: acceptsImages(run.model),
+            onOutput: (chunk) => onEvent({ type: "toolOutput", chunk }),
+          });
+        } catch (error) {
+          result = { text: (error as Error).message, isError: true };
         }
       }
-    } 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,
-        },
+
+      const toolMessage: ToolResultMessage<ToolDetails> = {
+        role: "toolResult",
+        toolCallId: call.id,
+        toolName: call.name,
+        content: [{ type: "text", text: result.text }, ...(result.images ?? [])],
+        details: result.details,
+        isError: result.isError,
+        timestamp: Date.now(),
       };
+      messages.push(toolMessage);
+      session.appendMessage(toolMessage);
+      onEvent({ type: "toolResult", name: call.name, text: result.text, isError: result.isError });
     }
+    steer(held.join("\n"));
   }
 }

package/src/cli.ts

@@ -0,0 +1,101 @@
+import process from "node:process";
+import { clampThinkingLevel, type AssistantMessage, type Message, type UserMessage } from "@earendil-works/pi-ai";
+import { loadConfig, resolveModel } from "./config.ts";
+import { buildSystemPrompt } from "./prompt.ts";
+import { acceptsImages, toolSchemas } from "./tools/index.ts";
+import { Session } from "./session.ts";
+import { NO_INTERACTION, runAgentTurn, type AgentOptions } from "./agent.ts";
+import { runTui } from "./tui/tui.ts";
+
+function parseArgs(argv: string[]): { print: string | null } {
+  let print: string | null = null;
+  for (let i = 0; i < argv.length; i++) {
+    const match = /^(?:-p|--print)(?:=(.*))?$/.exec(argv[i]);
+    if (match === null) throw new Error(`unknown argument: ${argv[i]}`);
+    const value = match[1] ?? argv[++i];
+    if (value === undefined) throw new Error(`${argv[i - 1]} requires a prompt`);
+    print = value;
+  }
+  return { print };
+}
+
+async function runPrint(prompt: string, ctx: AgentOptions): Promise<number> {
+  const messages: Message[] = [];
+  const user: UserMessage = { role: "user", content: prompt, timestamp: Date.now() };
+  messages.push(user);
+  ctx.session.appendMessage(user);
+
+  const controller = new AbortController();
+  const onSignal = () => controller.abort();
+  process.on("SIGINT", onSignal);
+  process.on("SIGTERM", onSignal);
+
+  let failed = false;
+  let cancelled = false;
+  try {
+    await runAgentTurn({
+      ...ctx,
+      messages,
+      signal: controller.signal,
+      interaction: NO_INTERACTION,
+      onEvent: (event) => {
+        if (event.type === "toolCall") process.stderr.write(`[tool] ${event.name}\n`);
+        else if (event.type === "toolOutput") process.stderr.write(event.chunk);
+        else if (event.type === "error") {
+          failed = true;
+          process.stderr.write(`[error] ${event.message}\n`);
+        } else if (event.type === "cancelled") {
+          cancelled = true;
+          process.stderr.write("[cancelled]\n");
+        }
+      },
+    });
+  } catch (error) {
+    failed = true;
+    process.stderr.write(`[error] ${(error as Error).message}\n`);
+  } finally {
+    process.off("SIGINT", onSignal);
+    process.off("SIGTERM", onSignal);
+    ctx.session.close();
+  }
+
+  const last = messages.filter((message): message is AssistantMessage => message.role === "assistant").at(-1);
+  if (!failed && !cancelled && last !== undefined) {
+    const text = last.content
+      .filter((block) => block.type === "text")
+      .map((block) => block.text)
+      .join("");
+    if (text !== "") process.stdout.write(text.endsWith("\n") ? text : `${text}\n`);
+  }
+  return failed || cancelled ? 1 : 0;
+}
+
+async function main(): Promise<void> {
+  const args = parseArgs(process.argv.slice(2));
+  const config = loadConfig();
+  const { models, model } = resolveModel(config);
+  const session = new Session(config.sessionsDir, process.cwd());
+  const ctx: AgentOptions = {
+    models,
+    model,
+    systemPrompt: buildSystemPrompt(config),
+    tools: toolSchemas(config.tools, acceptsImages(model)),
+    thinkingEffort: clampThinkingLevel(model, config.thinkingEffort),
+    session,
+  };
+
+  if (args.print !== null) {
+    process.exitCode = await runPrint(args.print, ctx);
+    return;
+  }
+
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    throw new Error("interactive mode requires a TTY; use -p for non-interactive mode");
+  }
+  await runTui(ctx);
+}
+
+main().catch((error) => {
+  process.stderr.write(`${(error as Error).message}\n`);
+  process.exit(1);
+});