skimpyclaw 0.3.14 → 0.4.0

package/dist/providers/index.js

@@ -1,4 +1,7 @@
 // Providers Module - Unified AI Provider Interface
+//
+// Provider registry pattern: adapters implement ProviderAdapter (chat, chatWithTools, isAvailable).
+// Routing resolves a model spec to an adapter and delegates to it.
 import { calculateUsageCost, isLangfuseEnabled } from '../langfuse.js';
 // Re-export utilities
 export { TOOL_GUARD, setUsingOAuth, isUsingOAuth, buildSystemParam, addToolCacheBreakpoint, contentToText, toOpenAITools, resolveModel, resolveProviderRoute, shouldUseCodexAliasProvider, getProvider, stripProvider, buildThinkingConfig, } from './utils.js';
@@ -7,15 +10,31 @@ export { toOpenAIContent, toCodexContent, toCodexToolDefinitions } from './conte
 // Re-export observability
 export { setLangfuseHelpers, toCostDetails, toAnthropicUsageDetails, toUsageDetails, toNumericUsageDetails, } from './observability.js';
 import { setLangfuseHelpers } from './observability.js';
-// Import provider functions directly to avoid circular deps
-import { setAnthropicClient, isAnthropicAvailable, chatAnthropic, chatWithToolsAnthropic, } from './anthropic.js';
-import { addOpenAIClient, clearOpenAIClients, isOpenAIAvailable, chatOpenAI, chatWithToolsOpenAI, } from './openai.js';
-import { addResponsesApiProvider, isResponsesApiProvider, setCodexAuthPath, setCodexBaseUrl, initCodexAuth, resetCodexProviderState, isCodexAvailable, chatCodex, chatWithToolsCodex, } from './codex.js';
+// Import provider module functions for init and backward-compat re-exports
+import { setAnthropicClient, } from './anthropic.js';
+import { addResponsesApiProvider, isResponsesApiProvider, setCodexAuthPath, setCodexBaseUrl, initCodexAuth, resetCodexProviderState, } from './codex.js';
 import { setUsingOAuth, resolveProviderRoute, shouldUseCodexAliasProvider, } from './utils.js';
 import Anthropic from '@anthropic-ai/sdk';
-import OpenAI from 'openai';
+// Lazy adapter imports (avoid circular deps at module load time)
+import { AnthropicAdapter } from './adapters/anthropic-adapter.js';
+import { CodexAdapter } from './adapters/codex-adapter.js';
 // Wire provider observability helpers to runtime cost calculator.
 setLangfuseHelpers(calculateUsageCost, isLangfuseEnabled);
+// ---------------------------------------------------------------------------
+// Provider Registry
+// ---------------------------------------------------------------------------
+/**
+ * Resolve a provider name to a ProviderAdapter instance.
+ * Adapters are lightweight — creating one per call is fine.
+ */
+export function getAdapter(provider) {
+    if (provider === 'anthropic')
+        return new AnthropicAdapter();
+    // Codex providers are registered dynamically via addResponsesApiProvider
+    if (isResponsesApiProvider(provider))
+        return new CodexAdapter();
+    throw new Error(`Unknown provider "${provider}"`);
+}
 function normalizeChatRoute(options, config) {
     const route = resolveProviderRoute(options.model, config);
     const { resolvedModel, provider, modelId, isCodexModel } = route;
@@ -27,16 +46,46 @@ function normalizeChatRoute(options, config) {
         useCodexAliasProvider: shouldUseCodexAliasProvider(provider, isCodexModel, isResponsesApiProvider('codex')),
     };
 }
