@juspay/neurolink 9.14.0 → 9.16.0

package/dist/types/subscriptionTypes.js

@@ -0,0 +1,7 @@
+/**
+ * Claude Subscription Types for NeuroLink
+ *
+ * Type definitions for Claude subscription tiers, authentication methods,
+ * and usage tracking for Anthropic API access.
+ */
+export {};

package/dist/utils/conversationMemory.js

@@ -2,11 +2,16 @@
  * Conversation Memory Utilities
  * Handles configuration merging and conversation memory operations
  */
+import { SpanKind, SpanStatusCode } from "@opentelemetry/api";
+import { tracers } from "../telemetry/tracers.js";
+import { withTimeout } from "./errorHandling.js";
 import { DEFAULT_FALLBACK_THRESHOLD, getConversationMemoryDefaults, MEMORY_THRESHOLD_PERCENTAGE, } from "../config/conversationMemory.js";
 import { getAvailableInputTokens } from "../constants/contextWindows.js";
 import { buildSummarizationPrompt } from "../context/prompts/summarizationPrompt.js";
-import { NeuroLink } from "../neurolink.js";
 import { logger } from "./logger.js";
+const memoryTracer = tracers.memory;
+// Cached NeuroLink instance for summarization to avoid creating a new instance per call
+let cachedSummarizer = null;
 /**
  * Apply conversation memory defaults to user configuration
  * Merges user config with environment variables and default values
@@ -34,41 +39,49 @@ export async function getConversationMessages(conversationMemory, options) {
         });
         return [];
     }
-    try {
-        // Extract userId from context
-        const userId = options.context?.userId;
-        const enableSummarization = options.enableSummarization ?? undefined;
-        const messages = await conversationMemory.buildContextMessages(sessionId, userId, enableSummarization);
-        logger.debug("[conversationMemoryUtils] Conversation messages retrieved successfully", {
-            sessionId,
-            messageCount: messages.length,
-            messageTypes: messages.map((m) => m.role),
-            firstMessage: messages.length > 0
-                ? {
-                    role: messages[0].role,
-                    contentLength: messages[0].content.length,
-                    contentPreview: messages[0].content.substring(0, 50),
-                }
-                : null,
-            lastMessage: messages.length > 0
-                ? {
-                    role: messages[messages.length - 1].role,
-                    contentLength: messages[messages.length - 1].content.length,
-                    contentPreview: messages[messages.length - 1].content.substring(0, 50),
-                }
-                : null,
-        });
-        return messages;
-    }
-    catch (error) {
-        logger.warn("[conversationMemoryUtils] Failed to get conversation messages", {
-            sessionId,
-            memoryType: conversationMemory.constructor.name,
-            error: error instanceof Error ? error.message : String(error),
-            stack: error instanceof Error ? error.stack : undefined,
-        });
-        return [];
-    }
+    return memoryTracer.startActiveSpan("neurolink.conversation.getMessages", {
+        kind: SpanKind.INTERNAL,
+        attributes: {
+            "session.id": sessionId,
+            "memory.type": conversationMemory.constructor.name,
+        },
+    }, async (span) => {
+        try {
+            // Extract userId from context
+            const userId = options.context?.userId;
+            if (userId) {
+                span.setAttribute("user.id", userId);
+            }
+            const enableSummarization = options.enableSummarization ?? undefined;
+            const messages = await conversationMemory.buildContextMessages(sessionId, userId, enableSummarization);
+            span.setAttribute("message.count", messages.length);
+            if (logger.shouldLog("debug")) {
+                logger.debug("[conversationMemoryUtils] Conversation messages retrieved successfully", {
+                    sessionId,
+                    messageCount: messages.length,
+                    messageTypes: messages.map((m) => m.role),
+                });
+            }
+            return messages;
+        }
+        catch (error) {
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: error instanceof Error ? error.message : String(error),
+            });
+            span.recordException(error instanceof Error ? error : new Error(String(error)));
+            logger.warn("[conversationMemoryUtils] Failed to get conversation messages", {
+                sessionId,
+                memoryType: conversationMemory.constructor.name,
+                error: error instanceof Error ? error.message : String(error),
+                stack: error instanceof Error ? error.stack : undefined,
+            });
+            return [];
+        }
+        finally {
+            span.end();
+        }
+    });
 }
 /**
  * Store conversation turn for future context
@@ -128,47 +141,66 @@ export async function storeConversationTurn(conversationMemory, originalOptions,
             model: result.model,
         };
     }
-    try {
-        await conversationMemory.storeConversationTurn({
-            sessionId,
-            userId,
-            userMessage,
-            aiResponse,
-            startTimeStamp,
-            providerDetails,
-            enableSummarization: originalOptions.enableSummarization,
-            requestId,
-            tokenUsage: result.usage
-                ? {
-                    inputTokens: result.usage.input,
-                    outputTokens: result.usage.output,
-                    totalTokens: result.usage.total,
-                    cacheReadTokens: result.usage.cacheReadTokens,
-                    cacheWriteTokens: result.usage.cacheCreationTokens,
-                }
-                : undefined,
-        });
-        logger.debug("[conversationMemoryUtils] Conversation turn stored successfully", {
-            requestId,
-            sessionId,
-            userId,
-            memoryType: conversationMemory.constructor.name,
-            userMessageLength: userMessage.length,
-            aiResponseLength: aiResponse.length,
-        });
-    }
-    catch (error) {
-        const details = error?.details;
-        logger.warn("[conversationMemoryUtils] Failed to store conversation turn", {
-            sessionId,
-            userId,
-            memoryType: conversationMemory.constructor.name,
-            error: error instanceof Error ? error.message : String(error),
-            innerError: details?.error || "none",
-            errorCode: error?.code || "unknown",
-            stack: error instanceof Error ? error.stack : undefined,
-        });
-    }
+    await memoryTracer.startActiveSpan("neurolink.conversation.storeTurn", {
+        kind: SpanKind.INTERNAL,
+        attributes: {
+            "session.id": sessionId,
+            "content.length": userMessage.length + aiResponse.length,
+        },
+    }, async (span) => {
+        if (userId) {
+            span.setAttribute("user.id", userId);
+        }
+        try {
+            await conversationMemory.storeConversationTurn({
+                sessionId,
+                userId,
+                userMessage,
+                aiResponse,
+                startTimeStamp,
+                providerDetails,
+                enableSummarization: originalOptions.enableSummarization,
+                requestId,
+                tokenUsage: result.usage
+                    ? {
+                        inputTokens: result.usage.input,
+                        outputTokens: result.usage.output,
+                        totalTokens: result.usage.total,
+                        cacheReadTokens: result.usage.cacheReadTokens,
+                        cacheWriteTokens: result.usage.cacheCreationTokens,
+                    }
+                    : undefined,
+            });
+            logger.debug("[conversationMemoryUtils] Conversation turn stored successfully", {
+                requestId,
+                sessionId,
+                userId,
+                memoryType: conversationMemory.constructor.name,
+                userMessageLength: userMessage.length,
+                aiResponseLength: aiResponse.length,
+            });
+        }
+        catch (error) {
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: error instanceof Error ? error.message : String(error),
+            });
+            span.recordException(error instanceof Error ? error : new Error(String(error)));
+            const details = error?.details;
+            logger.warn("[conversationMemoryUtils] Failed to store conversation turn", {
+                sessionId,
+                userId,
+                memoryType: conversationMemory.constructor.name,
+                error: error instanceof Error ? error.message : String(error),
+                innerError: details?.error || "none",
+                errorCode: error?.code || "unknown",
+                stack: error instanceof Error ? error.stack : undefined,
+            });
+        }
+        finally {
+            span.end();
+        }
+    });
 }
 /**
  * Build context messages from pointer onwards (token-based memory)
@@ -322,22 +354,29 @@ export function getEffectiveTokenThreshold(provider, model, envOverride, session
  */
 export async function generateSummary(messages, config, logPrefix = "[ConversationMemory]", previousSummary, requestId) {
     const summarizationPrompt = createSummarizationPrompt(messages, previousSummary);
-    const summarizer = new NeuroLink({
-        conversationMemory: { enabled: false },
-    });
+    const SUMMARIZER_INIT_TIMEOUT = 15_000;
+    const SUMMARIZER_GENERATE_TIMEOUT = 60_000;
     try {
+        if (!cachedSummarizer) {
+            cachedSummarizer = await withTimeout((async () => {
+                const { NeuroLink: NeuroLinkClass } = await import("../neurolink.js");
+                return new NeuroLinkClass({
+                    conversationMemory: { enabled: false },
+                });
+            })(), SUMMARIZER_INIT_TIMEOUT, new Error("Summarizer initialization timed out"));
+        }
         if (!config.summarizationProvider || !config.summarizationModel) {
             logger.error(`${logPrefix} Missing summarization provider`, {
                 requestId,
             });
             return null;
         }
-        const summaryResult = await summarizer.generate({
+        const summaryResult = await withTimeout(cachedSummarizer.generate({
             input: { text: summarizationPrompt },
             provider: config.summarizationProvider,
             model: config.summarizationModel,
             disableTools: true,
-        });
+        }), SUMMARIZER_GENERATE_TIMEOUT, new Error("Summary generation timed out"));
         return summaryResult.content || null;
     }
     catch (error) {

package/dist/utils/logger.d.ts

@@ -63,6 +63,11 @@ declare class NeuroLinkLogger {
      * @returns Formatted prefix string like "[2025-08-18T13:45:30.123Z] [NEUROLINK:ERROR]"
      */
     private getLogPrefix;
+    /**
+     * Extracts current OTel trace context (trace_id, span_id) if available.
+     * Returns empty object if OTel is not initialized or no active span exists.
+     */
+    private getTraceContext;
     /**
      * Safely serialize data to fully expanded JSON string.
      * Handles circular references and non-serializable values.

package/dist/utils/logger.js

@@ -13,6 +13,22 @@
  * - Structured data support for complex objects
  * - Tabular data display
  */
+// OTel trace context for log correlation (optional — gracefully no-ops if OTel not initialized)
+let traceApi = null;
+let traceApiPromise = null;
+async function getTraceApi() {
+    if (!traceApiPromise) {
+        traceApiPromise = import("@opentelemetry/api")
+            .then((mod) => {
+            traceApi = mod;
+            return mod;
+        })
+            .catch(() => null);
+    }
+    return traceApiPromise;
+}
+// Eagerly kick off the import so the cached value is available for synchronous callers
+void getTraceApi();
 // Pre-computed uppercase log levels for performance optimization
 const UPPERCASE_LOG_LEVELS = {
     debug: "DEBUG",
@@ -95,6 +111,34 @@ class NeuroLinkLogger {
     getLogPrefix(timestamp, level) {
         return `[${timestamp}] [NEUROLINK:${UPPERCASE_LOG_LEVELS[level]}]`;
     }
+    /**
+     * Extracts current OTel trace context (trace_id, span_id) if available.
+     * Returns empty object if OTel is not initialized or no active span exists.
+     */
+    getTraceContext() {
+        if (!traceApi) {
+            return {};
+        }
+        try {
+            const span = traceApi.trace.getSpan(traceApi.context.active());
+            if (!span) {
+                return {};
+            }
+            const spanContext = span.spanContext();
+            if (!spanContext ||
+                spanContext.traceId === "00000000000000000000000000000000") {
+                return {};
+            }
+            return {
+                trace_id: spanContext.traceId,
+                span_id: spanContext.spanId,
+                trace_flags: String(spanContext.traceFlags),
+            };
+        }
+        catch {
+            return {};
+        }
+    }
     /**
      * Safely serialize data to fully expanded JSON string.
      * Handles circular references and non-serializable values.
@@ -163,11 +207,15 @@ class NeuroLinkLogger {
             warn: console.warn,
             error: console.error,
         }[level];
+        const traceCtx = this.getTraceContext();
+        const tracePrefix = traceCtx.trace_id
+            ? ` [trace_id=${traceCtx.trace_id} span_id=${traceCtx.span_id}]`
+            : "";
         if (data !== undefined && data !== null) {
-            logMethod(prefix, message, this.serializeData(data));
+            logMethod(prefix + tracePrefix, message, this.serializeData(data));
         }
         else {
-            logMethod(prefix, message);
+            logMethod(prefix + tracePrefix, message);
         }
     }
     /**

package/dist/utils/messageBuilder.js

@@ -436,56 +436,28 @@ function shouldUseStructuredOutput(options) {
 }
 /**
  * Log structural metadata about a composed message array without logging content.
- * Per-message breakdown is behind logger.debug() to avoid production spam.
+ * Only logs a compact summary (role counts, total chars, estimated tokens).
+ * Per-message breakdown is intentionally omitted to avoid log noise
+ * (~600 lines per retry cascade with many messages).
  */
 function logMessageComposition(messages, requestId) {
-    // Skip entirely if neither info nor debug is enabled
-    if (!logger.shouldLog("info")) {
+    if (!logger.shouldLog("debug")) {
         return;
     }
     const roles = {};
     let totalChars = 0;
     for (const msg of messages) {
-        // Avoid JSON.stringify on multimodal content for the info-level summary;
-        // accurate per-message breakdown (with sizes) is computed only when debug
-        // logging is active (see below).
         const chars = typeof msg.content === "string" ? msg.content.length : 0;
         roles[msg.role] = (roles[msg.role] || 0) + 1;
         totalChars += chars;
     }
-    logger.info("[MessageBuilder] Composed", {
+    logger.debug("[MessageBuilder] Composed", {
         requestId,
         totalMessages: messages.length,
         roles,
         totalChars,
         estimatedTokens: Math.ceil(totalChars / 4),
     });
-    if (logger.shouldLog("debug")) {
-        const breakdown = messages.map((msg, i) => {
-            let chars;
-            if (typeof msg.content === "string") {
-                chars = msg.content.length;
-            }
-            else {
-                try {
-                    chars = JSON.stringify(msg.content).length;
-                }
-                catch {
-                    chars = String(msg.content).length;
-                }
-            }
-            return {
-                index: i,
-                role: msg.role,
-                chars,
-                estimatedTokens: Math.ceil(chars / 4),
-            };
-        });
-        logger.debug("[MessageBuilder] Per-message breakdown", {
-            requestId,
-            breakdown,
-        });
-    }
 }
 /**
  * Build a properly formatted message array for AI providers
@@ -663,10 +635,11 @@ function enforceFileBudget(options, provider, model) {
         fileType: f.fileType,
     })), availableTokens);
     if (budgetResult.excluded.length > 0) {
-        const includedNames = new Set(budgetResult.included.map((f) => f.name));
+        const includedIndices = new Set(budgetResult.included.map((f) => {
+            return budgetFiles.findIndex((bf) => bf.name === f.name);
+        }));
         options.input.files = options.input.files.filter((_file, idx) => {
-            const entry = budgetFiles[idx];
-            return includedNames.has(entry.name);
+            return includedIndices.has(idx);
         });
         options.input.text =
             (options.input.text || "") + "\n\n" + budgetResult.notices.join("\n");
@@ -1071,12 +1044,19 @@ export async function buildMultimodalMessagesArray(options, provider, model) {
     // Add conversation history if available
     const hasConversationHistory = options.conversationHistory && options.conversationHistory.length > 0;
     if (hasConversationHistory && options.conversationHistory) {
-        options.conversationHistory.forEach((msg) => {
-            messages.push({
-                role: msg.role,
-                content: msg.content,
-            });
-        });
+        for (const msg of options.conversationHistory) {
+            // Filter out tool_call and tool_result roles — only user/assistant/system are valid for AI providers
+            if (msg.role === "user" ||
+                msg.role === "assistant" ||
+                msg.role === "system") {
+                const providerOptions = msg.providerOptions;
+                messages.push({
+                    role: msg.role,
+                    content: msg.content,
+                    ...(providerOptions && { providerOptions }),
+                });
+            }
+        }
     }
     // Handle multimodal content
     try {

package/dist/utils/modelDetection.js

@@ -11,7 +11,7 @@ export function isGemini3Model(modelName) {
     if (!isValidModelName(modelName)) {
         return false;
     }
-    return /^gemini-3(-.*)?$/i.test(modelName);
+    return /^gemini-3(\.\d+)?(-.*)?$/i.test(modelName);
 }
 export function isGemini25Model(modelName) {
     if (!isValidModelName(modelName)) {
@@ -46,10 +46,10 @@ export function getMaxThinkingBudgetTokens(modelName) {
     if (!isValidModelName(modelName)) {
         return 10000;
     }
-    if (/^gemini-3-pro/i.test(modelName)) {
+    if (/^gemini-3(\.\d+)?-pro/i.test(modelName)) {
         return 100000;
     }
-    if (/^gemini-3-flash/i.test(modelName)) {
+    if (/^gemini-3(\.\d+)?-flash/i.test(modelName)) {
         return 50000;
     }
     if (/^gemini-2\.5/i.test(modelName)) {

package/dist/utils/providerConfig.d.ts

@@ -3,14 +3,22 @@
  * Consolidated configuration helpers for all AI providers
  * Eliminates duplicate error messages and configuration logic
  * Enhanced with format validation and advanced error classification
+ * Extended with Claude subscription OAuth support
  */
 import type { APIValidationResult } from "../types/utilities.js";
 import type { ProviderConfigOptions } from "../types/providers.js";
+import type { AnthropicAuthMethod, ClaudeSubscriptionTier, AnthropicAuthConfig, AnthropicAuthConfigResult } from "../types/subscriptionTypes.js";
+export type { AnthropicAuthMethod, ClaudeSubscriptionTier, AnthropicAuthConfig, OAuthToken, AnthropicAuthConfigResult, } from "../types/subscriptionTypes.js";
 /**
  * API key format validation patterns (extracted from advanced validation system)
  * Exported for use across the codebase to replace scattered regex patterns
  */
 export declare const API_KEY_FORMATS: Record<string, RegExp>;
+/**
+ * OAuth token format validation patterns
+ * These patterns are more flexible as OAuth tokens can vary by provider
+ */
+export declare const OAUTH_TOKEN_FORMATS: Record<string, RegExp>;
 /**
  * API key length constants to replace scattered magic numbers
  */
@@ -67,6 +75,7 @@ export declare function getProviderModel(envVar: string, defaultModel: string):
 export declare function hasProviderCredentials(envVars: string[]): boolean;
 /**
  * Creates Anthropic provider configuration
+ * Supports both API key and OAuth authentication methods
  */
 export declare function createAnthropicConfig(): ProviderConfigOptions;
 /**
@@ -126,3 +135,161 @@ export declare function getAWSSessionToken(): string | undefined;
  * Checks if HuggingFace credentials are available
  */
 export declare function hasHuggingFaceCredentials(): boolean;
+/**
+ * Gets the configured Anthropic authentication method
+ * Defaults to "api_key" for backward compatibility
+ * @returns The configured authentication method
+ */
+export declare function getAnthropicAuthMethod(): AnthropicAuthMethod;
+/**
+ * Gets the configured Claude subscription tier
+ * Defaults to "api" for backward compatibility (API key users)
+ * @returns The configured subscription tier
+ */
+export declare function getAnthropicSubscriptionTier(): ClaudeSubscriptionTier;
+/**
+ * Validates OAuth access token format
+ * @param token The token to validate
+ * @returns True if the token format is valid
+ */
+export declare function validateOAuthAccessToken(token: string): boolean;
+/**
+ * Validates OAuth refresh token format
+ * @param token The token to validate
+ * @returns True if the token format is valid
+ */
+export declare function validateOAuthRefreshToken(token: string): boolean;
+/**
+ * Detects the best available authentication method for Anthropic
+ * Checks environment variables and returns the most appropriate auth configuration
+ * @returns Complete authentication configuration
+ */
+export declare function detectAnthropicAuth(): AnthropicAuthConfigResult;
+/**
+ * Checks if Anthropic credentials are available (either API key or OAuth)
+ * @returns True if any valid authentication is configured
+ */
+export declare function hasAnthropicCredentials(): boolean;
+/**
+ * Gets the authentication token or key for Anthropic API calls
+ * Returns the appropriate credential based on configured auth method
+ * @returns The API key or OAuth access token, or undefined if not configured
+ */
+export declare function getAnthropicCredential(): string | undefined;
+/**
+ * Checks if OAuth refresh is needed based on token state
+ * This is a placeholder for actual token expiration checking
+ * @returns True if refresh is needed
+ */
+export declare function needsOAuthRefresh(): boolean;
+/**
+ * Gets subscription tier limits for informational purposes
+ * These are approximate limits and may change
+ * @param tier The subscription tier
+ * @returns Object with tier limit information
+ */
+export declare function getSubscriptionTierLimits(tier: ClaudeSubscriptionTier): {
+    messagesPerDay: number | "unlimited";
+    contextWindow: number;
+    priorityAccess: boolean;
+    description: string;
+};
+/**
+ * Environment variables for Anthropic/Claude subscription configuration
+ * These control authentication method, subscription tier, and feature flags
+ */
+export declare const ANTHROPIC_ENV_VARS: {
+    /** Authentication method: "api_key" or "oauth" */
+    readonly AUTH_METHOD: "ANTHROPIC_AUTH_METHOD";
+    /** Subscription tier: "free", "pro", "max", "max_5", "max_20", or "api" */
+    readonly SUBSCRIPTION_TIER: "ANTHROPIC_SUBSCRIPTION_TIER";
+    /** Enable beta features: "true" or "false" */
+    readonly ENABLE_BETA_FEATURES: "ANTHROPIC_ENABLE_BETA_FEATURES";
+    /** API key for api_key authentication */
+    readonly API_KEY: "ANTHROPIC_API_KEY";
+    /** OAuth access token for oauth authentication (canonical, with BC fallbacks) */
+    readonly OAUTH_ACCESS_TOKEN: "ANTHROPIC_OAUTH_TOKEN";
+    /** OAuth refresh token for oauth authentication */
+    readonly OAUTH_REFRESH_TOKEN: "ANTHROPIC_OAUTH_REFRESH_TOKEN";
+    /** OAuth token expiry timestamp (Unix epoch in seconds) */
+    readonly OAUTH_TOKEN_EXPIRY: "ANTHROPIC_OAUTH_TOKEN_EXPIRY";
+};
+/**
+ * Valid subscription tier values for validation
+ */
+export declare const VALID_SUBSCRIPTION_TIERS: readonly ClaudeSubscriptionTier[];
+/**
+ * Valid authentication method values for validation
+ */
+export declare const VALID_AUTH_METHODS: readonly AnthropicAuthMethod[];
+/**
+ * Validates a subscription tier value
+ * @param tier The tier value to validate
+ * @returns True if the tier is valid, false otherwise
+ */
+export declare function isValidSubscriptionTier(tier: string | undefined): tier is ClaudeSubscriptionTier;
+/**
+ * Validates an authentication method value
+ * @param method The method value to validate
+ * @returns True if the method is valid, false otherwise
+ */
+export declare function isValidAuthMethod(method: string | undefined): method is AnthropicAuthMethod;
+/**
+ * Validates subscription tier and returns a detailed result
+ * @param tier The tier value to validate
+ * @returns Validation result with error details if invalid
+ */
+export declare function validateSubscriptionTier(tier: string | undefined): {
+    isValid: boolean;
+    tier?: ClaudeSubscriptionTier;
+    error?: string;
+};
+/**
+ * Gets the complete Anthropic authentication configuration
+ * Detects auth method from environment or config and loads appropriate credentials
+ *
+ * @returns Complete AnthropicAuthConfig with method, credentials, and tier
+ */
+export declare function getAnthropicAuthConfig(): AnthropicAuthConfig;
+/**
+ * Detects the subscription tier from environment variables or config
+ * Checks environment variable first, then config, defaults to "api" if using API key
+ *
+ * @returns The detected subscription tier
+ */
+export declare function detectSubscriptionTier(): ClaudeSubscriptionTier;
+/**
+ * Determines whether beta features should be enabled
+ * Checks environment/config and defaults based on authentication method
+ *
+ * @returns True if beta features should be enabled
+ */
+export declare function shouldEnableBetaFeatures(): boolean;
+/**
+ * Gets complete subscription configuration including auth, tier, and features
+ * Combines all configuration sources into a unified config object
+ *
+ * @returns Complete subscription configuration
+ */
+export declare function getAnthropicSubscriptionConfig(): {
+    auth: AnthropicAuthConfig;
+    tier: ClaudeSubscriptionTier;
+    betaFeaturesEnabled: boolean;
+    limits: ReturnType<typeof getSubscriptionTierLimits>;
+    isConfigured: boolean;
+    error?: string;
+};
+/**
+ * Checks if the current subscription tier has access to a specific feature
+ * @param feature The feature to check
+ * @param currentTier The current subscription tier (optional, auto-detects if not provided)
+ * @returns True if the tier has access to the feature
+ */
+export declare function hasSubscriptionFeature(feature: "extended_thinking" | "priority_access" | "vision" | "file_analysis" | "mcp_tools" | "computer_use" | "web_search", currentTier?: ClaudeSubscriptionTier): boolean;
+/**
+ * Gets a human-readable description of the current authentication configuration
+ * Useful for debugging and user feedback
+ *
+ * @returns Human-readable configuration description
+ */
+export declare function describeAnthropicConfig(): string;