@windagency/valora 2.0.1

package/dist/llm/provider.interface.d.ts

@@ -0,0 +1,60 @@
+/**
+ * LLM Provider Interface
+ */
+import type { LLMCompletionOptions, LLMCompletionResult, LLMProvider } from '../types/llm.types.js';
+/**
+ * Base abstract class for LLM providers
+ */
+export declare abstract class BaseLLMProvider implements LLMProvider {
+    protected config: Record<string, unknown>;
+    abstract name: string;
+    constructor(config: Record<string, unknown>);
+    /**
+     * Check if provider is properly configured
+     */
+    abstract isConfigured(): boolean;
+    /**
+     * Complete a chat conversation
+     */
+    abstract complete(options: LLMCompletionOptions): Promise<LLMCompletionResult>;
+    /**
+     * Stream a chat conversation
+     */
+    abstract streamComplete(options: LLMCompletionOptions, onChunk: (chunk: string) => void): Promise<LLMCompletionResult>;
+    /**
+     * Check if the requested model is available/valid for this provider
+     *
+     * @param _modelName The model name to check
+     * @returns true if available, false otherwise
+     */
+    validateModel(_modelName: string): Promise<boolean>;
+    /**
+     * Get a list of alternative models for this provider
+     * Used when the requested model is unavailable
+     *
+     * @param _currentModel The model that failed validation
+     * @returns Array of alternative model names in order of preference
+     */
+    getAlternativeModels(_currentModel?: string): string[];
+    /**
+     * Get default model for this provider
+     */
+    protected getDefaultModel(): string | undefined;
+    /**
+     * Get API key from config
+     */
+    protected getApiKey(): string;
+    /**
+     * Get a hashed identifier for rate limiting (to avoid exposing API keys in logs)
+     */
+    protected getRateLimitKey(): string;
+    /**
+     * Get timeout from config
+     */
+    protected getTimeout(): number;
+    /**
+     * Get max retries from config
+     */
+    protected getMaxRetries(): number;
+}
+//# sourceMappingURL=provider.interface.d.ts.map

package/dist/llm/provider.interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider.interface.d.ts","sourceRoot":"","sources":["../../src/llm/provider.interface.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,oBAAoB,EAAE,mBAAmB,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAI9F;;GAEG;AACH,8BAAsB,eAAgB,YAAW,WAAW;IAG/C,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAFrD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;gBAEA,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAErD;;OAEG;IACH,QAAQ,CAAC,YAAY,IAAI,OAAO;IAEhC;;OAEG;IACH,QAAQ,CAAC,QAAQ,CAAC,OAAO,EAAE,oBAAoB,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAE9E;;OAEG;IACH,QAAQ,CAAC,cAAc,CACtB,OAAO,EAAE,oBAAoB,EAC7B,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,GAC9B,OAAO,CAAC,mBAAmB,CAAC;IAE/B;;;;;OAKG;IACH,aAAa,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAMnD;;;;;;OAMG;IACH,oBAAoB,CAAC,aAAa,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE;IAMtD;;OAEG;IACH,SAAS,CAAC,eAAe,IAAI,MAAM,GAAG,SAAS;IAI/C;;OAEG;IACH,SAAS,CAAC,SAAS,IAAI,MAAM;IAQ7B;;OAEG;IACH,SAAS,CAAC,eAAe,IAAI,MAAM;IAYnC;;OAEG;IACH,SAAS,CAAC,UAAU,IAAI,MAAM;IAI9B;;OAEG;IACH,SAAS,CAAC,aAAa,IAAI,MAAM;CAGjC"}

package/dist/llm/provider.interface.js