-// Re-export all provider functions
+/**
+ * Resolve routing and return the correct adapter + normalized options.
+ * Handles the Codex alias compatibility path (openai/*-codex → codex provider).
+ */
+function resolveAdapter(options, config) {
+    const { resolvedModel, provider, chatOpts, useCodexAliasProvider } = normalizeChatRoute(options, config);
+    // Codex alias compatibility: openai/*-codex routes to codex when configured
+    if (useCodexAliasProvider || isResponsesApiProvider(provider)) {
+        const codexAdapter = new CodexAdapter();
+        if (codexAdapter.isAvailable()) {
+            return { adapter: codexAdapter, resolvedModel, chatOpts };
+        }
+        throw new Error(`Codex provider "${provider}" is configured but auth is unavailable. Run "codex" to re-authenticate.`);
+    }
+    let adapter;
+    try {
+        adapter = getAdapter(provider);
+    }
+    catch {
+        throw new Error(`Unknown provider "${provider}" for model: ${resolvedModel}`);
+    }
+    if (adapter.isAvailable()) {
+        return { adapter, resolvedModel, chatOpts };
+    }
+    throw new Error(`Unknown provider "${provider}" for model: ${resolvedModel}`);
+}
+// ---------------------------------------------------------------------------
+// Backward-compat re-exports (provider module functions)
+// ---------------------------------------------------------------------------
+// Anthropic
 export { setAnthropicClient, isAnthropicAvailable, chatAnthropic, chatWithToolsAnthropic, } from './anthropic.js';
-export { addOpenAIClient, getOpenAIClient, hasOpenAIClient, clearOpenAIClients, resetOpenAIProviderState, isOpenAIAvailable, chatOpenAI, chatWithToolsOpenAI, } from './openai.js';
+// Codex
 export { addResponsesApiProvider, isResponsesApiProvider, setCodexAuthPath, setCodexBaseUrl, initCodexAuth, resetCodexProviderState, loadCodexAuth, getCodexAuth, isCodexAvailable, chatCodex, chatWithToolsCodex, } from './codex.js';
-// Initialize all providers from config
+// ---------------------------------------------------------------------------
+// Provider Initialization (unchanged behavior)
+// ---------------------------------------------------------------------------
 export async function initProviders(config) {
     // Reset provider state so reloads strictly reflect current config.
     setAnthropicClient(null);
     setUsingOAuth(false);
-    clearOpenAIClients();
     resetCodexProviderState();
     const anthropicConfig = config.models.providers.anthropic;
     // Initialize Anthropic if configured
@@ -63,7 +112,7 @@ export async function initProviders(config) {
             console.log('[providers] Initialized anthropic');
         }
     }
-    // Initialize all non-Anthropic providers
+    // Initialize Codex providers. API-key chat providers are not core.
     for (const [name, providerConfig] of Object.entries(config.models.providers)) {
         if (name === 'anthropic' || !providerConfig)
             continue;
@@ -82,63 +131,23 @@ export async function initProviders(config) {
             }
             continue;
         }
-        const apiKey = providerConfig.apiKey;
-        if (!apiKey)
-            continue;
-        const opts = { apiKey };
-        if (providerConfig.baseURL) {
-            let normalizedBaseURL = providerConfig.baseURL;
-            if (name === 'minimax') {
-                const trimmed = normalizedBaseURL.replace(/\/+$/, '');
-                normalizedBaseURL = trimmed.endsWith('/v1') ? trimmed : `${trimmed}/v1`;
-            }
-            opts.baseURL = normalizedBaseURL;
-        }
-        // Kimi Code API requires a coding-agent User-Agent with version string
-        if (providerConfig.baseURL?.includes('kimi.com')) {
-            opts.defaultHeaders = { 'User-Agent': 'claude-code/2.1.42' };
-        }
-        addOpenAIClient(name, new OpenAI(opts));
-        console.log(`[providers] Initialized ${name}${providerConfig.baseURL ? ` (${providerConfig.baseURL})` : ''}`);
     }
 }
