skimpyclaw 0.3.14 → 0.4.0

package/dist/providers/adapters/anthropic-adapter.js

@@ -0,0 +1,204 @@
+/**
+ * Anthropic provider adapter for the unified tool loop.
+ */
+import { getAnthropicClient } from '../anthropic.js';
+import { buildSystemParam, addToolCacheBreakpoint, contentToText, stripProvider, buildThinkingConfig } from '../utils.js';
+import { toCostDetails } from '../observability.js';
+import { compactMessages, anthropicFormatHelper } from '../context-manager.js';
+import { buildUsageRecord, recordUsage } from '../../usage.js';
+const NONSTREAMING_TOKEN_LIMIT = 21_333;
+function shouldStreamAnthropicRequest(params) {
+    return typeof params.max_tokens === 'number' && params.max_tokens > NONSTREAMING_TOKEN_LIMIT;
+}
+async function createAnthropicMessage(client, params) {
+    if (shouldStreamAnthropicRequest(params) && typeof client.messages.stream === 'function') {
+        return await client.messages.stream(params).finalMessage();
+    }
+    return await client.messages.create(params);
+}
+export class AnthropicAdapter {
+    name = 'anthropic';
+    isAvailable() {
+        return getAnthropicClient() !== null;
+    }
+    async chat(messages, options, config) {
+        const client = getAnthropicClient();
+        if (!client) {
+            throw new Error('Anthropic client not initialized');
+        }
+        const modelId = stripProvider(options.model);
+        const systemMessage = messages.find(m => m.role === 'system');
+        const chatMessages = messages
+            .filter(m => m.role !== 'system')
+            .map(m => ({
+            role: m.role,
+            content: m.content,
+        }));
+        const cacheEnabled = config.models?.promptCaching !== false;
+        const anthropicParams = {
+            model: modelId,
+            max_tokens: options.maxTokens || 4096,
+            messages: chatMessages,
+        };
+        const systemParam = buildSystemParam(contentToText(systemMessage?.content || ''), cacheEnabled);
+        if (systemParam) {
+            anthropicParams.system = systemParam;
+        }
+        const thinkingConfig = buildThinkingConfig(options.thinking);
+        if (thinkingConfig) {
+            anthropicParams.thinking = { type: 'enabled', budget_tokens: thinkingConfig.budget };
+            anthropicParams.max_tokens = Math.max(anthropicParams.max_tokens, thinkingConfig.maxTokens);
+        }
+        const response = await createAnthropicMessage(client, anthropicParams);
+        const usage = response.usage;
+        if (usage?.cache_read_input_tokens > 0 || usage?.cache_creation_input_tokens > 0) {
+            console.log(`[cache] read=${usage.cache_read_input_tokens || 0} created=${usage.cache_creation_input_tokens || 0}`);
+        }
+        this.recordUsage(modelId, {
+            inputTokens: usage?.input_tokens ?? 0,
+            outputTokens: usage?.output_tokens ?? 0,
+            cacheReadTokens: usage?.cache_read_input_tokens,
+            cacheCreationTokens: usage?.cache_creation_input_tokens,
+        }, 'api');
+        const textContent = response.content.find((c) => c.type === 'text');
+        return textContent?.text || '';
+    }
+    buildMessages(messages, options, config) {
+        const cacheEnabled = config.models?.promptCaching !== false;
+        const systemMessage = messages.find(m => m.role === 'system');
+        const systemParam = buildSystemParam(contentToText(systemMessage?.content || ''), cacheEnabled);
+        const apiMessages = messages
+            .filter(m => m.role !== 'system')
+            .map(m => ({ role: m.role, content: m.content }));
+        return {
+            messages: apiMessages,
+            systemParam,
+        };
+    }
+    buildToolDefs(toolDefs, config) {
+        const cacheEnabled = config.models?.promptCaching !== false;
+        // Make a copy to avoid mutating the original
+        const defs = JSON.parse(JSON.stringify(toolDefs));
+        if (cacheEnabled) {
+            addToolCacheBreakpoint(defs);
+        }
+        return defs;
+    }
+    async call(providerMessages, toolDefs, options, config) {
+        const client = getAnthropicClient();
+        if (!client) {
+            throw new Error('Anthropic client not initialized');
+        }
+        const modelId = stripProvider(options.model);
+        const anthropicParams = {
+            model: modelId,
+            max_tokens: options.maxTokens || 16384,
+            messages: providerMessages.messages,
+            tools: toolDefs,
+        };
+        if (providerMessages.systemParam) {
+            anthropicParams.system = providerMessages.systemParam;
+        }
+        // Add thinking if configured
+        const thinkingConfig = buildThinkingConfig(options.thinking);
+        if (thinkingConfig) {
+            anthropicParams.thinking = { type: 'enabled', budget_tokens: thinkingConfig.budget };
+            anthropicParams.max_tokens = Math.max(anthropicParams.max_tokens, thinkingConfig.maxTokens);
+        }
+        const response = await createAnthropicMessage(client, anthropicParams);
+        const usage = response.usage;
+        // Log cache metrics
+        if (usage?.cache_read_input_tokens > 0 || usage?.cache_creation_input_tokens > 0) {
+            console.log(`[cache] read=${usage.cache_read_input_tokens || 0} created=${usage.cache_creation_input_tokens || 0}`);
+        }
+        // Normalize response
+        const hasToolCalls = response.stop_reason === 'tool_use';
+        const toolCalls = [];
+        let textContent = '';
+        for (const block of response.content) {
+            if (block.type === 'text') {
+                textContent += block.text;
+            }
+            else if (block.type === 'tool_use') {
+                toolCalls.push({
+                    id: block.id,
+                    name: block.name,
+                    args: block.input,
+                    rawArgs: JSON.stringify(block.input),
+                });
+            }
+        }
+        const cost = toCostDetails(modelId, usage) || undefined;
+        return {
+            hasToolCalls,
+            toolCalls,
+            textContent,
+            usage: {
+                inputTokens: usage?.input_tokens ?? 0,
+                outputTokens: usage?.output_tokens ?? 0,
+                cacheReadTokens: usage?.cache_read_input_tokens,
+                cacheCreationTokens: usage?.cache_creation_input_tokens,
+            },
+            cost,
+            rawResponse: response,
+        };
+    }
+    appendAssistantResponse(providerMessages, rawResponse) {
+        const response = rawResponse;
+        providerMessages.messages.push({ role: 'assistant', content: response.content });
+    }
+    appendToolResult(providerMessages, toolCallId, result, isError) {
+        const toolResult = {
+            type: 'tool_result',
+            tool_use_id: toolCallId,
+            content: result,
+        };
+        if (isError) {
+            toolResult.is_error = true;
+        }
+        // Anthropic expects tool_result blocks in a user message
+        providerMessages.messages.push({ role: 'user', content: [toolResult] });
+    }
+    appendToolResults(providerMessages, results) {
+        // Anthropic expects all tool_result blocks for one turn in a single user message
+        const toolResults = results.map(r => {
+            const block = {
+                type: 'tool_result',
+                tool_use_id: r.toolCallId,
+                content: r.result,
+            };
+            if (r.isError) {
+                block.is_error = true;
+            }
+            return block;
+        });
+        providerMessages.messages.push({ role: 'user', content: toolResults });
+    }
+    async compactMessages(providerMessages, config, iteration, fullConfig) {
+        const result = await compactMessages(providerMessages.messages, anthropicFormatHelper, config, iteration, fullConfig);
+        providerMessages.messages = result.messages;
+        return result;
+    }
+    recordUsage(model, usage, trigger, agentId) {
+        const u = usage;
+        const inputTokens = typeof u?.inputTokens === 'number' ? u.inputTokens : 0;
+        const outputTokens = typeof u?.outputTokens === 'number' ? u.outputTokens : 0;
+        if (inputTokens === 0 && outputTokens === 0)
+            return;
+        const cost = toCostDetails(model, { input_tokens: inputTokens, output_tokens: outputTokens });
+        const usageRecord = buildUsageRecord({
+            model,
+            provider: 'anthropic',
+            inputTokens,
+            outputTokens,
+            inputCost: cost?.input ?? 0,
+            outputCost: cost?.output ?? 0,
+            totalCost: cost?.total ?? 0,
+            trigger: trigger || 'api',
+            agentId,
+            cacheReadTokens: u?.cacheReadTokens,
+            cacheCreationTokens: u?.cacheCreationTokens,
+        });
+        recordUsage(usageRecord);
+    }
+}

