skimpyclaw 0.3.14 → 0.4.0

package/dist/providers/anthropic.js

@@ -1,12 +1,5 @@
 // Anthropic Provider
-import { startObservation } from '@langfuse/tracing';
-import { buildSystemParam, addToolCacheBreakpoint, contentToText, stripProvider, buildThinkingConfig, truncateToolResult } from './utils.js';
-import { compactAnthropicMessages } from './context-manager.js';
-import { toAnthropicUsageDetails, toCostDetails } from './observability.js';
-import { getToolDefinitions, executeTool } from '../tools.js';
-import { ToolCallGuard } from './tool-guard.js';
-import { toErrorMessage } from '../utils.js';
-import { startTrace, addEvent } from '../audit.js';
+import { toCostDetails } from './observability.js';
 import { buildUsageRecord, recordUsage } from '../usage.js';
 let anthropicClient = null;
 export function setAnthropicClient(client) {
@@ -46,276 +39,21 @@ async function startGenerationObservation(name, attributes) {
     if (!isLangfuseEnabled())
         return null;
     attributes.metadata = { app: LANGFUSE_APP_NAME, ...attributes.metadata };
+    const { startObservation } = await import('@langfuse/tracing');
     return startObservation(name, attributes, { asType: 'generation' });
 }
+/** @deprecated Use adapter.chat() via the provider registry instead. */
 export async function chatAnthropic(params) {
-    if (!anthropicClient) {
-        throw new Error('Anthropic client not initialized');
-    }
-    const { messages, options, config } = params;
-    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,
-    }));
-    // Build request parameters
-    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;
-    }
-    // Add extended thinking if requested
-    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 genObs = await startGenerationObservation(`anthropic:${modelId}`, {
-        input: { system: systemMessage?.content, messages: chatMessages },
-        model: modelId,
-        modelParameters: {
-            max_tokens: anthropicParams.max_tokens,
-            ...(options.thinking && options.thinking !== 'none' ? { thinking: options.thinking } : {}),
-        },
-        metadata: { provider: 'anthropic' },
-    });
-    try {
-        const response = await anthropicClient.messages.create(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}`);
-        }
-        recordAnthropicUsage({ model: modelId, usage, trigger: 'api' });
-        // Extract text content
-        const textContent = response.content.find(c => c.type === 'text');
-        const text = textContent?.text || '';
-        genObs?.update({
-            output: { text },
-            usageDetails: toAnthropicUsageDetails(usage),
-            costDetails: toCostDetails(modelId, usage),
-        });
-        genObs?.end();
-        return text;
-    }
-    catch (err) {
-        const errorMessage = toErrorMessage(err);
-        genObs?.update({ level: 'ERROR', statusMessage: errorMessage, output: { error: errorMessage } });
-        genObs?.end();
-        throw err;
-    }
+    const { AnthropicAdapter } = await import('./adapters/anthropic-adapter.js');
+    const adapter = new AnthropicAdapter();
+    return adapter.chat(params.messages, params.options, params.config);
 }
 export async function chatWithToolsAnthropic(params) {
     if (!anthropicClient) {
         throw new Error('Anthropic client not initialized');
     }
-    const { messages, options, config, toolConfig, toolContext } = params;
-    const modelId = stripProvider(options.model);
-    const maxIterations = toolConfig.maxIterations || 20;
-    // Resolve tools once at start of agent loop
-    const includeSpawn = !!(toolContext?.fullConfig && (toolContext?.chatId || toolContext?.isCronJob));
-    const toolDefs = await getToolDefinitions(toolConfig, { includeAgentTools: includeSpawn, projects: toolContext?.fullConfig?.projects });
-    // Enable prompt caching for system + tools
-    const cacheEnabled = config.models?.promptCaching !== false;
-    if (cacheEnabled)
-        addToolCacheBreakpoint(toolDefs);
-    // Build system param with OAuth identity guard
-    const systemMessage = messages.find(m => m.role === 'system');
-    const systemParam = buildSystemParam(contentToText(systemMessage?.content || ''), cacheEnabled);
-    // Build initial messages (exclude system)
-    const apiMessages = messages
-        .filter(m => m.role !== 'system')
-        .map(m => ({ role: m.role, content: m.content }));
-    // Track tool calls for logging
-    const toolLog = [];
-    // Guard: spin detection, no-progress detection, token budget
-    const guard = new ToolCallGuard(toolConfig.maxTurnTokens);
-    // Start audit trace
-    const auditTraceId = toolContext?.auditTraceId || startTrace((toolContext?.trigger || 'api'));
-    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 old tool results if context is growing large
-        const compactionResult = await compactAnthropicMessages(apiMessages, toolConfig.contextManagement, i + 1, config);
-        const messagesForApi = compactionResult.messages;
-        if (compactionResult.compacted) {
-            const method = compactionResult.method === 'llm' ? 'LLM summary' : 'truncation';
-            const detail = `~${Math.round((compactionResult.tokensBefore || 0) / 1000)}k → ~${Math.round((compactionResult.tokensAfter || 0) / 1000)}k tokens`;
-            toolLog.push(`[context compacted via ${method}: ${detail}]`);
-        }
-        const anthropicParams = {
-            model: modelId,
-            max_tokens: options.maxTokens || 16384,
-            messages: messagesForApi,
-            tools: toolDefs,
-        };
-        if (systemParam) {
-            anthropicParams.system = 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);
-        }
-        console.log(`[agent:tools] Iteration ${i + 1}/${maxIterations}`);
-        const genObs = await startGenerationObservation(`anthropic:${modelId}`, {
-            input: { messages: apiMessages },
-            model: modelId,
-            modelParameters: { max_tokens: anthropicParams.max_tokens },
-            metadata: { provider: 'anthropic', iteration: i + 1 },
-        });
-        let response;
-        try {
-            response = await anthropicClient.messages.create(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}`);
-            }
-            recordAnthropicUsage({
-                model: modelId,
-                usage,
-                trigger: toolContext?.trigger || 'api',
-                agentId: toolContext?.agentId,
-            });
-            genObs?.update({
-                output: response.content,
-                usageDetails: toAnthropicUsageDetails(usage),
-                costDetails: toCostDetails(modelId, usage),
-            });
-            genObs?.end();
-            // Guard: track token usage (stats only, no enforcement)
-            guard.recordTokens(response.usage?.input_tokens ?? 0, response.usage?.output_tokens ?? 0);
-        }
-        catch (err) {
-            const errorMessage = toErrorMessage(err);
-            genObs?.update({ level: 'ERROR', statusMessage: errorMessage, output: { error: errorMessage } });
-            genObs?.end();
-            throw err;
-        }
-        // If no tool use, we're done — extract text
-        if (response.stop_reason !== 'tool_use') {
-            const textBlocks = response.content.filter((c) => c.type === 'text');
-            let responseText = textBlocks.map((b) => b.text).join('\n') || '';
-            // Fallback when model did tool work but returned no text summary
-            if (!responseText && toolLog.length > 0) {
-                responseText = `[Completed with ${toolLog.length} tool calls, no text response]`;
-            }
-            const usage = response.usage;
-            return {
-                response: responseText,
-                toolCalls: toolLog,
-                usage: {
-                    prompt_tokens: usage?.input_tokens ?? 0,
-                    completion_tokens: usage?.output_tokens ?? 0,
-                    total_tokens: (usage?.input_tokens ?? 0) + (usage?.output_tokens ?? 0),
-                },
-                cost: toCostDetails(modelId, usage),
-            };
-        }
-        // Add assistant response (full content including tool_use blocks)
-        apiMessages.push({ role: 'assistant', content: response.content });
-        // Execute each tool_use block
-        const toolResults = [];
-        for (const block of response.content) {
-            if (block.type !== 'tool_use')
-                continue;
-            const inputStr = JSON.stringify(block.input).slice(0, 200);
-            console.log(`[agent:tools] -> ${block.name}(${inputStr})`);
-            // Dynamic import to avoid circular dependency
-            const { isLangfuseEnabled } = await import('../langfuse.js');
-            const { startObservation } = await import('@langfuse/tracing');
-            const toolObs = isLangfuseEnabled()
-                ? startObservation(`tool:${block.name}`, { input: block.input, metadata: { app: LANGFUSE_APP_NAME, tool: block.name } }, { asType: 'tool' })
-                : null;
-            // Guard: spin detection
-            const guardResult = guard.recordCall(block.name, block.input);
-            if (guardResult.warning)
-                console.warn(`[agent:tools:guard] ${guardResult.warning}`);
-            if (guardResult.blocked) {
-                toolResults.push({
-                    type: 'tool_result',
-                    tool_use_id: block.id,
-                    content: guardResult.warning || 'Blocked: repeated identical call',
-                    is_error: true,
-                });
-                toolLog.push(`${block.name} [BLOCKED: spin detected]`);
-                continue;
-            }
-            const toolStart = Date.now();
-            try {
-                const result = await executeTool(block.name, block.input, toolConfig, toolContext);
-                const truncatedResult = truncateToolResult(result);
-                const resultPreview = result.slice(0, 200) + (result.length > 200 ? '...' : '');
-                console.log(`[agent:tools] <- ${resultPreview}`);
-                toolLog.push(`${block.name}(${inputStr}) → ${resultPreview}`);
-                toolObs?.update({ output: result });
-                toolObs?.end();
-                // Record audit event
-                if (toolContext?.auditTraceId) {
-                    addEvent(toolContext.auditTraceId, {
-                        type: 'tool_use',
-                        summary: `${block.name}(${inputStr})`,
-                        durationMs: Date.now() - toolStart,
-                    });
-                }
-                toolResults.push({
-                    type: 'tool_result',
-                    tool_use_id: block.id,
-                    content: truncatedResult,
-                });
-                // Guard: no-progress detection
-                const progressResult = guard.recordResult(result);
-                if (progressResult.nudge) {
-                    console.warn(`[agent:tools:guard] ${progressResult.nudge}`);
-                    toolResults[toolResults.length - 1].content += `\n\n[System: ${progressResult.nudge}]`;
-                }
-            }
-            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: `${block.name} error: ${errorMessage.slice(0, 150)}`,
-                        durationMs: Date.now() - toolStart,
-                    });
-                }
-                throw err;
-            }
-        }
-        // Send tool results back
-        apiMessages.push({ role: 'user', content: toolResults });
-    }
-    console.warn(`[agent:tools] Max iterations (${maxIterations}) reached`);
-    return {
-        response: '[Tool use loop reached maximum iterations]',
-        toolCalls: toolLog,
-    };
-}
-/** Build UsageDetails from Anthropic usage response */
-function buildUsageDetails(usage) {
-    return {
-        prompt_tokens: usage?.input_tokens ?? 0,
-        completion_tokens: usage?.output_tokens ?? 0,
-        total_tokens: (usage?.input_tokens ?? 0) + (usage?.output_tokens ?? 0),
-    };
+    const { runToolLoop } = await import('./tool-loop.js');
+    const { AnthropicAdapter } = await import('./adapters/anthropic-adapter.js');
+    const adapter = new AnthropicAdapter();
+    return runToolLoop(adapter, params.messages, params.options, params.config, params.toolConfig, params.toolContext);
 }