-// Unified chat function that routes to appropriate provider
+// ---------------------------------------------------------------------------
+// Unified chat + chatWithTools — route via adapter registry
+// ---------------------------------------------------------------------------
+/** Unified chat function that routes to appropriate provider via adapter. */
 export async function chat(messages, options, config) {
-    const { resolvedModel, provider, chatOpts, useCodexAliasProvider } = normalizeChatRoute(options, config);
-    // Route to Codex if available (supports openai/*-codex legacy alias)
-    if ((isResponsesApiProvider(provider) || useCodexAliasProvider) && isCodexAvailable()) {
-        return chatCodex({ messages, options: chatOpts, config });
-    }
-    if (isResponsesApiProvider(provider) || useCodexAliasProvider) {
-        throw new Error(`Codex provider "${provider}" is configured but auth is unavailable. Run "codex" to re-authenticate.`);
-    }
-    // Route to Anthropic if available
-    if (provider === 'anthropic' && isAnthropicAvailable()) {
-        return chatAnthropic({ messages, options: chatOpts, config });
-    }
-    // Route to OpenAI-compatible
-    if (isOpenAIAvailable(provider)) {
-        return chatOpenAI({ messages, options: chatOpts, config }, provider);
-    }
-    throw new Error(`Unknown provider "${provider}" for model: ${resolvedModel}`);
+    const { adapter, chatOpts } = resolveAdapter(options, config);
+    return adapter.chat(messages, chatOpts, config);
 }
-// Unified chatWithTools function that routes to appropriate provider
+/** Unified chatWithTools function that routes to appropriate provider via adapter. */
 export async function chatWithTools(messages, options, config, toolConfig, toolContext) {
-    const { resolvedModel, provider, chatOpts, useCodexAliasProvider } = normalizeChatRoute(options, config);
-    // Route to Codex if available (supports openai/*-codex legacy alias)
-    if ((isResponsesApiProvider(provider) || useCodexAliasProvider) && isCodexAvailable()) {
-        return chatWithToolsCodex({ messages, options: chatOpts, config, toolConfig, toolContext });
-    }
-    if (isResponsesApiProvider(provider) || useCodexAliasProvider) {
-        throw new Error(`Codex provider "${provider}" is configured but auth is unavailable. Run "codex" to re-authenticate.`);
-    }
-    // Route to Anthropic if available
-    if (provider === 'anthropic' && isAnthropicAvailable()) {
-        return chatWithToolsAnthropic({ messages, options: chatOpts, config, toolConfig, toolContext });
-    }
-    // Route to OpenAI-compatible
-    if (isOpenAIAvailable(provider)) {
-        return chatWithToolsOpenAI({ messages, options: chatOpts, config, toolConfig, toolContext }, provider);
-    }
-    throw new Error(`Unknown provider "${provider}" for model: ${resolvedModel}`);
+    const { adapter, resolvedModel, chatOpts } = resolveAdapter(options, config);
+    // Codex default: bump maxIterations to 100 if not specified
+    const effectiveToolConfig = (adapter.name === 'codex' && !toolConfig.maxIterations)
+        ? { ...toolConfig, maxIterations: 100 }
+        : toolConfig;
+    const { runToolLoop } = await import('./tool-loop.js');
+    return runToolLoop(adapter, messages, chatOpts, config, effectiveToolConfig, toolContext);
 }

package/dist/providers/loop-utils.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Shared utility functions for the tool loop.
+ * Extracted to eliminate duplication across provider implementations.
+ */
+/**
+ * Build a standardized tool log entry.
+ */
+export declare function buildToolLogEntry(toolName: string, inputStr: string, resultPreview: string): string;
+/**
+ * Log iteration progress to console.
+ */
+export declare function logIteration(provider: string, iteration: number, maxIterations: number, modelId: string): void;
+/**
+ * Log compaction event.
+ */
+export declare function logCompaction(provider: string, method: string, iteration: number): void;
+/**
+ * Log max iterations warning.
+ */
+export declare function logMaxIterations(provider: string, maxIterations: number): void;

package/dist/providers/loop-utils.js

