@compass-ai/nova 1.0.72 → 1.0.74

package/dist/services/anthropic-client.js

@@ -0,0 +1,1451 @@
+/**
+ * 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