@juspay/neurolink
Version:
Universal AI Development Platform with working MCP integration, multi-provider support, voice (TTS/STT/realtime), and professional CLI. 58+ external MCP servers discoverable, multimodal file processing, RAG pipelines. Build, test, and deploy AI applicatio
954 lines (953 loc) • 29.5 kB
TypeScript
/**
* Claude Subscription Types for NeuroLink
*
* Type definitions for Claude subscription tiers, authentication methods,
* and usage tracking for Anthropic API access.
*/
import type { StoredOAuthTokens } from "./auth.js";
export type { StoredOAuthTokens, TokenRefresher, TokenStorageData, StoredProviderTokens, } from "./auth.js";
/**
* Claude subscription tier levels
*
* @description Represents the different subscription tiers available for Claude:
* - "free": Free tier with basic access and limited usage
* - "pro": Professional tier with higher limits and priority access
* - "max": Maximum tier with highest limits and advanced features (alias for max_5)
* - "max_5": Max 5x usage tier
* - "max_20": Max 20x usage tier
* - "api": Direct API access tier for developers and enterprises
*/
export type ClaudeSubscriptionTier = "free" | "pro" | "max" | "max_5" | "max_20" | "api";
/**
* Authentication methods supported for Anthropic API access
*
* @description Defines the available authentication methods:
* - "api_key": Traditional API key authentication for direct API access
* - "oauth": OAuth 2.0 authentication for subscription-based access
*/
export type AnthropicAuthMethod = "api_key" | "oauth";
/**
* OAuth token structure for Claude subscriptions
*
* @description Contains the OAuth token information for authenticated sessions
*/
export type OAuthToken = {
/**
* The access token for API requests
*/
accessToken: string;
/**
* The refresh token for obtaining new access tokens
*/
refreshToken?: string;
/**
* Token expiration timestamp (Unix milliseconds, i.e. Date.now() scale)
*/
expiresAt?: number;
/**
* Token type (typically "Bearer")
*/
tokenType?: string;
/**
* Scopes granted to this token
*/
scopes?: string[];
};
/**
* Rate limit information parsed from Anthropic API response headers
*
* @see https://docs.anthropic.com/en/api/rate-limits
*/
export type AnthropicRateLimitInfo = {
/**
* Maximum number of requests allowed in the current window
*/
requestsLimit?: number;
/**
* Number of requests remaining in the current window
*/
requestsRemaining?: number;
/**
* Time when the request limit resets (ISO 8601 timestamp)
*/
requestsReset?: string;
/**
* Maximum number of tokens allowed in the current window
*/
tokensLimit?: number;
/**
* Number of tokens remaining in the current window
*/
tokensRemaining?: number;
/**
* Time when the token limit resets (ISO 8601 timestamp)
*/
tokensReset?: string;
/**
* Retry-After header value in seconds (present on 429 responses)
*/
retryAfter?: number;
};
/**
* Response metadata including rate limit information
*
* @description Contains metadata from Anthropic API responses
*/
export type AnthropicResponseMetadata = {
/**
* Rate limit information from response headers
*/
rateLimit?: AnthropicRateLimitInfo;
/**
* Request ID for debugging
*/
requestId?: string;
/**
* Server timing information
*/
serverTiming?: string;
};
/**
* Anthropic authentication configuration
*
* @description Configuration interface for authenticating with Anthropic services.
* Supports both API key and OAuth authentication methods.
*/
export type AnthropicAuthConfig = {
/**
* Authentication method to use
* @see AnthropicAuthMethod
*/
method: AnthropicAuthMethod;
/**
* API key for API key authentication method
* @description Required when method is "api_key"
*/
apiKey?: string;
/**
* OAuth token object for OAuth authentication method
* @description Full OAuth token with access, refresh, and expiry information
*/
oauthToken?: OAuthToken;
/**
* OAuth access token for OAuth authentication method
* @description Required when method is "oauth", obtained through OAuth flow
* @deprecated Use oauthToken.accessToken instead
*/
accessToken?: string;
/**
* OAuth refresh token for obtaining new access tokens
* @description Optional for OAuth method, enables automatic token refresh
* @deprecated Use oauthToken.refreshToken instead
*/
refreshToken?: string;
/**
* Token expiry timestamp in milliseconds (Unix epoch)
* @description Used to determine when access token needs to be refreshed
* @deprecated Use oauthToken.expiresAt instead
*/
tokenExpiry?: number;
/**
* User's subscription tier
* @description Determines rate limits, features, and capabilities available
*/
subscriptionTier?: ClaudeSubscriptionTier;
/**
* Whether to automatically refresh OAuth tokens
* @description When true, tokens will be refreshed before expiry
*/
autoRefresh?: boolean;
};
/**
* Subscription information for Claude API access
*
* @description Contains subscription tier and related metadata
* for providers that support subscription-based access
*/
export type SubscriptionInfo = {
/**
* The subscription tier
*/
tier: ClaudeSubscriptionTier;
/**
* Whether the subscription is active
*/
isActive: boolean;
/**
* Subscription start date (ISO 8601 timestamp)
*/
startDate?: string;
/**
* Subscription renewal date (ISO 8601 timestamp)
*/
renewalDate?: string;
/**
* Current rate limit information
*/
rateLimit?: AnthropicRateLimitInfo;
/**
* Features available with this subscription
*/
features?: SubscriptionFeatures;
};
/**
* Claude quota information for tracking usage limits
*
* @description Represents the quota limits for a Claude subscription,
* including message limits, token limits, and model access restrictions.
*/
export type ClaudeQuotaInfo = {
/**
* Maximum messages allowed per time period
* @description Number of messages the user can send within the reset period
*/
maxMessagesPerPeriod: number;
/**
* Maximum tokens allowed per time period
* @description Total tokens (input + output) allowed within the reset period
*/
maxTokensPerPeriod: number;
/**
* Maximum tokens per individual request
* @description Limit on tokens for a single API request
*/
maxTokensPerRequest: number;
/**
* Time period for quota reset in milliseconds
* @description Duration after which quota counters reset (e.g., 3600000 for 1 hour)
*/
resetPeriodMs: number;
/**
* Timestamp when quota will reset (Unix epoch in milliseconds)
* @description Next quota reset time
*/
nextResetTimestamp: number;
/**
* List of models accessible with current subscription
* @description Model identifiers the user has access to based on tier
*/
availableModels: string[];
/**
* Whether priority queue access is enabled
* @description Priority access reduces wait times during high traffic
*/
hasPriorityAccess: boolean;
/**
* Maximum concurrent requests allowed
* @description Number of simultaneous API requests permitted
*/
maxConcurrentRequests: number;
/**
* Whether extended thinking is available
* @description Access to extended thinking/reasoning capabilities
*/
hasExtendedThinking: boolean;
/**
* Maximum context window size in tokens
* @description Maximum context length supported for the subscription tier
*/
maxContextWindow: number;
};
/**
* Claude usage information for tracking current consumption
*
* @description Represents the current usage state within a billing period,
* tracking messages sent, tokens consumed, and remaining quotas.
*/
export type ClaudeUsageInfo = {
/**
* Messages sent in current period
* @description Count of messages sent since last quota reset
*/
messagesUsed: number;
/**
* Messages remaining in current period
* @description Calculated as maxMessagesPerPeriod - messagesUsed
*/
messagesRemaining: number;
/**
* Tokens consumed in current period
* @description Total tokens (input + output) used since last reset
*/
tokensUsed: number;
/**
* Tokens remaining in current period
* @description Calculated as maxTokensPerPeriod - tokensUsed
*/
tokensRemaining: number;
/**
* Input tokens consumed in current period
* @description Prompt/input tokens used since last reset
*/
inputTokensUsed: number;
/**
* Output tokens consumed in current period
* @description Response/output tokens used since last reset
*/
outputTokensUsed: number;
/**
* Timestamp of last API request (Unix epoch in milliseconds)
* @description When the last successful request was made
*/
lastRequestTimestamp: number;
/**
* Current rate limit status
* @description Whether the user is currently rate limited
*/
isRateLimited: boolean;
/**
* Timestamp when rate limit expires (Unix epoch in milliseconds)
* @description When rate limiting will be lifted, if applicable
*/
rateLimitExpiresAt?: number;
/**
* Total requests made in current period
* @description Count of all API requests since last reset
*/
requestCount: number;
/**
* Usage percentage of message quota
* @description Percentage of message quota consumed (0-100)
*/
messageQuotaPercent: number;
/**
* Usage percentage of token quota
* @description Percentage of token quota consumed (0-100)
*/
tokenQuotaPercent: number;
};
/**
* Subscription features defining capabilities per tier
*
* @description Defines what features and capabilities are available
* for each subscription tier. Used to determine access to specific
* functionality and feature gating.
*/
export type SubscriptionFeatures = {
/**
* Subscription tier this feature set belongs to
*/
tier: ClaudeSubscriptionTier;
/**
* Whether chat/conversation access is enabled
* @description Basic chat functionality with Claude
*/
hasChat: boolean;
/**
* Whether API access is enabled
* @description Programmatic access to Claude via API
*/
hasApiAccess: boolean;
/**
* Whether extended thinking/reasoning is enabled
* @description Access to extended thinking capabilities for complex reasoning
*/
hasExtendedThinking: boolean;
/**
* Whether priority queue access is enabled
* @description Faster response times during high traffic periods
*/
hasPriorityAccess: boolean;
/**
* Whether vision/image analysis is enabled
* @description Ability to analyze images and visual content
*/
hasVision: boolean;
/**
* Whether file/document analysis is enabled
* @description Ability to process PDFs, documents, and other files
*/
hasFileAnalysis: boolean;
/**
* Whether code execution is enabled
* @description Access to code execution/analysis features
*/
hasCodeExecution: boolean;
/**
* Whether MCP (Model Context Protocol) tools are enabled
* @description Access to external tool integrations via MCP
*/
hasMcpTools: boolean;
/**
* Whether computer use capability is enabled
* @description Access to computer use/automation features
*/
hasComputerUse: boolean;
/**
* Whether web search is enabled
* @description Access to web search capabilities
*/
hasWebSearch: boolean;
/**
* Maximum context window size in tokens
* @description Limit on context/conversation length
*/
maxContextWindow: number;
/**
* Maximum output tokens per request
* @description Limit on response length per request
*/
maxOutputTokens: number;
/**
* List of accessible model identifiers
* @description Which Claude models are available for this tier
*/
availableModels: string[];
/**
* Daily message limit
* @description Maximum messages per day, -1 for unlimited
*/
dailyMessageLimit: number;
/**
* Monthly token limit
* @description Maximum tokens per month, -1 for unlimited
*/
monthlyTokenLimit: number;
/**
* Whether usage analytics are available
* @description Access to detailed usage statistics and analytics
*/
hasUsageAnalytics: boolean;
/**
* Whether team/organization features are enabled
* @description Access to team management and collaboration features
*/
hasTeamFeatures: boolean;
/**
* Custom feature flags for extensibility
* @description Additional feature flags for future capabilities
*/
customFeatures?: Record<string, boolean>;
};
/**
* Subscription tier comparison result
*
* @description Result of comparing two subscription tiers
*/
export type TierComparisonResult = {
/** Whether the first tier is higher than the second */
isHigher: boolean;
/** Whether the first tier is lower than the second */
isLower: boolean;
/** Whether the tiers are equal */
isEqual: boolean;
/** Numeric difference between tier levels (positive = first is higher) */
levelDifference: number;
};
/**
* Authentication state for tracking auth status
*
* @description Represents the current authentication state
*/
export type AuthenticationState = {
/** Whether the user is authenticated */
isAuthenticated: boolean;
/** Current authentication method in use */
method?: AnthropicAuthMethod;
/** Current subscription tier */
tier?: ClaudeSubscriptionTier;
/** Whether tokens need to be refreshed */
needsRefresh: boolean;
/** Error message if authentication failed */
error?: string;
/** Timestamp of last successful authentication */
lastAuthenticatedAt?: number;
};
/**
* Quota check result for determining if an operation can proceed
*
* @description Result of checking whether quota allows an operation
*/
export type QuotaCheckResult = {
/** Whether the operation is allowed within quota */
allowed: boolean;
/** Reason if operation is not allowed */
reason?: string;
/** Estimated tokens required for the operation */
estimatedTokens?: number;
/** Tokens remaining after operation (if allowed) */
tokensRemainingAfter?: number;
/** Suggested wait time in ms if rate limited */
suggestedWaitMs?: number;
};
/**
* OAuth tokens structure for Claude subscription authentication
*
* @description Contains OAuth token information for authenticated sessions.
* This is the preferred type for OAuth token storage.
*/
/**
* OAuth configuration for Claude subscription authentication
*
* @description Configuration for OAuth 2.0 authentication flow with Claude/Anthropic.
* Used to configure the OAuth client for subscription-based access.
*/
export type OAuthConfig = {
/**
* OAuth client ID for the application
* @description Obtained from Anthropic developer console
*/
clientId: string;
/**
* OAuth redirect URI for the callback
* @description Must match the registered redirect URI in Anthropic console
*/
redirectUri: string;
/**
* OAuth scopes to request
* @description Array of scope strings defining requested permissions
*/
scopes: string[];
/**
* OAuth client secret (optional, for confidential clients)
* @description Only used for server-side OAuth flows
*/
clientSecret?: string;
/**
* OAuth authorization endpoint URL
* @description Anthropic's OAuth authorization URL
*/
authorizationEndpoint?: string;
/**
* OAuth token endpoint URL
* @description Anthropic's OAuth token exchange URL
*/
tokenEndpoint?: string;
/**
* PKCE code verifier (for public clients)
* @description Used with PKCE flow for enhanced security
*/
codeVerifier?: string;
/**
* State parameter for CSRF protection
* @description Random string to prevent CSRF attacks
*/
state?: string;
};
/**
* Usage quota for tracking Claude subscription usage
*
* @description Simplified quota tracking structure for monitoring
* subscription usage against limits. Used for real-time quota monitoring.
*/
export type UsageQuota = {
/**
* Current subscription tier
*/
tier: ClaudeSubscriptionTier;
/**
* Daily tokens used in current period
*/
dailyTokensUsed: number;
/**
* Daily token limit for current tier
*/
dailyTokensLimit: number;
/**
* Messages used in current period
*/
messagesUsed: number;
/**
* Message limit for current tier
*/
messagesLimit: number;
/**
* Time when usage counters will reset
*/
resetTime: Date;
/**
* Current requests used in rate limit window
*/
requestsUsed?: number;
/**
* Request limit for rate limit window
*/
requestsLimit?: number;
/**
* Whether quota is currently exceeded
*/
isExceeded?: boolean;
/**
* Percentage of quota used (0-100)
*/
usagePercent?: number;
};
/**
* Anthropic beta feature flags for beta header configuration
*
* @description Defines available beta features that can be enabled via
* the anthropic-beta header. Each feature enables specific beta functionality.
*
* @see https://docs.anthropic.com/en/api/versioning#beta-headers
*/
export type AnthropicBetaFeatures = {
/**
* Enable computer use capability
* @description Allows Claude to interact with computer interfaces
* Header value: "computer-use-2024-10-22"
*/
computerUse?: boolean;
/**
* Enable extended thinking/reasoning
* @description Allows extended thinking for complex reasoning tasks
* Header value: "extended-thinking-2025-01-24"
*/
extendedThinking?: boolean;
/**
* Enable prompt caching
* @description Allows caching of prompts for reduced latency
* Header value: "prompt-caching-2024-07-31"
*/
promptCaching?: boolean;
/**
* Enable token counting
* @description Allows pre-counting tokens before generation
* Header value: "token-counting-2024-11-01"
*/
tokenCounting?: boolean;
/**
* Enable message batches
* @description Allows batch processing of multiple messages
* Header value: "message-batches-2024-09-24"
*/
messageBatches?: boolean;
/**
* Enable PDF support
* @description Allows processing PDF documents
* Header value: "pdfs-2024-09-25"
*/
pdfs?: boolean;
/**
* Enable max tokens override (for higher output limits)
* @description Allows requesting more output tokens than default
* Header value: "max-tokens-3-5-sonnet-2024-07-15"
*/
maxTokensOverride?: boolean;
/**
* Enable interleaved thinking (for multi-turn reasoning)
* @description Allows interleaved thinking in conversations
* Header value: "interleaved-thinking-2025-01-24"
*/
interleavedThinking?: boolean;
/**
* Enable files API
* @description Allows using the Files API for document processing
* Header value: "files-api-2025-01-15"
*/
filesApi?: boolean;
/**
* Enable MCP connectors
* @description Allows using MCP connectors for tool integrations
* Header value: "mcp-connectors-2025-01-01"
*/
mcpConnectors?: boolean;
/**
* Enable code execution
* @description Allows Claude to execute code
* Header value: "code-execution-2025-01-24"
*/
codeExecution?: boolean;
/**
* Custom beta features as raw strings
* @description For beta features not yet added to this type
*/
custom?: string[];
};
/**
* Anthropic beta header string values
*
* @description The actual string values used in the anthropic-beta header.
* Use AnthropicBetaFeatures for configuration, this is for internal use.
*/
export type AnthropicBetaHeader = "computer-use-2024-10-22" | "extended-thinking-2025-01-24" | "prompt-caching-2024-07-31" | "token-counting-2024-11-01" | "message-batches-2024-09-24" | "pdfs-2024-09-25" | "max-tokens-3-5-sonnet-2024-07-15" | "interleaved-thinking-2025-01-24" | "files-api-2025-01-15" | "mcp-connectors-2025-01-01" | "code-execution-2025-01-24" | string;
/**
* Subscription information summary for display purposes
*
* @description Extended subscription information including human-readable
* tier descriptions and usage data. Use for UI display and status reporting.
* For basic subscription state, see SubscriptionInfo.
*/
export type SubscriptionInfoSummary = {
/** Current subscription tier */
tier: ClaudeSubscriptionTier;
/** Human-readable tier name */
tierName: string;
/** Human-readable tier description */
description: string;
/** Messages allowed per day (-1 for unlimited) */
messagesPerDay: number | "unlimited";
/** Maximum context window size in tokens */
contextWindow: number;
/** Whether the user has priority access */
priorityAccess: boolean;
/** Whether the subscription is active */
isActive: boolean;
/** Subscription expiration date (if applicable) */
expiresAt?: number;
/** Current usage information */
usage?: ClaudeUsageInfo;
/** Available features for this tier */
features?: SubscriptionFeatures;
};
/**
* OAuth 2.0 token response from Anthropic (raw API response shape)
*/
export type OAuthTokenResponse = {
/** The access token for API authentication */
access_token: string;
/** Token type (typically "Bearer") */
token_type: string;
/** Token expiration time in seconds */
expires_in: number;
/** Refresh token for obtaining new access tokens */
refresh_token?: string;
/** Granted scopes (space-separated) */
scope?: string;
};
/**
* Parsed OAuth tokens from a fresh OAuth flow.
* Uses Date for expiresAt (vs number in OAuthTokens for storage).
*/
export type OAuthFlowTokens = {
/** The access token for API authentication */
accessToken: string;
/** Token type (typically "Bearer") */
tokenType: string;
/** Expiration timestamp (Date object) */
expiresAt: Date;
/** Refresh token for obtaining new access tokens */
refreshToken?: string;
/** Granted scopes as an array */
scopes: string[];
};
/**
* Token validation result
*/
export type ClaudeTokenValidationResult = {
/** Whether the token is valid */
isValid: boolean;
/** Remaining time in seconds until expiration */
expiresIn?: number;
/** Scopes associated with the token */
scopes?: string[];
/** User information if available */
user?: {
id: string;
email?: string;
subscription?: string;
};
/** Error message if validation failed */
error?: string;
};
/**
* OAuth configuration options for AnthropicOAuth class
*/
export type AnthropicOAuthConfig = {
/** OAuth client ID (optional, uses env var if not provided) */
clientId?: string;
/** OAuth client secret (optional, for confidential clients) */
clientSecret?: string;
/** Redirect URI for OAuth callback */
redirectUri?: string;
/** OAuth scopes to request */
scopes?: string[];
/** Custom authorization endpoint URL */
authorizationUrl?: string;
/** Custom token endpoint URL */
tokenUrl?: string;
/** Custom token validation endpoint URL */
validationUrl?: string;
/** Custom token revocation endpoint URL */
revocationUrl?: string;
};
/**
* PKCE (Proof Key for Code Exchange) parameters
*/
export type PKCEParams = {
/** Code verifier - random string used to generate challenge */
codeVerifier: string;
/** Code challenge - SHA-256 hash of verifier, base64url encoded */
codeChallenge: string;
/** Code challenge method - always "S256" */
codeChallengeMethod: "S256";
};
/**
* Callback server result containing the authorization code
*/
export type CallbackResult = {
/** Authorization code from OAuth callback */
code: string;
/** State parameter for CSRF verification */
state?: string;
};
/**
* Anthropic authentication configuration result for providerConfig
* Extended version with OAuth token details for configuration detection
*/
export type AnthropicAuthConfigResult = {
method: AnthropicAuthMethod;
tier: ClaudeSubscriptionTier;
apiKey?: string;
accessToken?: string;
refreshToken?: string;
isConfigured: boolean;
error?: string;
};
/**
* Unified authentication options for NeuroLink
*
* Supports both direct API key authentication and OAuth-based authentication
* for Claude Pro/Max subscriptions.
*/
export type NeuroLinkAuthOptions = {
/**
* Authentication method to use
* - "api-key": Use ANTHROPIC_API_KEY environment variable
* - "oauth": Use OAuth 2.0 flow for Claude Pro/Max subscriptions
*/
method: "api-key" | "oauth";
/**
* OAuth configuration (required when method is "oauth")
*/
oauth?: {
/** OAuth client ID */
clientId?: string;
/** OAuth redirect URI */
redirectUri?: string;
/** Custom scopes to request */
scopes?: string[];
};
/**
* Token storage configuration (optional, defaults to file-based storage)
*/
tokenStorage?: {
/** Enable encryption for stored tokens */
encryptionEnabled?: boolean;
/** Custom storage path */
customStoragePath?: string;
};
};
/**
* Authentication status result
*/
export type AuthStatus = {
/** Whether the user is authenticated */
isAuthenticated: boolean;
/** Authentication method in use */
method: "api-key" | "oauth" | "none";
/** Token expiration time (for OAuth) */
expiresAt?: Date;
/** Whether token refresh is needed (for OAuth) */
needsRefresh?: boolean;
/** User information (for OAuth) */
user?: {
id?: string;
email?: string;
subscription?: string;
};
};
/**
* Model metadata definition for Anthropic models
*/
export type AnthropicModelMetadata = {
/** Human-readable display name */
displayName: string;
/** Maximum context window size in tokens */
contextWindow: number;
/** Maximum output tokens */
maxOutputTokens: number;
/** Whether the model supports vision/image input */
supportsVision: boolean;
/** Whether the model supports extended thinking mode */
supportsExtendedThinking: boolean;
/** Whether the model supports tool/function calling */
supportsToolUse: boolean;
/** Whether the model supports streaming */
supportsStreaming: boolean;
/** Whether the model is deprecated */
deprecated: boolean;
/** Model family (haiku, sonnet, opus) */
family: "haiku" | "sonnet" | "opus";
/** Short description of the model */
description: string;
};
/** A single Claude account in the pool */
export type ProxyAccount = {
id: string;
label?: string;
type: "oauth" | "api_key";
tokens?: StoredOAuthTokens;
apiKey?: string;
status: "healthy" | "cooling" | "disabled";
cooldownUntil?: number;
consecutiveFailures: number;
requestCount: number;
lastUsed: number;
subscriptionTier?: ClaudeSubscriptionTier;
};
/** Configuration for AccountPool */
export type AccountPoolConfig = {
strategy: "round-robin" | "fill-first";
defaultCooldownMs?: number;
maxCooldownMs?: number;
maxRetryAccounts?: number;
};
/** A single model mapping entry */
export type ModelMapping = {
from: string;
to: string;
provider: string;
};
/** A fallback chain entry */
export type FallbackEntry = {
provider: string;
model: string;
};
/** Full proxy routing config */
export type ProxyRoutingConfig = {
strategy: "round-robin" | "fill-first";
modelMappings: ModelMapping[];
fallbackChain: FallbackEntry[];
passthroughModels?: string[];
/** Email/label of the Anthropic account that should be tried first
* ("home"). When absent, falls back to insertion-order index 0.
* Resolved per-request to a stable key (anthropic:<email>); does not
* encode an index. */
primaryAccount?: string;
};
/** Cloaking plugin config */
export type CloakingConfig = {
mode: "auto" | "always" | "never";
plugins: {
headerScrubber?: boolean;
sessionIdentity?: boolean;
systemPromptInjector?: boolean;
wordObfuscator?: {
enabled: boolean;
words: string[];
};
tlsFingerprint?: {
enabled: boolean;
};
};
};
/** Full proxy config (loaded from YAML) */
export type ProxyConfig = {
host?: string;
port?: number;
auth?: "none" | "api-key";
proxyApiKey?: string;
/** Provider-keyed account map matching the YAML structure (e.g. accounts.anthropic[0]) */
accounts?: Record<string, Array<{
name: string;
apiKey?: string;
weight?: number;
rateLimit?: number;
enabled?: boolean;
baseUrl?: string;
orgId?: string;
metadata?: Record<string, unknown>;
}>>;
routing?: Partial<ProxyRoutingConfig>;
cloaking?: CloakingConfig;
};