@@ -0,0 +1,30 @@
+/**
+ * Shared utility functions for the tool loop.
+ * Extracted to eliminate duplication across provider implementations.
+ */
+/**
+ * Build a standardized tool log entry.
+ */
+export function buildToolLogEntry(toolName, inputStr, resultPreview) {
+    const truncatedInput = inputStr.length > 100 ? inputStr.slice(0, 100) + '...' : inputStr;
+    const truncatedResult = resultPreview.length > 200 ? resultPreview.slice(0, 200) + '...' : resultPreview;
+    return `${toolName}(${truncatedInput}) → ${truncatedResult}`;
+}
+/**
+ * Log iteration progress to console.
+ */
+export function logIteration(provider, iteration, maxIterations, modelId) {
+    console.log(`[${provider}] Iteration ${iteration + 1}/${maxIterations} (model: ${modelId})`);
+}
+/**
+ * Log compaction event.
+ */
+export function logCompaction(provider, method, iteration) {
+    console.log(`[${provider}] Compacted messages (${method}) at iteration ${iteration + 1}`);
+}
+/**
+ * Log max iterations warning.
+ */
+export function logMaxIterations(provider, maxIterations) {
+    console.warn(`[${provider}] Max iterations (${maxIterations}) reached without final answer`);
+}

package/dist/providers/tool-loop.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Unified agentic tool loop - works with any provider adapter.
+ * Handles iteration control, tool execution, guard logic, compaction, and observability.
+ */
+import type { ChatMessage, ChatOptions, Config, ToolConfig } from '../types.js';
+import type { ToolChatResult } from './types.js';
+import type { ExecuteToolContext } from '../tools.js';
+import type { ProviderAdapter } from './adapter.js';
+/**
+ * Run the unified agentic tool loop with any provider adapter.
+ */
+export declare function runToolLoop(adapter: ProviderAdapter, messages: ChatMessage[], options: ChatOptions, config: Config, toolConfig: ToolConfig, toolContext?: ExecuteToolContext): Promise<ToolChatResult>;

package/dist/providers/tool-loop.js