@@ -0,0 +1,79 @@
+/**
+ * LLM Provider Interface
+ */
+import { DEFAULT_MAX_RETRIES, DEFAULT_TIMEOUT_MS } from '../config/constants.js';
+/**
+ * Base abstract class for LLM providers
+ */
+export class BaseLLMProvider {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    /**
+     * Check if the requested model is available/valid for this provider
+     *
+     * @param _modelName The model name to check
+     * @returns true if available, false otherwise
+     */
+    validateModel(_modelName) {
+        // Default implementation assumes true if no validation logic exists
+        // Providers should override this to implement specific checks
+        return Promise.resolve(true);
+    }
+    /**
+     * Get a list of alternative models for this provider
+     * Used when the requested model is unavailable
+     *
+     * @param _currentModel The model that failed validation
+     * @returns Array of alternative model names in order of preference
+     */
+    getAlternativeModels(_currentModel) {
+        // Default implementation returns empty array
+        // Providers should override this to return valid alternatives
+        return [];
+    }
+    /**
+     * Get default model for this provider
+     */
+    getDefaultModel() {
+        return this.config['default_model'];
+    }
+    /**
+     * Get API key from config
+     */
+    getApiKey() {
+        const apiKey = this.config['apiKey'];
+        if (!apiKey) {
+            throw new Error(`${this.name} API key not configured`);
+        }
+        return apiKey;
+    }
+    /**
+     * Get a hashed identifier for rate limiting (to avoid exposing API keys in logs)
+     */
+    getRateLimitKey() {
+        const apiKey = this.getApiKey();
+        // Simple hash for rate limiting - not cryptographically secure
+        let hash = 0;
+        for (let i = 0; i < apiKey.length; i++) {
+            const char = apiKey.charCodeAt(i);
+            hash = (hash << 5) - hash + char;
+            hash = hash & hash; // Convert to 32-bit integer
+        }
+        return `${this.name}:${Math.abs(hash)}`;
+    }
+    /**
+     * Get timeout from config
+     */
+    getTimeout() {
+        return this.config['timeout_ms'] || DEFAULT_TIMEOUT_MS;
+    }
+    /**
+     * Get max retries from config
+     */
+    getMaxRetries() {
+        return this.config['max_retries'] || DEFAULT_MAX_RETRIES;
+    }
+}
+//# sourceMappingURL=provider.interface.js.map

package/dist/llm/provider.interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider.interface.js","sourceRoot":"","sources":["../../src/llm/provider.interface.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAE3E;;GAEG;AACH,MAAM,OAAgB,eAAe;IAGd;IAAtB,YAAsB,MAA+B;QAA/B,WAAM,GAAN,MAAM,CAAyB;IAAG,CAAC;IAoBzD;;;;;OAKG;IACH,aAAa,CAAC,UAAkB;QAC/B,oEAAoE;QACpE,8DAA8D;QAC9D,OAAO,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9B,CAAC;IAED;;;;;;OAMG;IACH,oBAAoB,CAAC,aAAsB;QAC1C,6CAA6C;QAC7C,8DAA8D;QAC9D,OAAO,EAAE,CAAC;IACX,CAAC;IAED;;OAEG;IACO,eAAe;QACxB,OAAO,IAAI,CAAC,MAAM,CAAC,eAAe,CAAuB,CAAC;IAC3D,CAAC;IAED;;OAEG;IACO,SAAS;QAClB,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAW,CAAC;QAC/C,IAAI,CAAC,MAAM,EAAE,CAAC;YACb,MAAM,IAAI,KAAK,CAAC,GAAG,IAAI,CAAC,IAAI,yBAAyB,CAAC,CAAC;QACxD,CAAC;QACD,OAAO,MAAM,CAAC;IACf,CAAC;IAED;;OAEG;IACO,eAAe;QACxB,MAAM,MAAM,GAAG,IAAI,CAAC,SAAS,EAAE,CAAC;QAChC,+DAA+D;QAC/D,IAAI,IAAI,GAAG,CAAC,CAAC;QACb,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACxC,MAAM,IAAI,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;YAClC,IAAI,GAAG,CAAC,IAAI,IAAI,CAAC,CAAC,GAAG,IAAI,GAAG,IAAI,CAAC;YACjC,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC,CAAC,4BAA4B;QACjD,CAAC;QACD,OAAO,GAAG,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;IACzC,CAAC;IAED;;OAEG;IACO,UAAU;QACnB,OAAQ,IAAI,CAAC,MAAM,CAAC,YAAY,CAAY,IAAI,kBAAkB,CAAC;IACpE,CAAC;IAED;;OAEG;IACO,aAAa;QACtB,OAAQ,IAAI,CAAC,MAAM,CAAC,aAAa,CAAY,IAAI,mBAAmB,CAAC;IACtE,CAAC;CACD"}