package/dist/providers/adapters/codex-adapter.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Codex provider adapter for the unified tool loop.
+ */
+import type { ChatMessage, ChatOptions, Config } from '../../types.js';
+import type { ProviderAdapter, ProviderMessages, NormalizedResponse, CompactionResult } from '../adapter.js';
+import type { ExecuteToolContext } from '../../tools.js';
+export declare class CodexAdapter implements ProviderAdapter {
+    readonly name = "codex";
+    isAvailable(): boolean;
+    chat(messages: ChatMessage[], options: ChatOptions, _config: Config): Promise<string>;
+    getToolDefinitionOptions(_toolContext?: ExecuteToolContext, _config?: Config): {
+        includeMcp?: boolean;
+    };
+    buildMessages(messages: ChatMessage[], _options: ChatOptions, _config: Config): ProviderMessages;
+    buildToolDefs(toolDefs: any[], _config: Config): any[];
+    call(providerMessages: ProviderMessages, toolDefs: any[], options: ChatOptions, _config: Config): Promise<NormalizedResponse>;
+    appendAssistantResponse(providerMessages: ProviderMessages, rawResponse: unknown): void;
+    appendToolResult(providerMessages: ProviderMessages, toolCallId: string, result: string, _isError?: boolean): void;
+    /**
+     * Codex sometimes finishes tool execution but omits final text.
+     * Re-ask once (without tools) for a user-facing answer from the gathered context.
+     */
+    onEmptyFinalResponse(providerMessages: ProviderMessages, _toolDefs: any[], options: ChatOptions, _config: Config): Promise<string | undefined>;
+    compactMessages(providerMessages: ProviderMessages, config: any, iteration: number, fullConfig?: Config): Promise<CompactionResult<any>>;
+    recordUsage(model: string, usage: unknown, trigger?: string, agentId?: string): void;
+}