@@ -0,0 +1,251 @@
+/**
+ * Unified agentic tool loop - works with any provider adapter.
+ * Handles iteration control, tool execution, guard logic, compaction, and observability.
+ */
+import { getToolDefinitions, executeTool } from '../tools.js';
+import { ToolCallGuard } from './tool-guard.js';
+import { splitToolResult } from './utils.js';
+import { startTrace, addEvent, endTrace } from '../audit.js';
+import { toErrorMessage } from '../utils.js';
+import { buildToolLogEntry, logIteration, logCompaction, logMaxIterations } from './loop-utils.js';
+/** Start a Langfuse observation (lazy import to avoid circular deps). Returns null if disabled. */
+async function tryStartObservation(name, params, type) {
+    try {
+        const { isLangfuseEnabled } = await import('../langfuse.js');
+        if (!isLangfuseEnabled())
+            return null;
+        const { startObservation } = await import('@langfuse/tracing');
+        return startObservation(name, params, { asType: type });
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Run the unified agentic tool loop with any provider adapter.
+ */
+export async function runToolLoop(adapter, messages, options, config, toolConfig, toolContext) {
+    const maxIterations = toolConfig.maxIterations || 20;
+    const guard = new ToolCallGuard(toolConfig.maxTurnTokens);
+    const toolLog = [];
+    // Resolve tool definitions once
+    const includeSpawn = !!(toolContext?.fullConfig && (toolContext?.chatId || toolContext?.isCronJob));
+    const providerToolDefOptions = adapter.getToolDefinitionOptions?.(toolContext, config) || {};
+    const rawToolDefs = await getToolDefinitions(toolConfig, {
+        includeAgentTools: includeSpawn,
+        includeMcp: providerToolDefOptions.includeMcp,
+        projects: toolContext?.fullConfig?.projects,
+    });
+    // Build provider-specific tool definitions
+    const providerToolDefs = adapter.buildToolDefs(rawToolDefs, config);
+    // Build initial provider messages
+    const providerMessages = adapter.buildMessages(messages, options, config);
+    // Start audit trace if not already started
+    const trigger = (toolContext?.trigger || 'api');
+    const ownTrace = !toolContext?.auditTraceId;
+    const auditTraceId = toolContext?.auditTraceId || startTrace(trigger);
+    // Cumulative usage and cost across all iterations
+    let totalInputTokens = 0;
+    let totalOutputTokens = 0;
+    const totalCost = { input: 0, output: 0, total: 0 };
+    let traceStatus = 'ok';
+    try {
+        // Agentic loop
+        for (let i = 0; i < maxIterations; i++) {
+            // Check abort signal before each iteration
+            if (toolContext?.abortSignal?.aborted) {
+                return {
+                    response: `[Cancelled after ${toolLog.length} tool calls]`,
+                    toolCalls: toolLog,
+                };
+            }
+            // Compact messages if needed
+            const compactionResult = await adapter.compactMessages(providerMessages, toolConfig.contextManagement, i + 1, config);
+            if (compactionResult.compacted) {
+                logCompaction(adapter.name, compactionResult.method || 'unknown', i);
+                toolLog.push(`[context compacted via ${compactionResult.method}]`);
+            }
+            // Make API call
+            logIteration(adapter.name, i, maxIterations, options.model);
+            const genObs = await tryStartObservation(`${adapter.name}:${options.model}`, {
+                input: { messages: providerMessages.messages },
+                model: options.model,
+                modelParameters: { max_tokens: options.maxTokens },
+                metadata: { provider: adapter.name, iteration: i + 1 },
+            }, 'generation');
+            let response;
+            try {
+                response = await adapter.call(providerMessages, providerToolDefs, options, config);
+                // Record usage
+                adapter.recordUsage(options.model, response.usage, toolContext?.trigger || 'api', toolContext?.agentId);
+                // Accumulate usage across iterations
+                totalInputTokens += response.usage?.inputTokens ?? 0;
+                totalOutputTokens += response.usage?.outputTokens ?? 0;
+                // Accumulate cost
+                if (response.cost) {
+                    totalCost.input += response.cost.input;
+                    totalCost.output += response.cost.output;
+                    totalCost.total += response.cost.total;
+                }
+                // Track tokens in guard (for stats only, no enforcement)
+                guard.recordTokens(response.usage?.inputTokens ?? 0, response.usage?.outputTokens ?? 0);
+                genObs?.update({ output: response.textContent });
+                genObs?.end();
+            }
+            catch (err) {
+                const errorMessage = toErrorMessage(err);
+                genObs?.update({ level: 'ERROR', statusMessage: errorMessage, output: { error: errorMessage } });
+                genObs?.end();
+                traceStatus = 'error';
+                throw err;
+            }
+            // If no tool calls, we're done
+            if (!response.hasToolCalls) {
+                let responseText = response.textContent;
+                // Fallback when model returned no text
+                if (!responseText) {
+                    console.warn(`[${adapter.name}] empty text response (stop_reason: ${response.rawResponse?.stop_reason}, content blocks: ${JSON.stringify((response.rawResponse?.content || []).map((b) => b.type))})`);
+                    if (toolLog.length > 0) {
+                        // Let adapter attempt a finalization pass (e.g. Codex re-asks without tools)
+                        if (adapter.onEmptyFinalResponse) {
+                            try {
+                                const finalized = await adapter.onEmptyFinalResponse(providerMessages, providerToolDefs, options, config);
+                                if (finalized)
+                                    responseText = finalized;
+                            }
+                            catch (err) {
+                                console.warn(`[${adapter.name}] finalization pass failed: ${toErrorMessage(err)}`);
+                            }
+                        }
+                        if (!responseText) {
+                            responseText = `[Completed with ${toolLog.length} tool calls, no text response]`;
+                        }
+                    }
+                    else {
+                        responseText = '[Model returned empty response — please try again]';
+                    }
+                }
+                return {
+                    response: responseText,
+                    toolCalls: toolLog,
+                    usage: {
+                        prompt_tokens: totalInputTokens,
+                        completion_tokens: totalOutputTokens,
+                        total_tokens: totalInputTokens + totalOutputTokens,
+                    },
+                    cost: totalCost.total > 0 ? totalCost : undefined,
+                };
+            }
+            // Append assistant's response to history
+            adapter.appendAssistantResponse(providerMessages, response.rawResponse);
+            // Execute each tool call, collecting results for batching
+            const toolResults = [];
+            for (const toolCall of response.toolCalls) {
+                const result = await executeToolCall(toolCall, guard, toolConfig, toolContext, toolLog, adapter.name);
+                toolResults.push(result);
+            }
+            // Append all tool results — batch if adapter supports it, otherwise one at a time
+            if (adapter.appendToolResults && toolResults.length > 1) {
+                adapter.appendToolResults(providerMessages, toolResults);
+            }
+            else {
+                for (const tr of toolResults) {
+                    adapter.appendToolResult(providerMessages, tr.toolCallId, tr.result, tr.isError);
+                }
+            }
+        }
+        // Max iterations reached
+        logMaxIterations(adapter.name, maxIterations);
+        let responseText = `Tool use loop reached maximum iterations (${maxIterations}) before the model produced a final answer.`;
+        if (toolLog.length > 0 && adapter.onEmptyFinalResponse) {
+            try {
+                const finalized = await adapter.onEmptyFinalResponse(providerMessages, providerToolDefs, options, config);
+                if (finalized)
+                    responseText = finalized;
+            }
+            catch (err) {
+                console.warn(`[${adapter.name}] max-iteration finalization pass failed: ${toErrorMessage(err)}`);
+            }
+        }
+        return {
+            response: responseText,
+            toolCalls: toolLog,
+            usage: {
+                prompt_tokens: totalInputTokens,
+                completion_tokens: totalOutputTokens,
+                total_tokens: totalInputTokens + totalOutputTokens,
+            },
+            cost: totalCost.total > 0 ? totalCost : undefined,
+        };
+    }
+    finally {
+        // End the audit trace if we created it
+        if (ownTrace) {
+            await endTrace(auditTraceId, traceStatus).catch(() => { });
+        }
+    }
+}
+/**
+ * Execute a single tool call and return the result (does NOT append to messages).
+ */
+async function executeToolCall(toolCall, guard, toolConfig, toolContext, toolLog, providerName) {
+    const inputStr = toolCall.rawArgs.slice(0, 200);
+    console.log(`[${providerName}:tools] -> ${toolCall.name}(${inputStr})`);
+    // Guard: spin detection
+    const guardResult = guard.recordCall(toolCall.name, toolCall.args);
+    if (guardResult.warning) {
+        console.warn(`[${providerName}:tools:guard] ${guardResult.warning}`);
+    }
+    if (guardResult.blocked) {
+        toolLog.push(`${toolCall.name} [BLOCKED: spin detected]`);
+        return {
+            toolCallId: toolCall.id,
+            result: guardResult.warning || 'Blocked: repeated identical call',
+            isError: true,
+        };
+    }
+    // Execute tool
+    const toolObs = await tryStartObservation(`tool:${toolCall.name}`, { input: toolCall.args, metadata: { app: 'skimpyclaw', tool: toolCall.name } }, 'tool');
+    const toolStart = Date.now();
+    try {
+        const result = await executeTool(toolCall.name, toolCall.args, toolConfig, toolContext);
+        const truncatedResult = splitToolResult(toolCall.name, toolCall.args, result);
+        const resultPreview = result.slice(0, 200) + (result.length > 200 ? '...' : '');
+        console.log(`[${providerName}:tools] <- ${resultPreview}`);
+        toolLog.push(buildToolLogEntry(toolCall.name, inputStr, resultPreview));
+        toolObs?.update({ output: result });
+        toolObs?.end();
+        // Record audit event
+        if (toolContext?.auditTraceId) {
+            addEvent(toolContext.auditTraceId, {
+                type: 'tool_use',
+                summary: `${toolCall.name}(${inputStr})`,
+                durationMs: Date.now() - toolStart,
+            });
+        }
+        // Guard: no-progress detection
+        const progressResult = guard.recordResult(result);
+        let finalResult = truncatedResult;
+        if (progressResult.nudge) {
+            console.warn(`[${providerName}:tools:guard] ${progressResult.nudge}`);
+            finalResult += `\n\n[System: ${progressResult.nudge}]`;
+        }
+        return { toolCallId: toolCall.id, result: finalResult, isError: false };
+    }
+    catch (err) {
+        const errorMessage = toErrorMessage(err);
+        toolObs?.update({ level: 'ERROR', statusMessage: errorMessage, output: { error: errorMessage } });
+        toolObs?.end();
+        if (toolContext?.auditTraceId) {
+            addEvent(toolContext.auditTraceId, {
+                type: 'tool_error',
+                summary: `${toolCall.name} error: ${errorMessage.slice(0, 150)}`,
+                durationMs: Date.now() - toolStart,
+            });
+        }
+        const errorResult = `[Tool Error] ${toolCall.name}: ${errorMessage}`;
+        console.error(`[${providerName}:tools] tool error: ${errorMessage}`);
+        toolLog.push(`${toolCall.name} [ERROR: ${errorMessage.slice(0, 100)}]`);
+        return { toolCallId: toolCall.id, result: errorResult, isError: true };
+    }
+}

package/dist/providers/utils.d.ts

@@ -1,5 +1,5 @@
-import type { ContentBlock, Config } from '../types.js';
-export declare const TOOL_GUARD = "You are a personal assistant running inside SkimpyClaw.\nYou are NOT the full Claude Code CLI. Do NOT roleplay as Claude Code.\n\n## Tool Rules\n- You have ONLY the tools provided via the API tool_use mechanism.\n- Tool names are case-sensitive. Call tools exactly as listed.\n- NEVER output tool calls as text/XML/JSON. Use the API tool_use mechanism only.\n- NEVER fabricate tool results or file contents. If you haven't read a file, say so.\n- NEVER invent tools that are not in your tool list (no str_replace_editor, no view, etc.)\n- If a Browser tool is available, you DO have web-browsing access via that tool. Use it instead of claiming you can't browse.\n- If you need information, use a tool to get it. Do not guess.";
+import type { ContentBlock, Config, ThinkingLevel } from '../types.js';
+export declare const TOOL_GUARD = "You are SkimpyClaw (NOT Claude Code CLI). Use only API tool_use \u2014 never text/XML tools. Never fabricate results.";
 export declare function setUsingOAuth(value: boolean): void;
 export declare function isUsingOAuth(): boolean;
 /**
@@ -60,10 +60,26 @@ export declare function stripProvider(model: string, openaiClients?: Map<string,
  * Falls back to simple truncation if file write fails.
  */
 export declare function truncateToolResult(result: string, _maxBytes?: number): string;
+/**
+ * Structured split tool results: generates a semantic summary based on tool type.
+ * For small results (<= MASK_THRESHOLD), returns unchanged.
+ * For large results, writes full output to scratch file and returns a compact,
+ * tool-aware summary with the scratch file path.
+ */
+export declare function splitToolResult(toolName: string, toolInput: Record<string, any>, result: string): string;
+/**
+ * Compact old tool results in Anthropic-format messages.
+ * Replaces tool_result content with '✓' for all results except the last
+ * `keepRecent` messages. The model has already processed these results,
+ * so we only need to preserve the structure (tool_use_id matching).
+ *
+ * Mutates the messages array in place for efficiency.
+ */
+export declare function compactOldResults(messages: any[], keepRecent?: number): void;
 /**
  * Build thinking config based on thinking level.
  */
-export declare function buildThinkingConfig(thinking?: 'none' | 'low' | 'medium' | 'high'): {
+export declare function buildThinkingConfig(thinking?: ThinkingLevel): {
     budget: number;
     maxTokens: number;
 } | undefined;