botholomew 0.18.7 → 0.19.4

package/src/prompts/capabilities.ts

@@ -1,8 +1,15 @@
 import { join } from "node:path";
-import Anthropic from "@anthropic-ai/sdk";
 import type { McpxClient } from "@evantahler/mcpx";
+import { generateObject } from "ai";
+import { z } from "zod";
 import type { BotholomewConfig } from "../config/schemas.ts";
 import { getPromptsDir } from "../constants.ts";
+import {
+  buildProviderOptions,
+  formatLlmError,
+  getLanguageModel,
+  getMaxInputTokens,
+} from "../llm/index.ts";
 import { getAllTools, type ToolDefinition } from "../tools/tool.ts";
 import {
   type ContextFileMeta,
@@ -14,7 +21,6 @@ import { logger } from "../utils/logger.ts";
 export const CAPABILITIES_FILENAME = "capabilities.md";
 
 // LLM config — summarization is one call per refresh, no streaming needed.
-const SUMMARIZE_TIMEOUT_MS = 30_000;
 const SUMMARIZE_MAX_TOKENS = 4096;
 
 // biome-ignore lint/suspicious/noExplicitAny: Zod-free tool schema for Anthropic SDK
@@ -142,71 +148,34 @@ interface SummarizedCapabilities {
   mcpx_servers: ServerThemes[];
 }
 
-const SUMMARIZE_TOOL_NAME = "return_capability_summary";
-const SUMMARIZE_TOOL = {
-  name: SUMMARIZE_TOOL_NAME,
-  description:
-    "Return thematic capability summaries for the agent's tool inventory.",
-  input_schema: {
-    type: "object" as const,
-    properties: {
-      internal_themes: {
-        type: "array",
-        description:
-          "Themes covering the agent's built-in tools (task queue, files & sandbox, search, threads, MCPX meta-tools, workers, self-reflection, etc.).",
-        items: {
-          type: "object",
-          properties: {
-            name: {
-              type: "string",
-              description: "Short theme name (2-4 words).",
-            },
-            summary: {
-              type: "string",
-              description:
-                "One sentence with concrete action verbs. No tool names. No preamble.",
-            },
-          },
-          required: ["name", "summary"],
-        },
-      },
-      mcpx_servers: {
-        type: "array",
-        description:
-          "MCPX tools grouped by their source server. Within each server, split into themes only when the server exposes distinct services (e.g. Gmail + Google Calendar on one server).",
-        items: {
-          type: "object",
-          properties: {
-            server: {
-              type: "string",
-              description: "Server name exactly as given in the inventory.",
-            },
-            themes: {
-              type: "array",
-              items: {
-                type: "object",
-                properties: {
-                  name: {
-                    type: "string",
-                    description: "Theme name (usually the service, e.g. Gmail)",
-                  },
-                  summary: {
-                    type: "string",
-                    description:
-                      "One sentence with concrete action verbs. No tool names.",
-                  },
-                },
-                required: ["name", "summary"],
-              },
-            },
-          },
-          required: ["server", "themes"],
-        },
-      },
-    },
-    required: ["internal_themes", "mcpx_servers"],
-  },
-};
+const ThemeSchema = z.object({
+  name: z.string().describe("Short theme name (2-4 words)."),
+  summary: z
+    .string()
+    .describe(
+      "One sentence with concrete action verbs. No tool names. No preamble.",
+    ),
+});
+
+const SummarySchema = z.object({
+  internal_themes: z
+    .array(ThemeSchema)
+    .describe(
+      "Themes covering the agent's built-in tools (task queue, files & sandbox, search, threads, MCPX meta-tools, workers, self-reflection, etc.).",
+    ),
+  mcpx_servers: z
+    .array(
+      z.object({
+        server: z
+          .string()
+          .describe("Server name exactly as given in the inventory."),
+        themes: z.array(ThemeSchema),
+      }),
+    )
+    .describe(
+      "MCPX tools grouped by their source server. Within each server, split into themes only when the server exposes distinct services.",
+    ),
+});
 
 function renderInventoryForPrompt(inv: RawInventory): string {
   const sections: string[] = [];
@@ -255,42 +224,42 @@ BAD examples (do not produce):
   "Provides access to Gmail operations via tools like Gmail_SendEmail..."
   "Tools for working with email"`;
 
+function hasUsableCreds(config: BotholomewConfig): boolean {
+  const cfg = config.chunker_llm;
+  if (cfg.provider === "anthropic") {
+    return !!cfg.api_key && cfg.api_key !== "your-api-key-here";
+  }
+  if (cfg.provider === "openai-compatible") {
+    return !!cfg.base_url;
+  }
+  // ollama: no credentials required, assume reachable.
+  return true;
+}
+
 async function summarizeViaLLM(
   inv: RawInventory,
-  config: Required<BotholomewConfig>,
+  config: BotholomewConfig,
 ): Promise<SummarizedCapabilities | null> {
-  if (
-    !config.anthropic_api_key ||
-    config.anthropic_api_key === "your-api-key-here"
-  ) {
-    return null;
-  }
+  if (!hasUsableCreds(config)) return null;
 
-  const client = new Anthropic({ apiKey: config.anthropic_api_key });
-  const userPrompt = `Summarize this tool inventory. Return via the \`${SUMMARIZE_TOOL_NAME}\` tool.\n\n${renderInventoryForPrompt(inv)}`;
+  const userPrompt = `Summarize this tool inventory.\n\n${renderInventoryForPrompt(inv)}`;
 
   try {
-    const response = await client.messages.create(
-      {
-        model: config.chunker_model,
-        max_tokens: SUMMARIZE_MAX_TOKENS,
-        system: SUMMARIZE_SYSTEM,
-        tools: [SUMMARIZE_TOOL],
-        tool_choice: { type: "tool", name: SUMMARIZE_TOOL_NAME },
-        messages: [{ role: "user", content: userPrompt }],
-      },
-      { timeout: SUMMARIZE_TIMEOUT_MS },
-    );
-
-    const toolBlock = response.content.find((b) => b.type === "tool_use");
-    if (!toolBlock || toolBlock.type !== "tool_use") return null;
-
-    const input = toolBlock.input as SummarizedCapabilities;
-    if (!Array.isArray(input.internal_themes)) return null;
-    if (!Array.isArray(input.mcpx_servers)) return null;
-    return input;
+    const model = getLanguageModel(config.chunker_llm);
+    const numCtx = await getMaxInputTokens(config.chunker_llm);
+    const { object } = await generateObject({
+      model,
+      schema: SummarySchema,
+      system: SUMMARIZE_SYSTEM,
+      prompt: userPrompt,
+      maxOutputTokens: SUMMARIZE_MAX_TOKENS,
+      providerOptions: buildProviderOptions(config.chunker_llm, numCtx),
+    });
+    return object;
   } catch (err) {
-    logger.debug(`Capability summarization failed: ${(err as Error).message}`);
+    logger.debug(
+      `Capability summarization failed: ${formatLlmError(err, config.chunker_llm)}`,
+    );
     return null;
   }
 }
@@ -404,7 +373,7 @@ function renderFallback(inv: RawInventory, now: Date): string {
     );
   } else {
     parts.push(
-      "_(LLM summarization unavailable — set `anthropic_api_key` and rerun to generate themed summaries. Until then, use `mcp_list_tools` with each server to see what's exposed.)_",
+      "_(LLM summarization unavailable — set `llm.api_key` (or `llm.base_url` for local providers) and rerun to generate themed summaries. Until then, use `mcp_list_tools` with each server to see what's exposed.)_",
     );
     parts.push("");
     const servers = [...inv.mcpByServer.keys()].sort();
@@ -418,29 +387,24 @@ function renderFallback(inv: RawInventory, now: Date): string {
 }
 
 /**
- * Build the body of capabilities.md. When `config.anthropic_api_key` is set,
- * Claude is asked to produce thematic summaries. Otherwise (or on failure) a
- * static fallback listing is rendered.
+ * Build the body of capabilities.md. When the configured chunker LLM has
+ * usable credentials, the model is asked to produce thematic summaries.
+ * Otherwise (or on failure) a static fallback listing is rendered.
  */
 export async function generateCapabilitiesMarkdown(
   mcpxClient: McpxClient | null,
-  config: Required<BotholomewConfig>,
+  config: BotholomewConfig,
   now: Date = new Date(),
   onPhase?: ProgressCallback,
 ): Promise<GenerateResult> {
   const inv = await collectInventory(mcpxClient, onPhase);
 
-  // Don't call the LLM when the inventory is empty / broken — the fallback
-  // conveys the same information and avoids an unnecessary API round trip.
   const hasAnythingToSummarize =
     inv.mcpByServer.size > 0 || inv.internalTotal > 0;
 
   let summary: SummarizedCapabilities | null = null;
   if (hasAnythingToSummarize) {
-    const canSummarize =
-      config.anthropic_api_key &&
-      config.anthropic_api_key !== "your-api-key-here";
-    if (canSummarize) {
+    if (hasUsableCreds(config)) {
       onPhase?.(
         `Summarizing ${inv.internalTotal} internal + ${inv.mcpTotal} MCPX tools`,
       );
@@ -472,7 +436,7 @@ export interface WriteResult {
 export async function writeCapabilitiesFile(
   projectDir: string,
   mcpxClient: McpxClient | null,
-  config: Required<BotholomewConfig>,
+  config: BotholomewConfig,
   onPhase?: ProgressCallback,
 ): Promise<WriteResult> {
   const filePath = join(getPromptsDir(projectDir), CAPABILITIES_FILENAME);

package/src/tools/tool.ts

@@ -1,6 +1,5 @@
-import type { Tool as AnthropicTool } from "@anthropic-ai/sdk/resources/messages";
 import type { McpxClient } from "@evantahler/mcpx";
-import { z } from "zod";
+import type { z } from "zod";
 import type { BotholomewConfig } from "../config/schemas.ts";
 import type { WithMem } from "../mem/client.ts";
 
@@ -14,7 +13,7 @@ export interface ToolContext {
    */
   withMem: WithMem;
   projectDir: string;
-  config: Required<BotholomewConfig>;
+  config: BotholomewConfig;
   mcpxClient: McpxClient | null;
   /**
    * Identifier of the agent process running this tool, used as the holder
@@ -84,22 +83,3 @@ export function getAllTools(): AnyToolDefinition[] {
 export function getToolsByGroup(group: string): AnyToolDefinition[] {
   return getAllTools().filter((t) => t.group === group);
 }
-
-// --- Anthropic adapter ---
-
-export function toAnthropicTool(tool: AnyToolDefinition): AnthropicTool {
-  const jsonSchema = z.toJSONSchema(tool.inputSchema);
-  return {
-    name: tool.name,
-    description: tool.description,
-    input_schema: {
-      type: "object" as const,
-      properties: jsonSchema.properties ?? {},
-      required: jsonSchema.required as string[] | undefined,
-    },
-  };
-}
-
-export function toAnthropicTools(): AnthropicTool[] {
-  return getAllTools().map(toAnthropicTool);
-}

package/src/tui/hooks/useMessageQueue.ts

@@ -222,10 +222,11 @@ export function useMessageQueue({
         }
         finalizeSegment();
       } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
         const errorMsg: ChatMessage = {
           id: msgId(),
           role: "system",
-          content: `Error: ${err}`,
+          content: `Error: ${message}`,
           timestamp: new Date(),
         };
         setMessages((prev) => [...prev, errorMsg]);

package/src/utils/title.ts

@@ -1,45 +1,44 @@
+import { generateText } from "ai";
 import type { BotholomewConfig } from "../config/schemas.ts";
+import {
+  buildProviderOptions,
+  formatLlmError,
+  getLanguageModel,
+  getMaxInputTokens,
+} from "../llm/index.ts";
 import { updateThreadTitle } from "../threads/store.ts";
-import { createLlmClient } from "../worker/llm-client.ts";
 import { logger } from "./logger.ts";
 
 /**
- * Generate a short title for a thread using the chunker model (Haiku).
- * Fire-and-forget — errors are logged and never propagated. Writes the
- * title back to the thread's CSV file by rewriting the thread_meta row.
+ * Generate a short title for a thread using the chunker model.
+ * Fire-and-forget — errors are logged and never propagated.
  */
 export async function generateThreadTitle(
-  config: Required<BotholomewConfig>,
+  config: BotholomewConfig,
   projectDir: string,
   threadId: string,
   context: string,
 ): Promise<void> {
   try {
-    const client = createLlmClient(config);
+    const model = getLanguageModel(config.chunker_llm);
+    const numCtx = await getMaxInputTokens(config.chunker_llm);
 
-    const response = await client.messages.create({
-      model: config.chunker_model,
-      max_tokens: 50,
+    const { text } = await generateText({
+      model,
+      maxOutputTokens: 50,
       system:
         "You are a title generator. The user will provide the first message from a conversation. Output a short descriptive title (5-8 words). Output ONLY the title, nothing else.",
-      messages: [
-        {
-          role: "user",
-          content: `Generate a title for this message:\n\n"${context}"`,
-        },
-      ],
+      prompt: `Generate a title for this message:\n\n"${context}"`,
+      providerOptions: buildProviderOptions(config.chunker_llm, numCtx),
     });
 
-    const title = response.content
-      .filter((b) => b.type === "text")
-      .map((b) => b.text)
-      .join("")
-      .trim();
-
+    const title = text.trim();
     if (title) {
       await updateThreadTitle(projectDir, threadId, title);
     }
   } catch (err) {
-    logger.warn(`Failed to generate thread title: ${err}`);
+    logger.warn(
+      `Failed to generate thread title: ${formatLlmError(err, config.chunker_llm)}`,
+    );
   }
 }

package/src/worker/context.ts

@@ -1,113 +1,86 @@
-import Anthropic from "@anthropic-ai/sdk";
-import type { MessageParam } from "@anthropic-ai/sdk/resources/messages";
+import type { ModelMessage } from "ai";
+import type { LlmBlock } from "../config/schemas.ts";
+import { getMaxInputTokens as llmGetMaxInputTokens } from "../llm/index.ts";
 import { logger } from "../utils/logger.ts";
 
 /** Rough estimate: ~4 characters per token for English text */
 const CHARS_PER_TOKEN = 4;
 
-/** Fallback if the models API call fails */
-const DEFAULT_MAX_INPUT_TOKENS = 200_000;
-
 /** Reserve this fraction of the context window for safety margin */
 const HEADROOM_FRACTION = 0.1;
 
 /** Maximum characters for a single tool result before truncation */
 const MAX_TOOL_RESULT_CHARS = 50_000;
 
-/** Cache model max_input_tokens to avoid repeated API calls */
-const modelTokenCache = new Map<string, number>();
-
-/**
- * Look up the model's max input tokens via the Anthropic Models API.
- * Results are cached per model ID for the lifetime of the process.
- */
-export async function getMaxInputTokens(
-  apiKey: string | undefined,
-  model: string,
-): Promise<number> {
-  const cached = modelTokenCache.get(model);
-  if (cached !== undefined) return cached;
-
-  try {
-    const client = new Anthropic({ apiKey: apiKey || undefined });
-    const info = await client.beta.models.retrieve(model);
-    const limit = info.max_input_tokens ?? DEFAULT_MAX_INPUT_TOKENS;
-    modelTokenCache.set(model, limit);
-    return limit;
-  } catch (err) {
-    logger.debug(`Failed to retrieve model info for ${model}: ${err}`);
-    modelTokenCache.set(model, DEFAULT_MAX_INPUT_TOKENS);
-    return DEFAULT_MAX_INPUT_TOKENS;
-  }
+/** Re-export so call sites have a single entry point. */
+export function getMaxInputTokens(cfg: LlmBlock): Promise<number> {
+  return llmGetMaxInputTokens(cfg);
 }
 
 function estimateTokens(text: string): number {
   return Math.ceil(text.length / CHARS_PER_TOKEN);
 }
 
-function messageChars(msg: MessageParam): number {
+function messageChars(msg: ModelMessage): number {
   if (typeof msg.content === "string") return msg.content.length;
-  if (Array.isArray(msg.content)) {
-    let total = 0;
-    for (const block of msg.content) {
-      if ("text" in block && typeof block.text === "string") {
-        total += block.text.length;
-      } else if ("content" in block && typeof block.content === "string") {
-        total += block.content.length;
-      } else {
-        // tool_use blocks with input, etc.
-        total += JSON.stringify(block).length;
-      }
+  if (!Array.isArray(msg.content)) return 0;
+  let total = 0;
+  for (const block of msg.content) {
+    const b = block as Record<string, unknown>;
+    if (typeof b.text === "string") {
+      total += b.text.length;
+    } else if (b.type === "tool-result" && typeof b.output === "object") {
+      const out = b.output as { value?: unknown };
+      total +=
+        typeof out.value === "string"
+          ? out.value.length
+          : JSON.stringify(out.value ?? "").length;
+    } else {
+      total += JSON.stringify(b).length;
     }
-    return total;
   }
-  return JSON.stringify(msg.content).length;
+  return total;
 }
 
 /**
- * Truncate individual tool results that are excessively large.
- * Mutates messages in-place.
+ * Truncate individual tool results that are excessively large. Mutates in-place.
  */
-function truncateToolResults(messages: MessageParam[]): void {
+function truncateToolResults(messages: ModelMessage[]): void {
   for (const msg of messages) {
+    if (msg.role !== "tool") continue;
     if (!Array.isArray(msg.content)) continue;
     for (const block of msg.content) {
-      if (
-        "type" in block &&
-        block.type === "tool_result" &&
-        "content" in block &&
-        typeof block.content === "string" &&
-        block.content.length > MAX_TOOL_RESULT_CHARS
-      ) {
-        const original = block.content.length;
-        (block as { content: string }).content =
-          block.content.slice(0, MAX_TOOL_RESULT_CHARS) +
-          `\n\n[truncated: ${original} chars → ${MAX_TOOL_RESULT_CHARS} chars]`;
-      }
+      const b = block as {
+        type?: string;
+        output?: { type?: string; value?: unknown };
+      };
+      if (b.type !== "tool-result" || !b.output) continue;
+      const out = b.output;
+      if (typeof out.value !== "string") continue;
+      if (out.value.length <= MAX_TOOL_RESULT_CHARS) continue;
+      const original = out.value.length;
+      out.value =
+        out.value.slice(0, MAX_TOOL_RESULT_CHARS) +
+        `\n\n[truncated: ${original} chars → ${MAX_TOOL_RESULT_CHARS} chars]`;
     }
   }
 }
 
 /**
  * Ensure the conversation fits within the context window.
- * Strategy:
- * 1. Truncate oversized tool results
- * 2. If still too large, drop oldest assistant/tool pairs from the middle
- *    (keeping the first user message and recent messages)
- *
- * Mutates messages in-place and returns the array.
+ * 1) Truncate oversized tool results in place.
+ * 2) If still too large, drop oldest messages from the middle (keeping the
+ *    first user message and recent messages).
  */
 export function fitToContextWindow(
-  messages: MessageParam[],
+  messages: ModelMessage[],
   systemPrompt: string,
   maxInputTokens: number,
-): MessageParam[] {
-  // Step 1: truncate oversized tool results
+): ModelMessage[] {
   truncateToolResults(messages);
 
-  // Step 2: estimate total tokens
   const systemTokens = estimateTokens(systemPrompt);
-  const responseBuffer = 4096; // max_tokens for the response
+  const responseBuffer = 4096;
   const headroom = Math.ceil(maxInputTokens * HEADROOM_FRACTION);
 
   const budget = maxInputTokens - systemTokens - responseBuffer - headroom;
@@ -121,16 +94,11 @@ export function fitToContextWindow(
   let totalChars = messages.reduce((sum, m) => sum + messageChars(m), 0);
   let totalTokens = Math.ceil(totalChars / CHARS_PER_TOKEN);
 
-  if (totalTokens <= budget) {
-    return messages;
-  }
+  if (totalTokens <= budget) return messages;
 
-  // Step 3: drop oldest message pairs from the middle until we fit.
-  // Keep messages[0] (initial user message) and remove from index 1 onward.
   let dropped = 0;
   while (totalTokens > budget && messages.length > 2) {
-    // Remove the oldest non-first message (index 1)
-    const removed = messages.splice(1, 1)[0] as MessageParam;
+    const removed = messages.splice(1, 1)[0] as ModelMessage;
     totalChars -= messageChars(removed);
     totalTokens = Math.ceil(totalChars / CHARS_PER_TOKEN);
     dropped++;