@juspay/neurolink 9.14.0 → 9.16.0

package/dist/services/server/ai/observability/instrumentation.js

@@ -700,6 +700,45 @@ export async function setLangfuseContext(context, callback) {
 export function getLangfuseContext() {
     return contextStorage.getStore();
 }
+/**
+ * Capture the current Langfuse AsyncLocalStorage context and return a wrapper
+ * that re-enters that context when executing the provided callback.
+ *
+ * This is essential for preserving trace context across async boundaries that
+ * break the automatic ALS propagation chain, such as `setImmediate()`,
+ * `setTimeout()`, or event-emitter callbacks. Without this, spans created
+ * inside those callbacks become orphaned traces in Langfuse.
+ *
+ * **How it works:**
+ * 1. Captures the current ALS store at call time (synchronously).
+ * 2. Returns an async function that, when invoked, re-enters the captured
+ *    context via `contextStorage.run()` before executing the callback.
+ * 3. If no context exists at capture time, the callback runs without
+ *    ALS wrapping (no-op passthrough).
+ *
+ * @param fn - The async function to execute within the captured context
+ * @returns A new async function that preserves the Langfuse ALS context
+ *
+ * @example
+ * // Before (broken — setImmediate loses ALS context):
+ * setImmediate(async () => {
+ *   await this.checkAndSummarize(session, threshold);
+ * });
+ *
+ * // After (fixed — context is captured and re-entered):
+ * const wrappedFn = runWithCurrentLangfuseContext(async () => {
+ *   await this.checkAndSummarize(session, threshold);
+ * });
+ * setImmediate(wrappedFn);
+ */
+export function runWithCurrentLangfuseContext(fn) {
+    const capturedContext = contextStorage.getStore();
+    if (capturedContext) {
+        return () => contextStorage.run(capturedContext, fn);
+    }
+    // No context to preserve — return the function as-is
+    return fn;
+}
 /**
  * Get an OpenTelemetry Tracer for creating custom spans
  *

package/dist/telemetry/attributes.d.ts

@@ -0,0 +1,52 @@
+export declare const ATTR: {
+    readonly GEN_AI_SYSTEM: "gen_ai.system";
+    readonly GEN_AI_MODEL: "gen_ai.request.model";
+    readonly GEN_AI_OPERATION: "gen_ai.operation.name";
+    readonly GEN_AI_INPUT_TOKENS: "gen_ai.usage.input_tokens";
+    readonly GEN_AI_OUTPUT_TOKENS: "gen_ai.usage.output_tokens";
+    readonly GEN_AI_FINISH_REASON: "gen_ai.response.finish_reason";
+    readonly GEN_AI_COST_USD: "gen_ai.cost_usd";
+    readonly GEN_AI_TOOL_NAME: "gen_ai.tool.name";
+    readonly GEN_AI_TEMPERATURE: "gen_ai.request.temperature";
+    readonly GEN_AI_MAX_TOKENS: "gen_ai.request.max_tokens";
+    readonly NL_PROVIDER: "neurolink.provider";
+    readonly NL_MODEL: "neurolink.model";
+    readonly NL_STREAM_MODE: "neurolink.stream_mode";
+    readonly NL_TOOL_COUNT: "neurolink.tool_count";
+    readonly NL_MESSAGE_COUNT: "neurolink.message_count";
+    readonly NL_HAS_TOOLS: "neurolink.has_tools";
+    readonly NL_INPUT_LENGTH: "neurolink.input_length";
+    readonly NL_OUTPUT_LENGTH: "neurolink.output_length";
+    readonly NL_REQUEST_ID: "neurolink.request_id";
+    readonly NL_PATH: "neurolink.path";
+    readonly NL_HAS_MEMORY: "neurolink.has_conversation_memory";
+    readonly NL_COST: "neurolink.cost";
+    readonly NL_STRUCTURED_OUTPUT: "neurolink.structured_output";
+    readonly NL_HAS_FALLBACK: "neurolink.has_fallback";
+    readonly MCP_SERVER_ID: "mcp.server_id";
+    readonly MCP_TOOL_NAME: "mcp.tool_name";
+    readonly MCP_TIMEOUT_MS: "mcp.timeout_ms";
+    readonly MCP_TRANSPORT: "mcp.transport";
+    readonly MCP_CIRCUIT_STATE: "mcp.circuit_state";
+    readonly SESSION_ID: "session.id";
+    readonly USER_ID: "user.id";
+    readonly MEMORY_TYPE: "memory.type";
+    readonly MESSAGE_COUNT: "message.count";
+    readonly CONTENT_LENGTH: "content.length";
+    readonly RAG_FILE_COUNT: "rag.file_count";
+    readonly RAG_STRATEGY: "rag.strategy";
+    readonly RAG_CHUNK_SIZE: "rag.chunk_size";
+    readonly RAG_TOP_K: "rag.top_k";
+    readonly RAG_RESULT_COUNT: "rag.result_count";
+    readonly MSG_COUNT: "message.build.count";
+    readonly MSG_HAS_IMAGES: "message.has_images";
+    readonly MSG_HAS_FILES: "message.has_files";
+    readonly MSG_HAS_SYSTEM_PROMPT: "message.has_system_prompt";
+    readonly MSG_TOTAL_CONTENT_LENGTH: "message.total_content_length";
+    readonly MSG_IS_MULTIMODAL: "message.is_multimodal";
+    readonly CONTEXT_STAGE: "context.compaction_stage";
+    readonly CONTEXT_TOKENS_BEFORE: "context.tokens_before";
+    readonly CONTEXT_TOKENS_AFTER: "context.tokens_after";
+    readonly MW_COUNT: "middleware.count";
+    readonly MW_NAMES: "middleware.names";
+};

package/dist/telemetry/attributes.js

@@ -0,0 +1,60 @@
+export const ATTR = {
+    // GenAI standard (OpenTelemetry semantic conventions)
+    GEN_AI_SYSTEM: "gen_ai.system",
+    GEN_AI_MODEL: "gen_ai.request.model",
+    GEN_AI_OPERATION: "gen_ai.operation.name",
+    GEN_AI_INPUT_TOKENS: "gen_ai.usage.input_tokens",
+    GEN_AI_OUTPUT_TOKENS: "gen_ai.usage.output_tokens",
+    GEN_AI_FINISH_REASON: "gen_ai.response.finish_reason",
+    GEN_AI_COST_USD: "gen_ai.cost_usd",
+    GEN_AI_TOOL_NAME: "gen_ai.tool.name",
+    GEN_AI_TEMPERATURE: "gen_ai.request.temperature",
+    GEN_AI_MAX_TOKENS: "gen_ai.request.max_tokens",
+    // NeuroLink custom
+    NL_PROVIDER: "neurolink.provider",
+    NL_MODEL: "neurolink.model",
+    NL_STREAM_MODE: "neurolink.stream_mode",
+    NL_TOOL_COUNT: "neurolink.tool_count",
+    NL_MESSAGE_COUNT: "neurolink.message_count",
+    NL_HAS_TOOLS: "neurolink.has_tools",
+    NL_INPUT_LENGTH: "neurolink.input_length",
+    NL_OUTPUT_LENGTH: "neurolink.output_length",
+    NL_REQUEST_ID: "neurolink.request_id",
+    NL_PATH: "neurolink.path",
+    NL_HAS_MEMORY: "neurolink.has_conversation_memory",
+    NL_COST: "neurolink.cost",
+    NL_STRUCTURED_OUTPUT: "neurolink.structured_output",
+    NL_HAS_FALLBACK: "neurolink.has_fallback",
+    // MCP
+    MCP_SERVER_ID: "mcp.server_id",
+    MCP_TOOL_NAME: "mcp.tool_name",
+    MCP_TIMEOUT_MS: "mcp.timeout_ms",
+    MCP_TRANSPORT: "mcp.transport",
+    MCP_CIRCUIT_STATE: "mcp.circuit_state",
+    // Session/Memory
+    SESSION_ID: "session.id",
+    USER_ID: "user.id",
+    MEMORY_TYPE: "memory.type",
+    MESSAGE_COUNT: "message.count",
+    CONTENT_LENGTH: "content.length",
+    // RAG
+    RAG_FILE_COUNT: "rag.file_count",
+    RAG_STRATEGY: "rag.strategy",
+    RAG_CHUNK_SIZE: "rag.chunk_size",
+    RAG_TOP_K: "rag.top_k",
+    RAG_RESULT_COUNT: "rag.result_count",
+    // Message building
+    MSG_COUNT: "message.build.count",
+    MSG_HAS_IMAGES: "message.has_images",
+    MSG_HAS_FILES: "message.has_files",
+    MSG_HAS_SYSTEM_PROMPT: "message.has_system_prompt",
+    MSG_TOTAL_CONTENT_LENGTH: "message.total_content_length",
+    MSG_IS_MULTIMODAL: "message.is_multimodal",
+    // Context
+    CONTEXT_STAGE: "context.compaction_stage",
+    CONTEXT_TOKENS_BEFORE: "context.tokens_before",
+    CONTEXT_TOKENS_AFTER: "context.tokens_after",
+    // Middleware
+    MW_COUNT: "middleware.count",
+    MW_NAMES: "middleware.names",
+};

package/dist/telemetry/index.d.ts

@@ -1,4 +1,7 @@
 export { TelemetryService, type HealthMetrics } from "./telemetryService.js";
+export { tracers } from "./tracers.js";
+export { withSpan, withClientSpan, type SpanOptions } from "./withSpan.js";
+export { ATTR } from "./attributes.js";
 /**
  * Initialize telemetry for NeuroLink
  * OPTIONAL - Only works when NEUROLINK_TELEMETRY_ENABLED=true

package/dist/telemetry/index.js

@@ -1,5 +1,8 @@
 // Optional Telemetry Infrastructure (Phase 2)
 export { TelemetryService } from "./telemetryService.js";
+export { tracers } from "./tracers.js";
+export { withSpan, withClientSpan } from "./withSpan.js";
+export { ATTR } from "./attributes.js";
 import { logger } from "../utils/logger.js";
 /**
  * Initialize telemetry for NeuroLink

package/dist/telemetry/telemetryService.d.ts

@@ -32,6 +32,12 @@ export declare class TelemetryService {
     private initializeTelemetry;
     private initializeMetrics;
     initialize(): Promise<void>;
+    /**
+     * @deprecated Vercel AI SDK's experimental_telemetry creates ai.generateText/ai.streamText
+     * spans automatically via OpenTelemetry. Using this method would create duplicate spans.
+     * Kept for potential future use with non-Vercel providers (e.g., Amazon Bedrock).
+     * See: TelemetryHandler.getTelemetryConfig() for the active telemetry path.
+     */
     traceAIRequest<T>(provider: string, operation: () => Promise<T>, operationType?: string): Promise<T>;
     recordAIRequest(provider: string, model: string, tokens: number, duration: number, cost?: number): void;
     recordAIError(provider: string, error: Error): void;

package/dist/telemetry/telemetryService.js

@@ -112,6 +112,12 @@ export class TelemetryService {
         }
     }
     // AI Operation Tracing (NO-OP when disabled)
