skimpyclaw 0.3.14 → 0.4.0

package/dist/providers/context-manager.js

@@ -4,33 +4,205 @@
 //
 // Falls back to mechanical truncation if the LLM call fails.
 //
-// Key constraint: tool_use/tool_result pairs (Anthropic) and
-// function_call/function_call_output pairs (Codex) must stay structurally intact.
+// Uses a generic compactMessages() driven by MessageFormatHelper adapters,
+// so the compaction algorithm is written once regardless of provider format.
 const DEFAULT_MAX_CONTEXT_TOKENS = 200_000;
 const KEEP_TAIL = 8; // always keep last N messages/items untouched
-const RESULT_MAX_CHARS = 500; // fallback truncation length
-const SUMMARY_MAX_TOKENS = 2048; // max tokens for summary response
+const RESULT_MAX_CHARS = 200; // fallback truncation length
+const SUMMARY_MAX_TOKENS = 1024; // max tokens for summary response
 // Preferred compaction models in priority order (cheap & fast).
 // Can be overridden via contextManagement.compactionModel in config.
 const COMPACTION_MODEL_CANDIDATES = [
-    'anthropic/claude-haiku-3-5',
-    'openai/gpt-4o-mini',
-    'groq/llama-3.1-8b-instant',
+    'anthropic/claude-haiku-4-5',
 ];
 /** Rough token estimate: 1 token ≈ 4 chars of JSON. */
 export function estimateTokens(data) {
     return Math.ceil(JSON.stringify(data).length / 4);
 }
 // --- LLM Summarization ---
