@compass-ai/nova 1.0.74 → 1.0.76

package/dist/services/anthropic-client.js

@@ -1,1451 +0,0 @@
-/**
- * Anthropic API client service for Claude interactions
- *
- * This module provides a comprehensive client for interacting with Anthropic's Claude API,
- * supporting streaming responses, model switching, token tracking, and retry logic with
- * exponential backoff.
- */
-import Anthropic, { AnthropicError } from '@anthropic-ai/sdk';
-import { getCompassAuthService } from './compass-auth-service.js';
-import { getModelConfig, CLAUDE_MODELS, resolveModelId } from '../constants/models.js';
-import { DEFAULT_MODEL, DEFAULT_MAX_TOKENS, DEFAULT_ANTHROPIC_TEMPERATURE } from '../constants/defaults.js';
-import { getCredentialStore } from './credential-store.js';
-import { getTokenTracker } from './token-tracker.js';
-import { getDisabledReason, getAvailableFallbackModel } from './model-availability.js';
-import { getAuditLogger } from './audit-logger.js';
-import { getCostTracker, calculateCost as calculateModelCost } from './cost-tracker.js';
-import { logger } from '../utils/logger.js';
-import { getEventEmitter } from '../core/event-emitter.js';
-import { transformJSONSchema } from '@anthropic-ai/sdk/lib/transform-json-schema.js';
-/**
- * Formats system prompt for Anthropic's prompt caching feature.
- * Caching can reduce costs by up to 90% and latency by 25% for cached content.
- * Note: Minimum cacheable content is 1024 tokens for Claude 3.5 Sonnet and 2048 for other models.
- *
- * @param systemPrompt - The system prompt text
- * @param enableCaching - Whether to enable caching (default: true)
- * @returns Formatted system prompt with cache_control if enabled
- */
-function formatSystemPromptForCaching(systemPrompt, enableCaching = true) {
-    if (!systemPrompt) {
-        return undefined;
-    }
-    // If caching disabled, return as plain string
-    if (!enableCaching) {
-        return systemPrompt;
-    }
-    // Format with cache_control for caching
-    // The system prompt is typically repeated across calls, making it a good caching candidate
-    // Use type assertion for cache_control which may not be in base SDK types but is supported by API
-    return [
-        {
-            type: 'text',
-            text: systemPrompt,
-            cache_control: { type: 'ephemeral' },
-        },
-    ];
-}
-/**
- * Default retry configuration with exponential backoff
- */
-const DEFAULT_RETRY_CONFIG = {
-    maxRetries: 4,
-    baseDelayMs: 1000,
-    maxDelayMs: 16000,
-    jitterFactor: 0.1,
-};
-/**
- * AnthropicClient class provides a comprehensive interface for interacting
- * with Anthropic's Claude API. It supports streaming responses, model switching,
- * automatic token tracking, and retry logic with exponential backoff.
- *
- * Features:
- * - Streaming and non-streaming message generation
- * - Automatic model switching with validation
- * - Token usage tracking and cost estimation
- * - Retry logic with exponential backoff and jitter
- * - Event emission for token updates and model changes
- * - Connection testing and validation
- */
-class AnthropicClient {
-    clients = new Map();
-    currentModel = DEFAULT_MODEL;
-    eventEmitter;
-    retryConfig;
-    initialized = false;
-    apiKey = null;
-    providerApiKeys = new Map();
-    constructor(retryConfig) {
-        this.eventEmitter = getEventEmitter();
-        this.retryConfig = { ...DEFAULT_RETRY_CONFIG, ...retryConfig };
-    }
-    /**
-     * Gets the provider for a given model.
-     */
-    getModelProvider(modelId) {
-        const resolvedId = resolveModelId(modelId);
-        const modelConfig = getModelConfig(resolvedId);
-        return (modelConfig?.provider || 'anthropic');
-    }
-    /**
-     * Gets the API key for a specific provider.
-     * Returns cached key if available, otherwise fetches from credential store.
-     */
-    async getApiKeyForProvider(provider) {
-        // Check cache first
-        if (this.providerApiKeys.has(provider)) {
-            return this.providerApiKeys.get(provider);
-        }
-        // Fetch from credential store
-        const credentialStore = await getCredentialStore();
-        const apiKey = await credentialStore.getProviderApiKey(provider);
-        if (apiKey) {
-            this.providerApiKeys.set(provider, apiKey);
-        }
-        return apiKey;
-    }
-    /**
-     * Resolves the base URL for a given model.
-     *
-     * @param modelId - The model ID to resolve base URL for
-     * @returns The base URL for the model
-     */
-    resolveBaseUrl(modelId) {
-        const resolvedId = resolveModelId(modelId);
-        const modelConfig = getModelConfig(resolvedId);
-        // Priority: environment variable > model config > default
-        return process.env.COMPASS_ANTHROPIC_BASE_URL || modelConfig?.baseUrl || 'https://api.anthropic.com';
-    }
-    /**
-     * Gets or creates a client for the specified model.
-     * Uses provider-specific API keys when available.
-     *
-     * @param modelId - The model ID to get client for
-     * @returns The Anthropic client instance for the model's base URL
-     */
-    getClientForModel(modelId) {
-        const baseURL = this.resolveBaseUrl(modelId);
-        const provider = this.getModelProvider(modelId);
-        // Create a unique client key that includes both baseURL and provider
-        const clientKey = `${baseURL}:${provider}`;
-        // Return existing client if available
-        if (this.clients.has(clientKey)) {
-            return this.clients.get(clientKey);
-        }
-        // Get the API key for this provider (try provider-specific first, fall back to default)
-        const apiKey = this.providerApiKeys.get(provider) || this.apiKey;
-        if (!apiKey) {
-            throw new Error(`API key not available for provider '${provider}'. Call initialize() first or configure the API key.`);
-        }
-        const isOllama = baseURL.includes('ollama') || provider === 'ollama';
-        const client = new Anthropic({
-            apiKey: apiKey,
-            baseURL,
-            defaultHeaders: isOllama ? { 'Authorization': 'Bearer ' + apiKey } : {}
-        });
-        this.clients.set(clientKey, client);
-        logger.debug(`Created new client for provider '${provider}' at base URL: ${baseURL}`);
-        return client;
-    }
-    /**
-     * Initializes the client with API keys from credential store.
-     * Loads API keys for all configured providers.
-     * Must be called before making any API requests.
-     *
-     * @returns True if initialization was successful, false otherwise
-     */
-    async initialize() {
-        if (this.initialized && this.apiKey) {
-            return true;
-        }
-        try {
-            const credentialStore = await getCredentialStore();
-            // Load the default Anthropic API key (backward compatibility)
-            const defaultApiKey = await credentialStore.getApiKey();
-            if (!defaultApiKey) {
-                logger.warn('No default API key found. Please configure your Anthropic API key.');
-                return false;
-            }
-            this.apiKey = defaultApiKey;
-            this.providerApiKeys.set('anthropic', defaultApiKey);
-            // Load API keys for all other configured providers
-            const configuredProviders = await credentialStore.getConfiguredProviders();
-            for (const provider of configuredProviders) {
-                const providerKey = await credentialStore.getProviderApiKey(provider);
-                if (providerKey) {
-                    this.providerApiKeys.set(provider, providerKey);
-                    logger.debug(`Loaded API key for provider: ${provider}`);
-                }
-            }
-            // Create client for the default model
-            this.getClientForModel(this.currentModel);
-            this.initialized = true;
-            logger.info(`Initialized with API keys for providers: ${Array.from(this.providerApiKeys.keys()).join(', ')}`);
-            return true;
-        }
-        catch (error) {
-            logger.error('Failed to initialize Anthropic client', error);
-            return false;
-        }
-    }
-    /**
-     * Checks if the client has been initialized with a valid API key.
-     *
-     * @returns True if the client is ready to make requests
-     */
-    isInitialized() {
-        return this.initialized && this.apiKey !== null;
-    }
-    /**
-     * Gets the current model configuration.
-     *
-     * @returns The ModelConfig for the currently selected model
-     */
-    getCurrentModel() {
-        const config = getModelConfig(this.currentModel);
-        if (!config) {
-            logger.warn(`Current model ${this.currentModel} not found, falling back to default`);
-            return CLAUDE_MODELS[DEFAULT_MODEL];
-        }
-        return config;
-    }
-    /**
-     * Gets the current model ID.
-     *
-     * @returns The model ID string
-     */
-    getCurrentModelId() {
-        return this.currentModel;
-    }
-    /**
-     * Switches to a different Claude model.
-     * Automatically loads the API key for the new model's provider if needed.
-     *
-     * @param modelIdOrAlias - The model ID or alias (e.g., 'sonnet', 'opus', 'haiku')
-     * @returns True if the switch was successful, false if the model is unknown or API key is missing
-     */
-    setModel(modelIdOrAlias) {
-        const resolvedId = resolveModelId(modelIdOrAlias);
-        const config = getModelConfig(resolvedId);
-        if (!config) {
-            logger.warn(`Unknown model: ${modelIdOrAlias}`);
-            return false;
-        }
-        const previousModel = this.currentModel;
-        const previousProvider = this.getModelProvider(previousModel);
-        const newProvider = (config.provider || 'anthropic');
-        this.currentModel = config.id;
-        if (previousModel !== this.currentModel) {
-            // Ensure client exists for the new model's base URL (lazy initialization)
-            // Note: The API key for the new provider should already be loaded during initialize()
-            // or will be fetched on-demand when getClientForModel is called
-            if (this.apiKey || this.providerApiKeys.has(newProvider)) {
-                try {
-                    this.getClientForModel(this.currentModel);
-                }
-                catch (error) {
-                    logger.warn(`Failed to create client for new model (provider: ${newProvider}). API key may not be configured.`, error);
-                    // Revert to previous model if we can't create a client
-                    this.currentModel = previousModel;
-                    return false;
-                }
-            }
-            this.eventEmitter.emit('model-switched', { model: config });
-            if (previousProvider !== newProvider) {
-                logger.info(`Switched from ${previousProvider}/${previousModel} to ${newProvider}/${config.name} (${config.id})`);
-            }
-            else {
-                logger.info(`Switched model from ${previousModel} to ${config.name} (${config.id})`);
-            }
-        }
-        return true;
-    }
-    /**
-     * Switches to a different model (async version).
-     * Automatically loads the API key for the new model's provider if not already cached.
-     *
-     * @param modelIdOrAlias - The model ID or alias
-     * @returns True if the switch was successful
-     */
-    async setModelAsync(modelIdOrAlias) {
-        const resolvedId = resolveModelId(modelIdOrAlias);
-        const config = getModelConfig(resolvedId);
-        if (!config) {
-            logger.warn(`Unknown model: ${modelIdOrAlias}`);
-            return false;
-        }
-        const newProvider = (config.provider || 'anthropic');
-        // Ensure we have the API key for the new provider
-        if (!this.providerApiKeys.has(newProvider)) {
-            const providerKey = await this.getApiKeyForProvider(newProvider);
-            if (!providerKey) {
-                logger.warn(`No API key configured for provider '${newProvider}'. Cannot switch to model ${modelIdOrAlias}.`);
-                return false;
-            }
-        }
-        return this.setModel(modelIdOrAlias);
-    }
-    /**
-     * Sends a message and streams the response in real-time.
-     * Yields StreamingResponse objects as content is generated.
-     *
-     * @param messages - Array of conversation messages
-     * @param options - Optional configuration for the request
-     * @yields StreamingResponse objects containing text chunks, tool use, or completion info
-     */
-    async *streamMessage(messages, options = {}) {
-        if (!this.apiKey) {
-            yield { type: 'error', error: 'Client not initialized. Call initialize() first.' };
-            return;
-        }
-        // Super-users bypass all token limits and model restrictions
-        const compassAuth = getCompassAuthService();
-        const isSuperUser = compassAuth.isSuperUser();
-        // Support per-call model override (e.g., use haiku for cheaper summarization)
-        let model = options.model
-            ? getModelConfig(resolveModelId(options.model)) || this.getCurrentModel()
-            : this.getCurrentModel();
-        // Pre-flight: model availability + rolling window limit check
-        if (!isSuperUser) {
-            const planStatus = compassAuth.getPlanStatus();
-            // Check if model is disabled for this plan — attempt fallback
-            const disabledReason = getDisabledReason(model.id, planStatus);
-            if (disabledReason) {
-                const fallback = getAvailableFallbackModel(planStatus);
-                if (fallback) {
-                    logger.warn(`Model "${model.id}" unavailable on current plan — falling back to "${fallback.id}"`);
-                    model = fallback;
-                }
-                else {
-                    yield { type: 'error', error: disabledReason };
-                    return;
-                }
-            }
-            // Check rolling window token limits
-            try {
-                const tokenTracker = await getTokenTracker();
-                const planType = compassAuth.getPlanType();
-                const limitCheck = await tokenTracker.checkLimit(model.id, planStatus, planType);
-                if (!limitCheck.allowed) {
-                    yield {
-                        type: 'error',
-                        error: `${limitCheck.reason}\nSubscribe or renew for higher limits: https://app.compassap.ai/`,
-                    };
-                    return;
-                }
-                // Warn if approaching limit (< 10% remaining on either bucket)
-                const minRemaining = Math.min(limitCheck.generalRemaining, limitCheck.modelRemaining);
-                const effectiveLimit = Math.max(limitCheck.generalRemaining + (limitCheck.generalRemaining === minRemaining ? 0 : 1), 1);
-                if (minRemaining < effectiveLimit * 0.1 && minRemaining > 0) {
-                    logger.warn(`Low token quota: ${minRemaining.toLocaleString()} remaining`);
-                }
-            }
-            catch (limitCheckError) {
-                // Don't block requests if limit check fails - log and continue
-                logger.debug('Token limit check failed, proceeding with request', limitCheckError);
-            }
-        }
-        const maxTokens = options.maxTokens || Math.min(DEFAULT_MAX_TOKENS, model.maxOutputTokens);
-        // Get the appropriate client for this model's base URL (after potential fallback)
-        const client = this.getClientForModel(model.id);
-        // Get audit logger
-        const auditLogger = getAuditLogger();
-        // Store request data for consolidated logging at the end
-        const requestMessages = messages.map(m => ({ role: m.role, content: String(m.content) }));
-        const systemPrompt = options.system;
-        const requestOptions = {
-            model: model.id,
-            maxTokens,
-            temperature: options.temperature ?? DEFAULT_ANTHROPIC_TEMPERATURE,
-            tools: options.tools,
-        };
-        let lastError = null;
-        let attempt = 0;
-        let fullResponseContent = '';
-        // Enable prompt caching by default for system prompts
-        const enableCaching = options.enablePromptCaching !== false;
-        const formattedSystem = formatSystemPromptForCaching(options.system, enableCaching);
-        while (attempt <= this.retryConfig.maxRetries) {
-            try {
-                const stream = await client.messages.stream({
-                    model: model.id,
-                    max_tokens: maxTokens,
-                    temperature: options.temperature ?? DEFAULT_ANTHROPIC_TEMPERATURE,
-                    system: formattedSystem,
-                    messages: this.formatMessages(messages, enableCaching),
-                    ...(options.tools && options.tools.length > 0 && { tools: options.tools }),
-                    ...(options.stopSequences && { stop_sequences: options.stopSequences }),
-                }, {
-                    signal: options.abortSignal,
-                });
-                let inputTokens = 0;
-                let outputTokens = 0;
-                let cacheCreationInputTokens = 0;
-                let cacheReadInputTokens = 0;
-                // let thinkingContent = '';
-                for await (const event of stream) {
-                    // Check if abort was requested
-                    if (options.abortSignal?.aborted) {
-                        logger.info('Aborting stream due to abort signal');
-                        throw new Error('Request aborted');
-                    }
-                    // logger.debug(`Stream event type: ${event.type}`);
-                    if (event.type === 'message_start') {
-                        inputTokens = event.message.usage?.input_tokens || 0;
-                        cacheCreationInputTokens = event.message.usage?.cache_creation_input_tokens || 0;
-                        cacheReadInputTokens = event.message.usage?.cache_read_input_tokens || 0;
-                    }
-                    else if (event.type === 'content_block_delta') {
-                        if (event.delta.type === 'text_delta') {
-                            fullResponseContent += event.delta.text;
-                            yield { type: 'text', content: event.delta.text };
-                        }
-                        else if (event.delta.type === 'input_json_delta') {
-                            fullResponseContent += event.delta.partial_json;
-                            yield { type: 'tool_use', content: event.delta.partial_json };
-                        }
-                    }
-                    else if (event.type === 'message_delta') {
-                        outputTokens = event.usage?.output_tokens || 0;
-                    }
-                }
-                // Log accumulated thinking content if present
-                // if (thinkingContent) {
-                //   logger.debug(`Accumulated thinking content: "${thinkingContent}"`);
-                // }
-                // Get final message from stream for accurate usage data
-                // This is important for Ollama/OpenAI-compatible APIs that may not emit
-                // usage data in message_start event the same way Anthropic does.
-                // For Anthropic models, message_start already provides accurate input_tokens,
-                // and finalMessage() may hang or fail since the stream is already consumed.
-                const isAnthropicProvider = model.provider === 'anthropic' || !model.provider;
-                if (!isAnthropicProvider) {
-                    try {
-                        const finalMessage = await Promise.race([
-                            stream.finalMessage(),
-                            new Promise((_, reject) => setTimeout(() => reject(new Error('finalMessage() timed out after 5s')), 5000)),
-                        ]);
-                        if (finalMessage?.usage) {
-                            inputTokens = finalMessage.usage.input_tokens || inputTokens;
-                            outputTokens = finalMessage.usage.output_tokens || outputTokens;
-                            cacheCreationInputTokens = finalMessage.usage?.cache_creation_input_tokens || cacheCreationInputTokens;
-                            cacheReadInputTokens = finalMessage.usage?.cache_read_input_tokens || cacheReadInputTokens;
-                            logger.debug('Got usage from finalMessage for non-Anthropic provider', {
-                                provider: model.provider,
-                                inputTokens,
-                                outputTokens,
-                                cacheCreationInputTokens,
-                                cacheReadInputTokens,
-                            });
-                        }
-                    }
-                    catch (finalMessageError) {
-                        // finalMessage() may fail if stream was aborted or errored
-                        // Fall back to accumulated usage from events
-                        logger.debug('Could not get finalMessage, using accumulated usage', finalMessageError);
-                    }
-                }
-                else {
-                    logger.debug('Using usage from message_start event for Anthropic provider', {
-                        inputTokens,
-                        outputTokens,
-                        cacheCreationInputTokens,
-                        cacheReadInputTokens,
-                    });
-                }
-                // Build final usage statistics
-                const usage = {
-                    inputTokens,
-                    outputTokens,
-                    totalTokens: inputTokens + outputTokens,
-                    cacheCreationInputTokens,
-                    cacheReadInputTokens,
-                };
-                const cost = this.calculateCost(usage, model);
-                // Log complete LLM call with all data in a single entry
-                await auditLogger.logLLMCall(systemPrompt, requestMessages, fullResponseContent, usage, cost, requestOptions);
-                // Track token usage
-                try {
-                    const tokenTracker = await getTokenTracker();
-                    await tokenTracker.recordUsage(model.id, usage, 'streaming_message');
-                }
-                catch (trackingError) {
-                    logger.debug('Failed to track token usage', trackingError);
-                }
-                // Record actual usage against rolling window limits (fire-and-forget)
-                getTokenTracker().then(tt => tt.recordLimitUsage(model.id, usage.totalTokens)).catch(err => {
-                    logger.debug('Failed to record rolling window usage', err);
-                });
-                // Emit token update event
-                this.eventEmitter.emit('token-update', { usage, cost });
-                // Track usage with Compass (sessionless)
-                try {
-                    const credentialStore = await getCredentialStore();
-                    const compassApiKey = await credentialStore.getCompassApiKey();
-                    if (compassApiKey) {
-                        // Calculate cost locally for accurate tracking
-                        const calculatedCost = calculateModelCost({
-                            modelId: model.id,
-                            inputTokens: usage.inputTokens,
-                            outputTokens: usage.outputTokens,
-                            cacheWriteTokens: usage.cacheCreationInputTokens ?? 0,
-                            cacheReadTokens: usage.cacheReadInputTokens ?? 0,
-                            provider: model.provider,
-                        });
-                        logger.debug('Tracking usage with Compass', {
-                            input_tokens: usage.inputTokens,
-                            cache_write_input_tokens: usage.cacheCreationInputTokens ?? 0,
-                            cache_read_input_tokens: usage.cacheReadInputTokens ?? 0,
-                            output_tokens: usage.outputTokens,
-                            provider: model.provider,
-                            model: model.id,
-                            calculatedCost: calculatedCost?.totalCost,
-                        });
-                        const compassAuth = getCompassAuthService();
-                        await compassAuth.trackUsage({
-                            input_tokens: usage.inputTokens,
-                            cache_write_input_tokens: usage.cacheCreationInputTokens ?? 0,
-                            cache_read_input_tokens: usage.cacheReadInputTokens ?? 0,
-                            output_tokens: usage.outputTokens,
-                            provider: model.provider,
-                            model: model.id,
-                            // Include pre-calculated cost for backend to register
-                            cost: calculatedCost ?? undefined,
-                        }, compassApiKey);
-                        // Record cost in local tracker (use our calculated cost, not backend response)
-                        if (calculatedCost) {
-                            const costTracker = getCostTracker();
-                            costTracker.recordCost(calculatedCost.totalCost, calculatedCost.currency, model.id, model.provider, options.callType || 'conversation', {
-                                inputTokens: usage.inputTokens,
-                                outputTokens: usage.outputTokens,
-                                cacheCreationTokens: usage.cacheCreationInputTokens ?? 0,
-                                cacheReadTokens: usage.cacheReadInputTokens ?? 0,
-                            });
-                            logger.info('Cost tracked', {
-                                cost: calculatedCost.totalCost,
-                                currency: calculatedCost.currency,
-                                callType: options.callType || 'conversation',
-                            });
-                        }
-                    }
-                    else {
-                        logger.debug('No Compass API key found, skipping usage tracking');
-                    }
-                }
-                catch (trackingError) {
-                    logger.debug('Failed to track usage with Compass', trackingError);
-                }
-                yield { type: 'done', usage };
-                return;
-            }
-            catch (error) {
-                lastError = error instanceof Error ? error : new Error(String(error));
-                // Check if error is retryable
-                if (!this.isRetryableError(error) || attempt >= this.retryConfig.maxRetries) {
-                    break;
-                }
-                // Calculate delay with exponential backoff and jitter
-                const delay = this.calculateRetryDelay(attempt);
-                logger.debug(`Retrying request after ${delay}ms (attempt ${attempt + 1}/${this.retryConfig.maxRetries})`);
-                await this.sleep(delay);
-                attempt++;
-            }
-        }
-        // All retries exhausted or non-retryable error
-        const friendlyMessage = this.getFriendlyErrorMessage(lastError);
-        const errorMessage = friendlyMessage || lastError?.message || 'Unknown error occurred';
-        logger.error('API request failed after retries', lastError);
-        await auditLogger.logError(errorMessage, lastError);
-        yield { type: 'error', error: errorMessage };
-    }
-    /**
-     * Sends a message and waits for the complete response.
-     * Use this for non-streaming use cases where you need the full response at once.
-     *
-     * @param messages - Array of conversation messages
-     * @param options - Optional configuration for the request
-     * @returns Promise resolving to the complete message result
-     * @throws Error if the request fails after all retries
-     */
-    async sendMessage(messages, options = {}) {
-        // If structured output is requested, use beta parse API
-        if (options.outputFormat) {
-            return this.sendStructuredMessage(messages, options);
-        }
-        // Otherwise use standard streaming API
-        let content = '';
-        let finalUsage = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
-        let errorMessage = null;
-        for await (const response of this.streamMessage(messages, options)) {
-            switch (response.type) {
-                case 'text':
-                    if (response.content) {
-                        content += response.content;
-                    }
-                    break;
-                case 'done':
-                    if (response.usage) {
-                        finalUsage = response.usage;
-                    }
-                    break;
-                case 'error':
-                    errorMessage = response.error || 'Unknown error';
-                    break;
-            }
-        }
-        if (errorMessage) {
-            throw new Error(errorMessage);
-        }
-        const model = this.getCurrentModel();
-        const cost = this.calculateCost(finalUsage, model);
-        return {
-            content,
-            usage: finalUsage,
-            cost,
-            model: model.id,
-        };
-    }
-    /**
-     * Removes markdown code fence delimiters from JSON content.
-     * Extracts JSON from ```json or ``` code blocks, or returns trimmed content if no code fence found.
-     *
-     * @param content - The raw content string that may contain markdown code fences
-     * @returns The cleaned JSON string
-     */
-    removeMarkdownCodeFence(content) {
-        const jsonMatch = content.match(/```(?:json)?\s*([\s\S]*?)```/);
-        return jsonMatch ? jsonMatch[1].trim() : content.trim();
-    }
-    /**
-     * Creates a JSON schema output format object from the given JSON schema.
-     * If this is passed to the `.parse()` method then the response message will contain a
-     * `.parsed_output` property that is the result of parsing the content with the given JSON schema.
-     *
-     */
-    betaJSONSchemaOutputFormat(jsonSchema, options) {
-        if (jsonSchema.type !== 'object') {
-            throw new Error(`JSON schema for tool must be an object, but got ${jsonSchema.type}`);
-        }
-        const transform = options?.transform ?? true;
-        if (transform) {
-            // todo: doing this is arguably necessary, but it does change the schema the user passed in
-            // so I'm not sure how we should handle that
-            jsonSchema = transformJSONSchema(jsonSchema);
-        }
-        // @ts-expect-error - Type instantiation complexity from generic JSON schema
-        return {
-            type: 'json_schema',
-            schema: {
-                ...jsonSchema,
-            },
-            parse: (content) => {
-                try {
-                    const cleanedContent = this.removeMarkdownCodeFence(content);
-                    return JSON.parse(cleanedContent);
-                }
-                catch (error) {
-                    throw new AnthropicError(`Failed to parse structured output: ${error}`);
-                }
-            },
-        };
-    }
-    /**
-     * Sends a message with structured JSON output using the beta parse API.
-     * This enforces the response to conform to a specific JSON schema.
-     *
-     * @param messages - Array of conversation messages
-     * @param options - Configuration including outputFormat (JSON schema)
-     * @returns Promise resolving to the complete message result with structured JSON
-     * @throws Error if the request fails or schema validation fails
-     */
-    async sendStructuredMessage(messages, options) {
-        if (!this.apiKey) {
-            throw new Error('Client not initialized. Call initialize() first.');
-        }
-        if (!options.outputFormat) {
-            throw new Error('outputFormat is required for structured messages');
-        }
-        // Support per-call model override
-        let model = options.model
-            ? getModelConfig(resolveModelId(options.model)) || this.getCurrentModel()
-            : this.getCurrentModel();
-        const auditLogger = getAuditLogger();
-        // Pre-flight: model availability + rolling window limit check
-        const compassAuth = getCompassAuthService();
-        if (!compassAuth.isSuperUser()) {
-            const planStatus = compassAuth.getPlanStatus();
-            const disabledReason = getDisabledReason(model.id, planStatus);
-            if (disabledReason) {
-                const fallback = getAvailableFallbackModel(planStatus);
-                if (fallback) {
-                    logger.warn(`Model "${model.id}" unavailable on current plan — falling back to "${fallback.id}"`);
-                    model = fallback;
-                }
-                else {
-                    throw new Error(disabledReason);
-                }
-            }
-            const tokenTracker = await getTokenTracker();
-            const planType = compassAuth.getPlanType();
-            const limitCheck = await tokenTracker.checkLimit(model.id, planStatus, planType);
-            if (!limitCheck.allowed) {
-                throw new Error(`${limitCheck.reason}\nSubscribe or renew for higher limits: https://app.compassap.ai/`);
-            }
-        }
-        const maxTokens = options.maxTokens || Math.min(DEFAULT_MAX_TOKENS, model.maxOutputTokens);
-        // Get the appropriate client for this model's base URL (after potential fallback)
-        const client = this.getClientForModel(model.id);
-        // Enable prompt caching by default for system prompts
-        const enableCaching = options.enablePromptCaching !== false;
-        const formattedSystem = formatSystemPromptForCaching(options.system, enableCaching);
-        try {
-            // Use beta.messages.create (not .parse) to avoid SDK crash when content is null.
-            // Some models/providers may return content: null which causes parseBetaMessage to throw
-            // "Cannot read properties of null (reading 'map')".
-            const response = await client.beta.messages.create({
-                model: model.id,
-                max_tokens: maxTokens,
-                temperature: options.temperature ?? DEFAULT_ANTHROPIC_TEMPERATURE,
-                system: formattedSystem,
-                messages: this.formatMessages(messages, enableCaching),
-                output_format: this.betaJSONSchemaOutputFormat(options.outputFormat),
-            }, {
-                signal: options.abortSignal,
-            });
-            // Handle null/empty content gracefully
-            if (!response.content || response.content.length === 0) {
-                throw new Error(`Model "${model.id}" returned empty content for structured output request. ` +
-                    `This model may not support the structured output format.`);
-            }
-            // Extract usage information
-            const usage = {
-                inputTokens: response.usage?.input_tokens || 0,
-                outputTokens: response.usage?.output_tokens || 0,
-                totalTokens: (response.usage?.input_tokens || 0) + (response.usage?.output_tokens || 0),
-                cacheCreationInputTokens: response.usage?.cache_creation_input_tokens || 0,
-                cacheReadInputTokens: response.usage?.cache_read_input_tokens || 0,
-            };
-            const cost = this.calculateCost(usage, model);
-            // Extract and parse JSON content from the text block
-            const textBlock = response.content.find((block) => block.type === 'text');
-            if (!textBlock || textBlock.type !== 'text') {
-                throw new Error('No text content block in structured output response');
-            }
-            let content;
-            try {
-                const parsed = JSON.parse(textBlock.text);
-                content = JSON.stringify(parsed);
-            }
-            catch {
-                // If JSON parsing fails, return the raw text so the caller can attempt its own parsing
-                content = textBlock.text;
-            }
-            // Log the LLM call
-            const requestMessages = messages.map(m => ({ role: m.role, content: String(m.content) }));
-            await auditLogger.logLLMCall(options.system, requestMessages, content, usage, cost, {
-                model: model.id,
-                maxTokens,
-                temperature: options.temperature ?? DEFAULT_ANTHROPIC_TEMPERATURE,
-                // outputFormat: 'json_schema',
-            });
-            // Track token usage
-            try {
-                const tokenTracker = await getTokenTracker();
-                await tokenTracker.recordUsage(model.id, usage, 'structured_message');
-            }
-            catch (trackingError) {
-                logger.debug('Failed to track token usage', trackingError);
-            }
-            // Record actual usage against rolling window limits (fire-and-forget)
-            getTokenTracker().then(tt => tt.recordLimitUsage(model.id, usage.totalTokens)).catch(err => {
-                logger.debug('Failed to record rolling window usage', err);
-            });
-            // Emit token update event
-            this.eventEmitter.emit('token-update', { usage, cost });
-            // Track usage with Compass (sessionless)
-            try {
-                const credentialStore = await getCredentialStore();
-                const compassApiKey = await credentialStore.getCompassApiKey();
-                if (compassApiKey) {
-                    // Calculate cost locally for accurate tracking
-                    const calculatedCost = calculateModelCost({
-                        modelId: model.id,
-                        inputTokens: usage.inputTokens,
-                        outputTokens: usage.outputTokens,
-                        cacheWriteTokens: usage.cacheCreationInputTokens ?? 0,
-                        cacheReadTokens: usage.cacheReadInputTokens ?? 0,
-                        provider: model.provider,
-                    });
-                    logger.debug('Tracking structured message usage with Compass', {
-                        input_tokens: usage.inputTokens,
-                        cache_write_input_tokens: usage.cacheCreationInputTokens ?? 0,
-                        cache_read_input_tokens: usage.cacheReadInputTokens ?? 0,
-                        output_tokens: usage.outputTokens,
-                        provider: model.provider,
-                        model: model.id,
-                        calculatedCost: calculatedCost?.totalCost,
-                    });
-                    const compassAuth = getCompassAuthService();
-                    await compassAuth.trackUsage({
-                        input_tokens: usage.inputTokens,
-                        cache_write_input_tokens: usage.cacheCreationInputTokens ?? 0,
-                        cache_read_input_tokens: usage.cacheReadInputTokens ?? 0,
-                        output_tokens: usage.outputTokens,
-                        provider: model.provider,
-                        model: model.id,
-                        // Include pre-calculated cost for backend to register
-                        cost: calculatedCost ?? undefined,
-                    }, compassApiKey);
-                    // Record cost in local tracker (use our calculated cost, not backend response)
-                    if (calculatedCost) {
-                        const costTracker = getCostTracker();
-                        costTracker.recordCost(calculatedCost.totalCost, calculatedCost.currency, model.id, model.provider, options.callType || 'conversation', {
-                            inputTokens: usage.inputTokens,
-                            outputTokens: usage.outputTokens,
-                            cacheCreationTokens: usage.cacheCreationInputTokens ?? 0,
-                            cacheReadTokens: usage.cacheReadInputTokens ?? 0,
-                        });
-                        logger.info('Cost tracked', {
-                            cost: calculatedCost.totalCost,
-                            currency: calculatedCost.currency,
-                            callType: options.callType || 'conversation',
-                        });
-                    }
-                }
-                else {
-                    logger.debug('No Compass API key found, skipping usage tracking');
-                }
-            }
-            catch (trackingError) {
-                logger.debug('Failed to track usage with Compass', trackingError);
-            }
-            return {
-                content,
-                usage,
-                cost,
-                stopReason: response.stop_reason || undefined,
-                model: model.id,
-            };
-        }
-        catch (error) {
-            const isAbort = error instanceof Error && (error.message.includes('aborted') || error.name === 'AbortError' || error.name === 'APIUserAbortError');
-            if (isAbort) {
-                logger.debug('Structured message request aborted');
-            }
-            else {
-                logger.error('Structured message request failed', error);
-            }
-            throw error;
-        }
-    }
-    /**
-     * Creates a message with full response including tool use blocks.
-     * This is the primary method for the agentic loop.
-     *
-     * @param messages - Array of conversation messages (can include tool_result blocks)
-     * @param options - Configuration for the request
-     * @param onTextChunk - Optional callback for streaming text chunks
-     * @param onToolEvent - Optional callback for tool use streaming events
-     * @returns Full response with tool use blocks and stop reason
-     */
-    async createAgenticMessage(messages, options = {}, onTextChunk, onToolEvent) {
-        if (!this.apiKey) {
-            throw new Error('Client not initialized. Call initialize() first.');
-        }
-        // Support per-call model override (e.g., use haiku for cheaper summarization)
-        let model = options.model
-            ? getModelConfig(resolveModelId(options.model)) || this.getCurrentModel()
-            : this.getCurrentModel();
-        const auditLogger = getAuditLogger();
-        // Pre-flight: model availability + rolling window limit check
-        const compassAuth = getCompassAuthService();
-        if (!compassAuth.isSuperUser()) {
-            const planStatus = compassAuth.getPlanStatus();
-            const disabledReason = getDisabledReason(model.id, planStatus);
-            if (disabledReason) {
-                // Attempt automatic fallback to an available model
-                const fallback = getAvailableFallbackModel(planStatus);
-                if (fallback) {
-                    logger.warn(`Model "${model.id}" unavailable on current plan — falling back to "${fallback.id}"`);
-                    model = fallback;
-                }
-                else {
-                    throw new Error(disabledReason);
-                }
-            }
-            const tokenTracker = await getTokenTracker();
-            const planType = compassAuth.getPlanType();
-            const limitCheck = await tokenTracker.checkLimit(model.id, planStatus, planType);
-            if (!limitCheck.allowed) {
-                throw new Error(`${limitCheck.reason}\nSubscribe or renew for higher limits: https://app.compassap.ai/`);
-            }
-        }
-        const maxTokens = options.maxTokens || Math.min(DEFAULT_MAX_TOKENS, model.maxOutputTokens);
-        // Get the appropriate client for this model's base URL (after potential fallback)
-        const client = this.getClientForModel(model.id);
-        let lastError = null;
-        let attempt = 0;
-        // Enable prompt caching by default for system prompts (can be disabled via options)
-        const enableCaching = options.enablePromptCaching !== false;
-        const formattedSystem = formatSystemPromptForCaching(options.system, enableCaching);
-        while (attempt <= this.retryConfig.maxRetries) {
-            try {
-                const stream = await client.messages.stream({
-                    model: model.id,
-                    max_tokens: maxTokens,
-                    temperature: options.temperature ?? DEFAULT_ANTHROPIC_TEMPERATURE,
-                    system: formattedSystem,
-                    messages: this.formatMessages(messages, enableCaching),
-                    ...(options.tools && options.tools.length > 0 && { tools: options.tools }),
-                    ...(options.stopSequences && { stop_sequences: options.stopSequences }),
-                }, {
-                    signal: options.abortSignal,
-                });
-                let inputTokens = 0;
-                let outputTokens = 0;
-                let cacheCreationInputTokens = 0;
-                let cacheReadInputTokens = 0;
-                let textContent = '';
-                const toolUseBlocks = [];
-                const contentBlocks = [];
-                let stopReason = 'end_turn';
-                // Track current tool use block being built
-                let currentToolUse = null;
-                for await (const event of stream) {
-                    // Check for abort between events
-                    if (options.abortSignal?.aborted) {
-                        logger.info('Aborting stream due to signal');
-                        throw new Error('Request aborted');
-                    }
-                    if (event.type === 'message_start') {
-                        inputTokens = event.message.usage?.input_tokens || 0;
-                        cacheCreationInputTokens = event.message.usage?.cache_creation_input_tokens || 0;
-                        cacheReadInputTokens = event.message.usage?.cache_read_input_tokens || 0;
-                    }
-                    else if (event.type === 'content_block_start') {
-                        if (event.content_block.type === 'tool_use') {
-                            currentToolUse = {
-                                id: event.content_block.id,
-                                name: event.content_block.name,
-                                inputJson: '',
-                            };
-                            // Emit tool_start event immediately when we know the tool name
-                            if (onToolEvent) {
-                                onToolEvent({
-                                    type: 'tool_start',
-                                    id: event.content_block.id,
-                                    name: event.content_block.name,
-                                });
-                            }
-                        }
-                        else if (event.content_block.type === 'text') {
-                            // Initialize text content block
-                        }
-                    }
-                    else if (event.type === 'content_block_delta') {
-                        if (event.delta.type === 'text_delta' && event.delta.text) {
-                            textContent += event.delta.text;
-                            if (onTextChunk) {
-                                onTextChunk(event.delta.text);
-                            }
-                        }
-                        else if (event.delta.type === 'input_json_delta' && currentToolUse) {
-                            currentToolUse.inputJson += event.delta.partial_json || '';
-                            // Optionally emit progress (useful for large inputs like file content)
-                            if (onToolEvent) {
-                                onToolEvent({
-                                    type: 'tool_input_delta',
-                                    id: currentToolUse.id,
-                                    partialInput: event.delta.partial_json || '',
-                                });
-                            }
-                        }
-                    }
-                    else if (event.type === 'content_block_stop') {
-                        if (currentToolUse) {
-                            // Parse the accumulated JSON and create tool use block
-                            try {
-                                const input = JSON.parse(currentToolUse.inputJson || '{}');
-                                toolUseBlocks.push({
-                                    id: currentToolUse.id,
-                                    name: currentToolUse.name,
-                                    input,
-                                });
-                                contentBlocks.push({
-                                    type: 'tool_use',
-                                    id: currentToolUse.id,
-                                    name: currentToolUse.name,
-                                    input,
-                                });
-                                // Emit tool_complete event with parsed input
-                                if (onToolEvent) {
-                                    onToolEvent({
-                                        type: 'tool_complete',
-                                        id: currentToolUse.id,
-                                        name: currentToolUse.name,
-                                        input,
-                                    });
-                                }
-                            }
-                            catch (parseError) {
-                                logger.error('Failed to parse tool input JSON', parseError);
-                            }
-                            currentToolUse = null;
-                        }
-                        else if (textContent) {
-                            // Only add text block if we have content
-                            if (!contentBlocks.some(b => b.type === 'text')) {
-                                contentBlocks.push({
-                                    type: 'text',
-                                    text: textContent,
-                                });
-                            }
-                        }
-                    }
-                    else if (event.type === 'message_delta') {
-                        outputTokens = event.usage?.output_tokens || 0;
-                        if (event.delta.stop_reason) {
-                            stopReason = event.delta.stop_reason;
-                        }
-                    }
-                }
-                // Get final message from stream for accurate usage data
-                // This is important for Ollama/OpenAI-compatible APIs that may not emit
-                // usage data in message_start event the same way Anthropic does.
-                // For Anthropic models, message_start already provides accurate input_tokens,
-                // and finalMessage() may hang or fail since the stream is already consumed.
-                const isAnthropicProvider = model.provider === 'anthropic' || !model.provider;
-                logger.debug('[SDK-DIAG] stream consumed', { isAnthropicProvider, provider: model.provider, model: model.id });
-                if (!isAnthropicProvider) {
-                    try {
-                        logger.debug('[SDK-DIAG] stream.finalMessage() START');
-                        const finalMessage = await Promise.race([
-                            stream.finalMessage(),
-                            new Promise((_, reject) => setTimeout(() => reject(new Error('finalMessage() timed out after 5s')), 5000)),
-                        ]);
-                        logger.debug('[SDK-DIAG] stream.finalMessage() DONE');
-                        if (finalMessage?.usage) {
-                            inputTokens = finalMessage.usage.input_tokens || inputTokens;
-                            outputTokens = finalMessage.usage.output_tokens || outputTokens;
-                            cacheCreationInputTokens = finalMessage.usage?.cache_creation_input_tokens || cacheCreationInputTokens;
-                            cacheReadInputTokens = finalMessage.usage?.cache_read_input_tokens || cacheReadInputTokens;
-                            logger.debug('Got usage from finalMessage for non-Anthropic provider (agentic)', {
-                                provider: model.provider,
-                                inputTokens,
-                                outputTokens,
-                                cacheCreationInputTokens,
-                                cacheReadInputTokens,
-                            });
-                        }
-                    }
-                    catch (finalMessageError) {
-                        // finalMessage() may fail if stream was aborted or errored
-                        // Fall back to accumulated usage from events
-                        logger.debug('Could not get finalMessage (agentic), using accumulated usage', finalMessageError);
-                    }
-                }
-                else {
-                    logger.debug('Using usage from message_start event for Anthropic provider (agentic)', {
-                        inputTokens,
-                        outputTokens,
-                        cacheCreationInputTokens,
-                        cacheReadInputTokens,
-                    });
-                }
-                // Ensure text content is in contentBlocks
-                if (textContent && !contentBlocks.some(b => b.type === 'text')) {
-                    contentBlocks.unshift({
-                        type: 'text',
-                        text: textContent,
-                    });
-                }
-                const usage = {
-                    inputTokens,
-                    outputTokens,
-                    totalTokens: inputTokens + outputTokens,
-                    cacheCreationInputTokens,
-                    cacheReadInputTokens,
-                };
-                const cost = this.calculateCost(usage, model);
-                // Log the LLM call
-                const requestMessages = messages.map(m => ({
-                    role: m.role,
-                    content: typeof m.content === 'string' ? m.content : JSON.stringify(m.content),
-                }));
-                await auditLogger.logLLMCall(options.system, requestMessages, textContent + (toolUseBlocks.length > 0 ? `\n[Tool calls: ${toolUseBlocks.map(t => t.name).join(', ')}]` : ''), usage, cost, {
-                    model: model.id,
-                    maxTokens,
-                    temperature: options.temperature ?? DEFAULT_ANTHROPIC_TEMPERATURE,
-                    tools: options.tools,
-                });
-                // Track token usage
-                try {
-                    const tokenTracker = await getTokenTracker();
-                    await tokenTracker.recordUsage(model.id, usage, 'agentic_message');
-                }
-                catch (trackingError) {
-                    logger.debug('Failed to track token usage', trackingError);
-                }
-                // Record actual usage against rolling window limits (fire-and-forget)
-                getTokenTracker().then(tt => tt.recordLimitUsage(model.id, usage.totalTokens)).catch(err => {
-                    logger.debug('Failed to record rolling window usage', err);
-                });
-                this.eventEmitter.emit('token-update', { usage, cost });
-                // Track usage with Compass (sessionless)
-                try {
-                    const credentialStore = await getCredentialStore();
-                    const compassApiKey = await credentialStore.getCompassApiKey();
-                    if (compassApiKey) {
-                        // Calculate cost locally for accurate tracking
-                        const calculatedCost = calculateModelCost({
-                            modelId: model.id,
-                            inputTokens: usage.inputTokens,
-                            outputTokens: usage.outputTokens,
-                            cacheWriteTokens: usage.cacheCreationInputTokens ?? 0,
-                            cacheReadTokens: usage.cacheReadInputTokens ?? 0,
-                            provider: model.provider,
-                        });
-                        const compassAuth = getCompassAuthService();
-                        await compassAuth.trackUsage({
-                            input_tokens: usage.inputTokens,
-                            cache_write_input_tokens: usage.cacheCreationInputTokens ?? 0,
-                            cache_read_input_tokens: usage.cacheReadInputTokens ?? 0,
-                            output_tokens: usage.outputTokens,
-                            provider: model.provider,
-                            model: model.id,
-                            // Include pre-calculated cost for backend to register
-                            cost: calculatedCost ?? undefined,
-                        }, compassApiKey);
-                        // Record cost in local tracker (use our calculated cost, not backend response)
-                        if (calculatedCost) {
-                            const costTracker = getCostTracker();
-                            costTracker.recordCost(calculatedCost.totalCost, calculatedCost.currency, model.id, model.provider, options.callType || 'conversation', {
-                                inputTokens: usage.inputTokens,
-                                outputTokens: usage.outputTokens,
-                                cacheCreationTokens: usage.cacheCreationInputTokens ?? 0,
-                                cacheReadTokens: usage.cacheReadInputTokens ?? 0,
-                            });
-                            logger.info('Cost tracked', {
-                                cost: calculatedCost.totalCost,
-                                currency: calculatedCost.currency,
-                                callType: options.callType || 'conversation',
-                            });
-                        }
-                    }
-                }
-                catch (trackingError) {
-                    logger.debug('Failed to track usage with Compass', trackingError);
-                }
-                return {
-                    textContent,
-                    toolUseBlocks,
-                    stopReason,
-                    usage,
-                    cost,
-                    contentBlocks,
-                };
-            }
-            catch (error) {
-                // Handle abort errors immediately without retry
-                if (error instanceof Error && (error.name === 'AbortError' || error.message.includes('aborted'))) {
-                    logger.info('Request aborted by user');
-                    throw new Error('Request aborted');
-                }
-                lastError = error instanceof Error ? error : new Error(String(error));
-                if (!this.isRetryableError(error) || attempt >= this.retryConfig.maxRetries) {
-                    break;
-                }
-                const delay = this.calculateRetryDelay(attempt);
-                logger.debug(`Retrying agentic request after ${delay}ms (attempt ${attempt + 1}/${this.retryConfig.maxRetries})`);
-                await this.sleep(delay);
-                attempt++;
-            }
-        }
-        const friendlyMessage = this.getFriendlyErrorMessage(lastError);
-        const errorMessage = friendlyMessage || lastError?.message || 'Unknown error occurred';
-        logger.error('Agentic API request failed after retries', lastError);
-        await auditLogger.logError(errorMessage, lastError);
-        throw new Error(errorMessage);
-    }
-    /**
-     * Tests the API connection by sending a minimal request.
-     * Useful for validating API key and connectivity.
-     *
-     * @returns True if the connection test succeeded, false otherwise
-     */
-    async testConnection() {
-        if (!this.apiKey) {
-            logger.warn('Cannot test connection: client not initialized');
-            return false;
-        }
-        try {
-            const client = this.getClientForModel(this.currentModel);
-            await client.messages.create({
-                model: this.currentModel,
-                max_tokens: 10,
-                messages: [{ role: 'user', content: 'Hi' }],
-            });
-            logger.debug('Connection test successful');
-            return true;
-        }
-        catch (error) {
-            logger.error('Connection test failed', error);
-            return false;
-        }
-    }
-    /**
-     * Validates an API key by attempting to make a test request.
-     *
-     * @param apiKey - The API key to validate
-     * @param model - Optional model to use for validation (determines base URL)
-     * @returns True if the API key is valid, false otherwise
-     */
-    async validateApiKey(apiKey, model) {
-        try {
-            // Determine base URL based on model
-            let baseURL;
-            let testModel = model || DEFAULT_MODEL;
-            if (model) {
-                const resolvedId = resolveModelId(model);
-                const modelConfig = getModelConfig(resolvedId);
-                if (modelConfig) {
-                    baseURL = modelConfig.baseUrl;
-                    testModel = modelConfig.id;
-                }
-                else {
-                    baseURL = process.env.COMPASS_ANTHROPIC_BASE_URL || 'https://api.anthropic.com';
-                }
-            }
-            else {
-                baseURL = process.env.COMPASS_ANTHROPIC_BASE_URL || 'https://api.anthropic.com';
-            }
-            const isOllama = baseURL.includes('ollama');
-            const testClient = new Anthropic({
-                apiKey,
-                baseURL,
-                defaultHeaders: isOllama ? { 'Authorization': 'Bearer ' + apiKey } : {}
-            });
-            await testClient.messages.create({
-                model: testModel,
-                max_tokens: 10,
-                messages: [{ role: 'user', content: 'test' }],
-            });
-            return true;
-        }
-        catch (error) {
-            logger.debug('API key validation failed', error);
-            return false;
-        }
-    }
-    /**
-     * Gets available models with their configurations.
-     *
-     * @returns Array of available ModelConfig objects
-     */
-    getAvailableModels() {
-        return Object.values(CLAUDE_MODELS);
-    }
-    /**
-     * Estimates the cost for a given token usage with the current model.
-     *
-     * @param usage - Token usage to estimate cost for
-     * @returns Cost estimate in USD
-     */
-    estimateCost(usage) {
-        return this.calculateCost(usage, this.getCurrentModel());
-    }
-    /**
-     * Calculates the cost for token usage with a specific model.
-     * Uses the centralized cost calculation from cost-tracker.ts which handles
-     * all token types including cache operations.
-     *
-     * @param usage - Token usage statistics
-     * @param model - Model configuration with pricing
-     * @returns Cost estimate breakdown (for backward compatibility with CostEstimate type)
-     */
-    calculateCost(usage, model) {
-        const calculated = calculateModelCost({
-            modelId: model.id,
-            inputTokens: usage.inputTokens,
-            outputTokens: usage.outputTokens,
-            cacheWriteTokens: usage.cacheCreationInputTokens ?? 0,
-            cacheReadTokens: usage.cacheReadInputTokens ?? 0,
-            provider: model.provider,
-        });
-        if (!calculated) {
-            // Fallback to simple calculation if model not found
-            const inputCost = (usage.inputTokens / 1_000_000) * model.pricing.inputPricePerMillion;
-            const outputCost = (usage.outputTokens / 1_000_000) * model.pricing.outputPricePerMillion;
-            return {
-                inputCost,
-                outputCost,
-                totalCost: inputCost + outputCost,
-                currency: 'USD',
-            };
-        }
-        return {
-            inputCost: calculated.inputCost,
-            outputCost: calculated.outputCost,
-            totalCost: calculated.totalCost,
-            currency: calculated.currency,
-        };
-    }
-    /**
-     * Formats messages for the Anthropic API.
-     *
-     * @param messages - Array of Message objects
-     * @returns Formatted messages for the API
-     */
-    formatMessages(messages, enableCaching = false) {
-        const formatted = messages.map((m) => ({
-            role: m.role,
-            content: m.content,
-        }));
-        if (!enableCaching || formatted.length < 4) {
-            return formatted;
-        }
-        // Add cache breakpoint at last user message before the final message
-        for (let i = formatted.length - 2; i >= 0; i--) {
-            if (formatted[i].role === 'user') {
-                const msg = formatted[i];
-                if (typeof msg.content === 'string') {
-                    formatted[i] = {
-                        ...msg,
-                        content: [{
-                                type: 'text',
-                                text: msg.content,
-                                cache_control: { type: 'ephemeral' },
-                            }],
-                    };
-                }
-                else if (Array.isArray(msg.content) && msg.content.length > 0) {
-                    const blocks = [...msg.content];
-                    blocks[blocks.length - 1] = { ...blocks[blocks.length - 1], cache_control: { type: 'ephemeral' } };
-                    formatted[i] = { ...msg, content: blocks };
-                }
-                break;
-            }
-        }
-        return formatted;
-    }
-    /**
-     * Determines if an error is retryable.
-     *
-     * @param error - The error to check
-     * @returns True if the error is retryable
-     */
-    getFriendlyErrorMessage(error) {
-        if (error instanceof Anthropic.APIError) {
-            if (error.status === 529 || error.status === 503) {
-                return `The model is currently overloaded. Please try again later or switch to a different model.`;
-            }
-            if (error.status === 429) {
-                return `Rate limit exceeded. Please wait a moment and try again, or switch to a different model.`;
-            }
-        }
-        return null;
-    }
-    isRetryableError(error) {
-        if (error instanceof Anthropic.APIError) {
-            // Retry on rate limits and server errors
-            const retryableStatuses = [429, 500, 502, 503, 504, 529];
-            return retryableStatuses.includes(error.status ?? 0);
-        }
-        // Retry on network errors
-        if (error instanceof Error) {
-            const networkErrors = ['ECONNRESET', 'ETIMEDOUT', 'ECONNREFUSED', 'EPIPE'];
-            return networkErrors.some((code) => error.message.includes(code));
-        }
-        return false;
-    }
-    /**
-     * Calculates retry delay with exponential backoff and jitter.
-     *
-     * @param attempt - Current attempt number (0-indexed)
-     * @returns Delay in milliseconds
-     */
-    calculateRetryDelay(attempt) {
-        // Exponential backoff: baseDelay * 2^attempt
-        const exponentialDelay = this.retryConfig.baseDelayMs * Math.pow(2, attempt);
-        // Cap at max delay
-        const cappedDelay = Math.min(exponentialDelay, this.retryConfig.maxDelayMs);
-        // Add jitter to prevent thundering herd
-        const jitter = cappedDelay * this.retryConfig.jitterFactor * Math.random();
-        return Math.floor(cappedDelay + jitter);
-    }
-    /**
-     * Sleeps for the specified duration.
-     *
-     * @param ms - Duration in milliseconds
-     */
-    sleep(ms) {
-        return new Promise((resolve) => setTimeout(resolve, ms));
-    }
-    /**
-     * Resets the client state, requiring re-initialization.
-     */
-    reset() {
-        this.clients.clear();
-        this.apiKey = null;
-        this.providerApiKeys.clear();
-        this.initialized = false;
-        this.currentModel = DEFAULT_MODEL;
-        logger.debug('Anthropic client reset');
-    }
-    /**
-     * Gets the list of providers that have API keys configured.
-     *
-     * @returns Array of provider names with configured API keys
-     */
-    getConfiguredProviders() {
-        return Array.from(this.providerApiKeys.keys());
-    }
-    /**
-     * Checks if an API key is configured for a specific provider.
-     *
-     * @param provider - The provider to check
-     * @returns True if an API key is configured for this provider
-     */
-    hasApiKeyForProvider(provider) {
-        return this.providerApiKeys.has(provider);
-    }
-    /**
-     * Sets an API key for a specific provider at runtime.
-     * Useful for dynamically adding provider API keys during a session.
-     *
-     * @param provider - The provider name
-     * @param apiKey - The API key to set
-     */
-    setProviderApiKey(provider, apiKey) {
-        this.providerApiKeys.set(provider, apiKey);
-        logger.info(`Set API key for provider: ${provider}`);
-    }
-}
-// Singleton instance
-let anthropicClientInstance = null;
-/**
- * Gets the singleton AnthropicClient instance.
- * Creates the instance on first call.
- *
- * Note: You must call initialize() on the returned client before making API requests.
- *
- * @returns Promise resolving to the AnthropicClient instance
- */
-export async function getAnthropicClient() {
-    if (!anthropicClientInstance) {
-        anthropicClientInstance = new AnthropicClient();
-    }
-    return anthropicClientInstance;
-}
-/**
- * Creates a new AnthropicClient instance with custom configuration.
- * Use this when you need a separate instance from the singleton.
- *
- * @param retryConfig - Optional custom retry configuration
- * @returns A new AnthropicClient instance
- */
-export function createAnthropicClient(retryConfig) {
-    return new AnthropicClient(retryConfig);
-}
-export { AnthropicClient };
-//# sourceMappingURL=anthropic-client.js.map