+    /**
+     * @deprecated Vercel AI SDK's experimental_telemetry creates ai.generateText/ai.streamText
+     * spans automatically via OpenTelemetry. Using this method would create duplicate spans.
+     * Kept for potential future use with non-Vercel providers (e.g., Amazon Bedrock).
+     * See: TelemetryHandler.getTelemetryConfig() for the active telemetry path.
+     */
     async traceAIRequest(provider, operation, operationType = "generate_text") {
         if (!this.enabled || !this.tracer) {
             return await operation();

package/dist/telemetry/tracers.d.ts

@@ -0,0 +1,15 @@
+export declare const tracers: {
+    readonly sdk: import("@opentelemetry/api").Tracer;
+    readonly provider: import("@opentelemetry/api").Tracer;
+    readonly generation: import("@opentelemetry/api").Tracer;
+    readonly stream: import("@opentelemetry/api").Tracer;
+    readonly http: import("@opentelemetry/api").Tracer;
+    readonly mcp: import("@opentelemetry/api").Tracer;
+    readonly memory: import("@opentelemetry/api").Tracer;
+    readonly redis: import("@opentelemetry/api").Tracer;
+    readonly factory: import("@opentelemetry/api").Tracer;
+    readonly rag: import("@opentelemetry/api").Tracer;
+    readonly context: import("@opentelemetry/api").Tracer;
+    readonly middleware: import("@opentelemetry/api").Tracer;
+    readonly processor: import("@opentelemetry/api").Tracer;
+};

package/dist/telemetry/tracers.js

@@ -0,0 +1,16 @@
+import { trace } from "@opentelemetry/api";
+export const tracers = {
+    sdk: trace.getTracer("neurolink"),
+    provider: trace.getTracer("neurolink.provider"),
+    generation: trace.getTracer("neurolink.generation"),
+    stream: trace.getTracer("neurolink.stream"),
+    http: trace.getTracer("neurolink.http"),
+    mcp: trace.getTracer("neurolink.mcp"),
+    memory: trace.getTracer("neurolink.memory"),
+    redis: trace.getTracer("neurolink.redis"),
+    factory: trace.getTracer("neurolink.factory"),
+    rag: trace.getTracer("neurolink.rag"),
+    context: trace.getTracer("neurolink.context"),
+    middleware: trace.getTracer("neurolink.middleware"),
+    processor: trace.getTracer("neurolink.processor"),
+};

package/dist/telemetry/withSpan.d.ts

@@ -0,0 +1,9 @@
+import { type Span, type Tracer, SpanKind } from "@opentelemetry/api";
+export type SpanOptions = {
+    name: string;
+    tracer: Tracer;
+    kind?: SpanKind;
+    attributes?: Record<string, string | number | boolean | undefined>;
+};
+export declare function withSpan<T>(options: SpanOptions, fn: (span: Span) => Promise<T>): Promise<T>;
+export declare function withClientSpan<T>(options: Omit<SpanOptions, "kind">, fn: (span: Span) => Promise<T>): Promise<T>;

package/dist/telemetry/withSpan.js

@@ -0,0 +1,34 @@
+import { SpanKind, SpanStatusCode, } from "@opentelemetry/api";
+export async function withSpan(options, fn) {
+    const { name, tracer, kind = SpanKind.INTERNAL, attributes } = options;
+    return tracer.startActiveSpan(name, { kind }, async (span) => {
+        if (attributes) {
+            for (const [key, value] of Object.entries(attributes)) {
+                if (value !== undefined) {
+                    span.setAttribute(key, value);
+                }
+            }
+        }
+        try {
+            const result = await fn(span);
+            span.setStatus({ code: SpanStatusCode.OK });
+            return result;
+        }
+        catch (error) {
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: error instanceof Error ? error.message : String(error),
+            });
+            if (error instanceof Error) {
+                span.recordException(error);
+            }
+            throw error;
+        }
+        finally {
+            span.end();
+        }
+    });
+}
+export async function withClientSpan(options, fn) {
+    return withSpan({ ...options, kind: SpanKind.CLIENT }, fn);
+}

