@juspay/neurolink 9.14.0 → 9.16.0

package/dist/factories/providerRegistry.d.ts

@@ -5,11 +5,16 @@ import type { ProviderRegistryOptions } from "../types/index.js";
  */
 export declare class ProviderRegistry {
     private static registered;
+    private static registrationPromise;
     private static options;
     /**
      * Register all providers with the factory
      */
     static registerAllProviders(): Promise<void>;
+    /**
+     * Internal registration implementation
+     */
+    private static _doRegister;
     /**
      * Check if providers are registered
      */

package/dist/factories/providerRegistry.js

@@ -7,6 +7,7 @@ import { AIProviderName, GoogleAIModels, OpenAIModels, AnthropicModels, VertexMo
  */
 export class ProviderRegistry {
     static registered = false;
+    static registrationPromise = null;
     static options = {
         enableManualMCP: false, // Default to disabled for safety
     };
@@ -17,6 +18,22 @@ export class ProviderRegistry {
         if (this.registered) {
             return;
         }
+        if (this.registrationPromise) {
+            return this.registrationPromise;
+        }
+        this.registrationPromise = this._doRegister();
+        try {
+            await this.registrationPromise;
+        }
+        catch (error) {
+            this.registrationPromise = null; // Allow retry on failure
+            throw error;
+        }
+    }
+    /**
+     * Internal registration implementation
+     */
+    static async _doRegister() {
         try {
             // Register providers with dynamic import factory functions
             const { ProviderFactory } = await import("./providerFactory.js");
@@ -34,7 +51,7 @@ export class ProviderRegistry {
             ProviderFactory.registerProvider(AIProviderName.ANTHROPIC, async (modelName, _providerName, sdk) => {
                 const { AnthropicProvider } = await import("../providers/anthropic.js");
                 return new AnthropicProvider(modelName, sdk);
-            }, AnthropicModels.CLAUDE_SONNET_4_0, ["claude", "anthropic"]);
+            }, AnthropicModels.CLAUDE_SONNET_4_6, ["claude", "anthropic"]);
             // Register Amazon Bedrock provider
             ProviderFactory.registerProvider(AIProviderName.BEDROCK, async (modelName, _providerName, sdk, region) => {
                 const { AmazonBedrockProvider } = await import("../providers/amazonBedrock.js");
@@ -54,7 +71,7 @@ export class ProviderRegistry {
             ProviderFactory.registerProvider(AIProviderName.VERTEX, async (modelName, providerName, sdk, region) => {
                 const { GoogleVertexProvider } = await import("../providers/googleVertex.js");
                 return new GoogleVertexProvider(modelName, providerName, sdk, region);
-            }, VertexModels.CLAUDE_4_0_SONNET, ["vertex", "googleVertex"]);
+            }, VertexModels.CLAUDE_4_6_SONNET, ["vertex", "googleVertex"]);
             // Register Hugging Face provider (Unified Router implementation)
             ProviderFactory.registerProvider(AIProviderName.HUGGINGFACE, async (modelName) => {
                 const { HuggingFaceProvider } = await import("../providers/huggingFace.js");
@@ -130,6 +147,7 @@ export class ProviderRegistry {
     static clearRegistrations() {
         ProviderFactory.clearRegistrations();
         this.registered = false;
+        this.registrationPromise = null;
     }
     /**
      * Set registry options (should be called before initialization)

package/dist/index.d.ts

@@ -49,9 +49,9 @@ export { NeuroLink };
 export type { MCPServerInfo } from "./types/mcpTypes.js";
 export type { LangfuseConfig, LangfuseSpanAttributes, ObservabilityConfig, OpenTelemetryConfig, TraceNameFormat, } from "./types/observability.js";
 export { buildObservabilityConfigFromEnv } from "./utils/observabilityHelpers.js";
-import { createContextEnricher, flushOpenTelemetry, getLangfuseContext, getLangfuseHealthStatus, getLangfuseSpanProcessor, getSpanProcessors, getTracer, getTracerProvider, initializeOpenTelemetry, isOpenTelemetryInitialized, isUsingExternalTracerProvider, setLangfuseContext, shutdownOpenTelemetry } from "./services/server/ai/observability/instrumentation.js";
+import { createContextEnricher, flushOpenTelemetry, getLangfuseContext, getLangfuseHealthStatus, getLangfuseSpanProcessor, getSpanProcessors, getTracer, getTracerProvider, initializeOpenTelemetry, isOpenTelemetryInitialized, isUsingExternalTracerProvider, runWithCurrentLangfuseContext, setLangfuseContext, shutdownOpenTelemetry } from "./services/server/ai/observability/instrumentation.js";
 export type { LangfuseContext } from "./services/server/ai/observability/instrumentation.js";
-export { initializeOpenTelemetry, shutdownOpenTelemetry, flushOpenTelemetry, getLangfuseHealthStatus, setLangfuseContext, getLangfuseSpanProcessor, getTracerProvider, isOpenTelemetryInitialized, getSpanProcessors, createContextEnricher, isUsingExternalTracerProvider, getLangfuseContext, getTracer, };
+export { initializeOpenTelemetry, shutdownOpenTelemetry, flushOpenTelemetry, getLangfuseHealthStatus, setLangfuseContext, getLangfuseSpanProcessor, getTracerProvider, isOpenTelemetryInitialized, getSpanProcessors, createContextEnricher, isUsingExternalTracerProvider, getLangfuseContext, getTracer, runWithCurrentLangfuseContext, };
 export { clearAnalyticsMetrics, createAnalyticsMiddleware, getAnalyticsMetrics, } from "./middleware/builtin/analytics.js";
 export { MiddlewareFactory } from "./middleware/factory.js";
 export type { MiddlewareConfig, MiddlewareContext, MiddlewareFactoryOptions, MiddlewarePreset, NeuroLinkMiddleware, } from "./types/middlewareTypes.js";
@@ -192,7 +192,7 @@ export declare function createBestAIProvider(requestedProvider?: string, modelNa
  * ```
  */
 export { CircuitBreakerManager, calculateExpiresAt, createMCPServer, createOAuthProviderFromConfig, DEFAULT_HTTP_RETRY_CONFIG, DEFAULT_RATE_LIMIT_CONFIG, executeMCP, FileTokenStorage, getMCPStats, getServerInfo, globalCircuitBreakerManager, globalRateLimiterManager, HTTPRateLimiter, InMemoryTokenStorage, initializeMCPEcosystem, isRetryableHTTPError, isRetryableStatusCode, isTokenExpired, listMCPs, MCPCircuitBreaker, mcpLogger, NeuroLinkOAuthProvider, RateLimiterManager, validateServerTools, validateTool as validateMCPTool, withHTTPRetry, } from "./mcp/index.js";
-export type { AuthorizationUrlResult, DiscoveredMcp, HTTPRetryConfig, MCPOAuthConfig, McpMetadata, OAuthClientInformation, OAuthTokens, RateLimitConfig, TokenExchangeRequest, TokenStorage, } from "./types/mcpTypes.js";
+export type { AuthorizationUrlResult, DiscoveredMcp, HTTPRetryConfig, MCPOAuthConfig, McpMetadata, OAuthClientInformation, OAuthTokens as McpOAuthTokens, RateLimitConfig, TokenExchangeRequest, TokenStorage, } from "./types/mcpTypes.js";
 export type { ExecutionContext, ToolExecutionResult, ToolInfo, } from "./types/tools.js";
 export type { LogLevel } from "./types/utilities.js";
 export { logger } from "./utils/logger.js";

package/dist/index.js

@@ -60,13 +60,15 @@ import { createContextEnricher, flushOpenTelemetry,
 // Enhanced context and tracing
 getLangfuseContext, getLangfuseHealthStatus, getLangfuseSpanProcessor, 
 // NEW EXPORTS - External TracerProvider Support
-getSpanProcessors, getTracer, getTracerProvider, initializeOpenTelemetry, isOpenTelemetryInitialized, isUsingExternalTracerProvider, setLangfuseContext, shutdownOpenTelemetry, } from "./services/server/ai/observability/instrumentation.js";
+getSpanProcessors, getTracer, getTracerProvider, initializeOpenTelemetry, isOpenTelemetryInitialized, isUsingExternalTracerProvider, runWithCurrentLangfuseContext, setLangfuseContext, shutdownOpenTelemetry, } from "./services/server/ai/observability/instrumentation.js";
 import { getTelemetryStatus as getStatus, initializeTelemetry as init, } from "./telemetry/index.js";
 export { initializeOpenTelemetry, shutdownOpenTelemetry, flushOpenTelemetry, getLangfuseHealthStatus, setLangfuseContext, getLangfuseSpanProcessor, getTracerProvider, isOpenTelemetryInitialized, 
 // NEW EXPORTS - External TracerProvider Support
 getSpanProcessors, createContextEnricher, isUsingExternalTracerProvider, 
 // Enhanced context and tracing
-getLangfuseContext, getTracer, };
+getLangfuseContext, getTracer, 
+// ALS context propagation helper
+runWithCurrentLangfuseContext, };
 // Analytics Middleware exports
 export { clearAnalyticsMetrics, createAnalyticsMiddleware, getAnalyticsMetrics, } from "./middleware/builtin/analytics.js";
 export { MiddlewareFactory } from "./middleware/factory.js";

package/dist/lib/adapters/video/videoAnalyzer.d.ts

@@ -1,7 +1,7 @@
 /**
  * Video Analysis Handler
  *
- * Provides video analysis using Google's Gemini 2.0 Flash model.
+ * Provides video analysis using Google's Gemini 2.5 Flash model.
  * Supports both Vertex AI and Gemini API providers.
  *
  * @module adapters/video/geminiVideoAnalyzer

package/dist/lib/adapters/video/videoAnalyzer.js

@@ -1,7 +1,7 @@
 /**
  * Video Analysis Handler
  *
- * Provides video analysis using Google's Gemini 2.0 Flash model.
+ * Provides video analysis using Google's Gemini 2.5 Flash model.
  * Supports both Vertex AI and Gemini API providers.
  *
  * @module adapters/video/geminiVideoAnalyzer
@@ -13,7 +13,7 @@ import { NeuroLinkError, ErrorFactory } from "../../utils/errorHandling.js";
 // ---------------------------------------------------------------------------
 // Shared config
 // ---------------------------------------------------------------------------
-const DEFAULT_MODEL = "gemini-2.0-flash";
+const DEFAULT_MODEL = "gemini-2.5-flash";
 const DEFAULT_LOCATION = "us-central1";
 /**
  * Extract content items from user messages
@@ -223,15 +223,17 @@ async function getVertexConfig() {
 }
 export async function analyzeVideo(messages, options = {}) {
     const provider = options.provider || AIProviderName.AUTO;
-    // Vertex — only when GOOGLE_VERTEX_PROJECT is explicitly set
-    if (provider === AIProviderName.VERTEX || provider === AIProviderName.AUTO) {
+    // Vertex — only when Vertex credentials are configured
+    if (provider === AIProviderName.VERTEX ||
+        (provider === AIProviderName.AUTO &&
+            (process.env.GOOGLE_VERTEX_PROJECT || process.env.GOOGLE_CLOUD_PROJECT))) {
         return analyzeVideoWithVertexAI(messages, options);
     }
-    // Gemini API — when GOOGLE_AI_API_KEY is set
-    if (provider === AIProviderName.GOOGLE_AI && process.env.GOOGLE_AI_API_KEY) {
+    // Gemini API — when Google AI API key is available
+    if (provider === AIProviderName.GOOGLE_AI ||
+        (provider === AIProviderName.AUTO && process.env.GOOGLE_AI_API_KEY)) {
         return analyzeVideoWithGeminiAPI(messages, options);
     }
-    throw new Error("No valid provider configuration found. " +
-        "Set GOOGLE_VERTEX_PROJECT for Vertex AI or GOOGLE_AI_API_KEY for Gemini API.");
+    throw ErrorFactory.invalidConfiguration("video analysis provider", "No valid provider configuration found. Set GOOGLE_VERTEX_PROJECT for Vertex AI or GOOGLE_AI_API_KEY for Gemini API.");
 }
 //# sourceMappingURL=videoAnalyzer.js.map

package/dist/lib/auth/anthropicOAuth.d.ts

@@ -0,0 +1,377 @@
+/**
+ * Anthropic OAuth 2.0 Authentication for Claude Pro/Max Subscriptions
+ *
+ * This module implements OAuth 2.0 flow with PKCE support for authenticating
+ * Claude Pro and Max subscription users through console.anthropic.com.
+ *
+ * OAuth Flow:
+ * 1. Generate PKCE code verifier and challenge
+ * 2. User is redirected to Anthropic authorization URL
+ * 3. User authenticates and grants permissions
+ * 4. Callback receives authorization code
+ * 5. Code is exchanged for access and refresh tokens
+ * 6. Tokens are used for API authentication
+ *
+ * @module auth/anthropicOAuth
+ */
+import type { Server } from "http";
+export { OAuthError, OAuthConfigurationError, OAuthTokenExchangeError, OAuthTokenRefreshError, OAuthTokenValidationError, OAuthTokenRevocationError, OAuthCallbackServerError, } from "../types/errors.js";
+/**
+ * Claude Code's official OAuth client ID
+ * Used to authenticate with Anthropic's OAuth system
+ */
+export declare const CLAUDE_CODE_CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
+/**
+ * Anthropic OAuth authorization URL for Claude Pro/Max
+ */
+export declare const ANTHROPIC_AUTH_URL = "https://claude.ai/oauth/authorize";
+/**
+ * Anthropic OAuth token endpoint
+ */
+export declare const ANTHROPIC_TOKEN_URL = "https://console.anthropic.com/v1/oauth/token";
+/**
+ * Anthropic OAuth redirect URI (official callback)
+ */
+export declare const ANTHROPIC_REDIRECT_URI = "https://console.anthropic.com/oauth/code/callback";
+/**
+ * Default OAuth scopes for Claude subscription access
+ */
+export declare const DEFAULT_SCOPES: readonly string[];
+/**
+ * User-Agent string to spoof Claude CLI
+ */
+export declare const CLAUDE_CLI_USER_AGENT = "claude-cli/2.1.2 (external, cli)";
+/**
+ * Required beta headers for OAuth API requests.
+ * The "oauth-2025-04-20" header is CRITICAL for OAuth authentication.
+ * The "interleaved-thinking-2025-05-14" enables extended thinking.
+ */
+export declare const OAUTH_BETA_HEADERS = "oauth-2025-04-20,interleaved-thinking-2025-05-14";
+/**
+ * Tool name prefix required for OAuth API requests
+ */
+export declare const MCP_TOOL_PREFIX = "mcp_";
+/**
+ * @deprecated Use ANTHROPIC_AUTH_URL instead
+ */
+export declare const ANTHROPIC_OAUTH_BASE_URL = "https://console.anthropic.com/oauth";
+/**
+ * @deprecated Use ANTHROPIC_REDIRECT_URI instead
+ */
+export declare const DEFAULT_REDIRECT_URI = "https://console.anthropic.com/oauth/code/callback";
+/**
+ * Default local callback server port (for local testing only)
+ */
+export declare const DEFAULT_CALLBACK_PORT = 8787;
+import type { OAuthFlowTokens, TokenValidationResult, AnthropicOAuthConfig, PKCEParams, CallbackResult } from "../types/subscriptionTypes.js";
+export type { OAuthTokenResponse, OAuthFlowTokens, OAuthFlowTokens as OAuthTokens, TokenValidationResult, AnthropicOAuthConfig, PKCEParams, CallbackResult, } from "../types/subscriptionTypes.js";
+/**
+ * AnthropicOAuth - OAuth 2.0 authentication for Claude Pro/Max subscriptions
+ *
+ * Implements OAuth 2.0 authorization code flow with PKCE support for
+ * authenticating users with Claude Pro or Max subscriptions.
+ *
+ * @example
+ * ```typescript
+ * const oauth = new AnthropicOAuth({
+ *   clientId: "your-client-id",
+ *   redirectUri: "http://localhost:8787/callback",
+ * });
+ *
+ * // Generate PKCE parameters
+ * const codeVerifier = AnthropicOAuth.generateCodeVerifier();
+ * const codeChallenge = await AnthropicOAuth.generateCodeChallenge(codeVerifier);
+ *
+ * // Generate auth URL
+ * const authUrl = oauth.generateAuthUrl({
+ *   codeChallenge,
+ *   state: "random-state",
+ * });
+ *
+ * // After user authenticates, exchange code for tokens
+ * const tokens = await oauth.exchangeCodeForTokens(code, codeVerifier);
+ * ```
+ */
+export declare class AnthropicOAuth {
+    private readonly clientId;
+    private readonly clientSecret?;
+    private readonly redirectUri;
+    private readonly scopes;
+    private readonly authorizationUrl;
+    private readonly tokenUrl;
+    private readonly validationUrl;
+    private readonly revocationUrl;
+    constructor(config?: AnthropicOAuthConfig);
+    /**
+     * Generates a cryptographically secure code verifier for PKCE
+     *
+     * The code verifier is a high-entropy random string between 43-128 characters
+     * using URL-safe characters (A-Z, a-z, 0-9, "-", ".", "_", "~").
+     *
+     * @returns A random code verifier string (64 characters)
+     *
+     * @example
+     * ```typescript
+     * const codeVerifier = AnthropicOAuth.generateCodeVerifier();
+     * // Returns something like "dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk"
+     * ```
+     */
+    static generateCodeVerifier(): string;
+    /**
+     * Generates a PKCE code challenge from a code verifier
+     *
+     * Uses SHA-256 hashing as per RFC 7636. The challenge is the
+     * base64url-encoded SHA-256 hash of the code verifier.
+     *
+     * @param verifier - The code verifier to generate challenge from
+     * @returns Promise resolving to the code challenge string
+     *
+     * @example
+     * ```typescript
+     * const verifier = AnthropicOAuth.generateCodeVerifier();
+     * const challenge = await AnthropicOAuth.generateCodeChallenge(verifier);
+     * ```
+     */
+    static generateCodeChallenge(verifier: string): Promise<string>;
+    /**
+     * Generates both code verifier and challenge for PKCE
+     *
+     * Convenience method that generates both PKCE parameters at once.
+     *
+     * @returns Promise resolving to PKCE parameters object
+     *
+     * @example
+     * ```typescript
+     * const pkce = await AnthropicOAuth.generatePKCE();
+     * console.log(pkce.codeVerifier);
+     * console.log(pkce.codeChallenge);
+     * ```
+     */
+    static generatePKCE(): Promise<PKCEParams>;
+    /**
+     * Generates the OAuth authorization URL with PKCE support
+     *
+     * Builds the complete authorization URL including all required parameters
+     * for the OAuth 2.0 authorization code flow with PKCE.
+     *
+     * @param config - Authorization URL configuration
+     * @param state - Optional state parameter for CSRF protection
+     * @returns The complete authorization URL
+     *
+     * @example
+     * ```typescript
+     * const pkce = await AnthropicOAuth.generatePKCE();
+     * const authUrl = oauth.generateAuthUrl({
+     *   codeChallenge: pkce.codeChallenge,
+     *   state: crypto.randomUUID(),
+     * });
+     * // Redirect user to authUrl
+     * ```
+     */
+    generateAuthUrl(config?: {
+        /** PKCE code challenge (required for public clients) */
+        codeChallenge?: string;
+        /** Additional URL parameters */
+        additionalParams?: Record<string, string>;
+    }, state?: string): string;
+    /**
+     * Exchanges an authorization code for access and refresh tokens
+     *
+     * Performs the token exchange step of the OAuth flow. For public clients
+     * using PKCE, the code verifier must be provided.
+     *
+     * @param code - The authorization code from the OAuth callback
+     * @param codeVerifier - The PKCE code verifier used to generate the challenge
+     * @param config - Optional additional configuration
+     * @returns Promise resolving to the parsed OAuth tokens
+     * @throws OAuthTokenExchangeError if the exchange fails
+     *
+     * @example
+     * ```typescript
+     * const tokens = await oauth.exchangeCodeForTokens(
+     *   authorizationCode,
+     *   pkce.codeVerifier
+     * );
+     * console.log("Access token:", tokens.accessToken);
+     * console.log("Expires at:", tokens.expiresAt);
+     * ```
+     */
+    exchangeCodeForTokens(code: string, codeVerifier: string, config?: AnthropicOAuthConfig): Promise<OAuthFlowTokens>;
+    /**
+     * Refreshes an expired access token using a refresh token
+     *
+     * @param refreshToken - The refresh token from a previous authentication
+     * @param config - Optional configuration overrides
+     * @returns Promise resolving to new OAuth tokens
+     * @throws OAuthTokenRefreshError if the refresh fails
+     *
+     * @example
+     * ```typescript
+     * if (AnthropicOAuth.isTokenExpired(tokens.expiresAt)) {
+     *   const newTokens = await oauth.refreshAccessToken(tokens.refreshToken);
+     *   console.log("New access token:", newTokens.accessToken);
+     * }
+     * ```
+     */
+    refreshAccessToken(refreshToken: string, config?: AnthropicOAuthConfig): Promise<OAuthFlowTokens>;
+    /**
+     * Validates an access token and returns token information
+     *
+     * Checks if the token is still valid by calling the validation endpoint.
+     * Returns user information if available.
+     *
+     * @param accessToken - The access token to validate
+     * @returns Promise resolving to validation result
+     *
+     * @example
+     * ```typescript
+     * const result = await oauth.validateToken(accessToken);
+     * if (result.isValid) {
+     *   console.log("Token is valid, expires in:", result.expiresIn, "seconds");
+     *   console.log("User email:", result.user?.email);
+     * } else {
+     *   console.log("Token is invalid:", result.error);
+     * }
+     * ```
+     */
+    validateToken(accessToken: string): Promise<boolean>;
+    /**
+     * Validates token and returns detailed information
+     *
+     * @param accessToken - The access token to validate
+     * @returns Promise resolving to detailed validation result
+     */
+    validateTokenWithDetails(accessToken: string): Promise<TokenValidationResult>;
+    /**
+     * Revokes an access token or refresh token
+     *
+     * @param token - The token to revoke
+     * @param tokenType - Type of token ("access_token" or "refresh_token")
+     * @returns Promise that resolves when revocation is complete
+     * @throws OAuthTokenRevocationError if revocation fails
+     */
+    revokeToken(token: string, tokenType?: "access_token" | "refresh_token"): Promise<void>;
+    /**
+     * Parses a token response into structured OAuthFlowTokens
+     */
+    private parseTokenResponse;
+    /**
+     * Generates a random state parameter for CSRF protection
+     */
+    private generateState;
+    /**
+     * Checks if a token is expired or about to expire
+     *
+     * @param expiresAt - Token expiration date
+     * @param bufferSeconds - Buffer time before actual expiration (default: 60 seconds)
+     * @returns True if token is expired or will expire within buffer time
+     */
+    static isTokenExpired(expiresAt: Date, bufferSeconds?: number): boolean;
+    /**
+     * Gets the configured client ID
+     */
+    getClientId(): string;
+    /**
+     * Gets the configured redirect URI
+     */
+    getRedirectUri(): string;
+    /**
+     * Gets the configured scopes
+     */
+    getScopes(): readonly string[];
+}
+/**
+ * Creates and starts a local HTTP server to receive OAuth callbacks
+ *
+ * This helper function starts a temporary HTTP server that listens for
+ * the OAuth callback and extracts the authorization code.
+ *
+ * @param port - Port to listen on (default: 8787)
+ * @param path - Path to listen on (default: "/callback")
+ * @param timeout - Timeout in milliseconds (default: 5 minutes)
+ * @returns Promise resolving to the callback result with authorization code
+ *
+ * @example
+ * ```typescript
+ * // Start callback server before redirecting user
+ * const callbackPromise = startCallbackServer();
+ *
+ * // Generate auth URL and redirect user
+ * const authUrl = oauth.generateAuthUrl({ codeChallenge });
+ * console.log("Please visit:", authUrl);
+ *
+ * // Wait for callback
+ * const result = await callbackPromise;
+ * console.log("Got authorization code:", result.code);
+ *
+ * // Exchange for tokens
+ * const tokens = await oauth.exchangeCodeForTokens(result.code, codeVerifier);
+ * ```
+ */
+export declare function startCallbackServer(port?: number, path?: string, timeout?: number): Promise<CallbackResult>;
+/**
+ * Stops the callback server if running
+ * Note: The server automatically stops after receiving a callback or timing out
+ */
+export declare function stopCallbackServer(server: Server): Promise<void>;
+/**
+ * Creates an AnthropicOAuth instance with default configuration from environment
+ *
+ * @param overrides - Optional configuration overrides
+ * @returns Configured AnthropicOAuth instance
+ *
+ * @example
+ * ```typescript
+ * const oauth = createAnthropicOAuth();
+ * const authUrl = oauth.generateAuthUrl({ codeChallenge });
+ * ```
+ */
+export declare function createAnthropicOAuth(overrides?: Partial<AnthropicOAuthConfig>): AnthropicOAuth;
+/**
+ * Anthropic OAuth configuration creator for providerConfig pattern
+ *
+ * @returns Provider configuration options for Anthropic OAuth
+ */
+export declare function createAnthropicOAuthConfig(): {
+    providerName: string;
+    envVarName: string;
+    setupUrl: string;
+    description: string;
+    instructions: string[];
+    fallbackEnvVars: never[];
+};
+/**
+ * Checks if Anthropic OAuth credentials are configured
+ *
+ * @returns True if OAuth client ID is available
+ */
+export declare function hasAnthropicOAuthCredentials(): boolean;
+/**
+ * Performs a complete OAuth flow including callback server
+ *
+ * This is a convenience function that handles the entire OAuth flow:
+ * 1. Generates PKCE parameters
+ * 2. Starts the callback server
+ * 3. Opens the browser (if possible)
+ * 4. Waits for the callback
+ * 5. Exchanges the code for tokens
+ *
+ * @param oauth - AnthropicOAuth instance
+ * @param options - Flow options
+ * @returns Promise resolving to OAuth tokens
+ *
+ * @example
+ * ```typescript
+ * const oauth = createAnthropicOAuth();
+ * const tokens = await performOAuthFlow(oauth);
+ * console.log("Authenticated! Token expires at:", tokens.expiresAt);
+ * ```
+ */
+export declare function performOAuthFlow(oauth: AnthropicOAuth, options?: {
+    /** Port for callback server (default: 8787) */
+    port?: number;
+    /** Timeout in milliseconds (default: 5 minutes) */
+    timeout?: number;
+    /** Whether to automatically open browser (default: true) */
+    openBrowser?: boolean;
+}): Promise<OAuthFlowTokens>;