@zhijiewang/openharness 2.0.0 → 2.3.0

package/dist/mcp/server.js

@@ -4,8 +4,8 @@
  * Other MCP clients (IDE extensions, other agents) can connect and use
  * openHarness's tools (Bash, Read, Write, Edit, Glob, Grep, etc.)
  */
-import { createInterface } from 'node:readline';
-import { zodToJsonSchemaSimple } from './schema.js';
+import { createInterface } from "node:readline";
+import { zodToJsonSchemaSimple } from "./schema.js";
 export class McpServer {
     tools;
     context;
@@ -16,78 +16,78 @@ export class McpServer {
     /** Start listening on stdio */
     start() {
         const rl = createInterface({ input: process.stdin });
-        rl.on('line', async (line) => {
+        rl.on("line", async (line) => {
             try {
                 const req = JSON.parse(line);
                 const res = await this.handleRequest(req);
                 if (res && req.id !== undefined) {
-                    process.stdout.write(JSON.stringify(res) + '\n');
+                    process.stdout.write(`${JSON.stringify(res)}\n`);
                 }
             }
             catch {
                 // Ignore parse errors
             }
         });
-        process.stderr.write('[mcp-server] OpenHarness MCP server ready\n');
+        process.stderr.write("[mcp-server] OpenHarness MCP server ready\n");
     }
     async handleRequest(req) {
         const id = req.id ?? null;
         switch (req.method) {
-            case 'initialize':
+            case "initialize":
                 return {
-                    jsonrpc: '2.0',
+                    jsonrpc: "2.0",
                     id,
                     result: {
-                        protocolVersion: '2024-11-05',
-                        serverInfo: { name: 'openharness', version: '0.6.0' },
+                        protocolVersion: "2024-11-05",
+                        serverInfo: { name: "openharness", version: "0.6.0" },
                         capabilities: { tools: { listChanged: false } },
                     },
                 };
-            case 'notifications/initialized':
+            case "notifications/initialized":
                 return null; // notification, no response
-            case 'tools/list':
+            case "tools/list":
                 return {
-                    jsonrpc: '2.0',
+                    jsonrpc: "2.0",
                     id,
                     result: {
-                        tools: this.tools.map(t => ({
+                        tools: this.tools.map((t) => ({
                             name: t.name,
                             description: t.prompt().slice(0, 200),
                             inputSchema: zodToJsonSchemaSimple(t.inputSchema),
                         })),
                     },
                 };
-            case 'tools/call': {
+            case "tools/call": {
                 const { name, arguments: args } = req.params ?? {};
-                const tool = this.tools.find(t => t.name === name);
+                const tool = this.tools.find((t) => t.name === name);
                 if (!tool) {
-                    return { jsonrpc: '2.0', id, error: { code: -32601, message: `Unknown tool: ${name}` } };
+                    return { jsonrpc: "2.0", id, error: { code: -32601, message: `Unknown tool: ${name}` } };
                 }
                 const parsed = tool.inputSchema.safeParse(args);
                 if (!parsed.success) {
-                    return { jsonrpc: '2.0', id, error: { code: -32602, message: parsed.error.message } };
+                    return { jsonrpc: "2.0", id, error: { code: -32602, message: parsed.error.message } };
                 }
                 try {
                     const result = await tool.call(parsed.data, this.context);
                     return {
-                        jsonrpc: '2.0',
+                        jsonrpc: "2.0",
                         id,
                         result: {
-                            content: [{ type: 'text', text: result.output }],
+                            content: [{ type: "text", text: result.output }],
                             isError: result.isError,
                         },
                     };
                 }
                 catch (err) {
                     return {
-                        jsonrpc: '2.0',
+                        jsonrpc: "2.0",
                         id,
                         error: { code: -32000, message: err instanceof Error ? err.message : String(err) },
                     };
                 }
             }
             default:
-                return { jsonrpc: '2.0', id, error: { code: -32601, message: `Unknown method: ${req.method}` } };
+                return { jsonrpc: "2.0", id, error: { code: -32601, message: `Unknown method: ${req.method}` } };
         }
     }
 }

package/dist/mcp/types.d.ts

@@ -1,12 +1,12 @@
 /** Minimal MCP protocol types (JSON-RPC 2.0 over stdio) */
 export interface JsonRpcRequest {
-    jsonrpc: '2.0';
+    jsonrpc: "2.0";
     id: number;
     method: string;
     params?: unknown;
 }
 export interface JsonRpcResponse {
-    jsonrpc: '2.0';
+    jsonrpc: "2.0";
     id: number;
     result?: unknown;
     error?: {
@@ -18,7 +18,7 @@ export interface McpToolDef {
     name: string;
     description?: string;
     inputSchema: {
-        type: 'object';
+        type: "object";
         properties?: Record<string, {
             type?: string;
             description?: string;

package/dist/providers/anthropic.d.ts

@@ -1,9 +1,9 @@
 /**
  * Anthropic provider — Claude models via the Anthropic Messages API.
  */
-import type { Message } from "../types/message.js";
 import type { StreamEvent } from "../types/events.js";
-import type { Provider, APIToolDef, ModelInfo, ProviderConfig } from "./base.js";
+import type { Message } from "../types/message.js";
+import type { APIToolDef, ModelInfo, Provider, ProviderConfig } from "./base.js";
 export declare class AnthropicProvider implements Provider {
     readonly name = "anthropic";
     private apiKey;

package/dist/providers/anthropic.js

@@ -1,8 +1,8 @@
 /**
  * Anthropic provider — Claude models via the Anthropic Messages API.
  */
-import { createAssistantMessage } from "../types/message.js";
 import { IMAGE_PREFIX } from "../tools/ImageReadTool/index.js";
+import { createAssistantMessage } from "../types/message.js";
 export class AnthropicProvider {
     name = "anthropic";
     apiKey;
@@ -47,7 +47,7 @@ export class AnthropicProvider {
             }
             else if (msg.role === "tool" && msg.toolResults?.length) {
                 const content = msg.toolResults.map((tr) => {
-                    if (!tr.isError && tr.output.startsWith(IMAGE_PREFIX + ":")) {
+                    if (!tr.isError && tr.output.startsWith(`${IMAGE_PREFIX}:`)) {
                         const [, mediaType, data] = tr.output.split(":");
                         return {
                             type: "tool_result",
@@ -86,9 +86,7 @@ export class AnthropicProvider {
         const m = model ?? this.defaultModel;
         // Prompt caching: send system prompt as content blocks with cache_control.
         // Anthropic caches matching prefixes — 90% cost reduction on repeat turns.
-        const systemBlocks = [
-            { type: "text", text: systemPrompt, cache_control: { type: "ephemeral" } },
-        ];
+        const systemBlocks = [{ type: "text", text: systemPrompt, cache_control: { type: "ephemeral" } }];
         const body = {
             model: m,
             max_tokens: 8192,
@@ -133,7 +131,7 @@ export class AnthropicProvider {
         let currentToolId = "";
         let currentToolName = "";
         let currentToolArgs = "";
-        let inThinkingBlock = false;
+        let _inThinkingBlock = false;
         while (true) {
             const { done, value } = await reader.read();
             if (done)
@@ -172,7 +170,7 @@ export class AnthropicProvider {
                             };
                         }
                         if (block?.type === "thinking") {
-                            inThinkingBlock = true;
+                            _inThinkingBlock = true;
                         }
                         break;
                     }
@@ -190,7 +188,7 @@ export class AnthropicProvider {
                         break;
                     }
                     case "content_block_stop": {
-                        inThinkingBlock = false;
+                        _inThinkingBlock = false;
                         if (currentToolId) {
                             let parsedArgs = {};
                             if (currentToolArgs) {
@@ -198,7 +196,10 @@ export class AnthropicProvider {
                                     parsedArgs = JSON.parse(currentToolArgs);
                                 }
                                 catch {
-                                    yield { type: "error", message: `Malformed tool args for ${currentToolName}: ${currentToolArgs.slice(0, 200)}` };
+                                    yield {
+                                        type: "error",
+                                        message: `Malformed tool args for ${currentToolName}: ${currentToolArgs.slice(0, 200)}`,
+                                    };
                                 }
                             }
                             yield {

package/dist/providers/base.d.ts

@@ -1,8 +1,8 @@
 /**
  * Base provider interface — every LLM provider implements this.
  */
-import type { Message } from "../types/message.js";
 import type { StreamEvent } from "../types/events.js";
+import type { Message } from "../types/message.js";
 export type ModelInfo = {
     id: string;
     provider: string;

package/dist/providers/index.js

@@ -1,11 +1,11 @@
 /**
  * Provider factory — create the right provider from a model string.
  */
+import { AnthropicProvider } from "./anthropic.js";
+import { LlamaCppProvider } from "./llamacpp.js";
 import { OllamaProvider } from "./ollama.js";
 import { OpenAIProvider } from "./openai.js";
-import { AnthropicProvider } from "./anthropic.js";
 import { OpenRouterProvider } from "./openrouter.js";
-import { LlamaCppProvider } from "./llamacpp.js";
 /**
  * Create a provider from a model string like "ollama/llama3" or "gpt-4o".
  */
@@ -61,7 +61,14 @@ function guessProviderFromModel(model) {
         return "anthropic";
     if (model.includes("gguf") || model.startsWith("llamacpp"))
         return "llamacpp";
-    if (model.includes("llama") || model.includes("mistral") || model.includes("phi") || model.includes("qwen") || model.includes("gemma") || model.includes("deepseek") || model.includes("codestral") || model.includes("starcoder"))
+    if (model.includes("llama") ||
+        model.includes("mistral") ||
+        model.includes("phi") ||
+        model.includes("qwen") ||
+        model.includes("gemma") ||
+        model.includes("deepseek") ||
+        model.includes("codestral") ||
+        model.includes("starcoder"))
         return "ollama";
     return "openai"; // default fallback
 }

package/dist/providers/llamacpp.d.ts

@@ -1,9 +1,9 @@
 /**
  * LlamaCpp provider — local LLM inference via llama-server OpenAI-compatible REST API.
  */
-import type { Message } from "../types/message.js";
 import type { StreamEvent } from "../types/events.js";
-import type { Provider, APIToolDef, ModelInfo, ProviderConfig } from "./base.js";
+import type { Message } from "../types/message.js";
+import type { APIToolDef, ModelInfo, Provider, ProviderConfig } from "./base.js";
 export declare class LlamaCppProvider implements Provider {
     readonly name = "llamacpp";
     private baseUrl;

package/dist/providers/llamacpp.js

@@ -7,9 +7,7 @@ export class LlamaCppProvider {
     baseUrl;
     defaultModel;
     constructor(config) {
-        this.baseUrl = (config.baseUrl ?? "http://localhost:8080")
-            .replace(/\/$/, "")
-            .replace(/\/v1$/, "");
+        this.baseUrl = (config.baseUrl ?? "http://localhost:8080").replace(/\/$/, "").replace(/\/v1$/, "");
         this.defaultModel = config.defaultModel ?? "";
     }
     convertMessages(messages, systemPrompt) {

package/dist/providers/ollama.d.ts

@@ -1,9 +1,9 @@
 /**
  * Ollama provider — local LLM inference via Ollama REST API.
  */
-import type { Message } from "../types/message.js";
 import type { StreamEvent } from "../types/events.js";
-import type { Provider, APIToolDef, ModelInfo, ProviderConfig } from "./base.js";
+import type { Message } from "../types/message.js";
+import type { APIToolDef, ModelInfo, Provider, ProviderConfig } from "./base.js";
 export declare class OllamaProvider implements Provider {
     readonly name = "ollama";
     private baseUrl;

package/dist/providers/ollama.js

@@ -189,7 +189,7 @@ export class OllamaProvider {
                         };
                         const args = typeof tc.function?.arguments === "string"
                             ? JSON.parse(tc.function.arguments)
-                            : tc.function?.arguments ?? {};
+                            : (tc.function?.arguments ?? {});
                         yield {
                             type: "tool_call_complete",
                             callId,
@@ -253,7 +253,7 @@ export class OllamaProvider {
                 toolName: tc.function?.name ?? "unknown",
                 arguments: typeof tc.function?.arguments === "string"
                     ? JSON.parse(tc.function.arguments)
-                    : tc.function?.arguments ?? {},
+                    : (tc.function?.arguments ?? {}),
             }));
         }
         return createAssistantMessage(content, toolCalls);
@@ -271,8 +271,7 @@ export class OllamaProvider {
                 // Detect vision support from model families
                 // Presence of "clip" or "llava" in families indicates vision capability
                 const families = m.details?.families ?? [];
-                const supportsVision = Array.isArray(families) &&
-                    families.some((f) => f.includes("clip") || f.includes("llava"));
+                const supportsVision = Array.isArray(families) && families.some((f) => f.includes("clip") || f.includes("llava"));
                 return {
                     id: m.name,
                     provider: "ollama",

package/dist/providers/openai.d.ts

@@ -1,9 +1,9 @@
 /**
  * OpenAI-compatible provider — works with OpenAI, DeepSeek, Groq, Together, etc.
  */
-import type { Message } from "../types/message.js";
 import type { StreamEvent } from "../types/events.js";
-import type { Provider, APIToolDef, ModelInfo, ProviderConfig } from "./base.js";
+import type { Message } from "../types/message.js";
+import type { APIToolDef, ModelInfo, Provider, ProviderConfig } from "./base.js";
 export declare class OpenAIProvider implements Provider {
     readonly name: string;
     private apiKey;

package/dist/providers/openai.js

@@ -1,8 +1,8 @@
 /**
  * OpenAI-compatible provider — works with OpenAI, DeepSeek, Groq, Together, etc.
  */
-import { createAssistantMessage } from "../types/message.js";
 import { IMAGE_PREFIX } from "../tools/ImageReadTool/index.js";
+import { createAssistantMessage } from "../types/message.js";
 export class OpenAIProvider {
     name;
     apiKey;
@@ -35,7 +35,7 @@ export class OpenAIProvider {
             }
             else if (msg.role === "tool" && msg.toolResults?.length) {
                 for (const tr of msg.toolResults) {
-                    if (!tr.isError && tr.output.startsWith(IMAGE_PREFIX + ":")) {
+                    if (!tr.isError && tr.output.startsWith(`${IMAGE_PREFIX}:`)) {
                         const [, mediaType, data] = tr.output.split(":");
                         out.push({
                             role: "tool",
@@ -129,9 +129,7 @@ export class OpenAIProvider {
                     const inputTokens = chunk.usage.prompt_tokens ?? 0;
                     const outputTokens = chunk.usage.completion_tokens ?? 0;
                     const info = this.getModelInfo(m);
-                    const cost = (inputTokens * (info?.inputCostPerMtok ?? 0) +
-                        outputTokens * (info?.outputCostPerMtok ?? 0)) /
-                        1_000_000;
+                    const cost = (inputTokens * (info?.inputCostPerMtok ?? 0) + outputTokens * (info?.outputCostPerMtok ?? 0)) / 1_000_000;
                     yield { type: "cost_update", inputTokens, outputTokens, cost, model: m };
                 }
                 const delta = chunk.choices?.[0]?.delta;

package/dist/providers/openrouter.d.ts

@@ -1,9 +1,9 @@
 /**
  * OpenRouter provider — aggregated LLM access via OpenAI-compatible API.
  */
-import type { Message } from "../types/message.js";
 import type { StreamEvent } from "../types/events.js";
-import type { Provider, APIToolDef, ModelInfo, ProviderConfig } from "./base.js";
+import type { Message } from "../types/message.js";
+import type { APIToolDef, ModelInfo, Provider, ProviderConfig } from "./base.js";
 export declare class OpenRouterProvider implements Provider {
     readonly name = "openrouter";
     private apiKey;

package/dist/providers/router.d.ts

@@ -8,7 +8,7 @@
  *
  * Saves ~20% cost and ~30% latency by avoiding expensive models for simple tasks.
  */
-export type ModelTier = 'fast' | 'balanced' | 'powerful';
+export type ModelTier = "fast" | "balanced" | "powerful";
 export type RouterConfig = {
     fast?: string;
     balanced?: string;

package/dist/providers/router.js

@@ -19,27 +19,27 @@ export class ModelRouter {
     select(context) {
         // High-context pressure → use fast model to minimize token cost
         if (context.contextUsage && context.contextUsage > 0.8) {
-            return this.route('fast', 'context pressure > 80%');
+            return this.route("fast", "context pressure > 80%");
         }
         // Roles that require deep reasoning → powerful
-        const powerfulRoles = ['code-reviewer', 'evaluator', 'architect', 'security-auditor'];
+        const powerfulRoles = ["code-reviewer", "evaluator", "architect", "security-auditor"];
         if (context.role && powerfulRoles.includes(context.role)) {
-            return this.route('powerful', `role: ${context.role}`);
+            return this.route("powerful", `role: ${context.role}`);
         }
         // Early exploration turns (1-2) → fast
         if (context.turn <= 2 && context.hadToolCalls) {
-            return this.route('fast', 'early exploration');
+            return this.route("fast", "early exploration");
         }
         // Tool-heavy turns (3+ tool calls) → fast (just dispatching)
         if (context.toolCallCount >= 3) {
-            return this.route('fast', 'tool-heavy turn');
+            return this.route("fast", "tool-heavy turn");
         }
         // Final response (no tool calls) → powerful for quality
         if (context.isFinalResponse) {
-            return this.route('powerful', 'final response');
+            return this.route("powerful", "final response");
         }
         // Default → balanced
-        return this.route('balanced', 'default');
+        return this.route("balanced", "default");
     }
     route(tier, reason) {
         const model = this.config[tier] ?? this.defaultModel;

package/dist/query/compress.d.ts

@@ -2,8 +2,8 @@
  * Message compression — multi-phase strategies to keep conversation
  * within the context window.
  */
-import type { Message } from "../types/message.js";
 import type { Provider } from "../providers/base.js";
+import type { Message } from "../types/message.js";
 /**
  * Semantic importance scoring for messages.
  * Higher score = more important to keep during compression.
@@ -18,5 +18,5 @@ export declare function compressMessages(messages: Message[], targetTokens: numb
 /**
  * LLM-assisted summarization of older messages.
  */
-export declare function summarizeConversation(provider: Provider, messages: Message[], model: string | undefined, targetTokens: number): Promise<Message[]>;
+export declare function summarizeConversation(provider: Provider, messages: Message[], model: string | undefined, _targetTokens: number): Promise<Message[]>;
 //# sourceMappingURL=compress.d.ts.map

package/dist/query/compress.js

@@ -2,9 +2,9 @@
  * Message compression — multi-phase strategies to keep conversation
  * within the context window.
  */
-import { createUserMessage } from "../types/message.js";
-import { defaultEstimateTokens } from "../providers/base.js";
 import { emitHook } from "../harness/hooks.js";
+import { defaultEstimateTokens } from "../providers/base.js";
+import { createUserMessage } from "../types/message.js";
 const DEFAULT_KEEP_LAST = 10;
 /**
  * Semantic importance scoring for messages.
@@ -15,15 +15,15 @@ export function scoreMessage(msg, index, total) {
         return Infinity;
     let score = 0;
     // Role weight: user intent > tool decisions > assistant text
-    if (msg.role === 'user')
+    if (msg.role === "user")
         score += 30;
-    else if (msg.role === 'assistant' && msg.toolCalls?.length)
+    else if (msg.role === "assistant" && msg.toolCalls?.length)
         score += 20;
-    else if (msg.role === 'assistant')
+    else if (msg.role === "assistant")
         score += 10;
-    else if (msg.role === 'system')
+    else if (msg.role === "system")
         score += 25; // system messages are usually important
-    else if (msg.role === 'tool')
+    else if (msg.role === "tool")
         score += 5;
     // Recency bonus: recent messages get +0 to +20
     const recencyFactor = index / total;
@@ -71,11 +71,11 @@ export function compressMessages(messages, targetTokens) {
             continue;
         if (result[i].role === "tool" && result[i].content.length > 500) {
             const c = result[i].content;
-            result[i] = { ...result[i], content: c.slice(0, 200) + "\n...[truncated]...\n" + c.slice(-100) };
+            result[i] = { ...result[i], content: `${c.slice(0, 200)}\n...[truncated]...\n${c.slice(-100)}` };
         }
         if (result[i].role === "assistant" && result[i].content.length > 2000) {
             const c = result[i].content;
-            result[i] = { ...result[i], content: c.slice(0, 500) + "\n...[truncated]...\n" + c.slice(-200) };
+            result[i] = { ...result[i], content: `${c.slice(0, 500)}\n...[truncated]...\n${c.slice(-200)}` };
         }
     }
     // AutoCompact Phase 1: Replace old tool results with stub
@@ -96,7 +96,7 @@ export function compressMessages(messages, targetTokens) {
         let lowestIdx = -1;
         for (let i = 0; i < result.length - keepLast; i++) {
             const msg = result[i];
-            if (msg.role === 'system' || msg.meta?.pinned)
+            if (msg.role === "system" || msg.meta?.pinned)
                 continue;
             const score = scoreMessage(msg, i, result.length);
             if (score < lowestScore) {
@@ -119,8 +119,7 @@ export function compressMessages(messages, targetTokens) {
     const filtered = result.filter((msg) => {
         if (msg.role !== "tool")
             return true;
-        return (msg.toolResults?.length ?? 0) > 0 &&
-            msg.toolResults.every((tr) => validCallIds.has(tr.callId));
+        return (msg.toolResults?.length ?? 0) > 0 && msg.toolResults.every((tr) => validCallIds.has(tr.callId));
     });
     emitHook("postCompact", {});
     return filtered;
@@ -128,28 +127,30 @@ export function compressMessages(messages, targetTokens) {
 /**
  * LLM-assisted summarization of older messages.
  */
-export async function summarizeConversation(provider, messages, model, targetTokens) {
+export async function summarizeConversation(provider, messages, model, _targetTokens) {
     const keepRecent = Math.min(6, messages.length - 1);
     const older = messages.slice(0, messages.length - keepRecent);
     const recent = messages.slice(messages.length - keepRecent);
     if (older.length < 2)
         return messages;
-    const pinned = older.filter(m => m.meta?.pinned);
-    const summarizable = older.filter(m => !m.meta?.pinned);
+    const pinned = older.filter((m) => m.meta?.pinned);
+    const summarizable = older.filter((m) => !m.meta?.pinned);
     if (summarizable.length < 2)
         return messages;
-    const olderText = summarizable.map(m => {
-        const prefix = m.role === 'user' ? 'User' : m.role === 'assistant' ? 'Assistant' : 'System';
+    const olderText = summarizable
+        .map((m) => {
+        const prefix = m.role === "user" ? "User" : m.role === "assistant" ? "Assistant" : "System";
         let text = `${prefix}: ${m.content.slice(0, 500)}`;
         if (m.toolCalls?.length) {
-            text += `\n  [Used tools: ${m.toolCalls.map(tc => tc.toolName).join(', ')}]`;
+            text += `\n  [Used tools: ${m.toolCalls.map((tc) => tc.toolName).join(", ")}]`;
         }
         return text;
-    }).join('\n\n');
+    })
+        .join("\n\n");
     const summaryPrompt = `Summarize this conversation history in 2-4 sentences, preserving key decisions, file paths mentioned, and what was accomplished:\n\n${olderText.slice(0, 3000)}`;
-    const summaryResponse = await provider.complete([createUserMessage(summaryPrompt)], 'You are a conversation summarizer. Be concise and factual. Preserve important details like file paths and decisions.', undefined, model);
+    const summaryResponse = await provider.complete([createUserMessage(summaryPrompt)], "You are a conversation summarizer. Be concise and factual. Preserve important details like file paths and decisions.", undefined, model);
     const summaryMessage = {
-        role: 'system',
+        role: "system",
         content: `[Conversation summary: ${summaryResponse.content}]`,
         uuid: `summary-${Date.now()}`,
         timestamp: Date.now(),

package/dist/query/context-manager.d.ts

@@ -9,7 +9,7 @@
  *
  * Based on the "context engineering" pattern from Anthropic's harness research.
  */
-import type { Message } from '../types/message.js';
+import type { Message } from "../types/message.js";
 export type ContextBudget = {
     /** Max tokens for a single tool output */
     toolOutputMax: number;
@@ -42,7 +42,7 @@ export declare class ContextManager {
      * Check if we should proactively compress before a tool call.
      * Returns true if estimated context usage exceeds the proactive threshold.
      */
-    shouldPreCompress(messages: Message[], estimatedOutputTokens: number, estimateTokens: (text: string) => number): boolean;
+    shouldPreCompress(messages: Message[], estimatedOutputTokens: number): boolean;
     /**
      * Estimate how many tokens a tool call might produce.
      * Based on historical averages for each tool type.

package/dist/query/context-manager.js

@@ -9,7 +9,8 @@
  *
  * Based on the "context engineering" pattern from Anthropic's harness research.
  */
-import { getContextWindow } from '../harness/cost.js';
+import { getContextWindow } from "../harness/cost.js";
+import { estimateMessagesTokens } from "./compress.js";
 const DEFAULT_BUDGET = {
     toolOutputMax: 10_000,
     perTool: {},
@@ -45,9 +46,9 @@ export class ContextManager {
         const keepHead = Math.floor(maxChars * 0.7);
         const keepTail = Math.floor(maxChars * 0.2);
         const truncated = output.length - keepHead - keepTail;
-        return output.slice(0, keepHead)
-            + `\n\n[...${truncated.toLocaleString()} chars truncated (budget: ${budget} tokens)...]\n\n`
-            + output.slice(-keepTail);
+        return (output.slice(0, keepHead) +
+            `\n\n[...${truncated.toLocaleString()} chars truncated (budget: ${budget} tokens)...]\n\n` +
+            output.slice(-keepTail));
     }
     /**
      * Fold a sub-agent's full output into a concise summary.
@@ -69,15 +70,11 @@ export class ContextManager {
      * Check if we should proactively compress before a tool call.
      * Returns true if estimated context usage exceeds the proactive threshold.
      */
-    shouldPreCompress(messages, estimatedOutputTokens, estimateTokens) {
+    shouldPreCompress(messages, estimatedOutputTokens) {
         const contextWindow = getContextWindow(this.model);
-        let currentTokens = 0;
-        for (const m of messages) {
-            currentTokens += estimateTokens(m.content) + 10;
-        }
+        const currentTokens = estimateMessagesTokens(messages);
         const projected = currentTokens + estimatedOutputTokens;
-        const usage = projected / contextWindow;
-        return usage > this.budget.proactiveThreshold;
+        return projected / contextWindow > this.budget.proactiveThreshold;
     }
     /**
      * Estimate how many tokens a tool call might produce.

package/dist/query/errors.js

@@ -9,7 +9,7 @@ export function isRateLimitError(err) {
 }
 export function isOverloadError(err) {
     const msg = err.message.toLowerCase();
-    return msg.includes("503") || msg.includes("overloaded") || msg.includes("service unavailable") || msg.includes("529");
+    return (msg.includes("503") || msg.includes("overloaded") || msg.includes("service unavailable") || msg.includes("529"));
 }
 export function isPromptTooLongError(err) {
     const msg = err.message.toLowerCase();

package/dist/query/index.d.ts

@@ -9,7 +9,7 @@
  */
 import type { StreamEvent } from "../types/events.js";
 import type { QueryConfig } from "./types.js";
-export type { QueryConfig, QueryLoopState } from "./types.js";
 export { compressMessages } from "./compress.js";
+export type { QueryConfig, QueryLoopState } from "./types.js";
 export declare function query(userMessage: string, config: QueryConfig, existingMessages?: import("../types/message.js").Message[]): AsyncGenerator<StreamEvent, void>;
 //# sourceMappingURL=index.d.ts.map