botholomew 0.12.1 → 0.12.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "botholomew",
-  "version": "0.12.1",
+  "version": "0.12.3",
   "description": "An autonomous AI agent for knowledge work — works your task queue while you sleep.",
   "type": "module",
   "bin": {
@@ -28,7 +28,7 @@
   "dependencies": {
     "@anthropic-ai/sdk": "^0.92.0",
     "@duckdb/node-api": "^1.5.2-r.1",
-    "@evantahler/mcpx": "0.19.1",
+    "@evantahler/mcpx": "0.21.0",
     "@huggingface/transformers": "^4.2.0",
     "ansis": "^4.2.0",
     "commander": "^14.0.0",

package/src/chat/agent.ts

@@ -1,4 +1,7 @@
+import type Anthropic from "@anthropic-ai/sdk";
+import { APIUserAbortError } from "@anthropic-ai/sdk";
 import type {
+  Message,
   MessageParam,
   ToolResultBlockParam,
   ToolUseBlock,
@@ -26,6 +29,7 @@ import {
   loadPersistentContext,
   STYLE_RULES,
 } from "../worker/prompt.ts";
+import type { ChatSession } from "./session.ts";
 
 registerAllTools();
 
@@ -176,6 +180,11 @@ export interface ChatTurnCallbacks {
     isError: boolean,
     meta?: ToolEndMeta,
   ) => void;
+  /** Called between LLM turns. The TUI returns any queued user messages so
+   *  the agent can inject them into the running turn instead of waiting for
+   *  the entire tool loop to finish. Each returned message is logged + pushed
+   *  to `messages` before the next `messages.stream(...)` call. */
+  takeInjections?: () => string[];
 }
 
 /**
@@ -205,6 +214,14 @@ export async function runChatTurn(input: {
   threadId: string;
   mcpxClient: McpxClient | null;
   callbacks: ChatTurnCallbacks;
+  /** When supplied, the loop honors `session.aborted` (set by Esc in the TUI)
+   *  and writes the live `MessageStream` to `session.activeStream` so it can
+   *  be aborted from outside. */
+  session?: ChatSession;
+  /** Test seam: inject a pre-built client and skip the model-info fetch.
+   *  Production callers should leave both unset. */
+  _testClient?: Anthropic;
+  _testMaxInputTokens?: number;
 }): Promise<void> {
   const {
     messages,
@@ -214,18 +231,35 @@ export async function runChatTurn(input: {
     threadId,
     mcpxClient,
     callbacks,
+    session,
   } = input;
 
-  const client = createLlmClient(config);
+  const client = input._testClient ?? createLlmClient(config);
 
   const chatTools = getChatTools();
-  const maxInputTokens = await getMaxInputTokens(
-    config.anthropic_api_key,
-    config.model,
-  );
+  const maxInputTokens =
+    input._testMaxInputTokens ??
+    (await getMaxInputTokens(config.anthropic_api_key, config.model));
   const maxTurns = config.max_turns;
 
   for (let turn = 0; !maxTurns || turn < maxTurns; turn++) {
+    if (session?.aborted) return;
+
+    // Steering: drain any user messages the TUI queued during the previous
+    // iteration so they land in the next LLM call rather than waiting for
+    // the whole tool loop to finish.
+    const injections = callbacks.takeInjections?.() ?? [];
+    for (const text of injections) {
+      await withDb(dbPath, (conn) =>
+        logInteraction(conn, threadId, {
+          role: "user",
+          kind: "message",
+          content: text,
+        }),
+      );
+      messages.push({ role: "user", content: text });
+    }
+
     const startTime = Date.now();
 
     // Rebuild the system prompt every iteration so that:
@@ -249,6 +283,7 @@ export async function runChatTurn(input: {
       messages,
       tools: chatTools,
     });
+    if (session) session.activeStream = stream;
 
     // Collect the full response
     let assistantText = "";
@@ -282,7 +317,31 @@ export async function runChatTurn(input: {
       }
     });
 
-    const response = await stream.finalMessage();
+    let response: Message;
+    try {
+      response = await stream.finalMessage();
+    } catch (err) {
+      if (!(err instanceof APIUserAbortError)) throw err;
+      // Esc was pressed mid-stream. Persist whatever text the user already saw
+      // (the `'text'` event has fired for everything reaching us, so
+      // `assistantText` is the right partial value). Deliberately drop any
+      // partial tool_use blocks — they would be unmatched on the next turn.
+      if (assistantText) {
+        await withDb(dbPath, (conn) =>
+          logInteraction(conn, threadId, {
+            role: "assistant",
+            kind: "message",
+            content: assistantText,
+            durationMs: Date.now() - startTime,
+            tokenCount: 0,
+          }),
+        );
+        messages.push({ role: "assistant", content: assistantText });
+      }
+      return;
+    } finally {
+      if (session) session.activeStream = null;
+    }
     const durationMs = Date.now() - startTime;
     const tokenCount =
       response.usage.input_tokens + response.usage.output_tokens;
@@ -382,6 +441,7 @@ export async function runChatTurn(input: {
     }
 
     messages.push({ role: "user", content: toolResults });
+    if (session?.aborted) return;
     // Loop to get the model's next response after tool results
   }
 }

package/src/chat/session.ts

@@ -1,3 +1,4 @@
+import type { MessageStream } from "@anthropic-ai/sdk/lib/MessageStream";
 import type { MessageParam } from "@anthropic-ai/sdk/resources/messages";
 import { loadConfig } from "../config/loader.ts";
 import type { BotholomewConfig } from "../config/schemas.ts";
@@ -27,6 +28,24 @@ export interface ChatSession {
   // biome-ignore lint/suspicious/noExplicitAny: mcpx client
   mcpxClient: any;
   cleanup: () => Promise<void>;
+  /** Set by `runChatTurn` while a `messages.stream(...)` is in flight. */
+  activeStream: MessageStream | null;
+  /** Esc-driven steer signal — checked at safe points in the chat agent loop. */
+  aborted: boolean;
+}
+
+/**
+ * Abort the in-flight LLM stream (if any) and set the steer flag so the chat
+ * agent loop short-circuits before issuing another `messages.stream(...)` call.
+ * Safe to call when no stream is active. Returns true if a live stream was aborted.
+ */
+export function abortActiveStream(session: ChatSession): boolean {
+  session.aborted = true;
+  if (session.activeStream && !session.activeStream.aborted) {
+    session.activeStream.abort();
+    return true;
+  }
+  return false;
 }
 
 export async function startChatSession(
@@ -96,6 +115,8 @@ export async function startChatSession(
     skills,
     mcpxClient,
     cleanup,
+    activeStream: null,
+    aborted: false,
   };
 }
 
@@ -104,6 +125,9 @@ export async function sendMessage(
   userMessage: string,
   callbacks: ChatTurnCallbacks,
 ): Promise<void> {
+  // Reset steer flag so a previous turn's Esc doesn't poison this one.
+  session.aborted = false;
+
   // Hot-reload skills so any skill the agent created/edited last turn (or any
   // out-of-band edit) is visible to slash-command dispatch this turn.
   session.skills = await loadSkills(session.projectDir);
@@ -137,6 +161,7 @@ export async function sendMessage(
     threadId: session.threadId,
     mcpxClient: session.mcpxClient,
     callbacks,
+    session,
   });
 }
 
@@ -161,5 +186,7 @@ export async function clearChatSession(
   });
   session.threadId = newThreadId;
   session.messages.length = 0;
