mini-coder 0.7.4 → 0.8.1

package/src/agent.ts

@@ -1,302 +1,223 @@
-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 type { ToolName } from "./config.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[];
+  /** The configured tool names, kept so a model switch can rebuild `tools`. */
+  toolNames: ToolName[];
+  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;
+/** The concatenated text blocks of an assistant message, ignoring the rest. */
+export function assistantText(message: AssistantMessage): string {
+  return message.content
+    .filter((block) => block.type === "text")
+    .map((block) => block.text)
+    .join("");
+}
 
-    const message = messages[i] as ToolResultMessage;
-    if (skillReadToolCallIds.has(message.toolCallId)) continue;
+export async function runAgentTurn(run: AgentRun): Promise<void> {
+  const { messages, session, signal, interaction, onEvent } = run;
 
-    const content = message.content;
-    if (
-      content.length === 1 &&
-      content[0].type === "text" &&
-      content[0].text.startsWith("Old environment output:")
-    ) {
-      continue;
-    }
-    toolResultIndices.push(i);
-  }
+  const cancelled = (): void => onEvent({ type: "cancelled" });
+  const failed = (message: string): void => onEvent({ type: "error", message });
 
-  if (toolResultIndices.length <= KEEP_OBSERVATIONS) return;
+  /** 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);
+  };
 
-  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)`;
+  /**
+   * 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;
     }
-    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) {
+      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) {
+      failed((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) {
+      failed((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") {
+      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") {
+      failed(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) {
+        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/auth.ts

@@ -0,0 +1,84 @@
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import type { AuthOperationOptions, Credential, CredentialInfo, CredentialStore } from "@earendil-works/pi-ai";
+
+/** The `auth.json` layout: one credential per provider id. */
+type AuthFile = Record<string, Credential>;
+
+function readFile(path: string): AuthFile {
+  try {
+    return JSON.parse(readFileSync(path, "utf8")) as AuthFile;
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") return {};
+    throw error;
+  }
+}
+
+/** Write the whole file atomically: temp file, then rename over the target. */
+function writeFile(path: string, data: AuthFile): void {
+  mkdirSync(dirname(path), { recursive: true });
+  const temp = join(dirname(path), `.${process.pid}.${Date.now()}.tmp`);
+  writeFileSync(temp, `${JSON.stringify(data, null, 2)}\n`);
+  renameSync(temp, path);
+}
+
+/**
+ * File-backed `CredentialStore` over `auth.json`. Writes are serialized per
+ * provider through an in-process promise chain, so `modify` and `delete` on
+ * the same provider never interleave.
+ */
+export function createCredentialStore(path: string): CredentialStore {
+  const chains = new Map<string, Promise<unknown>>();
+
+  function enqueue<T>(providerId: string, task: () => Promise<T>, options?: AuthOperationOptions): Promise<T> {
+    options?.signal?.throwIfAborted();
+    const previous = chains.get(providerId) ?? Promise.resolve();
+    const queued = (async () => {
+      await previous.catch(() => {});
+      options?.signal?.throwIfAborted();
+      return await task();
+    })();
+    const tail = queued.catch(() => {});
+    chains.set(providerId, tail);
+    void tail.then(() => {
+      if (chains.get(providerId) === tail) chains.delete(providerId);
+    });
+    return queued;
+  }
+
+  return {
+    async read(providerId, options): Promise<Credential | undefined> {
+      options?.signal?.throwIfAborted();
+      return readFile(path)[providerId];
+    },
+    async list(options): Promise<readonly CredentialInfo[]> {
+      options?.signal?.throwIfAborted();
+      return Object.entries(readFile(path)).map(([providerId, credential]) => ({ providerId, type: credential.type }));
+    },
+    modify(providerId, fn, options): Promise<Credential | undefined> {
+      return enqueue(
+        providerId,
+        async () => {
+          const data = readFile(path);
+          const next = await fn(data[providerId]);
+          options?.signal?.throwIfAborted();
+          if (next !== undefined) data[providerId] = next;
+          writeFile(path, data);
+          return next ?? data[providerId];
+        },
+        options,
+      );
+    },
+    delete(providerId, options): Promise<void> {
+      return enqueue(
+        providerId,
+        async () => {
+          const data = readFile(path);
+          delete data[providerId];
+          writeFile(path, data);
+        },
+        options,
+      );
+    },
+  };
+}