-const COMPACTION_SYSTEM_PROMPT = `You are a conversation summarizer for an AI coding assistant. Your job is to produce a concise summary of a conversation between a user and an assistant that used tools (file reads, bash commands, file writes, etc.).
-
-Rules:
-- Preserve ALL important context: file paths, variable names, error messages, decisions made, code changes
-- Summarize tool results (e.g. "Read package.json — found dependencies X, Y, Z") rather than reproducing full output
-- Keep the summary structured with bullet points or short paragraphs
-- Note any unresolved issues or ongoing tasks
-- Be concise but don't lose critical information that the assistant needs to continue working
-- Output ONLY the summary, no preamble`;
+const COMPACTION_SYSTEM_PROMPT = `Summarize this AI coding assistant conversation concisely.
+Preserve: file paths, variable names, error messages, decisions, code changes.
+Summarize tool results briefly. Note unresolved issues. Use bullet points.
+Output ONLY the summary.`;
+/**
+ * Pick the best available compaction model from candidates.
+ * Checks which providers are initialized and returns the first match.
+ */
+async function pickCompactionModel(config) {
+    const { isAnthropicAvailable } = await import('./anthropic.js');
+    for (const candidate of COMPACTION_MODEL_CANDIDATES) {
+        const provider = candidate.split('/')[0];
+        if (provider === 'anthropic' && isAnthropicAvailable())
+            return candidate;
+    }
+    // Last resort: return the first candidate and let chat() fail → fallback to truncation
+    return COMPACTION_MODEL_CANDIDATES[0];
+}
+/**
+ * Call the LLM to summarize a conversation transcript.
+ * Returns the summary text, or null if the call fails.
+ */
+async function llmSummarize(transcript, config, compactionModel) {
+    try {
+        // Dynamically import to avoid circular dependency
+        const { chat } = await import('./index.js');
+        const model = compactionModel || await pickCompactionModel(config);
+        const messages = [
+            { role: 'system', content: COMPACTION_SYSTEM_PROMPT },
+            {
+                role: 'user',
+                content: `Summarize the following conversation between an AI coding assistant and a user. This summary will replace the old messages in the context window so the assistant can continue working.\n\n---\n${transcript}\n---`,
+            },
+        ];
+        console.log(`[context-manager] Requesting LLM summary via ${model}`);
+        const summary = await chat(messages, {
+            model,
+            maxTokens: SUMMARY_MAX_TOKENS,
+        }, config);
+        if (!summary || summary.trim().length === 0) {
+            console.warn('[context-manager] LLM returned empty summary, falling back to truncation');
+            return null;
+        }
+        console.log(`[context-manager] LLM summary: ${summary.length} chars`);
+        return summary.trim();
+    }
+    catch (err) {
+        console.warn(`[context-manager] LLM summarization failed, falling back to truncation: ${err instanceof Error ? err.message : err}`);
+        return null;
+    }
+}
+// --- Track whether we already compacted for a given conversation ---
+const compactedMarker = new WeakSet();
+// =====================================================================
+// Generic compaction — single algorithm, format-agnostic via helper
+// =====================================================================
+/**
+ * Generic compaction function for any message format.
+ * Delegates format-specific concerns (truncation, serialization, summary building)
+ * to the provided MessageFormatHelper.
+ *
+ * Does NOT mutate the input array — returns a new array.
+ */
+export async function compactMessages(items, helper, config, iteration = 0, fullConfig) {
+    if (config?.enabled === false)
+        return { messages: items, compacted: false };
+    const maxTokens = config?.maxContextTokens ?? DEFAULT_MAX_CONTEXT_TOKENS;
+    const estimated = estimateTokens(items);
+    if (estimated <= maxTokens)
+        return { messages: items, compacted: false };
+    const tail = items.slice(-KEEP_TAIL);
+    const head = items.slice(0, -KEEP_TAIL);
+    // If we already compacted this array, use truncation fallback
+    // to progressively shrink rather than re-summarizing repeatedly.
+    if (compactedMarker.has(items)) {
+        console.log(`[context-manager] Already compacted, using truncation fallback (iteration ${iteration})`);
+        const truncatedHead = head.map(item => helper.isToolResult(item) ? helper.truncateToolResult(item, RESULT_MAX_CHARS) : item);
+        const result = [...truncatedHead, ...tail];
+        return { messages: result, compacted: true, method: 'truncation', tokensBefore: estimated, tokensAfter: estimateTokens(result) };
+    }
+    console.log(`[context-manager] Compacting at iteration ${iteration} (~${Math.round(estimated / 1000)}k tokens > ${Math.round(maxTokens / 1000)}k threshold)`);
+    // Attempt LLM summarization
+    if (fullConfig) {
+        const transcript = helper.serialize(head);
+        const summary = await llmSummarize(transcript, fullConfig, config?.compactionModel);
+        if (summary) {
+            const summaryItem = helper.buildSummaryMessage(summary);
+            const result = [summaryItem, ...tail];
+            compactedMarker.add(result);
+            const tokensAfter = estimateTokens(result);
+            return { messages: result, compacted: true, method: 'llm', summary, tokensBefore: estimated, tokensAfter };
+        }
+    }
+    // Fallback: mechanical truncation
+    const truncatedHead = head.map(item => helper.isToolResult(item) ? helper.truncateToolResult(item, RESULT_MAX_CHARS) : item);
+    const result = [...truncatedHead, ...tail];
+    return { messages: result, compacted: true, method: 'truncation', tokensBefore: estimated, tokensAfter: estimateTokens(result) };
+}
+// =====================================================================
+// Provider-specific MessageFormatHelper implementations
+// =====================================================================
+/** Anthropic message format helper. */
+export const anthropicFormatHelper = {
+    isToolResult(item) {
+        if (!Array.isArray(item.content))
+            return false;
+        return item.content.some((block) => block.type === 'tool_result');
+    },
+    truncateToolResult(item, maxChars) {
+        if (!Array.isArray(item.content))
+            return item;
+        let changed = false;
+        const newContent = item.content.map((block) => {
+            if (block.type !== 'tool_result')
+                return block;
+            const raw = typeof block.content === 'string'
+                ? block.content
+                : JSON.stringify(block.content);
+            if (raw.length <= maxChars)
+                return block;
+            changed = true;
+            return { ...block, content: raw.slice(0, maxChars) + ' [truncated]' };
+        });
+        return changed ? { ...item, content: newContent } : item;
+    },
+    serialize(items) {
+        return serializeAnthropicMessages(items);
+    },
+    buildSummaryMessage(summary) {
+        return {
+            role: 'user',
+            content: [{ type: 'text', text: `[Conversation Summary]\n${summary}` }],
+        };
+    },
+};
+/** OpenAI message format helper. */
+export const openaiFormatHelper = {
+    isToolResult(item) {
+        return item.role === 'tool';
+    },
+    truncateToolResult(item, maxChars) {
+        if (typeof item.content !== 'string')
+            return item;
+        if (item.content.length <= maxChars)
+            return item;
+        return { ...item, content: item.content.slice(0, maxChars) + ' [truncated]' };
+    },
+    serialize(items) {
+        return serializeOpenAIMessages(items);
+    },
+    buildSummaryMessage(summary) {
+        return {
+            role: 'user',
+            content: `[Conversation Summary]\n${summary}`,
+        };
+    },
+};
+/** Codex message format helper. */
+export const codexFormatHelper = {
+    isToolResult(item) {
+        return item.type === 'function_call_output';
+    },
+    truncateToolResult(item, maxChars) {
+        if (typeof item.output !== 'string')
+            return item;
+        if (item.output.length <= maxChars)
+            return item;
+        return { ...item, output: item.output.slice(0, maxChars) + ' [truncated]' };
+    },
+    serialize(items) {
+        return serializeCodexMessages(items);
+    },
+    buildSummaryMessage(summary) {
+        return {
+            type: 'message',
+            role: 'user',
+            content: `[Conversation Summary]\n${summary}`,
+        };
+    },
+};
+// =====================================================================
+// Serialization helpers (used by format helpers and exported for tests)
+// =====================================================================
 /**
  * Serialize Anthropic-format messages into a human-readable conversation transcript
  * suitable for LLM summarization.
@@ -125,227 +297,31 @@ function serializeCodexMessages(items) {
     }
     return lines.join('\n');
 }
-/**
- * Pick the best available compaction model from candidates.
- * Checks which providers are initialized and returns the first match.
- */
-async function pickCompactionModel(config) {
-    const { isAnthropicAvailable } = await import('./anthropic.js');
-    const { isOpenAIAvailable } = await import('./openai.js');
-    for (const candidate of COMPACTION_MODEL_CANDIDATES) {
-        const provider = candidate.split('/')[0];
-        if (provider === 'anthropic' && isAnthropicAvailable())
-            return candidate;
-        if (isOpenAIAvailable(provider))
-            return candidate;
-    }
-    // Last resort: return the first candidate and let chat() fail → fallback to truncation
-    return COMPACTION_MODEL_CANDIDATES[0];
-}
-/**
- * Call the LLM to summarize a conversation transcript.
- * Returns the summary text, or null if the call fails.
- */
-async function llmSummarize(transcript, config, compactionModel) {
-    try {
-        // Dynamically import to avoid circular dependency
-        const { chat } = await import('./index.js');
-        const model = compactionModel || await pickCompactionModel(config);
-        const messages = [
-            { role: 'system', content: COMPACTION_SYSTEM_PROMPT },
-            {
-                role: 'user',
-                content: `Summarize the following conversation between an AI coding assistant and a user. This summary will replace the old messages in the context window so the assistant can continue working.\n\n---\n${transcript}\n---`,
-            },
-        ];
-        console.log(`[context-manager] Requesting LLM summary via ${model}`);
-        const summary = await chat(messages, {
-            model,
-            maxTokens: SUMMARY_MAX_TOKENS,
-        }, config);
-        if (!summary || summary.trim().length === 0) {
-            console.warn('[context-manager] LLM returned empty summary, falling back to truncation');
-            return null;
-        }
-        console.log(`[context-manager] LLM summary: ${summary.length} chars`);
-        return summary.trim();
-    }
-    catch (err) {
-        console.warn(`[context-manager] LLM summarization failed, falling back to truncation: ${err instanceof Error ? err.message : err}`);
-        return null;
-    }
-}
-// --- Fallback truncation (original mechanical approach) ---
-function truncateAnthropicHead(head) {
-    return head.map(msg => {
-        if (!Array.isArray(msg.content))
-            return msg;
-        let changed = false;
-        const newContent = msg.content.map((block) => {
-            if (block.type !== 'tool_result')
-                return block;
-            const raw = typeof block.content === 'string'
-                ? block.content
-                : JSON.stringify(block.content);
-            if (raw.length <= RESULT_MAX_CHARS)
-                return block;
-            changed = true;
-            return { ...block, content: raw.slice(0, RESULT_MAX_CHARS) + ' [truncated]' };
-        });
-        return changed ? { ...msg, content: newContent } : msg;
-    });
-}
-function truncateOpenAIHead(head) {
-    return head.map(msg => {
-        if (msg.role !== 'tool')
-            return msg;
-        if (typeof msg.content !== 'string')
-            return msg;
-        if (msg.content.length <= RESULT_MAX_CHARS)
-            return msg;
-        return { ...msg, content: msg.content.slice(0, RESULT_MAX_CHARS) + ' [truncated]' };
-    });
-}
-function truncateCodexHead(head) {
-    return head.map(item => {
-        if (item.type !== 'function_call_output')
-            return item;
-        if (typeof item.output !== 'string')
-            return item;
-        if (item.output.length <= RESULT_MAX_CHARS)
-            return item;
-        return { ...item, output: item.output.slice(0, RESULT_MAX_CHARS) + ' [truncated]' };
-    });
-}
-// --- Track whether we already compacted for a given conversation ---
-// Key: a hash of the tail messages to avoid re-summarizing the same head repeatedly.
-// This is a WeakMap so we don't leak memory across conversations.
-const compactedMarker = new WeakSet();
+// =====================================================================
+// Legacy wrapper functions — delegate to generic compactMessages()
+// These preserve backward compatibility for the old provider tool loops
+// (anthropic.ts, codex.ts) until Phase 5 removes them.
+// =====================================================================
 /**
  * Compact Anthropic-format apiMessages when over threshold.
- * Uses LLM summarization for old messages; falls back to truncation on failure.
- * Does NOT mutate the input array — returns a new array.
+ * @deprecated Use compactMessages() with anthropicFormatHelper instead.
  */
 export async function compactAnthropicMessages(messages, config, iteration = 0, fullConfig) {
-    if (config?.enabled === false)
-        return { messages, compacted: false };
-    const maxTokens = config?.maxContextTokens ?? DEFAULT_MAX_CONTEXT_TOKENS;
-    const estimated = estimateTokens(messages);
-    if (estimated <= maxTokens)
-        return { messages, compacted: false };
-    // If we already compacted this array (it has a summary message), use truncation fallback
-    // to progressively shrink rather than re-summarizing repeatedly.
-    if (compactedMarker.has(messages)) {
-        console.log(`[context-manager] Already compacted, using truncation fallback (iteration ${iteration})`);
-        const tail = messages.slice(-KEEP_TAIL);
-        const head = messages.slice(0, -KEEP_TAIL);
-        const result = [...truncateAnthropicHead(head), ...tail];
-        return { messages: result, compacted: true, method: 'truncation', tokensBefore: estimated, tokensAfter: estimateTokens(result) };
-    }
-    console.log(`[context-manager] Compacting at iteration ${iteration} (~${Math.round(estimated / 1000)}k tokens > ${Math.round(maxTokens / 1000)}k threshold)`);
-    const tail = messages.slice(-KEEP_TAIL);
-    const head = messages.slice(0, -KEEP_TAIL);
-    // Attempt LLM summarization
-    if (fullConfig) {
-        const transcript = serializeAnthropicMessages(head);
-        const summary = await llmSummarize(transcript, fullConfig, config?.compactionModel);
-        if (summary) {
-            const summaryMessage = {
-                role: 'user',
-                content: [{ type: 'text', text: `[Conversation Summary]\n${summary}` }],
-            };
-            const result = [summaryMessage, ...tail];
-            compactedMarker.add(result);
-            const tokensAfter = estimateTokens(result);
-            return { messages: result, compacted: true, method: 'llm', summary, tokensBefore: estimated, tokensAfter };
-        }
-    }
-    // Fallback: mechanical truncation
-    const result = [...truncateAnthropicHead(head), ...tail];
-    return { messages: result, compacted: true, method: 'truncation', tokensBefore: estimated, tokensAfter: estimateTokens(result) };
+    return compactMessages(messages, anthropicFormatHelper, config, iteration, fullConfig);
 }
 /**
  * Compact OpenAI-format apiMessages when over threshold.
- * Uses LLM summarization for old messages; falls back to truncation on failure.
- * Does NOT mutate the input array — returns a new array.
+ * @deprecated Use compactMessages() with openaiFormatHelper instead.
  */
 export async function compactOpenAIMessages(messages, config, iteration = 0, fullConfig) {
-    if (config?.enabled === false)
-        return { messages, compacted: false };
-    const maxTokens = config?.maxContextTokens ?? DEFAULT_MAX_CONTEXT_TOKENS;
-    const estimated = estimateTokens(messages);
-    if (estimated <= maxTokens)
-        return { messages, compacted: false };
-    if (compactedMarker.has(messages)) {
-        console.log(`[context-manager] Already compacted, using truncation fallback (iteration ${iteration})`);
-        const tail = messages.slice(-KEEP_TAIL);
-        const head = messages.slice(0, -KEEP_TAIL);
-        const result = [...truncateOpenAIHead(head), ...tail];
-        return { messages: result, compacted: true, method: 'truncation', tokensBefore: estimated, tokensAfter: estimateTokens(result) };
-    }
-    console.log(`[context-manager] Compacting OpenAI messages at iteration ${iteration} (~${Math.round(estimated / 1000)}k tokens > ${Math.round(maxTokens / 1000)}k threshold)`);
-    const tail = messages.slice(-KEEP_TAIL);
-    const head = messages.slice(0, -KEEP_TAIL);
-    // Attempt LLM summarization
-    if (fullConfig) {
-        const transcript = serializeOpenAIMessages(head);
-        const summary = await llmSummarize(transcript, fullConfig, config?.compactionModel);
-        if (summary) {
-            const summaryMessage = {
-                role: 'user',
-                content: `[Conversation Summary]\n${summary}`,
-            };
-            const result = [summaryMessage, ...tail];
-            compactedMarker.add(result);
-            const tokensAfter = estimateTokens(result);
-            return { messages: result, compacted: true, method: 'llm', summary, tokensBefore: estimated, tokensAfter };
-        }
-    }
-    // Fallback: mechanical truncation
-    const result = [...truncateOpenAIHead(head), ...tail];
-    return { messages: result, compacted: true, method: 'truncation', tokensBefore: estimated, tokensAfter: estimateTokens(result) };
+    return compactMessages(messages, openaiFormatHelper, config, iteration, fullConfig);
 }
 /**
  * Compact Codex-format input items when over threshold.
- * Uses LLM summarization for old items; falls back to truncation on failure.
- * Does NOT mutate the input array — returns a new array.
+ * @deprecated Use compactMessages() with codexFormatHelper instead.
  */
 export async function compactCodexMessages(input, config, iteration = 0, fullConfig) {
-    if (config?.enabled === false)
-        return { messages: input, compacted: false };
-    const maxTokens = config?.maxContextTokens ?? DEFAULT_MAX_CONTEXT_TOKENS;
-    const estimated = estimateTokens(input);
-    if (estimated <= maxTokens)
-        return { messages: input, compacted: false };
-    if (compactedMarker.has(input)) {
-        console.log(`[context-manager] Already compacted, using truncation fallback (iteration ${iteration})`);
-        const tail = input.slice(-KEEP_TAIL);
-        const head = input.slice(0, -KEEP_TAIL);
-        const result = [...truncateCodexHead(head), ...tail];
-        return { messages: result, compacted: true, method: 'truncation', tokensBefore: estimated, tokensAfter: estimateTokens(result) };
-    }
-    console.log(`[context-manager] Compacting Codex input at iteration ${iteration} (~${Math.round(estimated / 1000)}k tokens > ${Math.round(maxTokens / 1000)}k threshold)`);
-    const tail = input.slice(-KEEP_TAIL);
-    const head = input.slice(0, -KEEP_TAIL);
-    // Attempt LLM summarization
-    if (fullConfig) {
-        const transcript = serializeCodexMessages(head);
-        const summary = await llmSummarize(transcript, fullConfig, config?.compactionModel);
-        if (summary) {
-            const summaryItem = {
-                type: 'message',
-                role: 'user',
-                content: `[Conversation Summary]\n${summary}`,
-            };
-            const result = [summaryItem, ...tail];
-            compactedMarker.add(result);
-            const tokensAfter = estimateTokens(result);
-            return { messages: result, compacted: true, method: 'llm', summary, tokensBefore: estimated, tokensAfter };
-        }
-    }
-    // Fallback: mechanical truncation
-    const result = [...truncateCodexHead(head), ...tail];
-    return { messages: result, compacted: true, method: 'truncation', tokensBefore: estimated, tokensAfter: estimateTokens(result) };
+    return compactMessages(input, codexFormatHelper, config, iteration, fullConfig);
 }
 // --- Exported helpers for testing ---
 export { serializeAnthropicMessages, serializeOpenAIMessages, serializeCodexMessages };