+  session.activeStream = null;
+  session.aborted = false;
   return { previousThreadId, newThreadId };
 }

package/src/tui/App.tsx

@@ -1,6 +1,7 @@
 import { Box, Static, Text, useApp, useInput } from "ink";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import {
+  abortActiveStream,
   type ChatSession,
   clearChatSession,
   endChatSession,
@@ -273,8 +274,20 @@ export function App({
         return;
       }
 
-      // Queue manipulation keybindings (only when queue has items on Chat tab)
       const tab = activeTabRef.current;
+
+      // Esc on Chat tab while a turn is in flight: steer / interrupt.
+      // Calls MessageStream.abort() at the SDK layer; tools already running
+      // finish normally, but no further LLM turn is started.
+      if (key.escape && tab === 1 && processingRef.current) {
+        const session = sessionRef.current;
+        if (session) {
+          abortActiveStream(session);
+          return;
+        }
+      }
+
+      // Queue manipulation keybindings (only when queue has items on Chat tab)
       const queue = queuedMessagesRef.current;
       if (tab === 1 && queue.length > 0 && key.ctrl) {
         if (input === "j") {
@@ -405,8 +418,35 @@ export function App({
             }
             setActiveToolCalls([...pendingToolCalls]);
           },
+          takeInjections: () => {
+            // Drain queued messages into the running turn so the agent sees
+            // them on the next LLM call instead of after the whole tool loop.
+            // Finalize the in-flight assistant segment first so the new user
+            // bubbles render in the right order in the chat view.
+            if (queueRef.current.length === 0) return [];
+            if (currentText || pendingToolCalls.length > 0) {
+              finalizeSegment();
+            }
+            const drained = queueRef.current.splice(0);
+            syncQueue();
+            for (const e of drained) {
+              const userMsg: ChatMessage = {
+                id: msgId(),
+                role: "user",
+                content: e.display,
+                timestamp: new Date(),
+              };
+              setMessages((prev) => [...prev, userMsg]);
+            }
+            return drained.map((e) => e.content);
+          },
         });
 
+        if (sessionRef.current?.aborted) {
+          currentText += currentText
+            ? "\n\n_(steered — response interrupted)_"
+            : "_(steered — no response)_";
+        }
         finalizeSegment();
       } catch (err) {
         const errorMsg: ChatMessage = {