package/dist/providers/codex.d.ts

@@ -8,10 +8,31 @@ interface CodexAuth {
     accessToken: string;
     accountId: string;
 }
+export declare function resolveCodexAuthPath(authPath?: string): string;
 export declare function loadCodexAuth(authPath?: string): CodexAuth | null;
 export declare function initCodexAuth(path?: string, baseUrl?: string): boolean;
 export declare function getCodexAuth(): CodexAuth | null;
 export declare function isCodexAvailable(): boolean;
+export declare function recordCodexUsage(params: {
+    model: string;
+    usage: any;
+    trigger?: string;
+    agentId?: string;
+}): void;
+/**
+ * Make a single Codex API call. Returns raw SSE text.
+ */
+export declare function codexFetch(body: any, timeoutMs?: number): Promise<string>;
+/**
+ * Parse an SSE response from the Codex backend.
+ * Extracts function calls from the completed response object.
+ */
+export declare function parseCodexSSE(text: string): {
+    outputText: string;
+    functionCalls: any[];
+    response: any | null;
+};
+/** @deprecated Use adapter.chat() via the provider registry instead. */
 export declare function chatCodex(params: ProviderChatParams): Promise<string>;
 export declare function chatWithToolsCodex(params: ProviderToolChatParams): Promise<ToolChatResult>;
 export {};