package/dist/providers/index.d.ts

@@ -1,13 +1,21 @@
 import type { Config, ChatMessage, ChatOptions, ToolConfig } from '../types.js';
 import type { ExecuteToolContext } from '../tools/execute-context.js';
 import type { ToolChatResult } from './types.js';
+import type { ProviderAdapter } from './adapter.js';
 export type { ToolChatResult, ProviderChatParams, ProviderToolChatParams } from './types.js';
+export type { ProviderAdapter } from './adapter.js';
 export { TOOL_GUARD, setUsingOAuth, isUsingOAuth, buildSystemParam, addToolCacheBreakpoint, contentToText, toOpenAITools, resolveModel, resolveProviderRoute, shouldUseCodexAliasProvider, getProvider, stripProvider, buildThinkingConfig, } from './utils.js';
 export { toOpenAIContent, toCodexContent, toCodexToolDefinitions } from './content.js';
 export { setLangfuseHelpers, toCostDetails, toAnthropicUsageDetails, toUsageDetails, toNumericUsageDetails, } from './observability.js';
+/**
+ * Resolve a provider name to a ProviderAdapter instance.
+ * Adapters are lightweight — creating one per call is fine.
+ */
+export declare function getAdapter(provider: string): ProviderAdapter;
 export { setAnthropicClient, isAnthropicAvailable, chatAnthropic, chatWithToolsAnthropic, } from './anthropic.js';
-export { addOpenAIClient, getOpenAIClient, hasOpenAIClient, clearOpenAIClients, resetOpenAIProviderState, isOpenAIAvailable, chatOpenAI, chatWithToolsOpenAI, } from './openai.js';
 export { addResponsesApiProvider, isResponsesApiProvider, setCodexAuthPath, setCodexBaseUrl, initCodexAuth, resetCodexProviderState, loadCodexAuth, getCodexAuth, isCodexAvailable, chatCodex, chatWithToolsCodex, } from './codex.js';
 export declare function initProviders(config: Config): Promise<void>;
+/** Unified chat function that routes to appropriate provider via adapter. */
 export declare function chat(messages: ChatMessage[], options: ChatOptions, config: Config): Promise<string>;
+/** Unified chatWithTools function that routes to appropriate provider via adapter. */
 export declare function chatWithTools(messages: ChatMessage[], options: ChatOptions, config: Config, toolConfig: ToolConfig, toolContext?: ExecuteToolContext): Promise<ToolChatResult>;