package/dist/types/contextTypes.d.ts

@@ -424,6 +424,16 @@ export type PruneResult = {
 /** Configuration for sliding window truncation (Stage 4). */
 export type TruncationConfig = {
     fraction?: number;
+    /** Current estimated tokens (enables adaptive mode) */
+    currentTokens?: number;
+    /** Target token budget (enables adaptive mode) */
+    targetTokens?: number;
+    /** Provider for token estimation (enables adaptive mode) */
+    provider?: string;
+    /** Buffer above required reduction (default: 0.15 = 15%) */
+    adaptiveBuffer?: number;
+    /** Maximum iterations for adaptive truncation (default: 3) */
+    maxIterations?: number;
 };
 /** Result of sliding window truncation (Stage 4). */
 export type TruncationResult = {

package/dist/types/errors.d.ts

@@ -42,3 +42,65 @@ export declare class RateLimitError extends ProviderError {
 export declare class InvalidModelError extends ProviderError {
     constructor(message: string, provider?: string);
 }
+/**
+ * Base class for OAuth-specific errors
+ */
+export declare class OAuthError extends BaseError {
+    code?: string | undefined;
+    constructor(message: string, code?: string | undefined);
+}
+/**
+ * Thrown when OAuth configuration is invalid or missing
+ */
+export declare class OAuthConfigurationError extends OAuthError {
+    constructor(message: string);
+}
+/**
+ * Thrown when authorization code exchange fails
+ */
+export declare class OAuthTokenExchangeError extends OAuthError {
+    statusCode?: number | undefined;
+    constructor(message: string, statusCode?: number | undefined);
+}
+/**
+ * Thrown when token refresh fails
+ */
+export declare class OAuthTokenRefreshError extends OAuthError {
+    statusCode?: number | undefined;
+    constructor(message: string, statusCode?: number | undefined);
+}
+/**
+ * Thrown when token validation fails
+ */
+export declare class OAuthTokenValidationError extends OAuthError {
+    constructor(message: string);
+}
+/**
+ * Thrown when token revocation fails
+ */
+export declare class OAuthTokenRevocationError extends OAuthError {
+    statusCode?: number | undefined;
+    constructor(message: string, statusCode?: number | undefined);
+}
+/**
+ * Thrown when callback server operations fail
+ */
+export declare class OAuthCallbackServerError extends OAuthError {
+    constructor(message: string);
+}
+/**
+ * Token storage error for authentication-related failures
+ */
+export declare class TokenStoreError extends BaseError {
+    readonly code: "STORAGE_ERROR" | "ENCRYPTION_ERROR" | "VALIDATION_ERROR" | "NOT_FOUND" | "REFRESH_ERROR";
+    constructor(message: string, code?: "STORAGE_ERROR" | "ENCRYPTION_ERROR" | "VALIDATION_ERROR" | "NOT_FOUND" | "REFRESH_ERROR");
+}
+/**
+ * Error thrown when model access is denied based on subscription tier
+ */
+export declare class ModelAccessError extends BaseError {
+    readonly model: string;
+    readonly tier: string;
+    readonly requiredTier: string;
+    constructor(model: string, tier: string, requiredTier: string);
+}

package/dist/types/errors.js

@@ -58,3 +58,110 @@ export class InvalidModelError extends ProviderError {
         super(message, provider);
     }
 }
+// =============================================================================
+// OAUTH ERROR CLASSES
+// =============================================================================
+/**
+ * Base class for OAuth-specific errors
+ */
+export class OAuthError extends BaseError {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = "OAuthError";
+    }
+}
+/**
+ * Thrown when OAuth configuration is invalid or missing
+ */
+export class OAuthConfigurationError extends OAuthError {
+    constructor(message) {
+        super(message, "CONFIGURATION_ERROR");
+        this.name = "OAuthConfigurationError";
+    }
+}
+/**
+ * Thrown when authorization code exchange fails
+ */
+export class OAuthTokenExchangeError extends OAuthError {
+    statusCode;
+    constructor(message, statusCode) {
+        super(message, "TOKEN_EXCHANGE_ERROR");
+        this.statusCode = statusCode;
+        this.name = "OAuthTokenExchangeError";
+    }
+}
+/**
+ * Thrown when token refresh fails
+ */
+export class OAuthTokenRefreshError extends OAuthError {
+    statusCode;
+    constructor(message, statusCode) {
+        super(message, "TOKEN_REFRESH_ERROR");
+        this.statusCode = statusCode;
+        this.name = "OAuthTokenRefreshError";
+    }
+}
+/**
+ * Thrown when token validation fails
+ */
+export class OAuthTokenValidationError extends OAuthError {
+    constructor(message) {
+        super(message, "TOKEN_VALIDATION_ERROR");
+        this.name = "OAuthTokenValidationError";
+    }
+}
+/**
+ * Thrown when token revocation fails
+ */
+export class OAuthTokenRevocationError extends OAuthError {
+    statusCode;
+    constructor(message, statusCode) {
+        super(message, "TOKEN_REVOCATION_ERROR");
+        this.statusCode = statusCode;
+        this.name = "OAuthTokenRevocationError";
+    }
+}
+/**
+ * Thrown when callback server operations fail
+ */
+export class OAuthCallbackServerError extends OAuthError {
+    constructor(message) {
+        super(message, "CALLBACK_SERVER_ERROR");
+        this.name = "OAuthCallbackServerError";
+    }
+}
+// =============================================================================
+// TOKEN STORE ERROR
+// =============================================================================
+/**
+ * Token storage error for authentication-related failures
+ */
+export class TokenStoreError extends BaseError {
+    code;
+    constructor(message, code = "STORAGE_ERROR") {
+        super(message);
+        this.code = code;
+        this.name = "TokenStoreError";
+    }
+}
+// =============================================================================
+// MODEL ACCESS ERROR
+// =============================================================================
+/**
+ * Error thrown when model access is denied based on subscription tier
+ */
+export class ModelAccessError extends BaseError {
+    model;
+    tier;
+    requiredTier;
+    constructor(model, tier, requiredTier) {
+        super(`Model "${model}" is not available for tier "${tier}". ` +
+            `Required tier: "${requiredTier}" or higher.`);
+        this.name = "ModelAccessError";
+        this.model = model;
+        this.tier = tier;
+        this.requiredTier = requiredTier;
+    }
+}

package/dist/types/index.d.ts

@@ -6,7 +6,7 @@ export * from "./cli.js";
 export * from "./common.js";
 export type { AnalyticsConfig, BackupInfo, BackupMetadata, CacheConfig, ConfigUpdateOptions, ConfigValidationResult, FallbackConfig, NeuroLinkConfig, PerformanceConfig, RetryConfig, ToolConfig, } from "./configTypes.js";
 export type { ExternalMCPConfigValidation, ExternalMCPManagerConfig, ExternalMCPOperationResult, ExternalMCPServerEvents, ExternalMCPServerHealth, ExternalMCPServerInstance, ExternalMCPServerStatus, ExternalMCPToolContext, ExternalMCPToolInfo, ExternalMCPToolResult, } from "./externalMcp.js";
-export type { AuthorizationUrlResult, CircuitBreakerConfig, CircuitBreakerEvents, CircuitBreakerState, CircuitBreakerStats, DiscoveredMcp, ExternalToolExecutionOptions, FlexibleValidationResult, HTTPRetryConfig, MCPClientResult, MCPConnectedServer, MCPDiscoveredServer, MCPExecutableTool, MCPOAuthConfig, MCPServerCategory, MCPServerConfig, MCPServerConnectionStatus, MCPServerMetadata, MCPServerRegistryEntry, MCPServerStatus, MCPToolInfo, MCPToolMetadata, MCPTransportType, McpMetadata, McpRegistry, NeuroLinkExecutionContext, NeuroLinkMCPServer, NeuroLinkMCPTool, OAuthClientInformation, OAuthTokens, RateLimitConfig, TokenBucketRateLimitConfig, TokenExchangeRequest, TokenStorage, ToolDiscoveryResult, ToolRegistryEvents, ToolValidationResult, } from "./mcpTypes.js";
+export type { AuthorizationUrlResult, CircuitBreakerConfig, CircuitBreakerEvents, CircuitBreakerState, CircuitBreakerStats, DiscoveredMcp, ExternalToolExecutionOptions, FlexibleValidationResult, HTTPRetryConfig, MCPClientResult, MCPConnectedServer, MCPDiscoveredServer, MCPExecutableTool, MCPOAuthConfig, MCPServerCategory, MCPServerConfig, MCPServerConnectionStatus, MCPServerMetadata, MCPServerRegistryEntry, MCPServerStatus, MCPToolInfo, MCPToolMetadata, MCPTransportType, McpMetadata, McpRegistry, NeuroLinkExecutionContext, NeuroLinkMCPServer, NeuroLinkMCPTool, OAuthClientInformation, OAuthTokens as McpOAuthTokens, RateLimitConfig, TokenBucketRateLimitConfig, TokenExchangeRequest, TokenStorage, ToolDiscoveryResult, ToolRegistryEvents, ToolValidationResult, } from "./mcpTypes.js";
 export type { ModelCapability, ModelFilter, ModelPricing, ModelResolutionContext, ModelStats, ModelUseCase, } from "./providers.js";
 export * from "./providers.js";
 export * from "./taskClassificationTypes.js";
@@ -38,3 +38,4 @@ export * from "./contextTypes.js";
 export * from "./fileReferenceTypes.js";
 export * from "./ragTypes.js";
 export * from "./conversationMemoryInterface.js";
+export * from "./subscriptionTypes.js";

package/dist/types/index.js

@@ -48,3 +48,5 @@ export * from "./fileReferenceTypes.js";
 export * from "./ragTypes.js";
 // Conversation memory manager type
 export * from "./conversationMemoryInterface.js";
+// Subscription types (Claude subscription tiers, authentication, usage tracking)
+export * from "./subscriptionTypes.js";

package/dist/types/providers.d.ts

@@ -8,6 +8,8 @@ import type { ValidationSchema } from "./typeAliases.js";
 import type { EnhancedGenerateResult, GenerateResult, TextGenerationOptions } from "./generateTypes.js";
 import type { StreamOptions, StreamResult } from "./streamTypes.js";
 import type { ExternalMCPToolInfo } from "./externalMcp.js";
+import type { ClaudeSubscriptionTier, AnthropicAuthMethod, AnthropicAuthConfig, SubscriptionInfo } from "./subscriptionTypes.js";
+export type { ClaudeSubscriptionTier, AnthropicAuthMethod, AnthropicAuthConfig, SubscriptionInfo, } from "./subscriptionTypes.js";
 /**
  * Generic AI SDK model interface
  */
@@ -33,6 +35,15 @@ export type ProviderStatus = {
     error?: string;
     responseTime?: number;
     model?: string;
+    /**
+     * Subscription information for providers that support subscription tiers
+     * (e.g., Anthropic Claude with Pro/Max/Team/Enterprise subscriptions)
+     */
+    subscription?: SubscriptionInfo;
+    /**
+     * The authentication method currently in use for this provider
+     */
+    authMethod?: AnthropicAuthMethod;
 };
 /**
  * Provider error information
@@ -185,6 +196,16 @@ export type ProviderCapabilities = {
     supportsAudio: boolean;
     maxTokens?: number;
     supportedModels: string[];
+    /**
+     * Whether the provider supports subscription-based features and tier management
+     * When true, the provider can adapt behavior based on subscription tier
+     */
+    subscriptionAware?: boolean;
+    /**
+     * List of authentication methods supported by this provider
+     * e.g., ["api_key", "oauth", "session_token", "environment"]
+     */
+    supportedAuthMethods?: string[];
 };
 /**
  * Provider configuration specifying provider and its available models (from core types)
@@ -202,8 +223,94 @@ export type IndividualProviderConfig = {
     timeout?: number;
     retries?: number;
     model?: string;
+    /**
+     * The subscription tier for the provider (e.g., Claude Pro, Max, Team, Enterprise)
+     * Used to determine rate limits, available features, and pricing
+     */
+    subscriptionTier?: ClaudeSubscriptionTier;
+    /**
+     * The authentication method to use for the provider
+     * Supports API key, OAuth, session token, or environment variable
+     */
+    authMethod?: AnthropicAuthMethod;
+    /**
+     * Detailed authentication configuration including credentials and options
+     */
+    authConfig?: AnthropicAuthConfig;
+    /**
+     * Whether to enable beta features for the provider
+     * Beta features may be unstable or subject to change
+     */
+    enableBetaFeatures?: boolean;
     [key: string]: unknown;
 };
