{"version":3,"file":"provider-registry-Bv8eMxuW.cjs","names":["MastraModelGateway","MastraError","createAnthropic","MASTRA_USER_AGENT","GATEWAY_AUTH_HEADER","createOpenRouter","staticRegistryJson","shouldEnableGateway","getGatewayId","ModelsDevGateway","NetlifyGateway","getCapabilityFileName","shouldWriteToSrc"],"sources":["../src/llm/model/gateways/mastra.ts","../src/llm/model/provider-registry.json","../src/llm/model/provider-registry.ts"],"sourcesContent":["import { createAnthropic } from '@ai-sdk/anthropic-v6';\nimport { createOpenRouter } from '@openrouter/ai-sdk-provider-v6';\nimport { MastraError } from '../../../error/index.js';\nimport { PROVIDER_REGISTRY } from '../provider-registry.js';\nimport { MastraModelGateway } from './base.js';\nimport type { ProviderConfig, GatewayLanguageModel } from './base.js';\nimport { GATEWAY_AUTH_HEADER, MASTRA_USER_AGENT } from './constants.js';\n\nexport interface MastraGatewayConfig {\n apiKey?: string;\n baseUrl?: string;\n customFetch?: typeof globalThis.fetch;\n}\n\nexport class MastraGateway extends MastraModelGateway {\n readonly id = 'mastra';\n readonly name = 'Gateway';\n\n constructor(private config?: MastraGatewayConfig) {\n super();\n }\n\n private getBaseUrl(): string {\n const raw = this.config?.baseUrl ?? process.env['MASTRA_GATEWAY_URL'] ?? 'https://gateway-api.mastra.ai';\n return raw.replace(/\\/+$/, '').replace(/\\/v1$/, '');\n }\n\n override shouldEnable(): boolean {\n return !!(this.config?.apiKey ?? process.env['MASTRA_GATEWAY_API_KEY']);\n }\n\n async fetchProviders(): Promise> {\n if (!this.shouldEnable()) {\n return {};\n }\n\n const openrouterConfig = PROVIDER_REGISTRY['openrouter'];\n const models = openrouterConfig?.models ?? [];\n\n const providers = {\n mastra: {\n apiKeyEnvVar: 'MASTRA_GATEWAY_API_KEY',\n apiKeyHeader: 'Authorization',\n name: 'Gateway',\n gateway: 'mastra',\n models: [...models],\n docUrl: 'https://mastra.ai/docs/gateway',\n },\n };\n\n return providers;\n }\n\n async buildUrl(_modelId: string): Promise {\n return `${this.getBaseUrl()}/v1`;\n }\n\n async getApiKey(): Promise {\n const apiKey = this.config?.apiKey ?? process.env['MASTRA_GATEWAY_API_KEY'];\n if (!apiKey) {\n throw new MastraError({\n id: 'MASTRA_GATEWAY_NO_API_KEY',\n domain: 'LLM',\n category: 'UNKNOWN',\n text: 'Missing MASTRA_GATEWAY_API_KEY environment variable',\n });\n }\n return apiKey;\n }\n\n resolveLanguageModel({\n modelId,\n providerId,\n apiKey,\n headers,\n }: {\n modelId: string;\n providerId: string;\n apiKey: string;\n headers?: Record;\n }): GatewayLanguageModel {\n const baseURL = `${this.getBaseUrl()}/v1`;\n const fullModelId = `${providerId}/${modelId}`;\n\n if (this.config?.customFetch && providerId === 'anthropic') {\n // Anthropic OAuth path: use native Anthropic SDK (sends /messages, not /chat/completions)\n return createAnthropic({\n apiKey: 'oauth-gateway-placeholder',\n baseURL,\n headers: {\n 'User-Agent': MASTRA_USER_AGENT,\n [GATEWAY_AUTH_HEADER]: `Bearer ${apiKey}`,\n ...headers,\n },\n fetch: this.config.customFetch as any,\n })(modelId) as unknown as GatewayLanguageModel;\n }\n\n if (this.config?.customFetch) {\n // Non-Anthropic OAuth path: gateway key in GATEWAY_AUTH_HEADER, customFetch owns Authorization\n return createOpenRouter({\n apiKey: 'oauth-gateway-placeholder',\n baseURL,\n headers: {\n 'User-Agent': MASTRA_USER_AGENT,\n [GATEWAY_AUTH_HEADER]: `Bearer ${apiKey}`,\n ...headers,\n },\n fetch: this.config.customFetch,\n }).chat(fullModelId) as unknown as GatewayLanguageModel;\n }\n\n // API key path: gateway key goes via Authorization (standard flow)\n return createOpenRouter({\n apiKey,\n baseURL,\n headers: {\n 'User-Agent': MASTRA_USER_AGENT,\n ...headers,\n },\n }).chat(fullModelId) as unknown as GatewayLanguageModel;\n }\n}\n","","/**\n * Runtime provider registry loader\n * Loads provider data from JSON file and exports typed interfaces\n */\n\nimport fs from 'node:fs';\nimport { createRequire } from 'node:module';\nimport os from 'node:os';\nimport path from 'node:path';\nimport { getCapabilityFileName } from './capability-file.js';\nimport type { ProviderConfig, MastraModelGatewayInterface } from './gateways/base.js';\nimport { getGatewayId, shouldEnableGateway } from './gateways/gateway-helpers.js';\nimport { MastraGateway } from './gateways/mastra.js';\nimport { ModelsDevGateway } from './gateways/models-dev.js';\nimport { NetlifyGateway } from './gateways/netlify.js';\nimport staticRegistryJson from './provider-registry.json';\nimport type { Provider, ModelForProvider, ModelRouterModelId, ProviderModels } from './provider-types.generated.js';\n\n// Re-export types for convenience\nexport type { Provider, ModelForProvider, ModelRouterModelId, ProviderModels };\nexport type { AttachmentCapabilities } from './gateways/base.js';\n\ninterface RegistryData {\n providers: Record;\n models: Record;\n version: string;\n}\n\n// JSON imports widen string literals to `string`, so fields like\n// `modelOverrides[*].shape` don't match their literal-union types.\nconst staticRegistry = staticRegistryJson as RegistryData;\n\n/**\n * Check if running in offline/air-gapped mode.\n * When MASTRA_OFFLINE is set to 'true' or '1', all network fetches for provider data are skipped.\n */\nexport function isOfflineMode(): boolean {\n const value = process.env.MASTRA_OFFLINE;\n return value === 'true' || value === '1';\n}\n\nfunction getEnabledGatewayIds(gateways: MastraModelGatewayInterface[]): Set {\n const enabledGatewayIds = new Set();\n\n for (const gateway of gateways) {\n const enabled = shouldEnableGateway(gateway);\n if (enabled) {\n enabledGatewayIds.add(getGatewayId(gateway));\n }\n }\n\n return enabledGatewayIds;\n}\n\nfunction sanitizeRegistryDataForRuntime(data: RegistryData, enabledGatewayIds: Set): RegistryData {\n const providers = Object.fromEntries(\n Object.entries(data.providers).filter(([, config]) => enabledGatewayIds.has(config.gateway)),\n );\n\n const models = Object.fromEntries(Object.entries(data.models).filter(([providerId]) => providerId in providers));\n\n return {\n ...data,\n providers,\n models,\n };\n}\n\n// In-memory cache for dynamic loading mode\nlet registryData: RegistryData | null = null;\n\n// Cache file helpers (dev mode only)\n// Use functions so we don't call os.homedir() at top level, which\n// causes an error in sandboxed environments when you merely\n// import @mastra/core. In those sandboxes, if you just don't use these\n// functions then you don't hit these errors.\nconst CACHE_DIR = () => path.join(os.homedir(), '.cache', 'mastra');\nconst CACHE_FILE = () => path.join(CACHE_DIR(), 'gateway-refresh-time');\nconst GLOBAL_PROVIDER_REGISTRY_JSON = () => path.join(CACHE_DIR(), 'provider-registry.json');\nconst GLOBAL_PROVIDER_TYPES_DTS = () => path.join(CACHE_DIR(), 'provider-types.generated.d.ts');\nconst GLOBAL_CAPABILITIES_DIR = () => path.join(CACHE_DIR(), 'capabilities');\n\nlet modelRouterCacheFailed = false;\n\n/**\n * Write a file atomically using the write-to-temp-then-rename pattern (synchronous version).\n * This prevents file corruption when multiple processes write to the same file concurrently.\n *\n * @param filePath - The target file path\n * @param content - The content to write\n * @param encoding - The encoding to use (default: 'utf-8')\n */\nfunction atomicWriteFileSync(filePath: string, content: string, encoding: BufferEncoding = 'utf-8'): void {\n // Use random suffix to avoid collisions between concurrent writes\n const randomSuffix = Math.random().toString(36).substring(2, 15);\n const tempPath = `${filePath}.${process.pid}.${Date.now()}.${randomSuffix}.tmp`;\n\n try {\n fs.writeFileSync(tempPath, content, encoding);\n fs.renameSync(tempPath, filePath);\n } catch (error) {\n try {\n fs.unlinkSync(tempPath);\n } catch {\n // Ignore cleanup errors\n }\n throw error;\n }\n}\n\n/**\n * Syncs provider files from global cache to local dist/ directory if needed.\n * Compares file contents to determine if copy is necessary.\n * Validates JSON before copying to prevent propagating corrupted files.\n */\nfunction syncGlobalCacheToLocal(): void {\n try {\n // Check if global cache files exist\n const globalJsonExists = fs.existsSync(GLOBAL_PROVIDER_REGISTRY_JSON());\n const globalDtsExists = fs.existsSync(GLOBAL_PROVIDER_TYPES_DTS());\n\n if (!globalJsonExists && !globalDtsExists) {\n // No global cache, nothing to sync\n return;\n }\n\n // Use getPackageRoot() to find the correct location in node_modules or local dev\n const packageRoot = getPackageRoot();\n const localJsonPath = path.join(packageRoot, 'dist', 'provider-registry.json');\n const localDtsPath = path.join(packageRoot, 'dist', 'llm', 'model', 'provider-types.generated.d.ts');\n\n // Ensure local dist directory exists\n fs.mkdirSync(path.dirname(localJsonPath), { recursive: true });\n fs.mkdirSync(path.dirname(localDtsPath), { recursive: true });\n\n // Sync JSON file if global exists and differs from local\n if (globalJsonExists) {\n const globalJsonContent = fs.readFileSync(GLOBAL_PROVIDER_REGISTRY_JSON(), 'utf-8');\n\n // Validate JSON before copying to prevent propagating corrupted files.\n // Silently delete on corruption — the next gateway sync will rewrite a\n // valid file, so logging here just creates noise when an older mastra\n // version (without the digit-quoting fix) shares the global cache.\n try {\n JSON.parse(globalJsonContent);\n } catch {\n try {\n fs.unlinkSync(GLOBAL_PROVIDER_REGISTRY_JSON());\n } catch {\n // Ignore deletion errors\n }\n return;\n }\n\n let shouldCopyJson = true;\n\n if (fs.existsSync(localJsonPath)) {\n const localJsonContent = fs.readFileSync(localJsonPath, 'utf-8');\n shouldCopyJson = globalJsonContent !== localJsonContent;\n }\n\n if (shouldCopyJson) {\n // Use atomic write to prevent corruption from concurrent writes\n atomicWriteFileSync(localJsonPath, globalJsonContent, 'utf-8');\n }\n }\n\n // Capabilities are loaded lazily per-provider by loadProviderAttachmentModels().\n // The global cache dir is included in findCapabilitiesDirs() so no bulk sync is needed.\n\n // Sync .d.ts file if global exists and differs from local\n if (globalDtsExists) {\n const globalDtsContent = fs.readFileSync(GLOBAL_PROVIDER_TYPES_DTS(), 'utf-8');\n\n // Validate .d.ts content: check for unquoted provider names that start with a digit\n // (e.g. \"readonly 302ai:\" instead of \"readonly '302ai':\"), which produces invalid TypeScript.\n // This can happen if the global cache was written by an older version without the quoting fix.\n // Silently delete on corruption — the next gateway sync will rewrite a valid file.\n if (/readonly\\s+\\d/.test(globalDtsContent)) {\n try {\n fs.unlinkSync(GLOBAL_PROVIDER_TYPES_DTS());\n } catch {\n // Ignore deletion errors\n }\n // Don't sync corrupted .d.ts file; fall through to keep existing local file\n } else {\n let shouldCopyDts = true;\n\n if (fs.existsSync(localDtsPath)) {\n const localDtsContent = fs.readFileSync(localDtsPath, 'utf-8');\n shouldCopyDts = globalDtsContent !== localDtsContent;\n }\n\n if (shouldCopyDts) {\n // Use atomic write to prevent corruption from concurrent writes\n atomicWriteFileSync(localDtsPath, globalDtsContent, 'utf-8');\n }\n }\n }\n } catch {\n // Silent fail - fall back to existing files. Sync errors are recoverable\n // on the next call and don't need to be surfaced to users.\n }\n}\n\nfunction getLastRefreshTimeFromDisk(): Date | null {\n try {\n if (!fs.existsSync(CACHE_FILE())) {\n return null;\n }\n const timestamp = fs.readFileSync(CACHE_FILE(), 'utf-8').trim();\n return new Date(parseInt(timestamp, 10));\n } catch (err) {\n console.warn('[GatewayRegistry] Failed to read cache file:', err);\n modelRouterCacheFailed = true;\n return null;\n }\n}\n\nfunction saveLastRefreshTimeToDisk(date: Date): void {\n try {\n if (!fs.existsSync(CACHE_DIR())) {\n fs.mkdirSync(CACHE_DIR(), { recursive: true });\n }\n fs.writeFileSync(CACHE_FILE(), date.getTime().toString(), 'utf-8');\n } catch (err) {\n modelRouterCacheFailed = true;\n console.warn('[GatewayRegistry] Failed to write cache file:', err);\n }\n}\n\nfunction getPackageRoot(): string {\n try {\n // Use require.resolve to find the package root reliably\n const require = createRequire(import.meta.url || 'file://');\n const packageJsonPath = require.resolve('@mastra/core/package.json');\n return path.dirname(packageJsonPath);\n } catch {\n // Fallback to cwd if we can't resolve the package\n return process.cwd();\n }\n}\n\nfunction loadRegistry(useDynamicLoading: boolean, customGateways: MastraModelGatewayInterface[] = []): RegistryData {\n const enabledGatewayIds = getEnabledGatewayIds([\n new ModelsDevGateway({}),\n new NetlifyGateway(),\n new MastraGateway(),\n ...customGateways,\n ]);\n\n // Production: use static import (bundled at build time)\n if (!useDynamicLoading) {\n return sanitizeRegistryDataForRuntime(staticRegistry, enabledGatewayIds);\n }\n\n // Dynamic loading mode: sync global cache to local before loading\n syncGlobalCacheToLocal();\n\n // Dynamic loading mode: check in-memory cache first\n if (registryData) {\n return registryData;\n }\n\n // Dynamic loading mode: load from file system for live updates\n const packageRoot = getPackageRoot();\n const possiblePaths: string[] = [\n // Built: in dist/ relative to package root (first priority - what gets distributed)\n path.join(packageRoot, 'dist', 'provider-registry.json'),\n // Development: in src/ relative to package root\n path.join(packageRoot, 'src', 'llm', 'model', 'provider-registry.json'),\n // Fallback: relative to cwd (for monorepo setups)\n path.join(process.cwd(), 'packages/core/src/llm/model/provider-registry.json'),\n path.join(process.cwd(), 'src/llm/model/provider-registry.json'),\n ];\n\n const errors: string[] = [];\n\n for (const jsonPath of possiblePaths) {\n try {\n const content = fs.readFileSync(jsonPath, 'utf-8');\n const parsed = JSON.parse(content) as RegistryData;\n registryData = sanitizeRegistryDataForRuntime(parsed, enabledGatewayIds);\n return registryData;\n } catch (err) {\n const errorMessage = err instanceof Error ? err.message : String(err);\n errors.push(`${jsonPath}: ${errorMessage}`);\n\n // If the file exists but has corrupted JSON (not ENOENT), delete it and fall back to static registry\n // This handles cases where concurrent writes corrupted the file before the atomic write fix\n const isFileNotFound = err instanceof Error && 'code' in err && (err as NodeJS.ErrnoException).code === 'ENOENT';\n const isJsonParseError = err instanceof SyntaxError;\n\n if (!isFileNotFound && isJsonParseError) {\n console.warn(\n `[GatewayRegistry] Detected corrupted provider-registry.json at ${jsonPath}. ` +\n `Deleting corrupted file and falling back to static registry.`,\n );\n try {\n fs.unlinkSync(jsonPath);\n } catch {\n // Ignore deletion errors\n }\n // Fall back to static registry (bundled at build time)\n registryData = sanitizeRegistryDataForRuntime(staticRegistry, enabledGatewayIds);\n return registryData;\n }\n\n continue;\n }\n }\n\n // If all paths failed, fall back to static registry instead of throwing\n // This provides a more graceful degradation\n console.warn(\n `[GatewayRegistry] Could not load provider registry from any path. Falling back to static registry.\\n` +\n `Tried paths:\\n${errors.join('\\n')}`,\n );\n registryData = sanitizeRegistryDataForRuntime(staticRegistry, enabledGatewayIds);\n return registryData;\n}\n\n// Export registry data via Proxy for lazy loading\nexport const PROVIDER_REGISTRY = new Proxy({} as Record, {\n get(_target, prop: string) {\n const registry = GatewayRegistry.getInstance();\n const providers = registry.getProviders();\n return providers[prop];\n },\n ownKeys() {\n const registry = GatewayRegistry.getInstance();\n const providers = registry.getProviders();\n return Object.keys(providers);\n },\n has(_target, prop: string) {\n const registry = GatewayRegistry.getInstance();\n const providers = registry.getProviders();\n return prop in providers;\n },\n getOwnPropertyDescriptor(_target, prop) {\n const registry = GatewayRegistry.getInstance();\n const providers = registry.getProviders();\n if (prop in providers) {\n return {\n enumerable: true,\n configurable: true,\n };\n }\n return undefined;\n },\n}) as Record;\n\nexport const PROVIDER_MODELS = new Proxy({} as ProviderModels, {\n get(_target, prop: string) {\n const registry = GatewayRegistry.getInstance();\n const models = registry.getModels();\n return models[prop];\n },\n ownKeys() {\n const registry = GatewayRegistry.getInstance();\n const models = registry.getModels();\n return Object.keys(models);\n },\n has(_target, prop: string) {\n const registry = GatewayRegistry.getInstance();\n const models = registry.getModels();\n return prop in models;\n },\n getOwnPropertyDescriptor(_target, prop) {\n const registry = GatewayRegistry.getInstance();\n const models = registry.getModels();\n if (prop in models) {\n return {\n enumerable: true,\n configurable: true,\n };\n }\n return undefined;\n },\n});\n\n/**\n * Parse a model string to extract provider and model ID\n * Examples:\n * \"openai/gpt-4o\" -> { provider: \"openai\", modelId: \"gpt-4o\" }\n * \"fireworks/accounts/etc/model\" -> { provider: \"fireworks\", modelId: \"accounts/etc/model\" }\n * \"gpt-4o\" -> { provider: null, modelId: \"gpt-4o\" }\n */\nexport function parseModelString(modelString: string): { provider: string | null; modelId: string } {\n const firstSlashIndex = modelString.indexOf('/');\n\n if (firstSlashIndex !== -1) {\n // Has at least one slash - extract everything before first slash as provider\n const provider = modelString.substring(0, firstSlashIndex);\n const modelId = modelString.substring(firstSlashIndex + 1);\n\n if (provider && modelId) {\n return {\n provider,\n modelId,\n };\n }\n }\n\n // No slash or invalid format\n return {\n provider: null,\n modelId: modelString,\n };\n}\n\n/**\n * Get provider configuration by provider ID\n */\nexport function getProviderConfig(providerId: string): ProviderConfig | undefined {\n const registry = GatewayRegistry.getInstance();\n return registry.getProviderConfig(providerId);\n}\n\n/**\n * Check if a provider is registered\n */\nexport function isProviderRegistered(providerId: string): boolean {\n const registry = GatewayRegistry.getInstance();\n return registry.isProviderRegistered(providerId);\n}\n\n/**\n * Get all registered provider IDs\n */\nexport function getRegisteredProviders(): string[] {\n const registry = GatewayRegistry.getInstance();\n const providers = registry.getProviders();\n return Object.keys(providers);\n}\n\n// ---------------------------------------------------------------------------\n// Provider capabilities (per-model attachment / modality metadata)\n// ---------------------------------------------------------------------------\n\ninterface ProviderCapabilityFile {\n attachment?: string[];\n temperature?: string[];\n structuredOutput?: string[];\n}\n\ntype CapabilityDimension = keyof ProviderCapabilityFile;\n\nconst providerCapCaches: Record> = {\n attachment: new Map(),\n temperature: new Map(),\n structuredOutput: new Map(),\n};\n\nconst capabilityOverrides: Partial>> = {\n // DeepSeek's native endpoint rejects response_format for this routed model even\n // though models.dev currently reports structured_output support.\n structuredOutput: {\n 'deepseek/deepseek-v4-pro': false,\n },\n};\n\nfunction isDirectory(dir: string): boolean {\n try {\n return fs.existsSync(dir) && fs.statSync(dir).isDirectory();\n } catch {\n return false;\n }\n}\n\nfunction findCapabilitiesDirs(useDynamicLoading: boolean): string[] {\n const packageRoot = getPackageRoot();\n const distCapabilitiesDir = path.join(packageRoot, 'dist', 'capabilities');\n const sourceCapabilitiesDir = path.join(packageRoot, 'src', 'llm', 'model', 'capabilities');\n const workspaceSourceCapabilitiesDir = path.join(process.cwd(), 'packages/core/src/llm/model/capabilities');\n\n const dirs: string[] = [];\n\n // In dynamic mode, prefer the global cache so fresher gateway-synced data wins.\n if (useDynamicLoading) {\n const globalCapDir = GLOBAL_CAPABILITIES_DIR();\n if (isDirectory(globalCapDir)) dirs.push(globalCapDir);\n }\n\n if (isDirectory(distCapabilitiesDir)) dirs.push(distCapabilitiesDir);\n\n // Published packages only include dist/. Source fallbacks are for local workspace/dev\n // runs where @mastra/core may resolve through a stale partial dist while checked-in\n // source capability files are available.\n if (isDirectory(sourceCapabilitiesDir)) dirs.push(sourceCapabilitiesDir);\n if (workspaceSourceCapabilitiesDir !== sourceCapabilitiesDir && isDirectory(workspaceSourceCapabilitiesDir)) {\n dirs.push(workspaceSourceCapabilitiesDir);\n }\n\n return dirs;\n}\n\nlet capabilitiesDirCache: string[] | undefined;\n\n/** Parsed capability file cache — avoids re-reading JSON per dimension. */\nconst parsedCapFileCache = new Map();\n\nfunction loadProviderCapabilityFile(provider: string, useDynamicLoading: boolean): ProviderCapabilityFile | null {\n if (parsedCapFileCache.has(provider)) return parsedCapFileCache.get(provider)!;\n\n if (capabilitiesDirCache === undefined) {\n capabilitiesDirCache = findCapabilitiesDirs(useDynamicLoading);\n }\n\n for (const capabilitiesDir of capabilitiesDirCache) {\n const filePath = path.join(capabilitiesDir, getCapabilityFileName(provider));\n try {\n const content = fs.readFileSync(filePath, 'utf-8');\n const data = JSON.parse(content) as ProviderCapabilityFile;\n parsedCapFileCache.set(provider, data);\n return data;\n } catch {\n continue;\n }\n }\n\n parsedCapFileCache.set(provider, null);\n return null;\n}\n\nfunction loadProviderCapability(\n provider: string,\n dimension: CapabilityDimension,\n useDynamicLoading: boolean,\n): string[] | null {\n const cache = providerCapCaches[dimension];\n if (cache.has(provider)) return cache.get(provider)!;\n\n const file = loadProviderCapabilityFile(provider, useDynamicLoading);\n const models = file?.[dimension] ?? null;\n cache.set(provider, models);\n return models;\n}\n\nfunction getProviderCapabilitySupport(\n provider: string,\n modelId: string,\n dimension: CapabilityDimension,\n useDynamicLoading: boolean,\n): boolean | undefined {\n const models = loadProviderCapability(provider, dimension, useDynamicLoading);\n if (!models) return undefined;\n return models.includes(modelId);\n}\n\nfunction modelSupportsCapability(modelRouterId: string, dimension: CapabilityDimension): boolean | undefined {\n const override = capabilityOverrides[dimension]?.[modelRouterId];\n if (override !== undefined) return override;\n\n const { provider, modelId } = parseModelString(modelRouterId);\n if (!provider) return undefined;\n\n const registry = GatewayRegistry.getInstance();\n const useDynamicLoading = registry['useDynamicLoading'];\n const directSupport = getProviderCapabilitySupport(provider, modelId, dimension, useDynamicLoading);\n\n // Positive direct match wins immediately.\n if (directSupport === true) return true;\n\n // For nested model IDs (e.g. `openrouter/anthropic/claude-sonnet-4-6`), the\n // outer gateway's capability list may not enumerate every nested model. Fall\n // back to the underlying provider's authoritative capability file before\n // trusting a `false` from the gateway.\n const nestedProviderDelimiter = modelId.indexOf('/');\n if (nestedProviderDelimiter !== -1) {\n const nestedProvider = modelId.substring(0, nestedProviderDelimiter);\n const nestedModelId = modelId.substring(nestedProviderDelimiter + 1);\n if (nestedProvider && nestedModelId) {\n const nestedSupport = getProviderCapabilitySupport(nestedProvider, nestedModelId, dimension, useDynamicLoading);\n if (nestedSupport !== undefined) return nestedSupport;\n }\n }\n\n return directSupport;\n}\n\n/** @internal Reset capability caches. For testing only. */\nexport function _resetCapabilityCaches(): void {\n for (const cache of Object.values(providerCapCaches)) cache.clear();\n parsedCapFileCache.clear();\n capabilitiesDirCache = undefined;\n}\n\n/**\n * Check whether a model supports image/file attachments.\n * Returns `true` if the model is listed, `false` if the provider is known but\n * the model isn't listed, or `undefined` when no data exists for the provider.\n */\nexport function modelSupportsAttachments(modelRouterId: string): boolean | undefined {\n return modelSupportsCapability(modelRouterId, 'attachment');\n}\n\n/**\n * Check whether a model supports the `temperature` sampling parameter.\n * Returns `true` if the model is listed, `false` if the provider is known but\n * the model isn't listed, or `undefined` when no data exists for the provider.\n */\nexport function modelSupportsTemperature(modelRouterId: string): boolean | undefined {\n return modelSupportsCapability(modelRouterId, 'temperature');\n}\n\n/**\n * Check whether a model supports native structured output.\n * Returns `true` if the model is listed, `false` if the provider is known but\n * the model isn't listed, or `undefined` when no data exists for the provider.\n */\nexport function modelSupportsStructuredOutput(modelRouterId: string): boolean | undefined {\n return modelSupportsCapability(modelRouterId, 'structuredOutput');\n}\n\n/**\n * Type guard to check if a string is a valid OpenAI-compatible model ID\n */\nexport function isValidModelId(modelId: string): modelId is ModelRouterModelId {\n const { provider } = parseModelString(modelId);\n return provider !== null && isProviderRegistered(provider);\n}\n\nexport interface GatewayRegistryOptions {\n /**\n * Enable dynamic loading from file system instead of using static bundled registry.\n * Required for syncGateways() and auto-refresh to work.\n * Defaults to true when MASTRA_DEV=true, false otherwise.\n */\n useDynamicLoading?: boolean;\n}\n\n/**\n * GatewayRegistry - Manages dynamic loading and refreshing of provider data from gateways\n * Singleton class that handles runtime updates to the provider registry\n */\nexport class GatewayRegistry {\n private static instance: GatewayRegistry | null = null;\n private lastRefreshTime: Date | null = null;\n private refreshInterval: NodeJS.Timeout | null = null;\n private isRefreshing = false;\n private useDynamicLoading: boolean;\n private customGateways: MastraModelGatewayInterface[] = [];\n\n private constructor(options: GatewayRegistryOptions = {}) {\n const isDev = process.env.MASTRA_DEV === 'true' || process.env.MASTRA_DEV === '1';\n this.useDynamicLoading = options.useDynamicLoading ?? isDev;\n }\n\n /**\n * Get the singleton instance\n */\n static getInstance(options?: GatewayRegistryOptions): GatewayRegistry {\n if (!GatewayRegistry.instance) {\n GatewayRegistry.instance = new GatewayRegistry(options);\n return GatewayRegistry.instance;\n }\n\n if (options?.useDynamicLoading === true) {\n GatewayRegistry.instance.useDynamicLoading = true;\n }\n\n return GatewayRegistry.instance;\n }\n\n /**\n * Register custom gateways for type generation\n * @param gateways - Array of custom gateway instances\n */\n registerCustomGateways(gateways: MastraModelGatewayInterface[]): void {\n this.customGateways = gateways;\n }\n\n /**\n * Get all registered custom gateways\n */\n getCustomGateways(): MastraModelGatewayInterface[] {\n return this.customGateways;\n }\n\n /**\n * Sync providers from all gateways\n * Requires dynamic loading to be enabled (useDynamicLoading=true).\n * @param forceRefresh - Force refresh even if recently synced\n * @param writeToSrc - Write to src/ directory in addition to dist/ (useful for manual generation in repo)\n */\n async syncGateways(forceRefresh = false, writeToSrc = false): Promise {\n // Only allow sync when dynamic loading is enabled or when explicitly writing to src (build script)\n if (!this.useDynamicLoading && !writeToSrc) {\n // console.debug('[GatewayRegistry] Skipping sync (dynamic loading disabled, registry is static)');\n return;\n }\n\n // Skip all network fetches when running in offline/air-gapped mode\n if (isOfflineMode()) {\n return;\n }\n\n if (this.isRefreshing && !forceRefresh) {\n // console.debug('[GatewayRegistry] Sync already in progress, skipping...');\n return;\n }\n\n this.isRefreshing = true;\n\n try {\n // console.debug('[GatewayRegistry] Starting gateway sync...');\n\n // Import gateway classes and generation functions\n const { ModelsDevGateway } = await import('./gateways/models-dev.js');\n const { NetlifyGateway } = await import('./gateways/netlify.js');\n const { MastraGateway } = await import('./gateways/mastra.js');\n const { fetchProvidersFromGateways, writeRegistryFiles } = await import('./registry-generator.js');\n\n // Initialize default gateways. Mastra Gateway is dynamic-only and should not be written into checked-in static artifacts.\n const defaultGateways = [\n new ModelsDevGateway({}),\n new NetlifyGateway(),\n ...(writeToSrc ? [] : [new MastraGateway()]),\n ];\n\n // Combine default and custom gateways\n const gateways = [...defaultGateways, ...this.customGateways];\n\n // Fetch provider data\n const {\n providers,\n models,\n attachmentCapabilities,\n temperatureCapabilities,\n structuredOutputCapabilities,\n failedGateways,\n } = await fetchProvidersFromGateways(gateways);\n\n // If any gateway failed, skip writing to prevent partial results from\n // overwriting the complete bundled registry. The existing static registry\n // already contains all provider data, so a partial write would only\n // remove providers (e.g. writing only Netlify providers when models.dev\n // is down strips all direct providers like openai, anthropic, etc.).\n if (failedGateways.length > 0) {\n return;\n }\n\n // Get package root for file paths\n const packageRoot = getPackageRoot();\n\n // Write to global cache first (so all projects can benefit)\n try {\n fs.mkdirSync(CACHE_DIR(), { recursive: true });\n await writeRegistryFiles(\n GLOBAL_PROVIDER_REGISTRY_JSON(),\n GLOBAL_PROVIDER_TYPES_DTS(),\n providers,\n models,\n attachmentCapabilities,\n temperatureCapabilities,\n structuredOutputCapabilities,\n );\n // console.debug(`[GatewayRegistry] ✅ Updated global cache at ${CACHE_DIR()}`);\n } catch (error) {\n console.warn('[GatewayRegistry] Failed to write to global cache:', error);\n }\n\n // Write to dist/ (the bundled location that gets distributed)\n const distJsonPath = path.join(packageRoot, 'dist', 'provider-registry.json');\n const distTypesPath = path.join(packageRoot, 'dist', 'llm', 'model', 'provider-types.generated.d.ts');\n\n await writeRegistryFiles(\n distJsonPath,\n distTypesPath,\n providers,\n models,\n attachmentCapabilities,\n temperatureCapabilities,\n structuredOutputCapabilities,\n );\n // console.debug(`[GatewayRegistry] ✅ Updated registry files in dist/`);\n\n // Copy to src/ only when explicitly requested (e.g., running the generation script)\n const shouldWriteToSrc = writeToSrc;\n if (shouldWriteToSrc) {\n const srcJsonPath = path.join(packageRoot, 'src', 'llm', 'model', 'provider-registry.json');\n const srcTypesPath = path.join(packageRoot, 'src', 'llm', 'model', 'provider-types.generated.d.ts');\n\n // Copy the already-generated files\n await fs.promises.copyFile(distJsonPath, srcJsonPath);\n await fs.promises.copyFile(distTypesPath, srcTypesPath);\n\n const distCapDir = path.join(packageRoot, 'dist', 'capabilities');\n const srcCapDir = path.join(packageRoot, 'src', 'llm', 'model', 'capabilities');\n if (fs.existsSync(distCapDir)) {\n await fs.promises.mkdir(srcCapDir, { recursive: true });\n const capFiles = fs.readdirSync(distCapDir).filter(f => f.endsWith('.json'));\n for (const file of capFiles) {\n await fs.promises.copyFile(path.join(distCapDir, file), path.join(srcCapDir, file));\n }\n }\n // console.debug(`[GatewayRegistry] ✅ Copied registry files to src/ (${writeToSrc ? 'manual' : 'dynamic loading'})`);\n }\n\n // Clear the in-memory cache to force reload (dynamic loading only)\n if (this.useDynamicLoading) {\n registryData = null;\n for (const cache of Object.values(providerCapCaches)) cache.clear();\n parsedCapFileCache.clear();\n capabilitiesDirCache = undefined;\n }\n\n this.lastRefreshTime = new Date();\n saveLastRefreshTimeToDisk(this.lastRefreshTime);\n // console.debug(`[GatewayRegistry] ✅ Gateway sync completed at ${this.lastRefreshTime.toISOString()}`);\n } catch {\n // Silently ignore — the bundled registry already contains all\n // model data so a failed sync is non-critical.\n } finally {\n this.isRefreshing = false;\n }\n }\n\n /**\n * Get the last refresh time (from memory or disk cache)\n */\n getLastRefreshTime(): Date | null {\n return this.lastRefreshTime || getLastRefreshTimeFromDisk();\n }\n\n /**\n * Start auto-refresh on an interval\n * Requires dynamic loading to be enabled (useDynamicLoading=true).\n * @param intervalMs - Interval in milliseconds (default: 1 hour)\n */\n startAutoRefresh(intervalMs = 60 * 60 * 1000): void {\n // Only allow auto-refresh when dynamic loading is enabled\n if (!this.useDynamicLoading) {\n // console.debug('[GatewayRegistry] Skipping auto-refresh (dynamic loading disabled, registry is static)');\n return;\n }\n\n // Skip auto-refresh when running in offline/air-gapped mode\n if (isOfflineMode()) {\n return;\n }\n\n if (this.refreshInterval) {\n // console.debug('[GatewayRegistry] Auto-refresh already running');\n return;\n }\n\n // console.debug(`[GatewayRegistry] Starting auto-refresh (interval: ${intervalMs}ms)`);\n\n // Check if we need to run an immediate sync\n const lastRefresh = getLastRefreshTimeFromDisk();\n const now = Date.now();\n const shouldRefresh = !modelRouterCacheFailed && (!lastRefresh || now - lastRefresh.getTime() > intervalMs);\n\n if (shouldRefresh) {\n this.syncGateways().catch(() => {});\n }\n\n this.refreshInterval = setInterval(() => {\n if (modelRouterCacheFailed && this.refreshInterval) {\n clearInterval(this.refreshInterval);\n this.refreshInterval = null;\n return;\n }\n this.syncGateways().catch(() => {});\n }, intervalMs);\n\n // Prevent the interval from keeping the process alive\n if (this.refreshInterval.unref) {\n this.refreshInterval.unref();\n }\n }\n\n /**\n * Stop auto-refresh\n */\n stopAutoRefresh(): void {\n if (this.refreshInterval) {\n clearInterval(this.refreshInterval);\n this.refreshInterval = null;\n // console.debug('[GatewayRegistry] Auto-refresh stopped');\n }\n }\n\n /**\n * Get provider configuration by ID\n */\n getProviderConfig(providerId: string): ProviderConfig | undefined {\n const data = loadRegistry(this.useDynamicLoading, this.customGateways);\n return data.providers[providerId];\n }\n\n /**\n * Check if a provider is registered\n */\n isProviderRegistered(providerId: string): boolean {\n const data = loadRegistry(this.useDynamicLoading, this.customGateways);\n return providerId in data.providers;\n }\n\n /**\n * Get all registered providers\n */\n getProviders(): Record {\n const data = loadRegistry(this.useDynamicLoading, this.customGateways);\n return data.providers;\n }\n\n /**\n * Get all models\n */\n getModels(): Record {\n return loadRegistry(this.useDynamicLoading, this.customGateways).models;\n }\n}\n\n// Auto-start refresh if enabled\n// Defaults to enabled when MASTRA_DEV=true (which enables dynamic loading by default)\n// Disabled entirely when MASTRA_OFFLINE is set (air-gapped/offline environments)\nconst isDev = process.env.MASTRA_DEV === 'true' || process.env.MASTRA_DEV === '1';\nconst autoRefreshEnabled =\n !isOfflineMode() &&\n (process.env.MASTRA_AUTO_REFRESH_PROVIDERS === 'true' ||\n (process.env.MASTRA_AUTO_REFRESH_PROVIDERS !== 'false' && isDev));\n\nif (autoRefreshEnabled) {\n // console.debug('[GatewayRegistry] Auto-refresh enabled');\n GatewayRegistry.getInstance({ useDynamicLoading: isDev }).startAutoRefresh();\n}\n"],"mappings":"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AE5FA,M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"}