erosolar-cli 1.7.439 → 1.7.441

package/dist/plugins/tools/search/localSearchPlugin.js

@@ -0,0 +1,14 @@
+import { SearchCapabilityModule } from '../../../capabilities/searchCapability.js';
+export function createLocalSearchToolPlugin() {
+    return {
+        id: 'tool.search.local',
+        description: 'Local ripgrep-based search tooling.',
+        targets: ['node', 'cloud'],
+        create: (context) => {
+            return new SearchCapabilityModule({
+                workingDir: context.workingDir,
+            });
+        },
+    };
+}
+//# sourceMappingURL=localSearchPlugin.js.map

package/dist/plugins/tools/search/localSearchPlugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"localSearchPlugin.js","sourceRoot":"","sources":["../../../../src/plugins/tools/search/localSearchPlugin.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,2CAA2C,CAAC;AAGnF,MAAM,UAAU,2BAA2B;IACzC,OAAO;QACL,EAAE,EAAE,mBAAmB;QACvB,WAAW,EAAE,qCAAqC;QAClD,OAAO,EAAE,CAAC,MAAM,EAAE,OAAO,CAAC;QAC1B,MAAM,EAAE,CAAC,OAAO,EAAE,EAAE;YAClB,OAAO,IAAI,sBAAsB,CAAC;gBAChC,UAAU,EAAE,OAAO,CAAC,UAAU;aAC/B,CAAC,CAAC;QACL,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/plugins/tools/skills/skillPlugin.d.ts

@@ -0,0 +1,3 @@
+import type { ToolPlugin } from '../registry.js';
+export declare function createSkillToolPlugin(): ToolPlugin;
+//# sourceMappingURL=skillPlugin.d.ts.map

package/dist/plugins/tools/skills/skillPlugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skillPlugin.d.ts","sourceRoot":"","sources":["../../../../src/plugins/tools/skills/skillPlugin.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAEjD,wBAAgB,qBAAqB,IAAI,UAAU,CAMlD"}

package/dist/plugins/tools/skills/skillPlugin.js

@@ -0,0 +1,9 @@
+import { skillCapability } from '../../../capabilities/skillCapability.js';
+export function createSkillToolPlugin() {
+    return {
+        id: 'tool.skills.loader',
+        targets: ['node', 'cloud'],
+        create: () => skillCapability,
+    };
+}
+//# sourceMappingURL=skillPlugin.js.map

package/dist/plugins/tools/skills/skillPlugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"skillPlugin.js","sourceRoot":"","sources":["../../../../src/plugins/tools/skills/skillPlugin.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,0CAA0C,CAAC;AAG3E,MAAM,UAAU,qBAAqB;IACnC,OAAO;QACL,EAAE,EAAE,oBAAoB;QACxB,OAAO,EAAE,CAAC,MAAM,EAAE,OAAO,CAAC;QAC1B,MAAM,EAAE,GAAG,EAAE,CAAC,eAAe;KAC9B,CAAC;AACJ,CAAC"}

package/dist/plugins/tools/taskManagement/taskManagementPlugin.d.ts

@@ -0,0 +1,3 @@
+import type { ToolPlugin } from '../registry.js';
+export declare function createTaskManagementToolPlugin(): ToolPlugin;
+//# sourceMappingURL=taskManagementPlugin.d.ts.map

package/dist/plugins/tools/taskManagement/taskManagementPlugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"taskManagementPlugin.d.ts","sourceRoot":"","sources":["../../../../src/plugins/tools/taskManagement/taskManagementPlugin.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAEjD,wBAAgB,8BAA8B,IAAI,UAAU,CAS3D"}

package/dist/plugins/tools/taskManagement/taskManagementPlugin.js

@@ -0,0 +1,12 @@
+import { TaskManagementCapabilityModule } from '../../../capabilities/taskManagementCapability.js';
+export function createTaskManagementToolPlugin() {
+    return {
+        id: 'tool.task-management.local',
+        description: 'Task tracking and planning tools for organizing complex multi-step work.',
+        targets: ['node', 'cloud'],
+        create: (_context) => {
+            return new TaskManagementCapabilityModule({});
+        },
+    };
+}
+//# sourceMappingURL=taskManagementPlugin.js.map

package/dist/plugins/tools/taskManagement/taskManagementPlugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"taskManagementPlugin.js","sourceRoot":"","sources":["../../../../src/plugins/tools/taskManagement/taskManagementPlugin.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,8BAA8B,EAAE,MAAM,mDAAmD,CAAC;AAGnG,MAAM,UAAU,8BAA8B;IAC5C,OAAO;QACL,EAAE,EAAE,4BAA4B;QAChC,WAAW,EAAE,0EAA0E;QACvF,OAAO,EAAE,CAAC,MAAM,EAAE,OAAO,CAAC;QAC1B,MAAM,EAAE,CAAC,QAAQ,EAAE,EAAE;YACnB,OAAO,IAAI,8BAA8B,CAAC,EAAE,CAAC,CAAC;QAChD,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/plugins/tools/testing/testingPlugin.d.ts

@@ -0,0 +1,3 @@
+import type { ToolPlugin } from '../registry.js';
+export declare function createTestingToolPlugin(): ToolPlugin;
+//# sourceMappingURL=testingPlugin.d.ts.map

package/dist/plugins/tools/testing/testingPlugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"testingPlugin.d.ts","sourceRoot":"","sources":["../../../../src/plugins/tools/testing/testingPlugin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAqB,MAAM,gBAAgB,CAAC;AAGpE,wBAAgB,uBAAuB,IAAI,UAAU,CAUpD"}

package/dist/plugins/tools/testing/testingPlugin.js

@@ -0,0 +1,12 @@
+import { TestingCapabilityModule } from '../../../capabilities/testingCapability.js';
+export function createTestingToolPlugin() {
+    return {
+        id: 'tool.testing.coverage',
+        description: 'Test generation scaffolding plus coverage execution/reporting utilities.',
+        targets: ['node'],
+        create: async (context) => new TestingCapabilityModule({
+            workingDir: context.workingDir,
+        }),
+    };
+}
+//# sourceMappingURL=testingPlugin.js.map

package/dist/plugins/tools/testing/testingPlugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"testingPlugin.js","sourceRoot":"","sources":["../../../../src/plugins/tools/testing/testingPlugin.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,uBAAuB,EAAE,MAAM,4CAA4C,CAAC;AAErF,MAAM,UAAU,uBAAuB;IACrC,OAAO;QACL,EAAE,EAAE,uBAAuB;QAC3B,WAAW,EAAE,0EAA0E;QACvF,OAAO,EAAE,CAAC,MAAM,CAAC;QACjB,MAAM,EAAE,KAAK,EAAE,OAA0B,EAAE,EAAE,CAC3C,IAAI,uBAAuB,CAAC;YAC1B,UAAU,EAAE,OAAO,CAAC,UAAU;SAC/B,CAAC;KACL,CAAC;AACJ,CAAC"}

package/dist/plugins/tools/validation/validationPlugin.d.ts

@@ -0,0 +1,3 @@
+import type { ToolPlugin } from '../registry.js';
+export declare function createValidationToolPlugin(): ToolPlugin;
+//# sourceMappingURL=validationPlugin.d.ts.map

package/dist/plugins/tools/validation/validationPlugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validationPlugin.d.ts","sourceRoot":"","sources":["../../../../src/plugins/tools/validation/validationPlugin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAqB,MAAM,gBAAgB,CAAC;AAGpE,wBAAgB,0BAA0B,IAAI,UAAU,CAWvD"}

package/dist/plugins/tools/validation/validationPlugin.js

@@ -0,0 +1,14 @@
+import { ValidationCapabilityModule } from '../../../capabilities/validationCapability.js';
+export function createValidationToolPlugin() {
+    return {
+        id: 'tool.validation.comprehensive',
+        description: 'Comprehensive code validation with intelligent error parsing and fix suggestions.',
+        targets: ['node'],
+        create: async (context) => {
+            return new ValidationCapabilityModule({
+                workingDir: context.workingDir,
+            });
+        },
+    };
+}
+//# sourceMappingURL=validationPlugin.js.map

package/dist/plugins/tools/validation/validationPlugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validationPlugin.js","sourceRoot":"","sources":["../../../../src/plugins/tools/validation/validationPlugin.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,0BAA0B,EAAE,MAAM,+CAA+C,CAAC;AAE3F,MAAM,UAAU,0BAA0B;IACxC,OAAO;QACL,EAAE,EAAE,+BAA+B;QACnC,WAAW,EAAE,mFAAmF;QAChG,OAAO,EAAE,CAAC,MAAM,CAAC;QACjB,MAAM,EAAE,KAAK,EAAE,OAA0B,EAAE,EAAE;YAC3C,OAAO,IAAI,0BAA0B,CAAC;gBACpC,UAAU,EAAE,OAAO,CAAC,UAAU;aAC/B,CAAC,CAAC;QACL,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/plugins/tools/web/webPlugin.d.ts

@@ -0,0 +1,3 @@
+import type { ToolPlugin } from '../registry.js';
+export declare function createWebToolPlugin(): ToolPlugin;
+//# sourceMappingURL=webPlugin.d.ts.map

package/dist/plugins/tools/web/webPlugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webPlugin.d.ts","sourceRoot":"","sources":["../../../../src/plugins/tools/web/webPlugin.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAEjD,wBAAgB,mBAAmB,IAAI,UAAU,CAShD"}

package/dist/plugins/tools/web/webPlugin.js

@@ -0,0 +1,12 @@
+import { WebCapabilityModule } from '../../../capabilities/webCapability.js';
+export function createWebToolPlugin() {
+    return {
+        id: 'tool.web.local',
+        description: 'Web content fetching and search tools for accessing online information.',
+        targets: ['node', 'cloud'],
+        create: (_context) => {
+            return new WebCapabilityModule({});
+        },
+    };
+}
+//# sourceMappingURL=webPlugin.js.map

package/dist/plugins/tools/web/webPlugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"webPlugin.js","sourceRoot":"","sources":["../../../../src/plugins/tools/web/webPlugin.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,wCAAwC,CAAC;AAG7E,MAAM,UAAU,mBAAmB;IACjC,OAAO;QACL,EAAE,EAAE,gBAAgB;QACpB,WAAW,EAAE,yEAAyE;QACtF,OAAO,EAAE,CAAC,MAAM,EAAE,OAAO,CAAC;QAC1B,MAAM,EAAE,CAAC,QAAQ,EAAE,EAAE;YACnB,OAAO,IAAI,mBAAmB,CAAC,EAAE,CAAC,CAAC;QACrC,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/providers/anthropicProvider.d.ts

@@ -0,0 +1,41 @@
+import type { ConversationMessage, LLMProvider, ProviderResponse, ProviderToolDefinition, StreamChunk } from '../core/types.js';
+interface AnthropicProviderOptions {
+    apiKey: string;
+    model: string;
+    maxTokens?: number;
+    temperature?: number;
+    rateLimitMaxRetries?: number;
+    rateLimitInitialDelayMs?: number;
+    enablePromptCaching?: boolean;
+    /** Maximum retries for transient errors (default: 3) */
+    transientMaxRetries?: number;
+}
+export declare class AnthropicMessagesProvider implements LLMProvider {
+    readonly id = "anthropic";
+    readonly model: string;
+    private readonly client;
+    private readonly maxTokens;
+    private readonly temperature;
+    private readonly rateLimitMaxRetries;
+    private readonly rateLimitInitialDelayMs;
+    private readonly enablePromptCaching;
+    private readonly _transientMaxRetries;
+    constructor(options: AnthropicProviderOptions);
+    generate(messages: ConversationMessage[], tools: ProviderToolDefinition[]): Promise<ProviderResponse>;
+    generateStream(messages: ConversationMessage[], tools: ProviderToolDefinition[]): AsyncIterableIterator<StreamChunk>;
+    getCapabilities(): {
+        streaming: boolean;
+        toolCalling: boolean;
+        vision: boolean;
+        functionCalling: boolean;
+        maxTokens: number;
+        supportedModalities: ("text" | "image" | "audio")[];
+    };
+    /**
+     * Calculate exponential backoff delay with jitter
+     */
+    private getBackoffDelay;
+    private executeWithRateLimitRetries;
+}
+export {};
+//# sourceMappingURL=anthropicProvider.d.ts.map

package/dist/providers/anthropicProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"anthropicProvider.d.ts","sourceRoot":"","sources":["../../src/providers/anthropicProvider.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,mBAAmB,EACnB,WAAW,EACX,gBAAgB,EAChB,sBAAsB,EAGtB,WAAW,EAEZ,MAAM,kBAAkB,CAAC;AAyD1B,UAAU,wBAAwB;IAChC,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,uBAAuB,CAAC,EAAE,MAAM,CAAC;IACjC,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,wDAAwD;IACxD,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B;AAQD,qBAAa,yBAA0B,YAAW,WAAW;IAC3D,QAAQ,CAAC,EAAE,eAAe;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAY;IACnC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAS;IAC7C,OAAO,CAAC,QAAQ,CAAC,uBAAuB,CAAS;IACjD,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAU;IAE9C,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAAS;gBAElC,OAAO,EAAE,wBAAwB;IAevC,QAAQ,CAAC,QAAQ,EAAE,mBAAmB,EAAE,EAAE,KAAK,EAAE,sBAAsB,EAAE,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAgDpG,cAAc,CAAC,QAAQ,EAAE,mBAAmB,EAAE,EAAE,KAAK,EAAE,sBAAsB,EAAE,GAAG,qBAAqB,CAAC,WAAW,CAAC;IA6E3H,eAAe;;;;;;6BAO+B,CAAC,MAAM,GAAG,OAAO,GAAG,OAAO,CAAC,EAAE;;IAI5E;;OAEG;IACH,OAAO,CAAC,eAAe;YAKT,2BAA2B;CAmD1C"}

package/dist/providers/anthropicProvider.js

@@ -0,0 +1,446 @@
+import Anthropic from '@anthropic-ai/sdk';
+import { APIError, RateLimitError } from '@anthropic-ai/sdk/error.js';
+import { sanitizeErrorMessage, safeErrorMessage } from '../core/secretStore.js';
+// ============================================================================
+// Error Recovery Constants
+// ============================================================================
+const TRANSIENT_ERROR_PATTERNS = [
+    'premature close',
+    'premature end',
+    'unexpected end',
+    'aborted',
+    'fetcherror',
+    'invalid response body',
+    'gunzip',
+    'decompress',
+    'econnreset',
+    'econnrefused',
+    'epipe',
+    'socket hang up',
+    'network',
+    'timeout',
+    '500',
+    '502',
+    '503',
+    '504',
+    'overloaded',
+];
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+function isTransientError(error) {
+    if (!(error instanceof Error))
+        return false;
+    const message = error.message.toLowerCase();
+    const errorName = error.name?.toLowerCase() ?? '';
+    const errorCode = error.code?.toLowerCase() ?? '';
+    const allText = `${message} ${errorName} ${errorCode}`;
+    // Check for transient patterns
+    if (TRANSIENT_ERROR_PATTERNS.some(pattern => allText.includes(pattern))) {
+        return true;
+    }
+    // Check for 5xx status codes
+    if (error instanceof APIError) {
+        const status = error.status;
+        if (status && status >= 500 && status < 600) {
+            return true;
+        }
+        // Anthropic overloaded error
+        if (status === 529) {
+            return true;
+        }
+    }
+    return false;
+}
+const DEFAULT_RATE_LIMIT_RETRIES = 4;
+const DEFAULT_RATE_LIMIT_INITIAL_DELAY_MS = 1500;
+const MIN_RATE_LIMIT_DELAY_MS = 750;
+const MAX_RATE_LIMIT_DELAY_MS = 40_000;
+const DEFAULT_TRANSIENT_RETRIES = 3;
+export class AnthropicMessagesProvider {
+    id = 'anthropic';
+    model;
+    client;
+    maxTokens;
+    temperature;
+    rateLimitMaxRetries;
+    rateLimitInitialDelayMs;
+    enablePromptCaching;
+    // Reserved for future transient error retry logic
+    _transientMaxRetries;
+    constructor(options) {
+        this.client = new Anthropic({ apiKey: options.apiKey });
+        this.model = options.model;
+        // Default to 16K output tokens to handle extended thinking and code generation
+        this.maxTokens = options.maxTokens ?? 16384;
+        this.temperature = options.temperature ?? 0;
+        this.rateLimitMaxRetries = Math.max(0, options.rateLimitMaxRetries ?? DEFAULT_RATE_LIMIT_RETRIES);
+        this.rateLimitInitialDelayMs = Math.max(MIN_RATE_LIMIT_DELAY_MS, options.rateLimitInitialDelayMs ?? DEFAULT_RATE_LIMIT_INITIAL_DELAY_MS);
+        this.enablePromptCaching = options.enablePromptCaching ?? true;
+        this._transientMaxRetries = options.transientMaxRetries ?? DEFAULT_TRANSIENT_RETRIES;
+    }
+    async generate(messages, tools) {
+        const { system, chat } = convertConversation(messages, this.enablePromptCaching);
+        const response = await this.executeWithRateLimitRetries(() => this.client.messages.create({
+            model: this.model,
+            max_tokens: this.maxTokens,
+            temperature: this.temperature,
+            messages: chat,
+            ...(system ? { system } : {}),
+            ...(tools.length ? { tools: tools.map(mapTool) } : {}),
+        }));
+        const usage = mapUsage(response.usage);
+        const stopReason = mapStopReason(response.stop_reason);
+        const toolCalls = response.content
+            .filter((block) => block.type === 'tool_use')
+            .map((block) => ({
+            id: block.id,
+            name: block.name,
+            arguments: toRecord(block.input),
+        }));
+        const textContent = response.content
+            .filter((block) => block.type === 'text')
+            .map((block) => ('text' in block ? block.text : ''))
+            .join('\n')
+            .trim();
+        if (toolCalls.length > 0) {
+            return {
+                type: 'tool_calls',
+                toolCalls,
+                content: textContent,
+                usage,
+                stopReason,
+            };
+        }
+        return {
+            type: 'message',
+            content: textContent,
+            usage,
+            stopReason,
+        };
+    }
+    async *generateStream(messages, tools) {
+        const { system, chat } = convertConversation(messages, this.enablePromptCaching);
+        const stream = this.client.messages.stream({
+            model: this.model,
+            max_tokens: this.maxTokens,
+            temperature: this.temperature,
+            messages: chat,
+            ...(system ? { system } : {}),
+            ...(tools.length ? { tools: tools.map(mapTool) } : {}),
+        });
+        let currentToolCall = null;
+        let currentToolCallInput = '';
+        let toolCallId = '';
+        for await (const event of stream) {
+            // Handle different event types
+            if (event.type === 'content_block_start') {
+                const block = event.content_block;
+                if (block.type === 'tool_use') {
+                    toolCallId = block.id;
+                    currentToolCall = {
+                        id: block.id,
+                        name: block.name,
+                        arguments: {},
+                    };
+                    currentToolCallInput = '';
+                }
+            }
+            else if (event.type === 'content_block_delta') {
+                const delta = event.delta;
+                if (delta.type === 'text_delta') {
+                    yield {
+                        type: 'content',
+                        content: delta.text,
+                    };
+                }
+                else if (delta.type === 'input_json_delta' && currentToolCall) {
+                    // accumulate tool input JSON fragments
+                    if (typeof delta.partial_json === 'string' && delta.partial_json) {
+                        currentToolCallInput += delta.partial_json;
+                    }
+                }
+            }
+            else if (event.type === 'content_block_stop') {
+                if (currentToolCall && toolCallId) {
+                    if (currentToolCallInput.trim()) {
+                        try {
+                            currentToolCall.arguments = toRecord(JSON.parse(currentToolCallInput));
+                        }
+                        catch {
+                            currentToolCall.arguments = {};
+                        }
+                    }
+                    yield {
+                        type: 'tool_call',
+                        toolCall: currentToolCall,
+                    };
+                    currentToolCall = null;
+                    currentToolCallInput = '';
+                    toolCallId = '';
+                }
+            }
+            else if (event.type === 'message_stop') {
+                const finalMessage = await stream.finalMessage();
+                const usage = mapUsage(finalMessage.usage);
+                const stopReason = mapStopReason(finalMessage.stop_reason);
+                if (usage) {
+                    yield {
+                        type: 'usage',
+                        usage,
+                    };
+                }
+                yield {
+                    type: 'done',
+                    stopReason,
+                };
+            }
+        }
+    }
+    getCapabilities() {
+        return {
+            streaming: true,
+            toolCalling: true,
+            vision: this.model.includes('sonnet') || this.model.includes('opus'),
+            functionCalling: true,
+            maxTokens: this.maxTokens,
+            supportedModalities: ['text', 'image'],
+        };
+    }
+    /**
+     * Calculate exponential backoff delay with jitter
+     */
+    getBackoffDelay(attempt, baseDelay = 1000, maxDelay = 30000) {
+        const delay = Math.min(baseDelay * Math.pow(2, attempt), maxDelay);
+        return delay + Math.random() * delay * 0.1;
+    }
+    async executeWithRateLimitRetries(operation) {
+        let rateLimitRetries = 0;
+        let transientRetries = 0;
+        let delayMs = this.rateLimitInitialDelayMs;
+        while (true) {
+            try {
+                return await operation();
+            }
+            catch (error) {
+                // Handle rate limit errors
+                if (isRateLimitError(error)) {
+                    if (rateLimitRetries >= this.rateLimitMaxRetries) {
+                        throw buildRateLimitFailureError(error, rateLimitRetries);
+                    }
+                    const waitMs = determineRetryDelay(error.headers, delayMs);
+                    // SECURITY: Don't log error details that might contain tokens
+                    console.warn(`[anthropic] Rate limited (attempt ${rateLimitRetries + 1}/${this.rateLimitMaxRetries + 1}). ` +
+                        `Retrying in ${Math.round(waitMs)}ms...`);
+                    await sleep(waitMs);
+                    rateLimitRetries += 1;
+                    delayMs = Math.min(delayMs * 2, MAX_RATE_LIMIT_DELAY_MS);
+                    continue;
+                }
+                // Handle transient errors (network, stream, etc.)
+                if (isTransientError(error)) {
+                    if (transientRetries >= this._transientMaxRetries) {
+                        // SECURITY: Sanitize error message before including in new error
+                        throw new Error(`Transient error after ${transientRetries + 1} attempts: ${safeErrorMessage(error)}`, { cause: error });
+                    }
+                    const waitMs = this.getBackoffDelay(transientRetries);
+                    // SECURITY: Sanitize error message to prevent token leakage
+                    console.warn(`[anthropic] Transient error (attempt ${transientRetries + 1}/${this._transientMaxRetries + 1}): ` +
+                        `${safeErrorMessage(error)}. Retrying in ${Math.round(waitMs)}ms...`);
+                    await sleep(waitMs);
+                    transientRetries += 1;
+                    continue;
+                }
+                // Non-retryable error
+                throw error;
+            }
+        }
+    }
+}
+function convertConversation(messages, enablePromptCaching = false) {
+    const systemPrompts = [];
+    const chat = [];
+    for (const message of messages) {
+        switch (message.role) {
+            case 'system': {
+                systemPrompts.push(message.content);
+                break;
+            }
+            case 'user': {
+                chat.push({
+                    role: 'user',
+                    content: [{ type: 'text', text: message.content }],
+                });
+                break;
+            }
+            case 'assistant': {
+                const contentBlocks = [];
+                if (message.content.trim().length > 0) {
+                    contentBlocks.push({ type: 'text', text: message.content });
+                }
+                for (const call of message.toolCalls ?? []) {
+                    contentBlocks.push({
+                        type: 'tool_use',
+                        id: call.id,
+                        name: call.name,
+                        input: call.arguments,
+                    });
+                }
+                chat.push({
+                    role: 'assistant',
+                    content: contentBlocks.length ? contentBlocks : [{ type: 'text', text: '' }],
+                });
+                break;
+            }
+            case 'tool': {
+                const block = {
+                    type: 'tool_result',
+                    tool_use_id: message.toolCallId,
+                    content: [{ type: 'text', text: message.content }],
+                };
+                chat.push({
+                    role: 'user',
+                    content: [block],
+                });
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    // Add cache control breakpoints to optimize costs
+    // Cache the first few user messages (usually contain system context)
+    if (enablePromptCaching && chat.length > 2) {
+        const cacheBreakpoint = Math.min(2, chat.length - 1);
+        for (let i = 0; i < cacheBreakpoint; i++) {
+            const message = chat[i];
+            if (message && message.role === 'user' && Array.isArray(message.content)) {
+                const lastContent = message.content[message.content.length - 1];
+                if (lastContent && 'text' in lastContent) {
+                    lastContent['cache_control'] = { type: 'ephemeral' };
+                }
+            }
+        }
+    }
+    return {
+        system: systemPrompts.length ? systemPrompts.join('\n\n') : null,
+        chat,
+    };
+}
+function mapTool(definition) {
+    return {
+        name: definition.name,
+        description: definition.description,
+        input_schema: (definition.parameters ?? {
+            type: 'object',
+            properties: {},
+        }),
+    };
+}
+function toRecord(value) {
+    if (isPlainRecord(value)) {
+        return value;
+    }
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        if (!trimmed) {
+            return {};
+        }
+        try {
+            const parsed = JSON.parse(trimmed);
+            return isPlainRecord(parsed) ? parsed : {};
+        }
+        catch {
+            return {};
+        }
+    }
+    return {};
+}
+function isPlainRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function mapUsage(usage) {
+    if (!usage) {
+        return null;
+    }
+    const total = typeof usage.input_tokens === 'number' && typeof usage.output_tokens === 'number'
+        ? usage.input_tokens + usage.output_tokens
+        : undefined;
+    return {
+        inputTokens: usage.input_tokens,
+        outputTokens: usage.output_tokens,
+        totalTokens: total,
+    };
+}
+/**
+ * Map Anthropic's stop_reason to our StopReason type
+ * Critical for agentic loop control - determines if model wants to continue
+ */
+function mapStopReason(stopReason) {
+    if (!stopReason)
+        return undefined;
+    switch (stopReason) {
+        case 'end_turn':
+            return 'end_turn';
+        case 'tool_use':
+            return 'tool_use';
+        case 'max_tokens':
+            return 'max_tokens';
+        case 'stop_sequence':
+            return 'stop_sequence';
+        default:
+            return undefined;
+    }
+}
+function isRateLimitError(error) {
+    if (error instanceof RateLimitError) {
+        return true;
+    }
+    if (error instanceof APIError && error.status === 429) {
+        return true;
+    }
+    return typeof error === 'object' && error !== null && 'status' in error && error.status === 429;
+}
+function determineRetryDelay(headers, fallbackMs) {
+    const retryAfter = parseRetryAfterHeader(headers);
+    if (retryAfter !== null) {
+        return clamp(retryAfter, MIN_RATE_LIMIT_DELAY_MS, MAX_RATE_LIMIT_DELAY_MS);
+    }
+    const jitter = fallbackMs * 0.25;
+    const randomized = fallbackMs + (Math.random() * (2 * jitter) - jitter);
+    return clamp(Math.round(randomized), MIN_RATE_LIMIT_DELAY_MS, MAX_RATE_LIMIT_DELAY_MS);
+}
+function parseRetryAfterHeader(headers) {
+    if (!headers || typeof headers.get !== 'function') {
+        return null;
+    }
+    const retryAfter = headers.get('retry-after');
+    if (!retryAfter) {
+        return null;
+    }
+    const numeric = Number(retryAfter);
+    if (Number.isFinite(numeric) && numeric >= 0) {
+        return numeric * 1000;
+    }
+    const parsedDate = Date.parse(retryAfter);
+    if (Number.isFinite(parsedDate)) {
+        return Math.max(0, parsedDate - Date.now());
+    }
+    return null;
+}
+function clamp(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+}
+async function sleep(durationMs) {
+    await new Promise((resolve) => setTimeout(resolve, durationMs));
+}
+function buildRateLimitFailureError(error, retries) {
+    const baseMessage = 'Anthropic rejected the request because the per-minute token rate limit was exceeded.';
+    const retryDetails = retries > 0 ? ` Waited and retried ${retries} time${retries === 1 ? '' : 's'} without success.` : '';
+    const advisory = ' Reduce the prompt size or wait for usage to reset before trying again. ' +
+        'See https://docs.claude.com/en/api/rate-limits for quota guidance.';
+    // SECURITY: Sanitize original error message to prevent token leakage
+    const original = error.message ? `\nOriginal message: ${sanitizeErrorMessage(error.message)}` : '';
+    return new Error(`${baseMessage}${retryDetails}${advisory}${original}`, {
+        cause: error,
+    });
+}
+//# sourceMappingURL=anthropicProvider.js.map