package/dist/providers/adapters/codex-adapter.js

@@ -0,0 +1,203 @@
+/**
+ * Codex provider adapter for the unified tool loop.
+ */
+import { contentToText, stripProvider } from '../utils.js';
+import { compactMessages, codexFormatHelper } from '../context-manager.js';
+import { toCodexContent, toCodexToolDefinitions } from '../content.js';
+import { toCostDetails } from '../observability.js';
+import { codexFetch, parseCodexSSE, isCodexAvailable, recordCodexUsage } from '../codex.js';
+function codexReasoningEffort(thinking) {
+    switch (thinking) {
+        case 'low':
+        case 'medium':
+        case 'high':
+        case 'xhigh':
+            return thinking;
+        default:
+            return 'medium';
+    }
+}
+function codexReasoning(options) {
+    return { effort: codexReasoningEffort(options.thinking), summary: 'auto' };
+}
+export class CodexAdapter {
+    name = 'codex';
+    isAvailable() {
+        return isCodexAvailable();
+    }
+    async chat(messages, options, _config) {
+        const modelId = stripProvider(options.model);
+        let instructions = 'You are a helpful assistant.';
+        const input = [];
+        for (const m of messages) {
+            if (m.role === 'system') {
+                instructions = contentToText(m.content);
+                continue;
+            }
+            const contentType = m.role === 'assistant' ? 'output_text' : 'input_text';
+            input.push({
+                type: 'message',
+                role: m.role,
+                content: toCodexContent(m.content, contentType),
+            });
+        }
+        const body = {
+            model: modelId,
+            instructions,
+            input,
+            store: false,
+            stream: true,
+            reasoning: codexReasoning(options),
+            include: ['reasoning.encrypted_content'],
+        };
+        const sseText = await codexFetch(body);
+        const parsed = parseCodexSSE(sseText);
+        this.recordUsage(modelId, {
+            inputTokens: parsed.response?.usage?.input_tokens ?? 0,
+            outputTokens: parsed.response?.usage?.output_tokens ?? 0,
+            cacheReadTokens: parsed.response?.usage?.input_tokens_details?.cached_tokens,
+        }, 'api');
+        return parsed.outputText || '[No response from Codex]';
+    }
+    getToolDefinitionOptions(_toolContext, _config) {
+        // MCP tools are standard function calls — Codex handles them fine.
+        return { includeMcp: true };
+    }
+    buildMessages(messages, _options, _config) {
+        let instructions = 'You are a helpful assistant.';
+        const input = [];
+        for (const m of messages) {
+            if (m.role === 'system') {
+                instructions = contentToText(m.content);
+                continue;
+            }
+            const contentType = m.role === 'assistant' ? 'output_text' : 'input_text';
+            input.push({
+                type: 'message',
+                role: m.role,
+                content: toCodexContent(m.content, contentType),
+            });
+        }
+        return {
+            messages: input,
+            systemParam: instructions,
+        };
+    }
+    buildToolDefs(toolDefs, _config) {
+        return toCodexToolDefinitions(toolDefs || []);
+    }
+    async call(providerMessages, toolDefs, options, _config) {
+        const modelId = stripProvider(options.model);
+        const body = {
+            model: modelId,
+            instructions: providerMessages.systemParam || 'You are a helpful assistant.',
+            input: providerMessages.messages,
+            store: false,
+            stream: true,
+            reasoning: codexReasoning(options),
+            include: ['reasoning.encrypted_content'],
+        };
+        if (toolDefs?.length) {
+            body.tools = toolDefs;
+        }
+        const sseText = await codexFetch(body);
+        const parsed = parseCodexSSE(sseText);
+        const toolCalls = parsed.functionCalls.map((fc) => {
+            const rawArgs = typeof fc.arguments === 'string' ? fc.arguments : '{}';
+            let args;
+            try {
+                args = JSON.parse(rawArgs);
+            }
+            catch {
+                args = {};
+            }
+            return {
+                id: fc.callId,
+                name: fc.name,
+                args,
+                rawArgs,
+            };
+        });
+        const usage = parsed.response?.usage;
+        const cost = toCostDetails(modelId, usage) || undefined;
+        return {
+            hasToolCalls: toolCalls.length > 0,
+            toolCalls,
+            textContent: parsed.outputText || '',
+            usage: {
+                inputTokens: usage?.input_tokens ?? 0,
+                outputTokens: usage?.output_tokens ?? 0,
+                cacheReadTokens: usage?.input_tokens_details?.cached_tokens,
+            },
+            cost,
+            rawResponse: parsed.response,
+        };
+    }
+    appendAssistantResponse(providerMessages, rawResponse) {
+        const response = rawResponse;
+        if (!response?.output || !Array.isArray(response.output))
+            return;
+        for (const item of response.output) {
+            providerMessages.messages.push(item);
+        }
+    }
+    appendToolResult(providerMessages, toolCallId, result, _isError) {
+        providerMessages.messages.push({
+            type: 'function_call_output',
+            call_id: toolCallId,
+            output: result,
+        });
+    }
+    /**
+     * Codex sometimes finishes tool execution but omits final text.
+     * Re-ask once (without tools) for a user-facing answer from the gathered context.
+     */
+    async onEmptyFinalResponse(providerMessages, _toolDefs, options, _config) {
+        const modelId = stripProvider(options.model);
+        // Build a finalization input: existing messages + nudge
+        const finalizeInput = [...providerMessages.messages];
+        finalizeInput.push({
+            type: 'message',
+            role: 'user',
+            content: [
+                {
+                    type: 'input_text',
+                    text: 'Provide the final answer to the user using the tool results above. Do not call tools. Be concise.',
+                },
+            ],
+        });
+        const body = {
+            model: modelId,
+            instructions: providerMessages.systemParam || 'You are a helpful assistant.',
+            input: finalizeInput,
+            store: false,
+            stream: true,
+            reasoning: codexReasoning(options),
+            include: ['reasoning.encrypted_content'],
+        };
+        console.log('[codex] Finalizing tool run with a text-only follow-up');
+        const sseText = await codexFetch(body);
+        const parsed = parseCodexSSE(sseText);
+        return parsed.outputText?.trim() || undefined;
+    }
+    async compactMessages(providerMessages, config, iteration, fullConfig) {
+        const result = await compactMessages(providerMessages.messages, codexFormatHelper, config, iteration, fullConfig);
+        providerMessages.messages = result.messages;
+        return result;
+    }
+    recordUsage(model, usage, trigger, agentId) {
+        const u = usage;
+        recordCodexUsage({
+            model,
+            usage: {
+                input_tokens: typeof u?.inputTokens === 'number' ? u.inputTokens : 0,
+                output_tokens: typeof u?.outputTokens === 'number' ? u.outputTokens : 0,
+                input_tokens_details: {
+                    cached_tokens: typeof u?.cacheReadTokens === 'number' ? u.cacheReadTokens : undefined,
+                },
+            },
+            trigger,
+            agentId,
+        });
+    }
+}

package/dist/providers/anthropic.d.ts

@@ -3,5 +3,6 @@ import type { ProviderChatParams, ProviderToolChatParams, ToolChatResult } from
 export declare function setAnthropicClient(client: Anthropic | null): void;
 export declare function getAnthropicClient(): Anthropic | null;
 export declare function isAnthropicAvailable(): boolean;
+/** @deprecated Use adapter.chat() via the provider registry instead. */
 export declare function chatAnthropic(params: ProviderChatParams): Promise<string>;
 export declare function chatWithToolsAnthropic(params: ProviderToolChatParams): Promise<ToolChatResult>;