package/dist/llm/providers/anthropic.provider.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Anthropic (Claude) provider implementation
+ *
+ * HTTP Agent Pooling Status: ✅ IMPLEMENTED
+ * Implementation: Custom fetch using undici with built-in connection pooling
+ * Benefits: Connection reuse, reduced latency, improved performance
+ * Note: undici (Node.js's fetch implementation) has built-in connection pooling enabled by default
+ *
+ * Self-registers with the LLM Provider Registry using dependency inversion pattern
+ */
+import type { LLMCompletionOptions, LLMCompletionResult } from '../../types/llm.types.js';
+import { ProviderName } from '../../config/providers.config.js';
+import { BaseLLMProvider } from '../provider.interface.js';
+export declare class AnthropicProvider extends BaseLLMProvider {
+    name: ProviderName;
+    private client;
+    private readonly modelMappingRegistry;
+    private static readonly STREAMING_THRESHOLD;
+    constructor(config?: Record<string, unknown>);
+    complete(options: LLMCompletionOptions): Promise<LLMCompletionResult>;
+    /**
+     * Complete using streaming (required for large token requests)
+     */
+    getAlternativeModels(currentModel?: string): string[];
+    isConfigured(): boolean;
+    private completeWithStreaming;
+    /**
+     * Get a hashed identifier for rate limiting
+     * Override to support both Vertex AI (project ID) and standard API (API key) modes
+     */
+    streamComplete(options: LLMCompletionOptions, onChunk: (chunk: string) => void): Promise<LLMCompletionResult>;
+    /**
+     * Build streaming parameters
+     */
+    private buildStreamParams;
+    /**
+     * Process streaming response
+     */
+    validateModel(modelName: string): Promise<boolean>;
+    protected getRateLimitKey(): string;
+    private getClient;
+    /**
+     * Create a custom fetch function with undici connection pooling
+     */
+    private createCustomFetch;
+    /**
+     * Create Vertex AI client
+     */
+    private createVertexClient;
+    /**
+     * Create standard Anthropic client
+     */
+    private createStandardClient;
+    private processStream;
+    /**
+     * Resolve the actual Anthropic model name based on model and mode
+     */
+    private extractContent;
+    /**
+     * Extract tool calls from an Anthropic response
+     */
+    private extractToolCalls;
+    private formatMessages;
+    /**
+     * Format a single message for the Anthropic API
+     */
+    private formatSingleMessage;
+    /**
+     * Format a tool result message for Anthropic API
+     */
+    private formatToolResultMessage;
+    /**
+     * Format an assistant message with tool calls for Anthropic API
+     */
+    private formatAssistantWithToolCalls;
+    private resolveModelName;
+}
+//# sourceMappingURL=anthropic.provider.d.ts.map

package/dist/llm/providers/anthropic.provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"anthropic.provider.d.ts","sourceRoot":"","sources":["../../../src/llm/providers/anthropic.provider.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,oBAAoB,EAAE,mBAAmB,EAAc,MAAM,iBAAiB,CAAC;AAK7F,OAAO,EAAqB,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAG1E,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAMzD,qBAAa,iBAAkB,SAAQ,eAAe;IACrD,IAAI,eAA0B;IAC9B,OAAO,CAAC,MAAM,CAA4C;IAC1D,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAAuB;IAG5D,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,mBAAmB,CAAS;gBAExC,MAAM,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM;IAK1C,QAAQ,CAAC,OAAO,EAAE,oBAAoB,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAqI3E;;OAEG;IACM,oBAAoB,CAAC,YAAY,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE;IAK9D,YAAY,IAAI,OAAO;YAYT,qBAAqB;IAOnC;;;OAGG;IACG,cAAc,CAAC,OAAO,EAAE,oBAAoB,EAAE,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAoBnH;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAwBzB;;OAEG;IACM,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;cAMxC,eAAe,IAAI,MAAM;IAoB5C,OAAO,CAAC,SAAS;IAQjB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAazB;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAgB1B;;OAEG;IACH,OAAO,CAAC,oBAAoB;YASd,aAAa;IA2F3B;;OAEG;IACH,OAAO,CAAC,cAAc;IAOtB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAkBxB,OAAO,CAAC,cAAc;IAwBtB;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAoB3B;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAa/B;;OAEG;IACH,OAAO,CAAC,4BAA4B;IAyBpC,OAAO,CAAC,gBAAgB;CAOxB"}

package/dist/llm/providers/anthropic.provider.js

@@ -0,0 +1,456 @@
+/**
+ * Anthropic (Claude) provider implementation
+ *
+ * HTTP Agent Pooling Status: ✅ IMPLEMENTED
+ * Implementation: Custom fetch using undici with built-in connection pooling
+ * Benefits: Connection reuse, reduced latency, improved performance
+ * Note: undici (Node.js's fetch implementation) has built-in connection pooling enabled by default
+ *
+ * Self-registers with the LLM Provider Registry using dependency inversion pattern
+ */
+import Anthropic from '@anthropic-ai/sdk';
+import { AnthropicVertex } from '@anthropic-ai/vertex-sdk';
+import { DEFAULT_MAX_TOKENS } from '../../config/constants.js';
+import { getProviderModels, ProviderName } from '../../config/providers.config.js';
+import { createHash } from 'crypto';
+import { getModelMappingRegistry } from '../model-mapping-registry.js';
+import { BaseLLMProvider } from '../provider.interface.js';
+import { getProviderRegistry } from '../registry.js';
+import { Agent as UndiciAgent, fetch as undiciFetch } from 'undici';
+import { createErrorContext, ProviderError, withCircuitBreaker, withRetry } from '../../utils/error-handler.js';
+import { checkRateLimit, getRateLimitStatus } from '../../utils/rate-limiter.js';
+export class AnthropicProvider extends BaseLLMProvider {
+    name = ProviderName.ANTHROPIC;
+    client = null;
+    modelMappingRegistry;
+    // Threshold above which streaming is required by Anthropic API
+    static STREAMING_THRESHOLD = 16000;
+    constructor(config = {}) {
+        super(config);
+        this.modelMappingRegistry = getModelMappingRegistry();
+    }
+    async complete(options) {
+        const context = createErrorContext('anthropic-provider', 'complete', {
+            maxTokens: options.max_tokens,
+            mode: options.mode,
+            model: options.model
+        });
+        // Check if we're in a sandboxed environment with network blocking
+        const isSandboxed = ['AI_MCP_ENABLED', 'CI'].some((key) => process.env[key] === 'true') || process.env['NODE_ENV'] === 'test';
+        if (isSandboxed && !this.isConfigured()) {
+            // In sandboxed environments without API keys, provide a helpful error
+            throw new ProviderError('Anthropic provider not configured. In sandboxed environments, API keys are required for LLM operations.', {
+                provider: ProviderName.ANTHROPIC,
+                sandboxed: true,
+                suggestion: 'Configure ANTHROPIC_API_KEY or use Cursor provider in non-sandboxed environments'
+            }, context, {
+                fallbackValue: {
+                    content: 'LLM operations not available in sandboxed environment',
+                    role: 'assistant',
+                    usage: { completion_tokens: 0, prompt_tokens: 0, total_tokens: 0 }
+                },
+                type: 'fallback'
+            });
+        }
+        // Check rate limiting before proceeding
+        const rateLimitKey = this.getRateLimitKey();
+        if (!checkRateLimit(rateLimitKey, 'llm_api_call')) {
+            const status = getRateLimitStatus(rateLimitKey, 'llm_api_call');
+            throw new ProviderError(`Anthropic API rate limit exceeded. Try again in ${Math.ceil((status.resetTime - Date.now()) / 1000)} seconds.`, {
+                blockedUntil: status.blockedUntil,
+                provider: ProviderName.ANTHROPIC,
+                remaining: status.remaining,
+                resetTime: status.resetTime
+            }, context, { maxRetries: 0, type: 'retry' } // Don't retry rate limited requests
+            );
+        }
+        // Use streaming for large token requests (Anthropic requires streaming for requests >10 min)
+        const maxTokens = options.max_tokens ?? DEFAULT_MAX_TOKENS;
+        if (maxTokens > AnthropicProvider.STREAMING_THRESHOLD) {
+            return this.completeWithStreaming(options);
+        }
+        const operation = async () => {
+            const client = this.getClient();
+            const { messages, system } = this.formatMessages(options.messages);
+            // Resolve model name based on model + mode combination
+            const resolvedModel = this.resolveModelName(options.model, options.mode);
+            // Format tools for Anthropic API
+            const formattedTools = options.tools?.map((tool) => ({
+                description: tool.description,
+                input_schema: tool.parameters,
+                name: tool.name
+            }));
+            // Diagnostic logging for tool configuration
+            const logger = await import('../../output/logger.js').then((m) => m.getLogger());
+            logger.info('Anthropic API call configuration', {
+                hasTools: !!formattedTools,
+                model: resolvedModel,
+                toolCount: formattedTools?.length ?? 0,
+                toolNames: formattedTools?.map((t) => t.name)
+            });
+            // Type-safe message creation for both Anthropic and AnthropicVertex
+            const messageParams = {
+                max_tokens: maxTokens,
+                messages: messages,
+                model: resolvedModel,
+                stop_sequences: options.stop,
+                system,
+                temperature: options.temperature,
+                tools: formattedTools,
+                top_p: options.top_p
+            };
+            const response = client instanceof AnthropicVertex
+                ? await client.messages.create(messageParams)
+                : await client.messages.create(messageParams);
+            return {
+                content: this.extractContent(response),
+                finish_reason: response.stop_reason ?? undefined,
+                role: 'assistant',
+                tool_calls: this.extractToolCalls(response),
+                usage: {
+                    completion_tokens: response.usage.output_tokens,
+                    prompt_tokens: response.usage.input_tokens,
+                    total_tokens: response.usage.input_tokens + response.usage.output_tokens
+                }
+            };
+        };
+        try {
+            return await withCircuitBreaker('anthropic-api', async () => {
+                return withRetry(operation, {
+                    baseDelayMs: 1000,
+                    context,
+                    maxRetries: 3
+                });
+            }, context);
+        }
+        catch (error) {
+            throw new ProviderError(`Anthropic API error: ${error.message}`, {
+                error: error,
+                model: options.model,
+                provider: ProviderName.ANTHROPIC
+            }, context);
+        }
+    }
+    /**
+     * Complete using streaming (required for large token requests)
+     */
+    getAlternativeModels(currentModel) {
+        const alternatives = getProviderModels(ProviderName.ANTHROPIC);
+        return currentModel ? alternatives.filter((m) => m !== currentModel) : alternatives;
+    }
+    isConfigured() {
+        const hasApiKey = typeof this.config['apiKey'] === 'string' && this.config['apiKey'].length > 0;
+        const useVertex = this.config['vertexAI'];
+        const hasVertexConfig = useVertex &&
+            typeof this.config['vertexProjectId'] === 'string' &&
+            typeof this.config['vertexRegion'] === 'string';
+        return hasApiKey || hasVertexConfig;
+    }
+    async completeWithStreaming(options) {
+        // Use streamComplete but collect all chunks into final result
+        return this.streamComplete(options, () => {
+            // No-op callback - we just need the final result
+        });
+    }
+    /**
+     * Get a hashed identifier for rate limiting
+     * Override to support both Vertex AI (project ID) and standard API (API key) modes
+     */
+    async streamComplete(options, onChunk) {
+        try {
+            const client = this.getClient();
+            const { messages, system } = this.formatMessages(options.messages);
+            const streamParams = this.buildStreamParams(options, messages, system);
+            const stream = client instanceof AnthropicVertex
+                ? await client.messages.create(streamParams)
+                : await client.messages.create(streamParams);
+            return await this.processStream(stream, onChunk);
+        }
+        catch (error) {
+            throw new ProviderError(`Anthropic streaming error: ${error.message}`, {
+                error: error,
+                provider: ProviderName.ANTHROPIC
+            });
+        }
+    }
+    /**
+     * Build streaming parameters
+     */
+    buildStreamParams(options, messages, system) {
+        // Resolve model name for Vertex AI compatibility
+        const resolvedModel = this.resolveModelName(options.model, options.mode);
+        return {
+            max_tokens: options.max_tokens ?? DEFAULT_MAX_TOKENS,
+            messages,
+            model: resolvedModel,
+            stream: true,
+            system,
+            temperature: options.temperature,
+            tools: options.tools?.map((tool) => ({
+                description: tool.description,
+                input_schema: tool.parameters,
+                name: tool.name
+            })),
+            top_p: options.top_p
+        };
+    }
+    /**
+     * Process streaming response
+     */
+    validateModel(modelName) {
+        const knownModels = getProviderModels(ProviderName.ANTHROPIC);
+        // Accept known models or any model following the claude-* pattern
+        return Promise.resolve(knownModels.includes(modelName) || modelName.startsWith('claude-'));
+    }
+    getRateLimitKey() {
+        const useVertex = this.config['vertexAI'];
+        if (!useVertex) {
+            // Fall back to standard API key rate limiting
+            return super.getRateLimitKey();
+        }
+        // Use Vertex Project ID for rate limiting
+        const projectId = this.config['vertexProjectId'];
+        if (!projectId) {
+            throw new Error('Vertex AI Project ID not configured');
+        }
+        // Hash the project ID using SHA-256 and take first 8 characters for rate limiting
+        const hash = createHash('sha256').update(projectId).digest('hex').substring(0, 8);
+        return `${this.name}:vertex:${hash}`;
+    }
+    getClient() {
+        if (!this.client) {
+            const useVertex = this.config['vertexAI'];
+            this.client = useVertex ? this.createVertexClient() : this.createStandardClient();
+        }
+        return this.client;
+    }
+    /**
+     * Create a custom fetch function with undici connection pooling
+     */
+    createCustomFetch() {
+        const dispatcher = new UndiciAgent({
+            connections: 128,
+            keepAliveMaxTimeout: 600 * 1000,
+            keepAliveTimeout: 4 * 1000,
+            keepAliveTimeoutThreshold: 1000,
+            pipelining: 1
+        });
+        return ((input, init) => undiciFetch(input, { ...init, dispatcher }));
+    }
+    /**
+     * Create Vertex AI client
+     */
+    createVertexClient() {
+        const region = this.config['vertexRegion'];
+        const projectId = this.config['vertexProjectId'];
+        if (!region || !projectId) {
+            throw new Error('Vertex AI configuration incomplete: region and projectId are required');
+        }
+        return new AnthropicVertex({
+            fetch: this.createCustomFetch(),
+            maxRetries: this.getMaxRetries(),
+            projectId,
+            region
+        });
+    }
+    /**
+     * Create standard Anthropic client
+     */
+    createStandardClient() {
+        return new Anthropic({
+            apiKey: this.getApiKey(),
+            fetch: this.createCustomFetch(),
+            maxRetries: this.getMaxRetries(),
+            timeout: this.getTimeout()
+        });
+    }
+    async processStream(stream, onChunk) {
+        let fullContent = '';
+        const usage = {
+            completion_tokens: 0,
+            prompt_tokens: 0,
+            total_tokens: 0
+        };
+        // Track tool use blocks being built during streaming
+        const toolUseBlocks = new Map();
+        const chunkHandlers = {
+            contentBlockDelta: (chunk) => {
+                if (chunk.type === 'content_block_delta') {
+                    if (chunk.delta.type === 'text_delta') {
+                        const text = chunk.delta.text;
+                        fullContent += text;
+                        onChunk(text);
+                    }
+                    else if (chunk.delta.type === 'input_json_delta') {
+                        // Accumulate JSON input for tool use
+                        const existing = toolUseBlocks.get(chunk.index);
+                        if (existing) {
+                            existing.input += chunk.delta.partial_json;
+                        }
+                    }
+                }
+            },
+            contentBlockStart: (chunk) => {
+                if (chunk.type === 'content_block_start' && chunk.content_block.type === 'tool_use') {
+                    // Start tracking a new tool use block
+                    toolUseBlocks.set(chunk.index, {
+                        id: chunk.content_block.id,
+                        input: '',
+                        name: chunk.content_block.name
+                    });
+                }
+            },
+            messageDelta: (chunk) => {
+                if (chunk.type === 'message_delta') {
+                    usage.completion_tokens = chunk.usage.output_tokens;
+                    usage.total_tokens = usage.prompt_tokens + usage.completion_tokens;
+                }
+            },
+            messageStart: (chunk) => {
+                if (chunk.type === 'message_start') {
+                    usage.prompt_tokens = chunk.message.usage.input_tokens;
+                }
+            }
+        };
+        // Map snake_case chunk types to camelCase handler keys
+        const typeMap = {
+            content_block_delta: 'contentBlockDelta',
+            content_block_start: 'contentBlockStart',
+            message_delta: 'messageDelta',
+            message_start: 'messageStart'
+        };
+        for await (const chunk of stream) {
+            chunkHandlers[typeMap[chunk.type] ?? '']?.(chunk);
+        }
+        // Convert accumulated tool use blocks to tool_calls format
+        const toolCalls = toolUseBlocks.size > 0
+            ? Array.from(toolUseBlocks.values()).map((block) => {
+                let parsedInput = {};
+                try {
+                    parsedInput = JSON.parse(block.input);
+                }
+                catch {
+                    // If JSON parsing fails, use empty object
+                }
+                return {
+                    arguments: parsedInput,
+                    id: block.id,
+                    name: block.name
+                };
+            })
+            : undefined;
+        return {
+            content: fullContent,
+            role: 'assistant',
+            tool_calls: toolCalls,
+            usage
+        };
+    }
+    /**
+     * Resolve the actual Anthropic model name based on model and mode
+     */
+    extractContent(response) {
+        return response.content
+            .filter((block) => block.type === 'text')
+            .map((block) => block.text)
+            .join('');
+    }
+    /**
+     * Extract tool calls from an Anthropic response
+     */
+    extractToolCalls(response) {
+        const toolUseBlocks = response.content.filter((block) => block.type === 'tool_use');
+        if (toolUseBlocks.length === 0) {
+            return undefined;
+        }
+        return toolUseBlocks.map((block) => ({
+            arguments: block.input,
+            id: block.id,
+            name: block.name
+        }));
+    }
+    formatMessages(messages) {
+        const systemContent = messages
+            .filter((m) => m.role === 'system')
+            .map((m) => m.content)
+            .join('\n\n');
+        const formattedMessages = [];
+        for (const msg of messages) {
+            const formatted = this.formatSingleMessage(msg);
+            if (formatted) {
+                formattedMessages.push(formatted);
+            }
+        }
+        return {
+            messages: formattedMessages,
+            system: systemContent || undefined
+        };
+    }
+    /**
+     * Format a single message for the Anthropic API
+     */
+    formatSingleMessage(msg) {
+        if (msg.role === 'system') {
+            return null; // System messages are handled separately
+        }
+        if (msg.role === 'tool') {
+            return this.formatToolResultMessage(msg);
+        }
+        if (msg.role === 'assistant' && msg.tool_calls && msg.tool_calls.length > 0) {
+            return this.formatAssistantWithToolCalls(msg);
+        }
+        // Regular assistant/user messages
+        return {
+            content: msg.content,
+            role: msg.role
+        };
+    }
+    /**
+     * Format a tool result message for Anthropic API
+     */
+    formatToolResultMessage(msg) {
+        return {
+            content: [
+                {
+                    content: msg.content,
+                    tool_use_id: msg.name ?? 'unknown',
+                    type: 'tool_result'
+                }
+            ],
+            role: 'user'
+        };
+    }
+    /**
+     * Format an assistant message with tool calls for Anthropic API
+     */
+    formatAssistantWithToolCalls(msg) {
+        const contentBlocks = [];
+        if (msg.content) {
+            contentBlocks.push({
+                text: msg.content,
+                type: 'text'
+            });
+        }
+        for (const toolCall of msg.tool_calls ?? []) {
+            contentBlocks.push({
+                id: toolCall.id,
+                input: toolCall.arguments,
+                name: toolCall.name,
+                type: 'tool_use'
+            });
+        }
+        return {
+            content: contentBlocks,
+            role: 'assistant'
+        };
+    }
+    resolveModelName(model, mode) {
+        model ??= this.getDefaultModel() ?? 'claude-sonnet-4.5';
+        const useVertex = this.config['vertexAI'];
+        // Use the model mapping registry for resolution
+        return this.modelMappingRegistry.resolveWithMode(model, mode, useVertex);
+    }
+}
+// Self-register this provider with the registry when module is loaded
+getProviderRegistry().registerProvider(ProviderName.ANTHROPIC, AnthropicProvider);
+//# sourceMappingURL=anthropic.provider.js.map