+/**
+ * Anthropic-specific provider configuration
+ *
+ * @description Extends the base provider configuration with Anthropic-specific
+ * options for OAuth, subscription management, and beta features.
+ */
+export type AnthropicProviderConfig = IndividualProviderConfig & {
+    /**
+     * The subscription tier for Claude access
+     */
+    subscriptionTier?: ClaudeSubscriptionTier;
+    /**
+     * The authentication method to use
+     */
+    authMethod?: AnthropicAuthMethod;
+    /**
+     * Whether to enable beta features
+     */
+    enableBetaFeatures?: boolean;
+    /**
+     * OAuth token for OAuth authentication.
+     * Required when authMethod is "oauth".
+     */
+    oauthToken?: import("./subscriptionTypes.js").OAuthToken;
+    /**
+     * OAuth configuration for OAuth-based authentication
+     */
+    oauthConfig?: {
+        /**
+         * OAuth client ID for the application
+         */
+        clientId?: string;
+        /**
+         * OAuth redirect URI for the callback
+         */
+        redirectUri?: string;
+        /**
+         * OAuth scopes to request
+         */
+        scopes?: string[];
+        /**
+         * OAuth authorization endpoint URL
+         */
+        authorizationEndpoint?: string;
+        /**
+         * OAuth token endpoint URL
+         */
+        tokenEndpoint?: string;
+    };
+};
+/**
+ * Type guard to check if a configuration is an AnthropicProviderConfig
+ *
+ * @param config - The configuration object to check
+ * @returns True if the configuration is an AnthropicProviderConfig
+ *
+ * @example
+ * ```typescript
+ * const config = getProviderConfig();
+ * if (isAnthropicConfig(config)) {
+ *   // TypeScript knows config is AnthropicProviderConfig here
+ *   console.log(config.subscriptionTier);
+ *   console.log(config.oauthConfig?.clientId);
+ * }
+ * ```
+ */
+export declare function isAnthropicConfig(config: unknown): config is AnthropicProviderConfig;
 /**
  * Configuration options for provider validation
  */