@juspay/neurolink 9.30.0 → 9.31.1

package/dist/client/providers/anthropic.js

@@ -0,0 +1,831 @@
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { stepCountIs, streamText } from "ai";
+import { trace, SpanKind, SpanStatusCode } from "@opentelemetry/api";
+import { AnthropicModels } from "../constants/enums.js";
+import { BaseProvider } from "../core/baseProvider.js";
+import { DEFAULT_MAX_STEPS } from "../core/constants.js";
+import { createProxyFetch } from "../proxy/proxyFetch.js";
+import { AuthenticationError, NetworkError, ProviderError, RateLimitError, } from "../types/errors.js";
+import { logger } from "../utils/logger.js";
+import { calculateCost } from "../utils/pricing.js";
+import { createAnthropicConfig, getProviderModel, validateApiKey, } from "../utils/providerConfig.js";
+import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
+import { isModelAvailableForTier, getRecommendedModelForTier, getModelCapabilities, } from "../models/anthropicModels.js";
+import { CLAUDE_CLI_USER_AGENT, CLAUDE_CODE_CLIENT_ID, ANTHROPIC_TOKEN_URL, } from "../auth/anthropicOAuth.js";
+import { createOAuthFetch } from "../proxy/oauthFetch.js";
+import { homedir } from "os";
+import { readFileSync, existsSync, writeFileSync, mkdirSync, renameSync, } from "fs";
+import { join } from "path";
+import { TOKEN_EXPIRY_BUFFER_MS } from "../constants/enums.js";
+import { getModelId } from "./providerTypeUtils.js";
+/**
+ * Beta headers for Claude Code integration.
+ * These enable experimental features:
+ * - claude-code-20250219: Claude Code specific features
+ * - interleaved-thinking-2025-05-14: Interleaved thinking mode
+ * - fine-grained-tool-streaming-2025-05-14: Fine-grained tool streaming
+ */
+const ANTHROPIC_BETA_HEADERS = {
+    "anthropic-beta": [
+        "claude-code-20250219",
+        "interleaved-thinking-2025-05-14",
+        "fine-grained-tool-streaming-2025-05-14",
+    ].join(","),
+};
+// Configuration helpers - now using consolidated utility
+const getAnthropicApiKey = () => {
+    return validateApiKey(createAnthropicConfig());
+};
+const getDefaultAnthropicModel = () => {
+    return getProviderModel("ANTHROPIC_MODEL", AnthropicModels.CLAUDE_SONNET_4_6);
+};
+const streamTracer = trace.getTracer("neurolink.provider.anthropic");
+/**
+ * Get OAuth token from stored credentials file or environment.
+ * Priority:
+ * 1. Stored credentials file (~/.neurolink/anthropic-credentials.json)
+ * 2. Environment variables (ANTHROPIC_OAUTH_TOKEN or CLAUDE_OAUTH_TOKEN)
+ */
+const getOAuthToken = () => {
+    // First, check stored credentials file (highest priority)
+    try {
+        const credentialsPath = join(homedir(), ".neurolink", "anthropic-credentials.json");
+        if (existsSync(credentialsPath)) {
+            const credentialsContent = readFileSync(credentialsPath, "utf-8");
+            const credentials = JSON.parse(credentialsContent);
+            if (credentials.type === "oauth" && credentials.oauth?.accessToken) {
+                logger.debug("[AnthropicProvider] Using OAuth token from stored credentials file");
+                return credentials.oauth;
+            }
+        }
+    }
+    catch (error) {
+        logger.debug("[AnthropicProvider] Failed to read stored credentials:", error);
+    }
+    // Fallback to environment variables
+    const tokenString = process.env.ANTHROPIC_OAUTH_TOKEN || process.env.CLAUDE_OAUTH_TOKEN;
+    if (!tokenString) {
+        return null;
+    }
+    // Try to parse as JSON (for full token object with refresh token and expiry)
+    try {
+        const parsed = JSON.parse(tokenString);
+        if (typeof parsed === "object" && parsed.accessToken) {
+            return parsed;
+        }
+        // If it's a simple string in JSON, use it as access token
+        if (typeof parsed === "string") {
+            return { accessToken: parsed };
+        }
+    }
+    catch {
+        // Not JSON, treat as plain access token string
+    }
+    // Treat as plain access token string
+    return { accessToken: tokenString };
+};
+/**
+ * Detect subscription tier from environment or token.
+ * Environment variable ANTHROPIC_SUBSCRIPTION_TIER takes precedence.
+ */
+const detectSubscriptionTier = (oauthToken) => {
+    // Check explicit environment variable first
+    const envTier = process.env.ANTHROPIC_SUBSCRIPTION_TIER?.toLowerCase();
+    if (envTier) {
+        const validTiers = [
+            "free",
+            "pro",
+            "max",
+            "max_5",
+            "max_20",
+            "api",
+        ];
+        if (validTiers.includes(envTier)) {
+            logger.debug("[detectSubscriptionTier] Using environment override", {
+                tier: envTier,
+            });
+            return envTier;
+        }
+        logger.warn("[detectSubscriptionTier] Invalid ANTHROPIC_SUBSCRIPTION_TIER", {
+            value: envTier,
+            validTiers,
+        });
+    }
+    // If using OAuth, default to 'pro' (most common subscription tier)
+    if (oauthToken) {
+        // Check if token scopes indicate tier (future-proofing)
+        const scopes = oauthToken.scopes ?? [];
+        let detectedTier = "pro";
+        if (scopes.includes("max_20")) {
+            detectedTier = "max_20";
+        }
+        else if (scopes.includes("max_5")) {
+            detectedTier = "max_5";
+        }
+        else if (scopes.includes("max")) {
+            detectedTier = "max";
+        }
+        logger.debug("[detectSubscriptionTier] Detected from OAuth token", {
+            tier: detectedTier,
+            scopes,
+        });
+        return detectedTier;
+    }
+    // Default to 'api' for API key authentication
+    logger.debug("[detectSubscriptionTier] No OAuth token, defaulting to API tier");
+    return "api";
+};
+/**
+ * Determine authentication method based on available credentials.
+ * OAuth takes precedence over API key if both are available.
+ */
+const detectAuthMethod = (oauthToken) => {
+    // OAuth takes precedence if available
+    const method = oauthToken ? "oauth" : "api_key";
+    logger.debug("[detectAuthMethod] Auth method resolved", {
+        method,
+        hasOAuthToken: !!oauthToken,
+    });
+    return method;
+};
+/**
+ * Parse rate limit information from Anthropic API response headers.
+ * @param headers - Response headers from Anthropic API
+ * @returns Parsed rate limit information
+ */
+const parseRateLimitHeaders = (headers) => {
+    const getHeader = (name) => {
+        if (headers instanceof Headers) {
+            return headers.get(name);
+        }
+        return headers[name] || headers[name.toLowerCase()] || null;
+    };
+    const parseNumber = (value) => {
+        if (!value) {
+            return undefined;
+        }
+        const num = parseInt(value, 10);
+        return isNaN(num) ? undefined : num;
+    };
+    return {
+        requestsLimit: parseNumber(getHeader("anthropic-ratelimit-requests-limit")),
+        requestsRemaining: parseNumber(getHeader("anthropic-ratelimit-requests-remaining")),
+        requestsReset: getHeader("anthropic-ratelimit-requests-reset") || undefined,
+        tokensLimit: parseNumber(getHeader("anthropic-ratelimit-tokens-limit")),
+        tokensRemaining: parseNumber(getHeader("anthropic-ratelimit-tokens-remaining")),
+        tokensReset: getHeader("anthropic-ratelimit-tokens-reset") || undefined,
+        retryAfter: parseNumber(getHeader("retry-after")),
+    };
+};
+/**
+ * Anthropic Provider v2 - BaseProvider Implementation
+ * Enhanced with OAuth support, subscription tiers, and beta headers for Claude Code integration.
+ */
+export class AnthropicProvider extends BaseProvider {
+    model;
+    authMethod;
+    subscriptionTier;
+    enableBetaFeatures;
+    oauthToken;
+    lastResponseMetadata = null;
+    usageInfo = null;
+    refreshPromise;
+    /**
+     * Create a new Anthropic provider instance.
+     *
+     * @param modelName - Optional model name to use (defaults to CLAUDE_3_5_SONNET)
+     * @param sdk - Optional NeuroLink SDK instance
+     * @param config - Optional configuration options for auth, subscription tier, and beta features
+     */
+    constructor(modelName, sdk, config) {
+        // Pre-compute effective model with tier validation before calling super
+        const oauthToken = config?.oauthToken ?? getOAuthToken();
+        const subscriptionTier = config?.subscriptionTier ?? detectSubscriptionTier(oauthToken);
+        const targetModel = modelName || getDefaultAnthropicModel();
+        // Determine effective model based on tier access
+        let effectiveModel = targetModel;
+        if (subscriptionTier !== "api" &&
+            !isModelAvailableForTier(targetModel, subscriptionTier)) {
+            effectiveModel = getRecommendedModelForTier(subscriptionTier);
+            logger.warn("Model not available for subscription tier, using recommended model", {
+                requestedModel: targetModel,
+                subscriptionTier,
+                recommendedModel: effectiveModel,
+            });
+        }
+        super(effectiveModel, "anthropic", sdk);
+        // Apply configuration with defaults
+        this.enableBetaFeatures = config?.enableBetaFeatures ?? true;
+        // Store computed values
+        this.oauthToken = oauthToken;
+        this.subscriptionTier = subscriptionTier;
+        // Determine auth method - config takes precedence, then auto-detect
+        this.authMethod = config?.authMethod ?? detectAuthMethod(this.oauthToken);
+        // Build headers based on auth method and subscription tier
+        const headers = this.getAuthHeaders();
+        // Create Anthropic instance based on auth method
+        let anthropic;
+        logger.debug("[AnthropicProvider] Constructor - checking OAuth:", {
+            authMethod: this.authMethod,
+            hasOAuthToken: !!this.oauthToken,
+            hasAccessToken: !!this.oauthToken?.accessToken,
+        });
+        if (this.authMethod === "oauth" && this.oauthToken) {
+            // OAuth authentication - use custom fetch wrapper that handles:
+            // - Bearer token authorization
+            // - OAuth beta headers (oauth-2025-04-20, NOT claude-code-20250219)
+            // - User-Agent spoofing
+            // - ?beta=true query param
+            // - Tool name prefixing/stripping
+            logger.debug("[AnthropicProvider] Creating OAuth fetch wrapper...");
+            // Pass a getter so the fetch wrapper always uses the current token,
+            // even after an automatic token refresh.
+            // oauthToken is guaranteed non-null here (checked by the enclosing if-guard).
+            const tokenRef = this.oauthToken;
+            // skipBodyTransform=true: For the SDK provider path, body transforms ARE
+            // intentionally skipped because the Vercel AI SDK builds its own request
+            // format (system prompts, metadata, tool definitions). The billing header,
+            // agent block, user_id injection, and mcp_ tool-name prefixing are only
+            // needed for proxy passthrough of raw Claude API requests where we must
+            // make the request look like it came from Claude Code / CLIProxyAPI.
+            const oauthFetch = createOAuthFetch(() => tokenRef.accessToken, this.enableBetaFeatures, false, // No mcp_ prefix — tool names pass through as-is (matches CLIProxyAPI)
+            true);
+            // For OAuth, we use a dummy API key since our fetch wrapper handles auth
+            // IMPORTANT: Do NOT pass beta headers here - our fetch wrapper handles them
+            // The claude-code-20250219 beta header triggers "credential only for Claude Code" error
+            anthropic = createAnthropic({
+                apiKey: "oauth-authenticated", // Placeholder, actual auth is in fetch wrapper
+                // Note: No headers passed - fetch wrapper sets oauth-2025-04-20 beta header
+                fetch: oauthFetch,
+            });
+            logger.debug("[AnthropicProvider] Anthropic SDK created with OAuth fetch wrapper");
+            logger.debug("Anthropic Provider initialized with OAuth", {
+                modelName: this.modelName,
+                provider: this.providerName,
+                authMethod: this.authMethod,
+                subscriptionTier: this.subscriptionTier,
+                enableBetaFeatures: this.enableBetaFeatures,
+                hasRefreshToken: !!this.oauthToken.refreshToken,
+                tokenExpiry: this.oauthToken.expiresAt
+                    ? new Date(this.oauthToken.expiresAt).toISOString()
+                    : "none",
+            });
+        }
+        else {
+            // Traditional API key authentication
+            const apiKeyToUse = config?.apiKey ?? getAnthropicApiKey();
+            anthropic = createAnthropic({
+                apiKey: apiKeyToUse,
+                headers,
+                fetch: createProxyFetch(),
+            });
+            logger.debug("Anthropic Provider initialized with API key", {
+                modelName: this.modelName,
+                provider: this.providerName,
+                authMethod: this.authMethod,
+                subscriptionTier: this.subscriptionTier,
+                enableBetaFeatures: this.enableBetaFeatures,
+            });
+        }
+        // Initialize Anthropic model with configured instance
+        this.model = anthropic(this.modelName || getDefaultAnthropicModel());
+        // Initialize usage tracking
+        this.usageInfo = {
+            messagesUsed: 0,
+            messagesRemaining: -1, // Unknown until we get rate limit headers
+            tokensUsed: 0,
+            tokensRemaining: -1,
+            inputTokensUsed: 0,
+            outputTokensUsed: 0,
+            lastRequestTimestamp: 0,
+            isRateLimited: false,
+            requestCount: 0,
+            messageQuotaPercent: 0,
+            tokenQuotaPercent: 0,
+        };
+        logger.debug("Anthropic Provider v2 initialized", {
+            modelName: this.modelName,
+            provider: this.providerName,
+            authMethod: this.authMethod,
+            subscriptionTier: this.subscriptionTier,
+            enableBetaFeatures: this.enableBetaFeatures,
+            betaFeatures: this.enableBetaFeatures
+                ? ANTHROPIC_BETA_HEADERS["anthropic-beta"]
+                : "disabled",
+        });
+    }
+    /**
+     * Get authentication headers based on current auth method and configuration.
+     *
+     * @returns Headers object containing auth and beta feature headers
+     */
+    getAuthHeaders() {
+        const headers = {};
+        // Add beta headers if enabled
+        if (this.enableBetaFeatures) {
+            headers["anthropic-beta"] = ANTHROPIC_BETA_HEADERS["anthropic-beta"];
+        }
+        // Add subscription-specific headers if applicable
+        if (this.subscriptionTier !== "api") {
+            headers["x-subscription-tier"] = this.subscriptionTier;
+        }
+        return headers;
+    }
+    /**
+     * Validate if a model is accessible with the current subscription tier.
+     *
+     * @param model - The model ID to validate
+     * @returns true if the model is accessible, false otherwise
+     *
+     * @example
+     * ```typescript
+     * const provider = new AnthropicProvider();
+     * if (provider.validateModelAccess("claude-opus-4-5-20251101")) {
+     *   // Use the model
+     * } else {
+     *   // Fall back to a different model or show upgrade prompt
+     * }
+     * ```
+     */
+    validateModelAccess(model) {
+        // API tier has access to all models
+        if (this.subscriptionTier === "api") {
+            return true;
+        }
+        const hasAccess = isModelAvailableForTier(model, this.subscriptionTier);
+        if (!hasAccess) {
+            logger.debug("[validateModelAccess] Model not available for tier", {
+                model,
+                tier: this.subscriptionTier,
+            });
+        }
+        return hasAccess;
+    }
+    /**
+     * Get current usage information.
+     *
+     * Returns usage tracking data including messages sent, tokens consumed,
+     * and remaining quotas. This information is updated after each API request.
+     *
+     * @returns Current usage info or null if no requests have been made
+     *
+     * @example
+     * ```typescript
+     * const usage = provider.getUsageInfo();
+     * if (usage && usage.tokenQuotaPercent > 80) {
+     *   console.warn("Approaching token quota limit");
+     * }
+     * ```
+     */
+    getUsageInfo() {
+        return this.usageInfo;
+    }
+    /**
+     * Check if beta features are enabled for this provider instance.
+     *
+     * @returns true if beta features are enabled
+     */
+    areBetaFeaturesEnabled() {
+        return this.enableBetaFeatures;
+    }
+    /**
+     * Get model capabilities for the current model.
+     *
+     * @returns The model capabilities or undefined if not found
+     */
+    getModelCapabilities() {
+        return getModelCapabilities(this.modelName || this.getDefaultModel());
+    }
+    /**
+     * Get the current subscription tier.
+     * @returns The detected or configured subscription tier
+     */
+    getSubscriptionTier() {
+        return this.subscriptionTier;
+    }
+    /**
+     * Get the authentication method being used.
+     * @returns The current authentication method
+     */
+    getAuthMethod() {
+        return this.authMethod;
+    }
+    /**
+     * Refresh OAuth token if needed and possible.
+     * This method checks if the token is expired or about to expire,
+     * and attempts to refresh it using the refresh token if available.
+     *
+     * @returns Promise that resolves when refresh is complete (or not needed)
+     * @throws Error if refresh is needed but fails
+     */
+    async refreshAuthIfNeeded() {
+        // Only applicable for OAuth authentication
+        if (this.authMethod !== "oauth" || !this.oauthToken) {
+            logger.debug("Token refresh not applicable for API key authentication");
+            return;
+        }
+        // Check if token has expiry information
+        if (!this.oauthToken.expiresAt) {
+            logger.debug("Token has no expiry information, assuming valid");
+            return;
+        }
+        // expiresAt is stored as Unix milliseconds (matching how auth status/refresh stores it).
+        // Compare against Date.now() so both sides are in milliseconds.
+        const now = Date.now();
+        const isExpired = this.oauthToken.expiresAt <= now;
+        const isExpiringSoon = this.oauthToken.expiresAt <= now + TOKEN_EXPIRY_BUFFER_MS;
+        if (!isExpired && !isExpiringSoon) {
+            logger.debug("OAuth token is still valid", {
+                expiresInMs: this.oauthToken.expiresAt - now,
+            });
+            return;
+        }
+        // Check if we have a refresh token
+        if (!this.oauthToken.refreshToken) {
+            if (isExpired) {
+                throw new AuthenticationError("OAuth token expired and no refresh token available. Please re-authenticate.", this.providerName);
+            }
+            logger.warn("OAuth token expiring soon but no refresh token available", {
+                expiresInMs: this.oauthToken.expiresAt - now,
+            });
+            return;
+        }
+        // Serialize concurrent refresh attempts — if a refresh is already in flight,
+        // wait for it rather than issuing a duplicate request.
+        if (this.refreshPromise) {
+            await this.refreshPromise;
+            return;
+        }
+        // Attempt to refresh the token using the correct Anthropic token endpoint.
+        logger.info("Refreshing OAuth token", {
+            isExpired,
+            expiresInMs: this.oauthToken.expiresAt - now,
+        });
+        // Capture the token reference before entering the async IIFE;
+        // the enclosing guards already verified both fields are non-null.
+        const tokenRef = this.oauthToken;
+        const refreshToken = tokenRef.refreshToken;
+        this.refreshPromise = (async () => {
+            const REFRESH_TIMEOUT_MS = 30_000;
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), REFRESH_TIMEOUT_MS);
+            const response = await fetch(ANTHROPIC_TOKEN_URL, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/x-www-form-urlencoded",
+                    "User-Agent": CLAUDE_CLI_USER_AGENT,
+                },
+                body: new URLSearchParams({
+                    grant_type: "refresh_token",
+                    refresh_token: refreshToken,
+                    client_id: CLAUDE_CODE_CLIENT_ID,
+                }),
+                signal: controller.signal,
+            });
+            clearTimeout(timeoutId);
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new AuthenticationError(`Failed to refresh OAuth token: ${response.status} ${errorText}`, this.providerName);
+            }
+            const newToken = (await response.json());
+            // Mutate the existing oauthToken object in-place so that the fetch wrapper
+            // closure (which captured the object reference, not a copy) picks up the
+            // new accessToken automatically on the next request.
+            // Store expiresAt as milliseconds to match the format used by auth status/refresh.
+            tokenRef.accessToken = newToken.access_token;
+            tokenRef.refreshToken = newToken.refresh_token || tokenRef.refreshToken;
+            tokenRef.expiresAt = newToken.expires_in
+                ? Date.now() + newToken.expires_in * 1000
+                : undefined;
+            tokenRef.tokenType = newToken.token_type || "Bearer";
+            const updatedToken = tokenRef;
+            // Persist the refreshed token to disk atomically (tmp + rename) so
+            // subsequent provider instances and the CLI pick up the new credentials.
+            try {
+                const credentialsDir = join(homedir(), ".neurolink");
+                if (!existsSync(credentialsDir)) {
+                    mkdirSync(credentialsDir, { recursive: true });
+                }
+                const credentialsPath = join(credentialsDir, "anthropic-credentials.json");
+                const tmpPath = `${credentialsPath}.tmp`;
+                const existingRaw = existsSync(credentialsPath)
+                    ? JSON.parse(readFileSync(credentialsPath, "utf-8"))
+                    : {};
+                const updated = {
+                    ...existingRaw,
+                    type: "oauth",
+                    oauth: updatedToken,
+                    updatedAt: Date.now(),
+                };
+                writeFileSync(tmpPath, JSON.stringify(updated, null, 2), {
+                    mode: 0o600,
+                });
+                renameSync(tmpPath, credentialsPath);
+                logger.debug("Refreshed OAuth credentials persisted to disk");
+            }
+            catch (persistError) {
+                // Non-fatal: in-memory token is already updated; next CLI start will
+                // need a manual refresh but the current session will work.
+                logger.warn("Failed to persist refreshed OAuth token to disk", {
+                    error: persistError instanceof Error
+                        ? persistError.message
+                        : String(persistError),
+                });
+            }
+            logger.info("OAuth token refreshed successfully", {
+                hasNewRefreshToken: !!newToken.refresh_token,
+                expiresIn: newToken.expires_in,
+            });
+        })();
+        try {
+            await this.refreshPromise;
+        }
+        catch (error) {
+            if (error instanceof AuthenticationError) {
+                throw error;
+            }
+            throw new AuthenticationError(`Failed to refresh OAuth token: ${error instanceof Error ? error.message : String(error)}`, this.providerName);
+        }
+        finally {
+            this.refreshPromise = undefined;
+        }
+    }
+    /**
+     * Get the last response metadata including rate limit information.
+     * @returns The last response metadata or null if no request has been made
+     */
+    getLastResponseMetadata() {
+        return this.lastResponseMetadata;
+    }
+    /**
+     * Update response metadata from API response headers.
+     * This should be called after each API request to track rate limits.
+     * @param headers - Response headers from the API
+     * @param requestId - Optional request ID
+     */
+    updateResponseMetadata(headers, requestId, usageUpdate) {
+        this.lastResponseMetadata = {
+            rateLimit: parseRateLimitHeaders(headers),
+            requestId: requestId ||
+                (headers instanceof Headers
+                    ? headers.get("x-request-id") || undefined
+                    : headers["x-request-id"]),
+            serverTiming: headers instanceof Headers
+                ? headers.get("server-timing") || undefined
+                : headers["server-timing"],
+        };
+        // Update usage tracking
+        const rateLimit = this.lastResponseMetadata.rateLimit;
+        if (this.usageInfo) {
+            this.usageInfo.requestCount++;
+            this.usageInfo.messagesUsed++;
+            this.usageInfo.lastRequestTimestamp = Date.now();
+            // Update token usage if provided
+            if (usageUpdate) {
+                if (usageUpdate.inputTokens !== undefined) {
+                    this.usageInfo.inputTokensUsed += usageUpdate.inputTokens;
+                    this.usageInfo.tokensUsed += usageUpdate.inputTokens;
+                }
+                if (usageUpdate.outputTokens !== undefined) {
+                    this.usageInfo.outputTokensUsed += usageUpdate.outputTokens;
+                    this.usageInfo.tokensUsed += usageUpdate.outputTokens;
+                }
+            }
+            // Update remaining quotas from rate limit headers
+            if (rateLimit?.requestsRemaining !== undefined) {
+                this.usageInfo.messagesRemaining = rateLimit.requestsRemaining;
+            }
+            if (rateLimit?.tokensRemaining !== undefined) {
+                this.usageInfo.tokensRemaining = rateLimit.tokensRemaining;
+            }
+            // Calculate quota percentages
+            if (rateLimit?.requestsLimit && rateLimit.requestsLimit > 0) {
+                this.usageInfo.messageQuotaPercent = Math.round(((rateLimit.requestsLimit - (rateLimit.requestsRemaining ?? 0)) /
+                    rateLimit.requestsLimit) *
+                    100);
+            }
+            if (rateLimit?.tokensLimit && rateLimit.tokensLimit > 0) {
+                this.usageInfo.tokenQuotaPercent = Math.round(((rateLimit.tokensLimit - (rateLimit.tokensRemaining ?? 0)) /
+                    rateLimit.tokensLimit) *
+                    100);
+            }
+            // Check for rate limiting
+            if (rateLimit?.retryAfter !== undefined) {
+                this.usageInfo.isRateLimited = true;
+                this.usageInfo.rateLimitExpiresAt =
+                    Date.now() + rateLimit.retryAfter * 1000;
+            }
+            else {
+                this.usageInfo.isRateLimited = false;
+                this.usageInfo.rateLimitExpiresAt = undefined;
+            }
+        }
+        // Log rate limit warnings if approaching limits
+        if (rateLimit?.requestsRemaining !== undefined) {
+            if (rateLimit.requestsRemaining <= 5) {
+                logger.warn("Approaching Anthropic request rate limit", {
+                    remaining: rateLimit.requestsRemaining,
+                    limit: rateLimit.requestsLimit,
+                    reset: rateLimit.requestsReset,
+                });
+            }
+        }
+        if (rateLimit?.tokensRemaining !== undefined) {
+            if (rateLimit.tokensLimit &&
+                rateLimit.tokensRemaining < rateLimit.tokensLimit * 0.1) {
+                logger.warn("Approaching Anthropic token rate limit", {
+                    remaining: rateLimit.tokensRemaining,
+                    limit: rateLimit.tokensLimit,
+                    reset: rateLimit.tokensReset,
+                });
+            }
+        }
+    }
+    getProviderName() {
+        return "anthropic";
+    }
+    getDefaultModel() {
+        return getDefaultAnthropicModel();
+    }
+    /**
+     * Returns the Vercel AI SDK model instance for Anthropic
+     */
+    getAISDKModel() {
+        return this.model;
+    }
+    formatProviderError(error) {
+        if (error instanceof TimeoutError) {
+            return new NetworkError(`Request timed out after ${error.timeout}ms`, this.providerName);
+        }
+        const errorRecord = error;
+        const message = typeof errorRecord?.message === "string"
+            ? errorRecord.message
+            : "Unknown error";
+        if (message.includes("API_KEY_INVALID") ||
+            message.includes("Invalid API key")) {
+            return new AuthenticationError("Invalid Anthropic API key. Please check your ANTHROPIC_API_KEY environment variable.", this.providerName);
+        }
+        if (message.includes("rate limit") ||
+            message.includes("too_many_requests") ||
+            message.includes("429")) {
+            return new RateLimitError("Anthropic rate limit exceeded. Please try again later.", this.providerName);
+        }
+        if (message.includes("ECONNRESET") ||
+            message.includes("ENOTFOUND") ||
+            message.includes("ECONNREFUSED") ||
+            message.includes("network") ||
+            message.includes("connection")) {
+            return new NetworkError(`Connection error: ${message}`, this.providerName);
+        }
+        if (message.includes("500") ||
+            message.includes("502") ||
+            message.includes("503") ||
+            message.includes("504") ||
+            message.includes("server error")) {
+            return new ProviderError(`Server error: ${message}`, this.providerName);
+        }
+        return new ProviderError(`Anthropic error: ${message}`, this.providerName);
+    }
+    // executeGenerate removed - BaseProvider handles all generation with tools
+    /**
+     * Override generate to refresh the OAuth token before delegating to
+     * BaseProvider so that expired tokens are renewed automatically.
+     */
+    async generate(optionsOrPrompt, analysisSchema) {
+        await this.refreshAuthIfNeeded();
+        return super.generate(optionsOrPrompt, analysisSchema);
+    }
+    async executeStream(options, _analysisSchema) {
+        // Refresh OAuth token if needed before making any API request.
+        await this.refreshAuthIfNeeded();
+        this.validateStreamOptions(options);
+        const timeout = this.getTimeout(options);
+        const timeoutController = createTimeoutController(timeout, this.providerName, "stream");
+        try {
+            // Get tools - options.tools is pre-merged by BaseProvider.stream() with
+            // base tools (MCP/built-in) + user-provided tools (RAG, etc.)
+            const shouldUseTools = !options.disableTools && this.supportsTools();
+            const tools = shouldUseTools
+                ? options.tools || (await this.getAllTools())
+                : {};
+            // Build message array from options with multimodal support
+            // Using protected helper from BaseProvider to eliminate code duplication
+            const messages = await this.buildMessagesForStream(options);
+            const model = await this.getAISDKModelWithMiddleware(options);
+            // Wrap streamText in an OTel span to capture provider-level latency and token usage
+            const streamSpan = streamTracer.startSpan("neurolink.provider.streamText", {
+                kind: SpanKind.CLIENT,
+                attributes: {
+                    "gen_ai.system": "anthropic",
+                    "gen_ai.request.model": getModelId(model, this.modelName || "unknown"),
+                },
+            });
+            let result;
+            try {
+                result = streamText({
+                    model: model,
+                    messages: messages,
+                    temperature: options.temperature,
+                    maxOutputTokens: options.maxTokens, // No default limit - unlimited unless specified
+                    maxRetries: 0, // NL11: Disable AI SDK's invisible internal retries; we handle retries with OTel instrumentation
+                    tools,
+                    stopWhen: stepCountIs(options.maxSteps || DEFAULT_MAX_STEPS),
+                    toolChoice: shouldUseTools ? "auto" : "none",
+                    abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
+                    experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
+                    onStepFinish: ({ toolCalls, toolResults }) => {
+                        this.handleToolExecutionStorage(toolCalls, toolResults, options, new Date()).catch((error) => {
+                            logger.warn("[AnthropicProvider] Failed to store tool executions", {
+                                provider: this.providerName,
+                                error: error instanceof Error ? error.message : String(error),
+                            });
+                        });
+                    },
+                });
+            }
+            catch (streamError) {
+                streamSpan.end();
+                throw streamError;
+            }
+            // Collect token usage and finish reason asynchronously when the stream completes,
+            // then end the span. This avoids blocking the stream consumer.
+            Promise.resolve(result.usage)
+                .then((usage) => {
+                streamSpan.setAttribute("gen_ai.usage.input_tokens", usage.inputTokens || 0);
+                streamSpan.setAttribute("gen_ai.usage.output_tokens", usage.outputTokens || 0);
+                const cost = calculateCost(this.providerName, this.modelName, {
+                    input: usage.inputTokens || 0,
+                    output: usage.outputTokens || 0,
+                    total: (usage.inputTokens || 0) + (usage.outputTokens || 0),
+                });
+                if (cost && cost > 0) {
+                    streamSpan.setAttribute("neurolink.cost", cost);
+                }
+            })
+                .catch(() => {
+                // Usage may not be available if the stream is aborted
+            });
+            Promise.resolve(result.finishReason)
+                .then((reason) => {
+                streamSpan.setAttribute("gen_ai.response.finish_reason", reason || "unknown");
+            })
+                .catch(() => {
+                // Finish reason may not be available if the stream is aborted
+            });
+            // End the span when the stream text resolves (stream fully consumed)
+            Promise.resolve(result.text)
+                .then(() => {
+                streamSpan.end();
+            })
+                .catch((err) => {
+                streamSpan.setStatus({
+                    code: SpanStatusCode.ERROR,
+                    message: err instanceof Error ? err.message : String(err),
+                });
+                streamSpan.end();
+            });
+            timeoutController?.cleanup();
+            const transformedStream = this.createTextStream(result);
+            // ✅ Note: Vercel AI SDK's streamText() method limitations with tools
+            // The streamText() function doesn't provide the same tool result access as generateText()
+            // Full tool support is now available with real streaming
+            const toolCalls = [];
+            const toolResults = [];
+            return {
+                stream: transformedStream,
+                provider: this.providerName,
+                model: this.modelName,
+                toolCalls, // ✅ Include tool calls in stream result
+                toolResults, // ✅ Include tool results in stream result
+                // Note: omit usage/finishReason to avoid blocking streaming; compute asynchronously if needed.
+            };
+        }
+        catch (error) {
+            timeoutController?.cleanup();
+            throw this.handleProviderError(error);
+        }
+    }
+    async isAvailable() {
+        try {
+            // Check OAuth token first
+            const oauthToken = getOAuthToken();
+            if (oauthToken) {
+                return true;
+            }
+            // Fall back to API key check
+            getAnthropicApiKey();
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    getModel() {
+        return this.model;
+    }
+}
+// Re-export types and utilities for convenience
+export { ModelAccessError, isModelAvailableForTier, getRecommendedModelForTier, getModelCapabilities, } from "../models/anthropicModels.js";
+// Export beta headers constant for external use
+export { ANTHROPIC_BETA_HEADERS };
+export default AnthropicProvider;