feat: implement API client with SWR integration for catalog management

- Added a new Textarea component for user input. - Configured ESLint with custom rules and global ignores. - Developed a comprehensive API client with CRUD operations and error handling. - Defined catalog types and schemas using Zod for type safety. - Created utility functions for class name merging and validation. - Established Next.js configuration for API rewrites and static file headers. - Set up package.json with necessary dependencies and scripts. - Configured PostCSS for Tailwind CSS integration. - Added SVG assets for UI components. - Configured TypeScript with strict settings and module resolution.
simplify config
2025-12-01 13:07:23 +08:00 · 2025-11-24 14:48:02 +08:00 · 2025-11-24 08:55:12 +08:00 · 2025-11-24 07:36:33 +08:00 · 2025-11-24 06:12:45 +08:00 · 2025-11-24 01:40:20 +08:00
78 changed files with 78161 additions and 38 deletions
@@ -14,7 +14,7 @@
      }
    },
    "enabled": true,
-    "includes": ["**/*.json", "!*.json", "!**/package.json"]
+    "includes": ["**/*.json", "!*.json", "!**/package.json", "!packages/**/*.json"]
  },
  "css": {
    "formatter": {
@@ -113,7 +113,8 @@ export default defineConfig({
        '@cherrystudio/extension-table-plus': resolve('packages/extension-table-plus/src'),
        '@cherrystudio/ai-sdk-provider': resolve('packages/ai-sdk-provider/src'),
        '@cherrystudio/ui/icons': resolve('packages/ui/src/components/icons'),
-        '@cherrystudio/ui': resolve('packages/ui/src')
+        '@cherrystudio/ui': resolve('packages/ui/src'),
+        '@cherrystudio/catalog': resolve('packages/catalog/src')
      }
    },
    optimizeDeps: {
@@ -0,0 +1,857 @@
+# 模型和供应商参数化配置实现方案
+
+## 📋 项目概述
+
+本文档描述了在 `@packages/catalog/` 下实现模型和供应商参数化配置的方案，目标是将现有的硬编码逻辑重构为元数据驱动的配置系统。
+
+## 🎯 目标
+
+### 主要目标
+- 将硬编码的模型识别逻辑转换为 JSON 配置驱动
+- 解决"同一模型在不同供应商下有差异"的问题
+- 提供类型安全的配置系统（使用 Zod）
+- 支持未来通过配置更新添加新模型
+
+### 痛点解决
+- **当前问题**：`src/renderer/src/config/models/` 下复杂的正则表达式和硬编码逻辑
+- **期望状态**：配置以 JSON 形式存在，代码中使用 Zod Schema 验证
+- **可维护性**：新模型发布时只需更新 JSON 配置，无需修改代码
+
+## 🏗️ 架构设计
+
+### 三层分离的元数据架构
+
+```
+1. Base Model Catalog (models/*.json)
+   ├─ 模型基础信息（ID、能力、模态、限制、价格）
+   └─ 官方/标准配置
+
+2. Provider Catalog (providers/*.json)
+   ├─ 供应商特性（端点支持、API 兼容性）
+   └─ 认证和定价模型
+
+3. Provider Model Overrides (overrides/*.json)
+   ├─ 供应商对特定模型的覆盖
+   └─ 解决"同一模型不同供应商差异"问题
+```
+
+### 简化后的文件结构
+
+```
+packages/catalog/
+├── src/
+│   ├── index.ts                   # 主导出文件
+│   ├── schemas/                   # Schema 定义
+│   │   ├── index.ts               # 统一导出
+│   │   ├── model.schema.ts        # 模型配置 Schema + Zod
+│   │   ├── provider.schema.ts     # 供应商配置 Schema + Zod
+│   │   └── override.schema.ts     # 覆盖配置 Schema + Zod
+│   ├── data/                      # 配置数据（单文件存储）
+│   │   ├── models.json            # 所有模型配置
+│   │   ├── providers.json         # 所有供应商配置
+│   │   └── overrides.json         # 所有覆盖配置
+│   ├── services/                  # 核心服务
+│   │   ├── CatalogService.ts      # 统一的目录服务
+│   │   └── ConfigLoader.ts        # 配置加载 + 验证
+│   ├── utils/                     # 工具函数
+│   │   ├── migrate.ts             # 迁移工具（从旧代码提取配置）
+│   │   └── helpers.ts             # 辅助函数
+│   └── __tests__/                 # 测试文件
+│       ├── fixtures/              # 测试数据
+│       ├── schemas.test.ts        # Schema 测试
+│       └── catalog.test.ts        # 目录服务测试
+├── scripts/
+│   └── migrate.ts                 # 迁移脚本 CLI
+└── package.json
+```
+
+## 📝 Schema 定义
+
+### 1. 模型配置 Schema
+
+```typescript
+// packages/catalog/src/schemas/model.schema.ts
+
+import * as z from 'zod'
+import { EndpointTypeSchema } from './provider.schema'
+
+// 模态类型
+export const ModalitySchema = z.enum(['TEXT', 'VISION', 'AUDIO', 'VIDEO', 'VECTOR'])
+
+// 能力类型
+export const ModelCapabilityTypeSchema = z.enum([
+  'FUNCTION_CALL',      // 函数调用
+  'REASONING',          // 推理
+  'IMAGE_RECOGNITION',  // 图像识别
+  'IMAGE_GENERATION',   // 图像生成
+  'AUDIO_RECOGNITION',  // 音频识别
+  'AUDIO_GENERATION',   // 音频生成
+  'EMBEDDING',          // 嵌入向量生成
+  'RERANK',             // 文本重排序
+  'AUDIO_TRANSCRIPT',   // 音频转录
+  'VIDEO_RECOGNITION',  // 视频识别
+  'VIDEO_GENERATION',   // 视频生成
+  'STRUCTURED_OUTPUT',  // 结构化输出
+  'FILE_INPUT',         // 文件输入支持
+  'WEB_SEARCH',         // 内置网络搜索
+  'CODE_EXECUTION',     // 代码执行
+  'FILE_SEARCH',        // 文件搜索
+  'COMPUTER_USE'        // 计算机使用
+])
+
+// 推理配置
+export const ReasoningConfigSchema = z.object({
+  supportedEfforts: z.array(z.enum(['low', 'medium', 'high'])),
+  implementation: z.enum(['OPENAI_O1', 'ANTHROPIC_CLAUDE', 'DEEPSEEK_R1', 'GEMINI_THINKING']),
+  reasoningMode: z.enum(['ALWAYS_ON', 'ON_DEMAND']),
+  thinkingControl: z.object({
+    enabled: z.boolean(),
+    budget: z.object({
+      min: z.number().optional(),
+      max: z.number().optional()
+    }).optional()
+  }).optional()
+})
+
+// 参数支持配置
+export const ParameterSupportSchema = z.object({
+  temperature: z.object({
+    supported: z.boolean(),
+    min: z.number().min(0).max(2).optional(),
+    max: z.number().min(0).max(2).optional(),
+    default: z.number().min(0).max(2).optional()
+  }).optional(),
+  topP: z.object({
+    supported: z.boolean(),
+    min: z.number().min(0).max(1).optional(),
+    max: z.number().min(0).max(1).optional(),
+    default: z.number().min(0).max(1).optional()
+  }).optional(),
+  topK: z.object({
+    supported: z.boolean(),
+    min: z.number().positive().optional(),
+    max: z.number().positive().optional()
+  }).optional(),
+  frequencyPenalty: z.boolean().optional(),
+  presencePenalty: z.boolean().optional(),
+  maxTokens: z.boolean().optional(),
+  stopSequences: z.boolean().optional(),
+  systemMessage: z.boolean().optional(),
+  developerRole: z.boolean().optional()
+})
+
+// 定价配置
+export const ModelPricingSchema = z.object({
+  input: z.object({
+    perMillionTokens: z.number(),
+    currency: z.string().default('USD')
+  }),
+  output: z.object({
+    perMillionTokens: z.number(),
+    currency: z.string().default('USD')
+  }),
+  perImage: z.object({
+    price: z.number(),
+    currency: z.string().default('USD')
+  }).optional(),
+  perMinute: z.object({
+    price: z.number(),
+    currency: z.string().default('USD')
+  }).optional()
+})
+
+// 模型配置 Schema
+export const ModelConfigSchema = z.object({
+  // 基础信息
+  id: z.string(),
+  name: z.string().optional(),
+  ownedBy: z.string().optional(),
+  description: z.string().optional(),
+
+  // 能力（核心）
+  capabilities: z.array(ModelCapabilityTypeSchema),
+
+  // 模态
+  inputModalities: z.array(ModalitySchema),
+  outputModalities: z.array(ModalitySchema),
+
+  // 限制
+  contextWindow: z.number(),
+  maxOutputTokens: z.number(),
+  maxInputTokens: z.number().optional(),
+
+  // 价格
+  pricing: ModelPricingSchema.optional(),
+
+  // 推理配置
+  reasoning: ReasoningConfigSchema.optional(),
+
+  // 参数支持
+  parameters: ParameterSupportSchema.optional(),
+
+  // 端点类型
+  endpointTypes: z.array(EndpointTypeSchema).optional(),
+
+  // 元数据
+  releaseDate: z.string().optional(),
+  deprecationDate: z.string().optional(),
+  replacedBy: z.string().optional()
+})
+
+export type ModelConfig = z.infer<typeof ModelConfigSchema>
+```
+
+### 2. 供应商配置 Schema（简化版）
+
+```typescript
+// packages/catalog/src/schemas/provider.schema.ts
+
+import * as z from 'zod'
+
+// 端点类型
+export const EndpointTypeSchema = z.enum([
+  'CHAT_COMPLETIONS',
+  'COMPLETIONS',
+  'EMBEDDINGS',
+  'IMAGE_GENERATION',
+  'AUDIO_SPEECH',
+  'AUDIO_TRANSCRIPTIONS',
+  'MESSAGES',
+  'GENERATE_CONTENT',
+  'RERANK',
+  'MODERATIONS'
+])
+
+// 认证方式
+export const AuthenticationSchema = z.enum([
+  'API_KEY',
+  'OAUTH',
+  'CLOUD_CREDENTIALS'
+])
+
+// 定价模型
+export const PricingModelSchema = z.enum([
+  'UNIFIED',       // 统一定价 (如 OpenRouter)
+  'PER_MODEL',     // 按模型独立定价 (如 OpenAI 官方)
+  'TRANSPARENT',   // 透明定价 (如 New-API)
+])
+
+// 模型路由策略
+export const ModelRoutingSchema = z.enum([
+  'INTELLIGENT',      // 智能路由
+  'DIRECT',          // 直接路由
+  'LOAD_BALANCED',   // 负载均衡
+])
+
+// API 兼容性配置
+export const ApiCompatibilitySchema = z.object({
+  supportsArrayContent: z.boolean().default(true),
+  supportsStreamOptions: z.boolean().default(true),
+  supportsDeveloperRole: z.boolean().default(false),
+  supportsThinkingControl: z.boolean().default(false),
+  supportsParallelTools: z.boolean().default(false),
+  supportsMultimodal: z.boolean().default(false),
+  maxFileUploadSize: z.number().optional(),
+  supportedFileTypes: z.array(z.string()).optional()
+})
+
+// 供应商能力（简化版 - 使用数组代替多个布尔字段）
+export const ProviderCapabilitySchema = z.enum([
+  'CUSTOM_MODELS',       // 支持自定义模型
+  'MODEL_MAPPING',       // 提供模型映射
+  'FALLBACK_ROUTING',    // 降级路由
+  'AUTO_RETRY',          // 自动重试
+  'REAL_TIME_METRICS',   // 实时指标
+  'USAGE_ANALYTICS',     // 使用分析
+  'STREAMING',           // 流式响应
+  'BATCH_PROCESSING',    // 批量处理
+  'RATE_LIMITING',       // 速率限制
+])
+
+// 供应商配置 Schema（简化版）
+export const ProviderConfigSchema = z.object({
+  // 基础信息
+  id: z.string(),
+  name: z.string(),
+  description: z.string().optional(),
+
+  // 核心配置
+  authentication: AuthenticationSchema,
+  pricingModel: PricingModelSchema,
+  modelRouting: ModelRoutingSchema,
+
+  // 能力（使用数组替代多个布尔字段）
+  capabilities: z.array(ProviderCapabilitySchema).default([]),
+
+  // 功能支持
+  supportedEndpoints: z.array(EndpointTypeSchema),
+  apiCompatibility: ApiCompatibilitySchema.optional(),
+
+  // 默认配置
+  defaultApiHost: z.string().optional(),
+  defaultRateLimit: z.number().optional(),
+
+  // 模型匹配
+  modelIdPatterns: z.array(z.string()).optional(),
+  aliasModelIds: z.record(z.string()).optional(),
+
+  // 元数据
+  documentation: z.string().url().optional(),
+  statusPage: z.string().url().optional(),
+
+  // 状态
+  deprecated: z.boolean().default(false)
+})
+
+export type ProviderConfig = z.infer<typeof ProviderConfigSchema>
+```
+
+### 3. 覆盖配置 Schema
+
+```typescript
+// packages/catalog/src/schemas/override.schema.ts
+
+import * as z from 'zod'
+import { ModelCapabilityTypeSchema, ModelPricingSchema, ParameterSupportSchema } from './model.schema'
+
+export const ProviderModelOverrideSchema = z.object({
+  providerId: z.string(),
+  modelId: z.string(),
+
+  // 能力覆盖
+  capabilities: z.object({
+    add: z.array(ModelCapabilityTypeSchema).optional(),
+    remove: z.array(ModelCapabilityTypeSchema).optional()
+  }).optional(),
+
+  // 限制覆盖
+  limits: z.object({
+    contextWindow: z.number().optional(),
+    maxOutputTokens: z.number().optional()
+  }).optional(),
+
+  // 价格覆盖
+  pricing: ModelPricingSchema.optional(),
+
+  // 参数支持覆盖
+  parameters: ParameterSupportSchema.optional(),
+
+  // 禁用模型
+  disabled: z.boolean().optional(),
+
+  // 覆盖原因
+  reason: z.string().optional()
+})
+
+export type ProviderModelOverride = z.infer<typeof ProviderModelOverrideSchema>
+```
+
+## 🔧 核心 API 设计
+
+### 统一的目录服务
+
+```typescript
+// packages/catalog/src/services/CatalogService.ts
+
+export interface ModelFilters {
+  capabilities?: ModelCapabilityType[]
+  inputModalities?: Modality[]
+  providers?: string[]
+  minContextWindow?: number
+}
+
+export interface ProviderFilter {
+  capabilities?: ProviderCapability[]
+  authentication?: AuthenticationSchema
+  pricingModel?: PricingModelSchema
+  notDeprecated?: boolean
+}
+
+export class CatalogService {
+  private models: Map<string, ModelConfig>
+  private providers: Map<string, ProviderConfig>
+  private overrides: Map<string, ProviderModelOverride[]>
+
+  // === 模型查询 ===
+
+  /**
+   * 获取模型配置（应用供应商覆盖）
+   */
+  getModel(modelId: string, providerId?: string): ModelConfig | null
+
+  /**
+   * 检查模型能力
+   */
+  hasCapability(modelId: string, capability: ModelCapabilityType, providerId?: string): boolean
+
+  /**
+   * 获取模型的推理配置
+   */
+  getReasoningConfig(modelId: string, providerId?: string): ReasoningConfig | null
+
+  /**
+   * 获取模型参数范围
+   */
+  getParameterRange(
+    modelId: string,
+    parameter: 'temperature' | 'topP' | 'topK',
+    providerId?: string
+  ): { min: number, max: number, default?: number } | null
+
+  /**
+   * 批量匹配模型
+   */
+  findModels(filters?: ModelFilters): ModelConfig[]
+
+  // === 供应商查询 ===
+
+  /**
+   * 获取供应商配置
+   */
+  getProvider(providerId: string): ProviderConfig | null
+
+  /**
+   * 检查供应商能力
+   */
+  hasProviderCapability(providerId: string, capability: ProviderCapability): boolean
+
+  /**
+   * 检查端点支持
+   */
+  supportsEndpoint(providerId: string, endpoint: EndpointType): boolean
+
+  /**
+   * 查找供应商
+   */
+  findProviders(filter?: ProviderFilter): ProviderConfig[]
+
+  // === 内部方法 ===
+
+  /**
+   * 应用覆盖配置
+   */
+  private applyOverrides(model: ModelConfig, providerId: string): ModelConfig
+}
+
+// 统一导出
+export const catalog = new CatalogService()
+
+// 向后兼容的辅助函数
+export const isFunctionCallingModel = (model: Model): boolean =>
+  catalog.hasCapability(model.id, 'FUNCTION_CALL', model.provider)
+
+export const isReasoningModel = (model: Model): boolean =>
+  catalog.hasCapability(model.id, 'REASONING', model.provider)
+
+export const isVisionModel = (model: Model): boolean =>
+  catalog.hasCapability(model.id, 'IMAGE_RECOGNITION', model.provider)
+```
+
+## 📊 JSON 配置示例
+
+### 模型配置示例
+
+```json
+// packages/catalog/src/data/models.json
+{
+  "version": "2025.11.24",
+  "models": [
+    {
+      "id": "claude-3-5-sonnet-20241022",
+      "name": "Claude 3.5 Sonnet",
+      "owned_by": "anthropic",
+      "capabilities": [
+        "FUNCTION_CALL",
+        "REASONING",
+        "IMAGE_RECOGNITION",
+        "STRUCTURED_OUTPUT",
+        "FILE_INPUT"
+      ],
+      "input_modalities": ["TEXT", "VISION"],
+      "output_modalities": ["TEXT"],
+      "context_window": 200000,
+      "max_output_tokens": 8192,
+      "pricing": {
+        "input": { "per_million_tokens": 3.0, "currency": "USD" },
+        "output": { "per_million_tokens": 15.0, "currency": "USD" }
+      },
+      "reasoning": {
+        "type": "anthropic",
+        "params": {
+          "type": "enabled",
+          "budgetTokens": 10000
+        }
+      },
+      "parameters": {
+        "temperature": {
+          "supported": true,
+          "min": 0.0,
+          "max": 1.0,
+          "default": 1.0
+        }
+      },
+      "metadata": {}
+    },
+    {
+      "id": "gpt-4-turbo",
+      "name": "GPT-4 Turbo",
+      "owned_by": "openai",
+      "capabilities": [
+        "FUNCTION_CALL",
+        "IMAGE_RECOGNITION",
+        "STRUCTURED_OUTPUT"
+      ],
+      "input_modalities": ["TEXT", "VISION"],
+      "output_modalities": ["TEXT"],
+      "context_window": 128000,
+      "max_output_tokens": 4096,
+      "pricing": {
+        "input": { "per_million_tokens": 10.0, "currency": "USD" },
+        "output": { "per_million_tokens": 30.0, "currency": "USD" }
+      },
+      "metadata": {}
+    }
+  ]
+}
+```
+
+### 供应商配置示例
+
+```json
+// packages/catalog/src/data/providers.json
+{
+  "version": "2025.11.24",
+  "providers": [
+    {
+      "id": "anthropic",
+      "name": "Anthropic",
+      "authentication": "API_KEY",
+      "pricing_model": "PER_MODEL",
+      "model_routing": "DIRECT",
+      "behaviors": {
+        "supports_custom_models": false,
+        "provides_model_mapping": false,
+        "supports_streaming": true,
+        "has_real_time_metrics": true,
+        "supports_rate_limiting": true,
+        "provides_usage_analytics": true,
+        "requires_api_key_validation": true
+      },
+      "supported_endpoints": ["MESSAGES"],
+      "api_compatibility": {
+        "supports_stream_options": true,
+        "supports_parallel_tools": true,
+        "supports_multimodal": true
+      },
+      "default_api_host": "https://api.anthropic.com",
+      "deprecated": false,
+      "maintenance_mode": false,
+      "config_version": "1.0.0",
+      "special_config": {},
+      "metadata": {}
+    },
+    {
+      "id": "openrouter",
+      "name": "OpenRouter",
+      "authentication": "API_KEY",
+      "pricing_model": "UNIFIED",
+      "model_routing": "INTELLIGENT",
+      "behaviors": {
+        "supports_custom_models": true,
+        "provides_model_mapping": true,
+        "provides_fallback_routing": true,
+        "has_auto_retry": true,
+        "supports_streaming": true,
+        "has_real_time_metrics": true
+      },
+      "supported_endpoints": ["CHAT_COMPLETIONS"],
+      "default_api_host": "https://openrouter.ai/api/v1",
+      "deprecated": false,
+      "maintenance_mode": false,
+      "config_version": "1.0.0",
+      "special_config": {},
+      "metadata": {}
+    }
+  ]
+}
+```
+
+### 覆盖配置示例
+
+```json
+// packages/catalog/src/data/overrides.json
+{
+  "version": "2025.11.24",
+  "overrides": [
+    {
+      "provider_id": "openrouter",
+      "model_id": "claude-3-5-sonnet-20241022",
+      "pricing": {
+        "input": { "per_million_tokens": 4.5, "currency": "USD" },
+        "output": { "per_million_tokens": 22.5, "currency": "USD" }
+      },
+      "capabilities": {
+        "add": ["WEB_SEARCH"]
+      },
+      "reason": "OpenRouter applies markup and adds web search",
+      "priority": 0
+    },
+    {
+      "provider_id": "openrouter",
+      "model_id": "gpt-4-turbo",
+      "limits": {
+        "context_window": 128000,
+        "max_output_tokens": 16384
+      },
+      "reason": "OpenRouter extends output token limit",
+      "priority": 0
+    }
+  ]
+}
+```
+
+## 🔄 实现计划
+
+### Phase 1: 基础架构 (2-3 days)
+
+**目标**：建立核心架构和类型系统
+
+**任务**：
+1. **Schema 定义**
+   - 实现 `model.schema.ts`、`provider.schema.ts`、`override.schema.ts`
+   - 所有 Schema 使用 Zod 验证
+   - 导出 TypeScript 类型
+
+2. **配置加载器**
+   ```typescript
+   // packages/catalog/src/services/ConfigLoader.ts
+   export class ConfigLoader {
+     loadModels(): ModelConfig[]
+     loadProviders(): ProviderConfig[]
+     loadOverrides(): ProviderModelOverride[]
+     validate(): boolean
+   }
+   ```
+
+3. **目录服务**
+   ```typescript
+   // packages/catalog/src/services/CatalogService.ts
+   export class CatalogService {
+     // 实现所有查询 API
+   }
+   ```
+
+**验收标准**：
+- ✅ 所有 Schema 定义完成，通过 Zod 验证
+- ✅ ConfigLoader 可以加载和验证 JSON 文件
+- ✅ CatalogService 基础 API 实现
+- ✅ 单元测试覆盖核心功能
+
+### Phase 2: 数据迁移 (1-2 days)
+
+**目标**：从现有硬编码逻辑生成 JSON 配置
+
+**任务**：
+1. **迁移工具**
+   ```typescript
+   // packages/catalog/src/utils/migrate.ts
+   export class MigrationTool {
+     // 从 src/renderer/src/config/models/ 提取模型配置
+     extractModelConfigs(): ModelConfig[]
+
+     // 提取供应商配置
+     extractProviderConfigs(): ProviderConfig[]
+
+     // 写入 JSON 文件
+     writeConfigs(models: ModelConfig[], providers: ProviderConfig[]): void
+
+     // 简单验证
+     validate(): boolean
+   }
+   ```
+
+2. **迁移脚本**
+   ```bash
+   # 运行迁移
+   yarn catalog:migrate
+   ```
+
+3. **手动审核**
+   - 检查生成的配置文件
+   - 补充缺失的价格和限制信息
+   - 调整不准确的能力定义
+
+**验收标准**：
+- ✅ 迁移工具能够提取现有配置
+- ✅ 生成的配置通过 Schema 验证
+- ✅ 手动审核完成，配置准确
+
+### Phase 3: 集成替换 (2-3 days)
+
+**目标**：替换现有硬编码逻辑
+
+**任务**：
+1. **向后兼容层**
+   ```typescript
+   // packages/catalog/src/index.ts
+   export const isFunctionCallingModel = (model: Model): boolean =>
+     catalog.hasCapability(model.id, 'FUNCTION_CALL', model.provider)
+   ```
+
+2. **逐步替换**
+   - 替换 `src/renderer/src/config/models/` 中的函数
+   - 更新所有调用点
+   - 确保测试通过
+
+3. **集成测试**
+   - 端到端测试
+   - 性能测试
+   - 兼容性测试
+
+**验收标准**：
+- ✅ 所有现有测试通过
+- ✅ 新配置系统与旧系统行为一致
+- ✅ 性能不低于原有实现
+
+### 延迟实现 ⏸️
+
+以下功能在初期版本不实现，等待实际需求：
+
+- ⏸️ **在线配置更新**：等到有用户需求再实现
+- ⏸️ **复杂缓存机制**：等出现性能问题再优化
+- ⏸️ **配置版本控制**：简化为文件级别的版本号
+
+## 🧪 测试策略
+
+### 测试覆盖
+
+1. **Schema 测试**
+   ```typescript
+   describe('ModelConfig Schema', () => {
+     it('validates correct config', () => {
+       expect(() => ModelConfigSchema.parse(validConfig)).not.toThrow()
+     })
+
+     it('rejects invalid config', () => {
+       expect(() => ModelConfigSchema.parse(invalidConfig)).toThrow()
+     })
+   })
+   ```
+
+2. **服务测试**
+   ```typescript
+   describe('CatalogService', () => {
+     it('returns model with overrides applied', () => {
+       const model = catalog.getModel('claude-3-5-sonnet', 'openrouter')
+       expect(model?.pricing).toEqual(expectedPricing)
+     })
+
+     it('checks capabilities correctly', () => {
+       expect(catalog.hasCapability('gpt-4', 'FUNCTION_CALL')).toBe(true)
+     })
+   })
+   ```
+
+3. **兼容性测试**
+   ```typescript
+   describe('Backward Compatibility', () => {
+     it('produces same results as legacy', () => {
+       expect(isFunctionCallingModel(testModel)).toBe(legacyResult)
+     })
+   })
+   ```
+
+## 📖 使用指南
+
+### 基本用法
+
+```typescript
+import { catalog } from '@cherrystudio/catalog'
+
+// 检查模型能力
+const canCallFunctions = catalog.hasCapability('gpt-4', 'FUNCTION_CALL')
+const canReason = catalog.hasCapability('o1-preview', 'REASONING')
+
+// 获取模型配置
+const modelConfig = catalog.getModel('claude-3-5-sonnet', 'openrouter')
+
+// 查找模型
+const visionModels = catalog.findModels({
+  capabilities: ['IMAGE_RECOGNITION'],
+  providers: ['anthropic', 'openai']
+})
+
+// 检查供应商能力
+const hasMapping = catalog.hasProviderCapability('openrouter', 'MODEL_MAPPING')
+```
+
+### 供应商查询
+
+```typescript
+// 查找具有特定能力的供应商
+const providersWithFallback = catalog.findProviders({
+  capabilities: ['FALLBACK_ROUTING', 'AUTO_RETRY']
+})
+
+// 查找统一定价的供应商
+const unifiedPricingProviders = catalog.findProviders({
+  pricingModel: 'UNIFIED'
+})
+```
+
+## 📝 维护指南
+
+### 添加新模型
+
+1. 编辑对应的模型配置文件
+2. 添加模型信息
+3. 运行验证：`yarn catalog:validate`
+4. 提交 PR
+
+### 添加新供应商
+
+1. 编辑 `providers.json`
+2. 添加供应商配置
+3. 如需覆盖，添加到 `overrides.json`
+4. 验证并提交
+
+## 🔧 开发工具
+
+### 命令行
+
+```json
+{
+  "scripts": {
+    "catalog:validate": "tsx scripts/validate.ts",
+    "catalog:migrate": "tsx scripts/migrate.ts",
+    "catalog:test": "vitest run",
+    "catalog:build": "tsdown"
+  }
+}
+```
+
+## 📚 迁移对照表
+
+| 旧函数 | 新 API |
+|--------|--------|
+| `isFunctionCallingModel(model)` | `catalog.hasCapability(model.id, 'FUNCTION_CALL', model.provider)` |
+| `isReasoningModel(model)` | `catalog.hasCapability(model.id, 'REASONING', model.provider)` |
+| `isVisionModel(model)` | `catalog.hasCapability(model.id, 'IMAGE_RECOGNITION', model.provider)` |
+| `getThinkModelType(model)` | `catalog.getReasoningConfig(model.id, model.provider)` |
+
+## 📊 预期成果
+
+### 时间估算
+- Phase 1: 2-3 天
+- Phase 2: 1-2 天
+- Phase 3: 2-3 天
+- **总计**: 5-8 天
+
+### 性能目标
+- 配置加载时间: < 100ms
+- 模型查询时间: < 1ms
+- 内存使用: < 50MB
+
+---
+
+这个简化方案专注于核心功能，避免过度设计，遵循"保持简洁"的原则，为未来扩展留有空间。
@@ -0,0 +1 @@
+# catalog
@@ -0,0 +1,627 @@
+{
+  "openapi": "3.0.3",
+  "info": {
+    "title": "Cherry Studio Catalog API",
+    "description": "REST API for managing AI models and providers catalog",
+    "version": "1.0.0",
+    "contact": {
+      "name": "Cherry Studio Team"
+    }
+  },
+  "servers": [
+    {
+      "url": "http://localhost:3000/api",
+      "description": "Development server"
+    }
+  ],
+  "paths": {
+    "/catalog/models": {
+      "get": {
+        "summary": "List models with pagination and filtering",
+        "parameters": [
+          {
+            "name": "page",
+            "in": "query",
+            "schema": {
+              "type": "integer",
+              "minimum": 1,
+              "default": 1
+            }
+          },
+          {
+            "name": "limit",
+            "in": "query",
+            "schema": {
+              "type": "integer",
+              "minimum": 1,
+              "maximum": 100,
+              "default": 20
+            }
+          },
+          {
+            "name": "search",
+            "in": "query",
+            "schema": {
+              "type": "string"
+            }
+          },
+          {
+            "name": "capabilities",
+            "in": "query",
+            "schema": {
+              "type": "array",
+              "items": {
+                "type": "string"
+              }
+            }
+          },
+          {
+            "name": "providers",
+            "in": "query",
+            "schema": {
+              "type": "array",
+              "items": {
+                "type": "string"
+              }
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Paginated list of models",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/PaginatedModels"
+                }
+              }
+            }
+          }
+        }
+      },
+      "put": {
+        "summary": "Update models configuration",
+        "requestBody": {
+          "required": true,
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/ModelsConfig"
+              }
+            }
+          }
+        },
+        "responses": {
+          "200": {
+            "description": "Models updated successfully"
+          }
+        }
+      }
+    },
+    "/catalog/models/{modelId}": {
+      "get": {
+        "summary": "Get specific model details",
+        "parameters": [
+          {
+            "name": "modelId",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Model details",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/Model"
+                }
+              }
+            }
+          }
+        }
+      },
+      "put": {
+        "summary": "Update specific model",
+        "parameters": [
+          {
+            "name": "modelId",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string"
+            }
+          }
+        ],
+        "requestBody": {
+          "required": true,
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/Model"
+              }
+            }
+          }
+        },
+        "responses": {
+          "200": {
+            "description": "Model updated successfully"
+          }
+        }
+      }
+    },
+    "/catalog/providers": {
+      "get": {
+        "summary": "List providers with pagination and filtering",
+        "parameters": [
+          {
+            "name": "page",
+            "in": "query",
+            "schema": {
+              "type": "integer",
+              "minimum": 1,
+              "default": 1
+            }
+          },
+          {
+            "name": "limit",
+            "in": "query",
+            "schema": {
+              "type": "integer",
+              "minimum": 1,
+              "maximum": 100,
+              "default": 20
+            }
+          },
+          {
+            "name": "search",
+            "in": "query",
+            "schema": {
+              "type": "string"
+            }
+          },
+          {
+            "name": "authentication",
+            "in": "query",
+            "schema": {
+              "type": "array",
+              "items": {
+                "type": "string"
+              }
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Paginated list of providers",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/PaginatedProviders"
+                }
+              }
+            }
+          }
+        }
+      },
+      "put": {
+        "summary": "Update providers configuration",
+        "requestBody": {
+          "required": true,
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/ProvidersConfig"
+              }
+            }
+          }
+        },
+        "responses": {
+          "200": {
+            "description": "Providers updated successfully"
+          }
+        }
+      }
+    },
+    "/catalog/providers/{providerId}": {
+      "get": {
+        "summary": "Get specific provider details",
+        "parameters": [
+          {
+            "name": "providerId",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Provider details",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/Provider"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/catalog/models/{modelId}/overrides": {
+      "get": {
+        "summary": "Get provider-specific overrides for a model",
+        "parameters": [
+          {
+            "name": "modelId",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Provider overrides for the model",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "additionalProperties": {
+                    "$ref": "#/components/schemas/Model"
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/catalog/models/{modelId}/providers/{providerId}": {
+      "get": {
+        "summary": "Get model configuration as seen by specific provider",
+        "parameters": [
+          {
+            "name": "modelId",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string"
+            }
+          },
+          {
+            "name": "providerId",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Model configuration with provider-specific overrides applied",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/Model"
+                }
+              }
+            }
+          }
+        }
+      },
+      "put": {
+        "summary": "Update model configuration for specific provider (auto-detects if override is needed)",
+        "parameters": [
+          {
+            "name": "modelId",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string"
+            }
+          },
+          {
+            "name": "providerId",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string"
+            }
+          }
+        ],
+        "requestBody": {
+          "required": true,
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/Model"
+              }
+            }
+          }
+        },
+        "responses": {
+          "200": {
+            "description": "Model configuration updated (override created/updated if needed)",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "updated": {
+                      "type": "string",
+                      "enum": ["base_model", "override", "both"]
+                    },
+                    "model": {
+                      "$ref": "#/components/schemas/Model"
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/catalog/stats": {
+      "get": {
+        "summary": "Get catalog statistics",
+        "responses": {
+          "200": {
+            "description": "Catalog statistics",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/CatalogStats"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/catalog/validate": {
+      "post": {
+        "summary": "Validate catalog configuration",
+        "responses": {
+          "200": {
+            "description": "Validation results",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ValidationResult"
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  },
+  "components": {
+    "schemas": {
+      "Model": {
+        "type": "object",
+        "properties": {
+          "id": { "type": "string" },
+          "name": { "type": "string" },
+          "owned_by": { "type": "string" },
+          "capabilities": {
+            "type": "array",
+            "items": { "type": "string" }
+          },
+          "input_modalities": {
+            "type": "array",
+            "items": { "type": "string" }
+          },
+          "output_modalities": {
+            "type": "array",
+            "items": { "type": "string" }
+          },
+          "context_window": { "type": "integer" },
+          "max_output_tokens": { "type": "integer" },
+          "max_input_tokens": { "type": "integer" },
+          "pricing": {
+            "$ref": "#/components/schemas/Pricing"
+          },
+          "parameters": {
+            "$ref": "#/components/schemas/Parameters"
+          },
+          "endpoint_types": {
+            "type": "array",
+            "items": { "type": "string" }
+          },
+          "metadata": { "type": "object" }
+        }
+      },
+      "Provider": {
+        "type": "object",
+        "properties": {
+          "id": { "type": "string" },
+          "name": { "type": "string" },
+          "description": { "type": "string" },
+          "authentication": { "type": "string" },
+          "pricing_model": { "type": "string" },
+          "model_routing": { "type": "string" },
+          "behaviors": { "type": "object" },
+          "supported_endpoints": {
+            "type": "array",
+            "items": { "type": "string" }
+          },
+          "api_compatibility": { "type": "object" },
+          "special_config": { "type": "object" },
+          "documentation": { "type": "string" },
+          "website": { "type": "string" },
+          "deprecated": { "type": "boolean" },
+          "maintenance_mode": { "type": "boolean" },
+          "config_version": { "type": "string" },
+          "metadata": { "type": "object" }
+        }
+      },
+      "Override": {
+        "type": "object",
+        "properties": {
+          "provider_id": { "type": "string" },
+          "model_id": { "type": "string" },
+          "disabled": { "type": "boolean" },
+          "reason": { "type": "string" },
+          "last_updated": { "type": "string" },
+          "updated_by": { "type": "string" },
+          "priority": { "type": "integer" },
+          "limits": {
+            "type": "object",
+            "properties": {
+              "context_window": { "type": "integer" },
+              "max_output_tokens": { "type": "integer" }
+            }
+          },
+          "pricing": {
+            "$ref": "#/components/schemas/Pricing"
+          }
+        }
+      },
+      "Pricing": {
+        "type": "object",
+        "properties": {
+          "input": {
+            "type": "object",
+            "properties": {
+              "per_million_tokens": { "type": "number" },
+              "currency": { "type": "string" }
+            }
+          },
+          "output": {
+            "type": "object",
+            "properties": {
+              "per_million_tokens": { "type": "number" },
+              "currency": { "type": "string" }
+            }
+          }
+        }
+      },
+      "Parameters": {
+        "type": "object",
+        "additionalProperties": true
+      },
+      "PaginatedModels": {
+        "type": "object",
+        "properties": {
+          "data": {
+            "type": "array",
+            "items": {
+              "$ref": "#/components/schemas/Model"
+            }
+          },
+          "pagination": {
+            "$ref": "#/components/schemas/Pagination"
+          }
+        }
+      },
+      "PaginatedProviders": {
+        "type": "object",
+        "properties": {
+          "data": {
+            "type": "array",
+            "items": {
+              "$ref": "#/components/schemas/Provider"
+            }
+          },
+          "pagination": {
+            "$ref": "#/components/schemas/Pagination"
+          }
+        }
+      },
+      "PaginatedOverrides": {
+        "type": "object",
+        "properties": {
+          "data": {
+            "type": "array",
+            "items": {
+              "$ref": "#/components/schemas/Override"
+            }
+          },
+          "pagination": {
+            "$ref": "#/components/schemas/Pagination"
+          }
+        }
+      },
+      "Pagination": {
+        "type": "object",
+        "properties": {
+          "page": { "type": "integer" },
+          "limit": { "type": "integer" },
+          "total": { "type": "integer" },
+          "totalPages": { "type": "integer" }
+        }
+      },
+      "ModelsConfig": {
+        "type": "object",
+        "properties": {
+          "version": { "type": "string" },
+          "models": {
+            "type": "array",
+            "items": {
+              "$ref": "#/components/schemas/Model"
+            }
+          }
+        }
+      },
+      "ProvidersConfig": {
+        "type": "object",
+        "properties": {
+          "version": { "type": "string" },
+          "providers": {
+            "type": "array",
+            "items": {
+              "$ref": "#/components/schemas/Provider"
+            }
+          }
+        }
+      },
+      "OverridesConfig": {
+        "type": "object",
+        "properties": {
+          "version": { "type": "string" },
+          "overrides": {
+            "type": "array",
+            "items": {
+              "$ref": "#/components/schemas/Override"
+            }
+          }
+        }
+      },
+      "CatalogStats": {
+        "type": "object",
+        "properties": {
+          "total_models": { "type": "integer" },
+          "total_providers": { "type": "integer" },
+          "total_overrides": { "type": "integer" },
+          "models_by_provider": { "type": "object" },
+          "overrides_by_provider": { "type": "object" },
+          "last_updated": { "type": "string" }
+        }
+      },
+      "ValidationResult": {
+        "type": "object",
+        "properties": {
+          "valid": { "type": "boolean" },
+          "errors": {
+            "type": "array",
+            "items": { "type": "string" }
+          },
+          "warnings": {
+            "type": "array",
+            "items": { "type": "string" }
+          }
+        }
+      }
+    }
+  }
+}
@@ -0,0 +1,88 @@
+{
+  "timestamp": "2025-11-24T06:41:03.487Z",
+  "summary": {
+    "total_providers": 104,
+    "total_base_models": 241,
+    "total_overrides": 1164,
+    "provider_categories": {
+      "direct": 2,
+      "cloud": 6,
+      "proxy": 3,
+      "self_hosted": 5
+    },
+    "models_by_provider": {
+      "openai": 79,
+      "anthropic": 20,
+      "dashscope": 22,
+      "deepseek": 7,
+      "gemini": 50,
+      "mistral": 31,
+      "xai": 32
+    },
+    "overrides_by_provider": {
+      "bedrock": 152,
+      "bedrock_converse": 56,
+      "anyscale": 12,
+      "azure": 112,
+      "azure_ai": 45,
+      "cerebras": 5,
+      "vertex_ai-chat-models": 5,
+      "nlp_cloud": 1,
+      "cloudflare": 4,
+      "vertex_ai-code-text-models": 1,
+      "vertex_ai-code-chat-models": 6,
+      "codestral": 2,
+      "cohere_chat": 7,
+      "databricks": 9,
+      "deepinfra": 67,
+      "featherless_ai": 2,
+      "fireworks_ai": 27,
+      "friendliai": 2,
+      "openai": 8,
+      "vertex_ai-language-models": 46,
+      "vertex_ai-vision-models": 3,
+      "gradient_ai": 13,
+      "groq": 27,
+      "heroku": 4,
+      "hyperbolic": 16,
+      "ai21": 9,
+      "lambda_ai": 20,
+      "lemonade": 5,
+      "aleph_alpha": 3,
+      "meta_llama": 4,
+      "moonshot": 17,
+      "morph": 2,
+      "nscale": 14,
+      "oci": 13,
+      "ollama": 21,
+      "openrouter": 92,
+      "ovhcloud": 15,
+      "palm": 2,
+      "perplexity": 25,
+      "replicate": 13,
+      "sagemaker": 3,
+      "sambanova": 16,
+      "snowflake": 24,
+      "together_ai": 36,
+      "v0": 3,
+      "vercel_ai_gateway": 85,
+      "vertex_ai-anthropic_models": 22,
+      "vertex_ai-mistral_models": 19,
+      "vertex_ai-deepseek_models": 2,
+      "vertex_ai": 1,
+      "vertex_ai-ai21_models": 5,
+      "vertex_ai-llama_models": 11,
+      "vertex_ai-minimax_models": 1,
+      "vertex_ai-moonshot_models": 1,
+      "vertex_ai-openai_models": 2,
+      "vertex_ai-qwen_models": 4,
+      "wandb": 14,
+      "watsonx": 28
+    }
+  },
+  "files": {
+    "providers": "providers.json",
+    "models": "models.json",
+    "overrides": "overrides.json"
+  }
+}
@@ -0,0 +1,54 @@
+{
+  "name": "@cherrystudio/catalog",
+  "version": "0.0.1-alpha.1",
+  "description": "All Model Catalog",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "packageManager": "yarn@4.9.1",
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsc -w",
+    "clean": "rm -rf dist",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "author": "Cherry Studio",
+  "license": "MIT",
+  "files": [
+    "dist/**/*"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/CherryHQ/cherry-studio.git"
+  },
+  "bugs": {
+    "url": "https://github.com/CherryHQ/cherry-studio/issues"
+  },
+  "homepage": "https://github.com/CherryHQ/cherry-studio#readme",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "react-native": "./dist/index.js",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "devDependencies": {
+    "@types/json-schema": "^7.0.15",
+    "tsdown": "^0.16.6",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.13",
+    "zod": "^4.1.12"
+  },
+  "peerDependencies": {
+    "zod": "^4.1.12"
+  },
+  "dependencies": {
+    "json-schema": "^0.4.0"
+  },
+  "workspaces": [
+    "web"
+  ]
+}
@@ -0,0 +1,39 @@
+#!/usr/bin/env tsx
+
+/**
+ * Migration Script - Phase 2 Implementation
+ * Usage: npx tsx migrate.ts
+ */
+
+import * as path from 'path'
+
+import { MigrationTool } from '../src/utils/migration'
+
+async function main() {
+  const packageRoot = path.resolve(__dirname, '..')
+  const sourceDir = packageRoot
+  const outputDir = path.join(packageRoot, 'data')
+
+  console.log('🔧 Cherry Studio Catalog Migration - Phase 2')
+  console.log('==========================================')
+  console.log(`📁 Source: ${sourceDir}`)
+  console.log(`📁 Output: ${outputDir}`)
+  console.log('')
+
+  const tool = new MigrationTool(
+    path.join(sourceDir, 'provider_endpoints_support.json'),
+    path.join(sourceDir, 'model_prices_and_context_window.json'),
+    outputDir
+  )
+
+  try {
+    await tool.migrate()
+    console.log('')
+    console.log('🎉 Migration completed! Check the src/data/ directory for results.')
+  } catch (error) {
+    console.error('❌ Migration failed:', error)
+    process.exit(1)
+  }
+}
+
+main()
@@ -0,0 +1,240 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`Config & Schema > Snapshot Tests > should snapshot complete configuration structure 1`] = `
+{
+  "models": Any<Array>,
+  "overrides": Any<Array>,
+  "providers": Any<Array>,
+}
+`;
+
+exports[`Config & Schema > Snapshot Tests > should snapshot model configurations 1`] = `
+[
+  {
+    "capabilities": [
+      "FUNCTION_CALL",
+      "REASONING",
+    ],
+    "contextWindow": 128000,
+    "description": "A test model for unit testing",
+    "endpointTypes": [
+      "CHAT_COMPLETIONS",
+    ],
+    "id": "test-model",
+    "inputModalities": [
+      "TEXT",
+    ],
+    "maxInputTokens": 124000,
+    "maxOutputTokens": 4096,
+    "metadata": {
+      "architecture": "transformer",
+      "category": "language-model",
+      "documentation": "https://docs.test.com/models/test-model",
+      "family": "test-family",
+      "license": "mit",
+      "source": "test",
+      "tags": [
+        "test",
+        "fast",
+        "reliable",
+      ],
+      "trainingData": "synthetic",
+    },
+    "name": "Test Model",
+    "outputModalities": [
+      "TEXT",
+    ],
+    "ownedBy": "TestProvider",
+    "parameters": {
+      "maxTokens": true,
+      "systemMessage": true,
+      "temperature": {
+        "default": 1,
+        "max": 2,
+        "min": 0,
+        "supported": true,
+      },
+      "topP": {
+        "default": 1,
+        "max": 1,
+        "min": 0,
+        "supported": true,
+      },
+    },
+    "pricing": {
+      "input": {
+        "currency": "USD",
+        "perMillionTokens": 1,
+      },
+      "output": {
+        "currency": "USD",
+        "perMillionTokens": 2,
+      },
+    },
+  },
+]
+`;
+
+exports[`Config & Schema > Snapshot Tests > should snapshot override configurations 1`] = `
+[
+  {
+    "capabilities": {
+      "add": [
+        "FUNCTION_CALL",
+      ],
+      "remove": [
+        "REASONING",
+      ],
+    },
+    "disabled": false,
+    "lastUpdated": "2025-11-24T07:08:00Z",
+    "limits": {
+      "contextWindow": 256000,
+      "maxOutputTokens": 8192,
+    },
+    "modelId": "test-model",
+    "pricing": {
+      "input": {
+        "currency": "USD",
+        "perMillionTokens": 0.5,
+      },
+    },
+    "priority": 100,
+    "providerId": "test-provider",
+    "reason": "Test override for enhanced capabilities and limits",
+    "updatedBy": "test-suite",
+  },
+]
+`;
+
+exports[`Config & Schema > Snapshot Tests > should snapshot provider configurations 1`] = `
+[
+  {
+    "apiCompatibility": {
+      "supportsApiVersion": false,
+      "supportsArrayContent": true,
+      "supportsDeveloperRole": false,
+      "supportsMultimodal": false,
+      "supportsParallelTools": false,
+      "supportsServiceTier": false,
+      "supportsStreamOptions": false,
+      "supportsThinkingControl": false,
+    },
+    "authentication": "API_KEY",
+    "behaviors": {
+      "hasAutoRetry": false,
+      "hasRealTimeMetrics": false,
+      "providesFallbackRouting": false,
+      "providesModelMapping": false,
+      "providesUsageAnalytics": false,
+      "providesUsageLimits": false,
+      "requiresApiKeyValidation": true,
+      "supportsBatchProcessing": false,
+      "supportsCustomModels": false,
+      "supportsHealthCheck": false,
+      "supportsModelFineTuning": false,
+      "supportsModelVersioning": false,
+      "supportsRateLimiting": false,
+      "supportsStreaming": true,
+      "supportsWebhookEvents": false,
+    },
+    "configVersion": "1.0.0",
+    "deprecated": false,
+    "description": "A test provider for unit testing",
+    "documentation": "https://docs.test.com",
+    "id": "test-provider",
+    "maintenanceMode": false,
+    "metadata": {
+      "category": "ai-provider",
+      "reliability": "high",
+      "source": "test",
+      "supportedLanguages": [
+        "en",
+      ],
+      "tags": [
+        "test",
+      ],
+    },
+    "modelRouting": "DIRECT",
+    "name": "Test Provider",
+    "pricingModel": "PER_MODEL",
+    "specialConfig": {},
+    "supportedEndpoints": [
+      "CHAT_COMPLETIONS",
+    ],
+    "website": "https://test.com",
+  },
+]
+`;
+
+exports[`Config & Schema > Snapshot Tests > should snapshot validation results 1`] = `
+{
+  "data": {
+    "capabilities": [
+      "FUNCTION_CALL",
+      "REASONING",
+    ],
+    "contextWindow": 128000,
+    "description": "A test model for unit testing",
+    "endpointTypes": [
+      "CHAT_COMPLETIONS",
+    ],
+    "id": "test-model",
+    "inputModalities": [
+      "TEXT",
+    ],
+    "maxInputTokens": 124000,
+    "maxOutputTokens": 4096,
+    "metadata": {
+      "architecture": "transformer",
+      "category": "language-model",
+      "documentation": "https://docs.test.com/models/test-model",
+      "family": "test-family",
+      "license": "mit",
+      "source": "test",
+      "tags": [
+        "test",
+        "fast",
+        "reliable",
+      ],
+      "trainingData": "synthetic",
+    },
+    "name": "Test Model",
+    "outputModalities": [
+      "TEXT",
+    ],
+    "ownedBy": "TestProvider",
+    "parameters": {
+      "maxTokens": true,
+      "systemMessage": true,
+      "temperature": {
+        "default": 1,
+        "max": 2,
+        "min": 0,
+        "supported": true,
+      },
+      "topP": {
+        "default": 1,
+        "max": 1,
+        "min": 0,
+        "supported": true,
+      },
+    },
+    "pricing": {
+      "input": {
+        "currency": "USD",
+        "perMillionTokens": 1,
+      },
+      "output": {
+        "currency": "USD",
+        "perMillionTokens": 2,
+      },
+    },
+  },
+  "success": true,
+  "warnings": [
+    "Model has REASONING capability but no reasoning configuration",
+    "Custom validation warning for snapshot",
+  ],
+}
+`;
@@ -0,0 +1,381 @@
+import * as path from 'path'
+import { describe, expect, it } from 'vitest'
+
+import { ConfigLoader } from '../loader/ConfigLoader'
+import { SchemaValidator } from '../validator/SchemaValidator'
+
+// Use fixtures directory for test data
+const fixturesPath = path.join(__dirname, 'fixtures')
+
+describe('Config & Schema', () => {
+  describe('ConfigLoader', () => {
+    it('should load models with complete validation', async () => {
+      const loader = new ConfigLoader({
+        basePath: fixturesPath,
+        validateOnLoad: true,
+        cacheEnabled: false
+      })
+
+      const models = await loader.loadModels('test-models.json')
+      expect(models).toBeDefined()
+      expect(Array.isArray(models)).toBe(true)
+      expect(models).toHaveLength(1)
+
+      const model = models[0]
+      expect(model).toStrictEqual({
+        id: 'test-model',
+        name: 'Test Model',
+        ownedBy: 'TestProvider',
+        description: 'A test model for unit testing',
+        capabilities: ['FUNCTION_CALL', 'REASONING'],
+        inputModalities: ['TEXT'],
+        outputModalities: ['TEXT'],
+        contextWindow: 128000,
+        maxOutputTokens: 4096,
+        maxInputTokens: 124000,
+        pricing: {
+          input: { perMillionTokens: 1, currency: 'USD' },
+          output: { perMillionTokens: 2, currency: 'USD' }
+        },
+        parameters: {
+          temperature: { supported: true, min: 0, max: 2, default: 1 },
+          maxTokens: true,
+          systemMessage: true,
+          topP: { supported: true, min: 0, max: 1, default: 1 }
+        },
+        endpointTypes: ['CHAT_COMPLETIONS'],
+        metadata: {
+          tags: ['test', 'fast', 'reliable'],
+          category: 'language-model',
+          source: 'test',
+          license: 'mit',
+          documentation: 'https://docs.test.com/models/test-model',
+          family: 'test-family',
+          architecture: 'transformer',
+          trainingData: 'synthetic'
+        }
+      })
+    })
+
+    it('should load providers with complete validation', async () => {
+      const loader = new ConfigLoader({
+        basePath: fixturesPath,
+        validateOnLoad: true,
+        cacheEnabled: false
+      })
+
+      const providers = await loader.loadProviders('test-providers.json')
+      expect(providers).toBeDefined()
+      expect(Array.isArray(providers)).toBe(true)
+      expect(providers).toHaveLength(1)
+
+      const provider = providers[0]
+      expect(provider).toStrictEqual({
+        id: 'test-provider',
+        name: 'Test Provider',
+        description: 'A test provider for unit testing',
+        authentication: 'API_KEY',
+        pricingModel: 'PER_MODEL',
+        modelRouting: 'DIRECT',
+        behaviors: {
+          supportsCustomModels: false,
+          providesModelMapping: false,
+          supportsModelVersioning: false,
+          providesFallbackRouting: false,
+          hasAutoRetry: false,
+          supportsHealthCheck: false,
+          hasRealTimeMetrics: false,
+          providesUsageAnalytics: false,
+          supportsWebhookEvents: false,
+          requiresApiKeyValidation: true,
+          supportsRateLimiting: false,
+          providesUsageLimits: false,
+          supportsStreaming: true,
+          supportsBatchProcessing: false,
+          supportsModelFineTuning: false
+        },
+        supportedEndpoints: ['CHAT_COMPLETIONS'],
+        apiCompatibility: {
+          supportsArrayContent: true,
+          supportsStreamOptions: false,
+          supportsDeveloperRole: false,
+          supportsThinkingControl: false,
+          supportsApiVersion: false,
+          supportsParallelTools: false,
+          supportsMultimodal: false,
+          supportsServiceTier: false
+        },
+        specialConfig: {},
+        documentation: 'https://docs.test.com',
+        website: 'https://test.com',
+        deprecated: false,
+        maintenanceMode: false,
+        configVersion: '1.0.0',
+        metadata: {
+          tags: ['test'],
+          category: 'ai-provider',
+          source: 'test',
+          reliability: 'high',
+          supportedLanguages: ['en']
+        }
+      })
+    })
+
+    it('should load overrides with complete validation', async () => {
+      const loader = new ConfigLoader({
+        basePath: fixturesPath,
+        validateOnLoad: true,
+        cacheEnabled: false
+      })
+
+      const overrides = await loader.loadOverrides('test-overrides.json')
+      expect(overrides).toBeDefined()
+      expect(Array.isArray(overrides)).toBe(true)
+      expect(overrides).toHaveLength(1)
+
+      const override = overrides[0]
+      expect(override).toMatchObject({
+        providerId: 'test-provider',
+        modelId: 'test-model',
+        disabled: false,
+        reason: 'Test override for enhanced capabilities and limits',
+        priority: 100
+      })
+
+      expect(override.capabilities?.add).toContain('FUNCTION_CALL')
+      expect(override.capabilities?.remove).toContain('REASONING')
+      expect(override.limits?.contextWindow).toBe(256000)
+      expect(override.limits?.maxOutputTokens).toBe(8192)
+    })
+
+    it('should load all configs simultaneously', async () => {
+      const loader = new ConfigLoader({
+        basePath: fixturesPath,
+        validateOnLoad: true,
+        cacheEnabled: false
+      })
+
+      const configs = await loader.loadAllConfigs({
+        modelsFile: 'test-models.json',
+        providersFile: 'test-providers.json',
+        overridesFile: 'test-overrides.json'
+      })
+
+      expect(configs).toHaveProperty('models')
+      expect(configs).toHaveProperty('providers')
+      expect(configs).toHaveProperty('overrides')
+      expect(configs.models).toHaveLength(1)
+      expect(configs.providers).toHaveLength(1)
+      expect(configs.overrides).toHaveLength(1)
+    })
+
+    it('should handle missing files gracefully', async () => {
+      const loader = new ConfigLoader({
+        basePath: '/nonexistent/path'
+      })
+
+      await expect(loader.loadModels('nonexistent.json')).rejects.toThrow('Failed to load models')
+    })
+  })
+
+  describe('SchemaValidator', () => {
+    it('should validate valid model configuration', async () => {
+      const validator = new SchemaValidator()
+
+      const validModel = {
+        id: 'test-model',
+        capabilities: ['FUNCTION_CALL', 'REASONING'],
+        inputModalities: ['TEXT'],
+        outputModalities: ['TEXT'],
+        contextWindow: 128000,
+        maxOutputTokens: 4096,
+        metadata: {
+          tags: ['test'],
+          category: 'language-model',
+          source: 'test'
+        }
+      }
+
+      const result = await validator.validateModel(validModel)
+      expect(result.success).toBe(true)
+      expect(result.data).toBeDefined()
+      expect(result.data!.id).toBe('test-model')
+    })
+
+    it('should reject invalid model configuration', async () => {
+      const validator = new SchemaValidator()
+
+      const invalidModel = {
+        id: 123, // Should be string
+        capabilities: 'not-array', // Should be array
+        contextWindow: -1000 // Should be positive
+      }
+
+      const result = await validator.validateModel(invalidModel)
+      expect(result.success).toBe(false)
+      expect(result.errors).toBeDefined()
+      expect(result.errors!.length).toBeGreaterThan(0)
+    })
+
+    it('should provide warnings for model configuration issues', async () => {
+      const validator = new SchemaValidator()
+
+      const modelWithIssues = {
+        id: 'test-model',
+        capabilities: [], // Empty capabilities
+        inputModalities: ['TEXT'],
+        outputModalities: ['TEXT'],
+        contextWindow: 200000, // Large context window
+        maxOutputTokens: 4096,
+        // Missing pricing and description
+        metadata: {
+          tags: ['test'],
+          category: 'language-model',
+          source: 'test'
+        }
+      }
+
+      const result = await validator.validateModel(modelWithIssues)
+      expect(result.success).toBe(true)
+      expect(result.warnings).toBeDefined()
+      expect(result.warnings!.length).toBeGreaterThan(0)
+    })
+
+    it('should accept custom validation warnings', async () => {
+      const validator = new SchemaValidator()
+
+      const model = {
+        id: 'test-model',
+        capabilities: ['FUNCTION_CALL'],
+        inputModalities: ['TEXT'],
+        outputModalities: ['TEXT'],
+        contextWindow: 1000,
+        maxOutputTokens: 500,
+        metadata: {
+          tags: ['test'],
+          category: 'language-model',
+          source: 'test'
+        }
+      }
+
+      const result = await validator.validateModel(model, {
+        includeWarnings: true,
+        customValidation: () => ['Custom warning message']
+      })
+
+      expect(result.success).toBe(true)
+      expect(result.warnings).toContain('Custom warning message')
+    })
+  })
+
+  describe('Integration Tests', () => {
+    it('should load and validate models end-to-end', async () => {
+      const loader = new ConfigLoader({
+        basePath: fixturesPath,
+        validateOnLoad: true,
+        cacheEnabled: false
+      })
+
+      const validator = new SchemaValidator()
+
+      // Load models
+      const models = await loader.loadModels('test-models.json')
+      expect(models.length).toBeGreaterThan(0)
+
+      // Validate first model
+      const validationResult = await validator.validateModel(models[0])
+      expect(validationResult.success).toBe(true)
+      expect(validationResult.data).toBeDefined()
+      expect(validationResult.data!.id).toBe(models[0].id)
+    })
+
+    it('should work with caching enabled', async () => {
+      const loader = new ConfigLoader({
+        basePath: fixturesPath,
+        validateOnLoad: true,
+        cacheEnabled: true
+      })
+
+      // Test that caching doesn't break basic functionality
+      const models1 = await loader.loadModels('test-models.json')
+      expect(models1.length).toBeGreaterThan(0)
+      expect(models1[0]).toHaveProperty('id', 'test-model')
+
+      // Test cache clear functionality
+      loader.clearCache()
+      expect(true).toBe(true) // Cache clear should not throw
+    })
+  })
+
+  describe('Snapshot Tests', () => {
+    it('should snapshot model configurations', async () => {
+      const loader = new ConfigLoader({
+        basePath: fixturesPath,
+        validateOnLoad: true,
+        cacheEnabled: false
+      })
+
+      const models = await loader.loadModels('test-models.json')
+      expect(models).toMatchSnapshot()
+    })
+
+    it('should snapshot provider configurations', async () => {
+      const loader = new ConfigLoader({
+        basePath: fixturesPath,
+        validateOnLoad: true,
+        cacheEnabled: false
+      })
+
+      const providers = await loader.loadProviders('test-providers.json')
+      expect(providers).toMatchSnapshot()
+    })
+
+    it('should snapshot override configurations', async () => {
+      const loader = new ConfigLoader({
+        basePath: fixturesPath,
+        validateOnLoad: true,
+        cacheEnabled: false
+      })
+
+      const overrides = await loader.loadOverrides('test-overrides.json')
+      expect(overrides).toMatchSnapshot()
+    })
+
+    it('should snapshot complete configuration structure', async () => {
+      const loader = new ConfigLoader({
+        basePath: fixturesPath,
+        validateOnLoad: true,
+        cacheEnabled: false
+      })
+
+      const configs = await loader.loadAllConfigs({
+        modelsFile: 'test-models.json',
+        providersFile: 'test-providers.json',
+        overridesFile: 'test-overrides.json'
+      })
+
+      expect(configs).toMatchSnapshot({
+        models: expect.any(Array),
+        providers: expect.any(Array),
+        overrides: expect.any(Array)
+      })
+    })
+
+    it('should snapshot validation results', async () => {
+      const loader = new ConfigLoader({
+        basePath: fixturesPath,
+        validateOnLoad: true,
+        cacheEnabled: false
+      })
+      const validator = new SchemaValidator()
+
+      const model = await loader.loadModels('test-models.json')
+      const validationResult = await validator.validateModel(model[0], {
+        includeWarnings: true,
+        customValidation: () => ['Custom validation warning for snapshot']
+      })
+
+      expect(validationResult).toMatchSnapshot()
+    })
+  })
+})
@@ -0,0 +1,54 @@
+{
+  "version": "1.0.0",
+  "models": [
+    {
+      "id": "test-model",
+      "name": "Test Model",
+      "ownedBy": "TestProvider",
+      "description": "A test model for unit testing",
+      "capabilities": ["FUNCTION_CALL", "REASONING"],
+      "inputModalities": ["TEXT"],
+      "outputModalities": ["TEXT"],
+      "contextWindow": 128000,
+      "maxOutputTokens": 4096,
+      "maxInputTokens": 124000,
+      "pricing": {
+        "input": {
+          "perMillionTokens": 1,
+          "currency": "USD"
+        },
+        "output": {
+          "perMillionTokens": 2,
+          "currency": "USD"
+        }
+      },
+      "parameters": {
+        "temperature": {
+          "supported": true,
+          "min": 0,
+          "max": 2,
+          "default": 1
+        },
+        "maxTokens": true,
+        "systemMessage": true,
+        "topP": {
+          "supported": true,
+          "min": 0,
+          "max": 1,
+          "default": 1
+        }
+      },
+      "endpointTypes": ["CHAT_COMPLETIONS"],
+      "metadata": {
+        "tags": ["test", "fast", "reliable"],
+        "category": "language-model",
+        "source": "test",
+        "license": "mit",
+        "documentation": "https://docs.test.com/models/test-model",
+        "family": "test-family",
+        "architecture": "transformer",
+        "trainingData": "synthetic"
+      }
+    }
+  ]
+}
@@ -0,0 +1,28 @@
+{
+  "version": "1.0.0",
+  "overrides": [
+    {
+      "providerId": "test-provider",
+      "modelId": "test-model",
+      "capabilities": {
+        "add": ["FUNCTION_CALL"],
+        "remove": ["REASONING"]
+      },
+      "limits": {
+        "contextWindow": 256000,
+        "maxOutputTokens": 8192
+      },
+      "pricing": {
+        "input": {
+          "perMillionTokens": 0.5,
+          "currency": "USD"
+        }
+      },
+      "disabled": false,
+      "reason": "Test override for enhanced capabilities and limits",
+      "lastUpdated": "2025-11-24T07:08:00Z",
+      "updatedBy": "test-suite",
+      "priority": 100
+    }
+  ]
+}
@@ -0,0 +1,53 @@
+{
+  "version": "1.0.0",
+  "providers": [
+    {
+      "id": "test-provider",
+      "name": "Test Provider",
+      "description": "A test provider for unit testing",
+      "authentication": "API_KEY",
+      "pricingModel": "PER_MODEL",
+      "modelRouting": "DIRECT",
+      "behaviors": {
+        "supportsCustomModels": false,
+        "providesModelMapping": false,
+        "supportsModelVersioning": false,
+        "providesFallbackRouting": false,
+        "hasAutoRetry": false,
+        "supportsHealthCheck": false,
+        "hasRealTimeMetrics": false,
+        "providesUsageAnalytics": false,
+        "supportsWebhookEvents": false,
+        "requiresApiKeyValidation": true,
+        "supportsRateLimiting": false,
+        "providesUsageLimits": false,
+        "supportsStreaming": true,
+        "supportsBatchProcessing": false,
+        "supportsModelFineTuning": false
+      },
+      "supportedEndpoints": ["CHAT_COMPLETIONS"],
+      "apiCompatibility": {
+        "supportsArrayContent": true,
+        "supportsStreamOptions": false,
+        "supportsDeveloperRole": false,
+        "supportsThinkingControl": false,
+        "supportsApiVersion": false,
+        "supportsParallelTools": false,
+        "supportsMultimodal": false
+      },
+      "specialConfig": {},
+      "documentation": "https://docs.test.com",
+      "website": "https://test.com",
+      "deprecated": false,
+      "maintenanceMode": false,
+      "configVersion": "1.0.0",
+      "metadata": {
+        "tags": ["test"],
+        "category": "ai-provider",
+        "source": "test",
+        "reliability": "high",
+        "supportedLanguages": ["en"]
+      }
+    }
+  ]
+}
@@ -0,0 +1,21 @@
+/**
+ * Cherry Studio Catalog
+ * Main entry point for the model and provider catalog system
+ */
+
+// Export all schemas
+export * from './schemas'
+
+// Export core functionality
+export type {
+  ConfigLoadOptions,
+  ModelConfig,
+  ProviderConfig,
+  ProviderModelOverride
+} from './loader/ConfigLoader'
+export { ConfigLoader } from './loader/ConfigLoader'
+export type {
+  ValidationOptions,
+  ValidationResult
+} from './validator/SchemaValidator'
+export { SchemaValidator } from './validator/SchemaValidator'
@@ -0,0 +1,244 @@
+/**
+ * Configuration Loader
+ * Responsible for loading and parsing JSON configuration files
+ */
+
+import * as fs from 'fs/promises'
+import * as path from 'path'
+import type * as z from 'zod'
+
+import { ModelListSchema, OverrideListSchema, ProviderListSchema } from '../schemas'
+import { safeParseJSON } from '../utils/parse-json/parse-json'
+import { zod4Schema } from '../utils/schema'
+
+export type ModelConfig = z.infer<typeof ModelListSchema>['models'][0]
+export type ProviderConfig = z.infer<typeof ProviderListSchema>['providers'][0]
+export type ProviderModelOverride = z.infer<typeof OverrideListSchema>['overrides'][0]
+
+export interface ConfigLoadOptions {
+  basePath?: string
+  validateOnLoad?: boolean
+  cacheEnabled?: boolean
+}
+
+export class ConfigLoader {
+  private cache = new Map<string, any>()
+  private options: ConfigLoadOptions
+
+  constructor(options: ConfigLoadOptions = {}) {
+    this.options = {
+      basePath: path.join(__dirname, '../data'),
+      validateOnLoad: true,
+      cacheEnabled: true,
+      ...options
+    }
+  }
+
+  /**
+   * Load model configurations from JSON file
+   */
+  async loadModels(filename = 'models.json'): Promise<ModelConfig[]> {
+    const filePath = path.join(this.options.basePath!, filename)
+
+    if (this.options.cacheEnabled && this.cache.has(filePath)) {
+      return this.cache.get(filePath)
+    }
+
+    try {
+      const rawData = await fs.readFile(filePath, 'utf-8')
+
+      let validatedData: any
+      if (this.options.validateOnLoad) {
+        const schema = zod4Schema(ModelListSchema)
+        const parseResult = await safeParseJSON({ text: rawData, schema })
+
+        if (!parseResult.success) {
+          throw new Error(`Validation failed: ${parseResult.error.message}`)
+        }
+        validatedData = parseResult.value
+      } else {
+        const parseResult = await safeParseJSON({ text: rawData })
+
+        if (!parseResult.success) {
+          throw new Error(`Parse failed: ${parseResult.error.message}`)
+        }
+        validatedData = parseResult.value
+      }
+
+      const models = validatedData.models
+      const version = validatedData.version
+
+      if (this.options.cacheEnabled) {
+        this.cache.set(filePath, { models, version })
+      }
+
+      return models
+    } catch (error) {
+      throw new Error(
+        `Failed to load models from ${filePath}: ${error instanceof Error ? error.message : 'Unknown error'}`
+      )
+    }
+  }
+
+  /**
+   * Load provider configurations from JSON file
+   */
+  async loadProviders(filename = 'providers.json'): Promise<ProviderConfig[]> {
+    const filePath = path.join(this.options.basePath!, filename)
+
+    if (this.options.cacheEnabled && this.cache.has(filePath)) {
+      return this.cache.get(filePath)
+    }
+
+    try {
+      const rawData = await fs.readFile(filePath, 'utf-8')
+      let validatedData: any
+      if (this.options.validateOnLoad) {
+        const schema = zod4Schema(ProviderListSchema)
+        const parseResult = await safeParseJSON({ text: rawData, schema })
+
+        if (!parseResult.success) {
+          throw new Error(`Validation failed: ${parseResult.error.message}`)
+        }
+        validatedData = parseResult.value
+      } else {
+        const parseResult = await safeParseJSON({ text: rawData })
+
+        if (!parseResult.success) {
+          throw new Error(`Parse failed: ${parseResult.error.message}`)
+        }
+        validatedData = parseResult.value
+      }
+
+      const providers = validatedData.providers
+      const version = validatedData.version
+
+      if (this.options.cacheEnabled) {
+        this.cache.set(filePath, { providers, version })
+      }
+
+      return providers
+    } catch (error) {
+      throw new Error(
+        `Failed to load providers from ${filePath}: ${error instanceof Error ? error.message : 'Unknown error'}`
+      )
+    }
+  }
+
+  /**
+   * Load override configurations from JSON file
+   */
+  async loadOverrides(filename = 'overrides.json'): Promise<ProviderModelOverride[]> {
+    const filePath = path.join(this.options.basePath!, filename)
+
+    if (this.options.cacheEnabled && this.cache.has(filePath)) {
+      return this.cache.get(filePath)
+    }
+
+    try {
+      const rawData = await fs.readFile(filePath, 'utf-8')
+      let validatedData: any
+      if (this.options.validateOnLoad) {
+        const schema = zod4Schema(OverrideListSchema)
+        const parseResult = await safeParseJSON({ text: rawData, schema })
+
+        if (!parseResult.success) {
+          throw new Error(`Validation failed: ${parseResult.error.message}`)
+        }
+        validatedData = parseResult.value
+      } else {
+        const parseResult = await safeParseJSON({ text: rawData })
+
+        if (!parseResult.success) {
+          throw new Error(`Parse failed: ${parseResult.error.message}`)
+        }
+        validatedData = parseResult.value
+      }
+
+      const overrides = validatedData.overrides
+      const version = validatedData.version
+
+      if (this.options.cacheEnabled) {
+        this.cache.set(filePath, { overrides, version })
+      }
+
+      return overrides
+    } catch (error) {
+      throw new Error(
+        `Failed to load overrides from ${filePath}: ${error instanceof Error ? error.message : 'Unknown error'}`
+      )
+    }
+  }
+
+  /**
+   * Load all configuration files
+   */
+  async loadAllConfigs(options: { modelsFile?: string; providersFile?: string; overridesFile?: string } = {}): Promise<{
+    models: ModelConfig[]
+    providers: ProviderConfig[]
+    overrides: ProviderModelOverride[]
+  }> {
+    const [models, providers, overrides] = await Promise.all([
+      this.loadModels(options.modelsFile),
+      this.loadProviders(options.providersFile),
+      this.loadOverrides(options.overridesFile)
+    ])
+
+    return { models, providers, overrides }
+  }
+
+  /**
+   * Clear cache
+   */
+  clearCache(): void {
+    this.cache.clear()
+  }
+
+  /**
+   * Check if file exists
+   */
+  private async fileExists(filePath: string): Promise<boolean> {
+    try {
+      await fs.access(filePath)
+      return true
+    } catch {
+      return false
+    }
+  }
+
+  /**
+   * Get configuration file version
+   */
+  async getConfigVersion(filename: string): Promise<string | null> {
+    const filePath = path.join(this.options.basePath!, filename)
+
+    if (!(await this.fileExists(filePath))) {
+      return null
+    }
+
+    try {
+      const rawData = await fs.readFile(filePath, 'utf-8')
+      const jsonData = JSON.parse(rawData)
+      return jsonData.version || null
+    } catch {
+      return null
+    }
+  }
+
+  /**
+   * Get all configuration versions
+   */
+  async getAllConfigVersions(): Promise<{
+    models: string | null
+    providers: string | null
+    overrides: string | null
+  }> {
+    const [models, providers, overrides] = await Promise.all([
+      this.getConfigVersion('models.json'),
+      this.getConfigVersion('providers.json'),
+      this.getConfigVersion('overrides.json')
+    ])
+
+    return { models, providers, overrides }
+  }
+}
@@ -0,0 +1,69 @@
+/**
+ * Common type definitions for the catalog system
+ * Shared across model, provider, and override schemas
+ */
+
+import * as z from 'zod'
+
+// Common string types for reuse
+export const ModelIdSchema = z.string()
+export const ProviderIdSchema = z.string()
+export const VersionSchema = z.string()
+
+// Currency codes
+export const CurrencySchema = z.enum(['USD', 'EUR', 'CNY', 'JPY', 'GBP'])
+
+// Common file size units
+export const FileSizeUnitSchema = z.enum(['B', 'KB', 'MB', 'GB'])
+
+// Common status types
+export const StatusSchema = z.enum(['active', 'inactive', 'deprecated', 'maintenance'])
+
+// Timestamp schema for date fields
+export const TimestampSchema = z.iso.datetime()
+
+// Range helper schemas
+export const NumericRangeSchema = z.object({
+  min: z.number(),
+  max: z.number()
+})
+
+export const StringRangeSchema = z.object({
+  min: z.string(),
+  max: z.string()
+})
+
+// Price per token schema
+export const PricePerTokenSchema = z.object({
+  perMillionTokens: z.number().nonnegative(),
+  currency: CurrencySchema.default('USD')
+})
+
+// Generic metadata schema
+export const MetadataSchema = z.record(z.string(), z.any()).optional()
+
+// Type exports
+export type ModelId = z.infer<typeof ModelIdSchema>
+export type ProviderId = z.infer<typeof ProviderIdSchema>
+export type Version = z.infer<typeof VersionSchema>
+export type Currency = z.infer<typeof CurrencySchema>
+export type FileSizeUnit = z.infer<typeof FileSizeUnitSchema>
+export type Status = z.infer<typeof StatusSchema>
+export type Timestamp = z.infer<typeof TimestampSchema>
+export type NumericRange = z.infer<typeof NumericRangeSchema>
+export type StringRange = z.infer<typeof StringRangeSchema>
+export type PricePerToken = z.infer<typeof PricePerTokenSchema>
+export type Metadata = z.infer<typeof MetadataSchema>
+
+// Common validation utilities
+export const validateRange = (min: number, max: number): boolean => {
+  return min <= max
+}
+
+export const validatePositiveNumber = (value: number): boolean => {
+  return value >= 0
+}
+
+export const validateNonEmptyString = (value: string): boolean => {
+  return value.trim().length > 0
+}
@@ -0,0 +1,49 @@
+/**
+ * Unified export of all catalog schemas and types
+ * This file provides a single entry point for all schema definitions
+ */
+
+// Export all schemas from common types
+export * from './common'
+
+// Export model schemas
+export * from './model'
+
+// Export provider schemas
+export * from './provider'
+
+// Export override schemas
+export * from './override'
+
+// Re-export commonly used combined types for convenience
+export type {
+  Modality,
+  ModelCapabilityType,
+  ModelConfig,
+  ModelPricing,
+  ParameterSupport,
+  Reasoning
+} from './model'
+export type {
+  OverrideResult,
+  OverrideValidation,
+  ProviderModelOverride
+} from './override'
+export type {
+  Authentication,
+  EndpointType,
+  McpSupport,
+  PricingModel,
+  ProviderBehaviors,
+  ProviderConfig
+} from './provider'
+
+// Export common types
+export type {
+  Currency,
+  Metadata,
+  ModelId,
+  ProviderId,
+  Timestamp,
+  Version
+} from './common'
@@ -0,0 +1,254 @@
+/**
+ * Model configuration schema definitions
+ * Defines the structure for model metadata, capabilities, and configurations
+ */
+
+import * as z from 'zod'
+
+import {
+  CurrencySchema,
+  MetadataSchema,
+  ModelIdSchema,
+  PricePerTokenSchema,
+  TimestampSchema,
+  VersionSchema
+} from './common'
+
+// Modality types - supported input/output modalities
+export const ModalitySchema = z.enum(['TEXT', 'VISION', 'AUDIO', 'VIDEO', 'VECTOR'])
+
+// Model capability types
+export const ModelCapabilityTypeSchema = z.enum([
+  'FUNCTION_CALL', // Function calling
+  'REASONING', // Reasoning/thinking
+  'IMAGE_RECOGNITION', // Image recognition
+  'IMAGE_GENERATION', // Image generation
+  'AUDIO_RECOGNITION', // Audio recognition
+  'AUDIO_GENERATION', // Audio generation
+  'EMBEDDING', // Embedding vector generation
+  'RERANK', // Text reranking
+  'AUDIO_TRANSCRIPT', // Audio transcription
+  'VIDEO_RECOGNITION', // Video recognition
+  'VIDEO_GENERATION', // Video generation
+  'STRUCTURED_OUTPUT', // Structured output
+  'FILE_INPUT', // File input support
+  'WEB_SEARCH', // Built-in web search
+  'CODE_EXECUTION', // Code execution
+  'FILE_SEARCH', // File search
+  'COMPUTER_USE' // Computer use
+])
+
+// Reasoning configuration
+export const ReasoningSchema = z.discriminatedUnion('type', [
+  z.object({
+    type: z.literal('openai-chat'),
+    params: z.object({
+      reasoning_effort: z.enum(['none', 'minimal', 'low', 'medium', 'high']).optional()
+    })
+  }),
+  z.object({
+    type: z.literal('openai-responses'),
+    params: z.object({
+      reasoning: z.object({
+        effort: z.enum(['none', 'minimal', 'low', 'medium', 'high']).optional(),
+        summary: z.enum(['auto', 'concise', 'detailed']).optional()
+      })
+    })
+  }),
+  z.object({
+    type: z.literal('anthropic'),
+    params: z.object({
+      type: z.union([z.literal('enabled'), z.literal('disabled')]),
+      budgetTokens: z.number().optional()
+    })
+  }),
+  z.object({
+    type: z.literal('gemini'),
+    params: z.union([
+      z
+        .object({
+          thinking_config: z.object({
+            include_thoughts: z.boolean().optional(),
+            thinking_budget: z.number().optional()
+          })
+        })
+        .optional(),
+      z
+        .object({
+          thinking_level: z.enum(['low', 'medium', 'high']).optional()
+        })
+        .optional()
+    ])
+  }),
+  z.object({
+    type: z.literal('openrouter'),
+    params: z.object({
+      reasoning: z
+        .object({
+          effort: z
+            .union([z.literal('none'), z.literal('minimal'), z.literal('low'), z.literal('medium'), z.literal('high')])
+            .optional(),
+          max_tokens: z.number().optional(),
+          exclude: z.boolean().optional()
+        })
+        .refine((v) => {
+          v.effort == null || v.max_tokens == null
+        }, 'One of the following (not both)')
+    })
+  }),
+  z.object({
+    type: z.literal('qwen'),
+    params: z.object({
+      enable_thinking: z.boolean(),
+      thinking_budget: z.number().optional()
+    })
+  }),
+  z.object({
+    type: z.literal('doubao'),
+    params: z.object({
+      thinking: z.object({
+        type: z.union([z.literal('enabled'), z.literal('disabled'), z.literal('auto')])
+      })
+    })
+  }),
+  z.object({
+    type: z.literal('dashscope'),
+    params: z.object({
+      enable_thinking: z.boolean(),
+      incremental_output: z.boolean().optional()
+    })
+  }),
+  z.object({
+    type: z.literal('self-hosted'),
+    params: z.object({
+      chat_template_kwargs: z.object({
+        enable_thinking: z.boolean().optional(),
+        thinking: z.boolean().optional()
+      })
+    })
+  })
+])
+
+// Parameter support configuration
+export const ParameterSupportSchema = z.object({
+  temperature: z
+    .object({
+      supported: z.boolean(),
+      min: z.number().min(0).max(2).optional(),
+      max: z.number().min(0).max(2).optional(),
+      default: z.number().min(0).max(2).optional()
+    })
+    .optional(),
+
+  topP: z
+    .object({
+      supported: z.boolean(),
+      min: z.number().min(0).max(1).optional(),
+      max: z.number().min(0).max(1).optional(),
+      default: z.number().min(0).max(1).optional()
+    })
+    .optional(),
+
+  topK: z
+    .object({
+      supported: z.boolean(),
+      min: z.number().positive().optional(),
+      max: z.number().positive().optional()
+    })
+    .optional(),
+
+  frequencyPenalty: z.boolean().optional(),
+  presencePenalty: z.boolean().optional(),
+  maxTokens: z.boolean().optional(),
+  stopSequences: z.boolean().optional(),
+  systemMessage: z.boolean().optional(),
+  developerRole: z.boolean().optional()
+})
+
+// Model pricing configuration
+export const ModelPricingSchema = z.object({
+  input: PricePerTokenSchema,
+  output: PricePerTokenSchema,
+
+  // Image pricing (optional)
+  per_image: z
+    .object({
+      price: z.number(),
+      currency: CurrencySchema.default('USD'),
+      unit: z.enum(['image', 'pixel']).optional()
+    })
+    .optional(),
+
+  // Audio/video pricing (optional)
+  per_minute: z
+    .object({
+      price: z.number(),
+      currency: CurrencySchema.default('USD')
+    })
+    .optional()
+})
+
+// Model configuration schema
+export const ModelConfigSchema = z.object({
+  // Basic information
+  id: ModelIdSchema,
+  name: z.string().optional(),
+  owned_by: z.string().optional(),
+  description: z.string().optional(),
+
+  // Capabilities (core)
+  capabilities: z.array(ModelCapabilityTypeSchema),
+
+  // Modalities
+  input_modalities: z.array(ModalitySchema),
+  output_modalities: z.array(ModalitySchema),
+
+  // Limits
+  context_window: z.number(),
+  max_output_tokens: z.number(),
+  max_input_tokens: z.number().optional(),
+
+  // Pricing
+  pricing: ModelPricingSchema.optional(),
+
+  // Reasoning configuration
+  reasoning: ReasoningSchema.optional(),
+
+  // Parameter support
+  parameters: ParameterSupportSchema.optional(),
+
+  // Endpoint types (will reference provider schema)
+  endpoint_types: z.array(z.string()).optional(),
+
+  // Metadata
+  release_date: TimestampSchema.optional(),
+  deprecation_date: TimestampSchema.optional(),
+  replaced_by: ModelIdSchema.optional(),
+
+  // Version control
+  version: VersionSchema.optional(),
+  compatibility: z
+    .object({
+      min_version: VersionSchema.optional(),
+      max_version: VersionSchema.optional()
+    })
+    .optional(),
+
+  // Additional metadata
+  metadata: MetadataSchema
+})
+
+// Model list container schema for JSON files
+export const ModelListSchema = z.object({
+  version: VersionSchema,
+  models: z.array(ModelConfigSchema)
+})
+
+// Type exports
+export type Modality = z.infer<typeof ModalitySchema>
+export type ModelCapabilityType = z.infer<typeof ModelCapabilityTypeSchema>
+export type Reasoning = z.infer<typeof ReasoningSchema>
+export type ParameterSupport = z.infer<typeof ParameterSupportSchema>
+export type ModelPricing = z.infer<typeof ModelPricingSchema>
+export type ModelConfig = z.infer<typeof ModelConfigSchema>
+export type ModelList = z.infer<typeof ModelListSchema>
@@ -0,0 +1,147 @@
+/**
+ * Provider model override schema definitions
+ * Defines how providers can override specific model configurations
+ */
+
+import * as z from 'zod'
+
+import { MetadataSchema, ModelIdSchema, ProviderIdSchema, VersionSchema } from './common'
+import { ModelCapabilityTypeSchema, ModelPricingSchema, ParameterSupportSchema, ReasoningSchema } from './model'
+import { EndpointTypeSchema } from './provider'
+
+// Capability override operations
+export const CapabilityOverrideSchema = z.object({
+  add: z.array(ModelCapabilityTypeSchema).optional(), // Add capabilities
+  remove: z.array(ModelCapabilityTypeSchema).optional(), // Remove capabilities
+  force: z.array(ModelCapabilityTypeSchema).optional() // Force set capabilities (ignore base config)
+})
+
+// Limits override configuration
+export const LimitsOverrideSchema = z.object({
+  context_window: z.number().optional(),
+  max_output_tokens: z.number().optional(),
+  max_input_tokens: z.number().optional()
+})
+
+// Pricing override configuration
+export const PricingOverrideSchema = ModelPricingSchema.partial().optional()
+
+// Endpoint types override
+export const EndpointTypesOverrideSchema = z.array(EndpointTypeSchema).optional()
+
+// Reasoning configuration override - allows partial override of reasoning configs
+export const ReasoningOverrideSchema = ReasoningSchema.optional()
+
+// Parameter support override
+export const ParameterSupportOverrideSchema = ParameterSupportSchema.partial().optional()
+
+// Model metadata override
+export const MetadataOverrideSchema = z
+  .object({
+    name: z.string().optional(),
+    description: z.string().optional(),
+    deprecation_date: z.iso.datetime().optional(),
+    replaced_by: ModelIdSchema.optional(),
+    metadata: MetadataSchema
+  })
+  .optional()
+
+// Main provider model override schema
+export const ProviderModelOverrideSchema = z.object({
+  // Identification
+  provider_id: ProviderIdSchema,
+  model_id: ModelIdSchema,
+
+  // Capability overrides
+  capabilities: CapabilityOverrideSchema.optional(),
+
+  // Limits overrides
+  limits: LimitsOverrideSchema.optional(),
+
+  // Pricing overrides
+  pricing: PricingOverrideSchema,
+
+  // Reasoning configuration overrides
+  reasoning: ReasoningOverrideSchema.optional(),
+
+  // Parameter support overrides
+  parameters: ParameterSupportOverrideSchema.optional(),
+
+  // Endpoint type overrides
+  endpoint_types: EndpointTypesOverrideSchema.optional(),
+
+  // Model metadata overrides
+  metadata: MetadataOverrideSchema.optional(),
+
+  // Status overrides
+  disabled: z.boolean().optional(), // Disable this model for this provider
+  replace_with: ModelIdSchema.optional(), // Replace with alternative model
+
+  // Override tracking
+  reason: z.string().optional(), // Reason for override
+  last_updated: z.iso.datetime().optional(),
+  updated_by: z.string().optional(), // Who made the override
+
+  // Override priority (higher number = higher priority)
+  priority: z.number().default(0),
+
+  // Override conditions
+  conditions: z
+    .object({
+      // Apply override only for specific regions
+      regions: z.array(z.string()).optional(),
+
+      // Apply override only for specific user tiers
+      user_tiers: z.array(z.string()).optional(),
+
+      // Apply override only in specific environments
+      environments: z.array(z.enum(['development', 'staging', 'production'])).optional(),
+
+      // Time-based conditions
+      valid_from: z.iso.datetime().optional(),
+      valid_until: z.iso.datetime().optional()
+    })
+    .optional(),
+
+  // Additional override metadata
+  override_metadata: MetadataSchema.optional()
+})
+
+// Override container schema for JSON files
+export const OverrideListSchema = z.object({
+  version: VersionSchema,
+  overrides: z.array(ProviderModelOverrideSchema)
+})
+
+// Override application result schema
+export const OverrideResultSchema = z.object({
+  model_id: ModelIdSchema,
+  provider_id: ProviderIdSchema,
+  applied: z.boolean(),
+  applied_overrides: z.array(z.string()), // List of applied override fields
+  original_values: z.record(z.string(), z.unknown()), // Original values before override
+  new_values: z.record(z.string(), z.unknown()), // New values after override
+  override_reason: z.string().optional(),
+  applied_at: z.iso.datetime().optional()
+})
+
+// Override validation result
+export const OverrideValidationSchema = z.object({
+  valid: z.boolean(),
+  errors: z.array(z.string()),
+  warnings: z.array(z.string()),
+  recommendations: z.array(z.string())
+})
+
+// Type exports
+export type CapabilityOverride = z.infer<typeof CapabilityOverrideSchema>
+export type LimitsOverride = z.infer<typeof LimitsOverrideSchema>
+export type PricingOverride = z.infer<typeof PricingOverrideSchema>
+export type EndpointTypesOverride = z.infer<typeof EndpointTypesOverrideSchema>
+export type ReasoningOverride = z.infer<typeof ReasoningOverrideSchema>
+export type ParameterSupportOverride = z.infer<typeof ParameterSupportOverrideSchema>
+export type MetadataOverride = z.infer<typeof MetadataOverrideSchema>
+export type ProviderModelOverride = z.infer<typeof ProviderModelOverrideSchema>
+export type OverrideList = z.infer<typeof OverrideListSchema>
+export type OverrideResult = z.infer<typeof OverrideResultSchema>
+export type OverrideValidation = z.infer<typeof OverrideValidationSchema>
@@ -0,0 +1,171 @@
+/**
+ * Provider configuration schema definitions
+ * Defines the structure for AI service provider metadata and capabilities
+ */
+
+import * as z from 'zod'
+
+import { MetadataSchema, ProviderIdSchema, VersionSchema } from './common'
+
+// Endpoint types supported by providers
+export const EndpointTypeSchema = z.enum([
+  'CHAT_COMPLETIONS', // /chat/completions
+  'COMPLETIONS', // /completions
+  'EMBEDDINGS', // /embeddings
+  'IMAGE_GENERATION', // /images/generations
+  'IMAGE_EDIT', // /images/edits
+  'AUDIO_SPEECH', // /audio/speech (TTS)
+  'AUDIO_TRANSCRIPTIONS', // /audio/transcriptions (STT)
+  'MESSAGES', // /messages
+  'RESPONSES', // /responses
+  'GENERATE_CONTENT', // :generateContent
+  'STREAM_GENERATE_CONTENT', // :streamGenerateContent
+  'RERANK', // /rerank
+  'MODERATIONS' // /moderations
+])
+
+// Authentication methods
+export const AuthenticationSchema = z.enum([
+  'API_KEY', // Standard API Key authentication
+  'OAUTH', // OAuth 2.0 authentication
+  'CLOUD_CREDENTIALS' // Cloud service credentials (AWS, GCP, Azure)
+])
+
+// Pricing models that affect UI and behavior
+export const PricingModelSchema = z.enum([
+  'UNIFIED', // Unified pricing (like OpenRouter)
+  'PER_MODEL', // Per-model independent pricing (like OpenAI official)
+  'TRANSPARENT', // Transparent pricing (like New-API)
+  'USAGE_BASED', // Dynamic usage-based pricing
+  'SUBSCRIPTION' // Subscription-based pricing
+])
+
+// Model routing strategies affecting performance and reliability
+export const ModelRoutingSchema = z.enum([
+  'INTELLIGENT', // Intelligent routing, auto-select optimal instance
+  'DIRECT', // Direct routing to specified model
+  'LOAD_BALANCED', // Load balanced across multiple instances
+  'GEO_ROUTED', // Geographic location routing
+  'COST_OPTIMIZED' // Cost-optimized routing
+])
+
+// Server-side MCP support configuration
+export const McpSupportSchema = z.object({
+  supported: z.boolean().default(false),
+  configuration: z
+    .object({
+      supports_url_pass_through: z.boolean().default(false),
+      supported_servers: z.array(z.string()).optional(),
+      max_concurrent_servers: z.number().optional()
+    })
+    .optional()
+})
+
+// API compatibility configuration
+export const ApiCompatibilitySchema = z.object({
+  supports_array_content: z.boolean().default(true),
+  supports_stream_options: z.boolean().default(true),
+  supports_developer_role: z.boolean().default(false),
+  supports_service_tier: z.boolean().default(false),
+  supports_thinking_control: z.boolean().default(false),
+  supports_api_version: z.boolean().default(false),
+  supports_parallel_tools: z.boolean().default(false),
+  supports_multimodal: z.boolean().default(false),
+  max_file_upload_size: z.number().optional(), // bytes
+  supported_file_types: z.array(z.string()).optional()
+})
+
+// Behavior characteristics configuration - replaces categorization, describes actual behavior
+export const ProviderBehaviorsSchema = z.object({
+  // Model management
+  supports_custom_models: z.boolean().default(false), // Supports user custom models
+  provides_model_mapping: z.boolean().default(false), // Provides model name mapping
+  supports_model_versioning: z.boolean().default(false), // Supports model version control
+
+  // Reliability and fault tolerance
+  provides_fallback_routing: z.boolean().default(false), // Provides fallback routing
+  has_auto_retry: z.boolean().default(false), // Has automatic retry mechanism
+  supports_health_check: z.boolean().default(false), // Supports health checks
+
+  // Monitoring and metrics
+  has_real_time_metrics: z.boolean().default(false), // Has real-time metrics
+  provides_usage_analytics: z.boolean().default(false), // Provides usage analytics
+  supports_webhook_events: z.boolean().default(false), // Supports webhook events
+
+  // Configuration and management
+  requires_api_key_validation: z.boolean().default(true), // Requires API key validation
+  supports_rate_limiting: z.boolean().default(false), // Supports rate limiting
+  provides_usage_limits: z.boolean().default(false), // Provides usage limit configuration
+
+  // Advanced features
+  supports_streaming: z.boolean().default(true), // Supports streaming responses
+  supports_batch_processing: z.boolean().default(false), // Supports batch processing
+  supports_model_fine_tuning: z.boolean().default(false) // Provides model fine-tuning
+})
+
+// Provider configuration schema
+export const ProviderConfigSchema = z.object({
+  // Basic information
+  id: ProviderIdSchema,
+  name: z.string(),
+  description: z.string().optional(),
+
+  // Behavior-related configuration
+  authentication: AuthenticationSchema,
+  pricing_model: PricingModelSchema,
+  model_routing: ModelRoutingSchema,
+  behaviors: ProviderBehaviorsSchema,
+
+  // Feature support
+  supported_endpoints: z.array(EndpointTypeSchema),
+  mcp_support: McpSupportSchema.optional(),
+  api_compatibility: ApiCompatibilitySchema.optional(),
+
+  // Default configuration
+  default_api_host: z.string().optional(),
+  default_rate_limit: z.number().optional(), // requests per minute
+
+  // Model matching assistance
+  model_id_patterns: z.array(z.string()).optional(),
+  alias_model_ids: z.record(z.string(), z.string()).optional(), // Model alias mapping
+
+  // Special configuration
+  special_config: MetadataSchema,
+
+  // Metadata and links
+  documentation: z.string().url().optional(),
+  status_page: z.string().url().optional(),
+  pricing_page: z.string().url().optional(),
+  support_email: z.string().email().optional(),
+  website: z.string().url().optional(),
+
+  // Status management
+  deprecated: z.boolean().default(false),
+  deprecation_date: z.iso.datetime().optional(),
+  maintenance_mode: z.boolean().default(false),
+
+  // Version and compatibility
+  min_app_version: VersionSchema.optional(), // Minimum supported app version
+  max_app_version: VersionSchema.optional(), // Maximum supported app version
+  config_version: VersionSchema.default('1.0.0'), // Configuration file version
+
+  // Additional metadata
+  metadata: MetadataSchema
+})
+
+// Provider list container schema for JSON files
+export const ProviderListSchema = z.object({
+  version: VersionSchema,
+  providers: z.array(ProviderConfigSchema)
+})
+
+// Type exports
+export type EndpointType = z.infer<typeof EndpointTypeSchema>
+export type Authentication = z.infer<typeof AuthenticationSchema>
+export type PricingModel = z.infer<typeof PricingModelSchema>
+export type ModelRouting = z.infer<typeof ModelRoutingSchema>
+export type McpSupport = z.infer<typeof McpSupportSchema>
+export type ApiCompatibility = z.infer<typeof ApiCompatibilitySchema>
+export type ProviderBehaviors = z.infer<typeof ProviderBehaviorsSchema>
+export type ProviderConfig = z.infer<typeof ProviderConfigSchema>
+export type ProviderList = z.infer<typeof ProviderListSchema>
@@ -0,0 +1,2 @@
+export { isJSONArray, isJSONObject, isJSONValue } from './is-json'
+export type { JSONArray, JSONObject, JSONValue } from './json-value'
@@ -0,0 +1,32 @@
+// https://github.com/vercel/ai/blob/4c44a5bea002ef0db0e1b86a1e223cd9f4837d62/packages/provider/src/json-value/is-json.ts
+import type { JSONArray, JSONObject, JSONValue } from './json-value'
+
+export function isJSONValue(value: unknown): value is JSONValue {
+  if (value === null || typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+    return true
+  }
+
+  if (Array.isArray(value)) {
+    return value.every(isJSONValue)
+  }
+
+  if (typeof value === 'object') {
+    return Object.entries(value).every(
+      ([key, val]) => typeof key === 'string' && (val === undefined || isJSONValue(val))
+    )
+  }
+
+  return false
+}
+
+export function isJSONArray(value: unknown): value is JSONArray {
+  return Array.isArray(value) && value.every(isJSONValue)
+}
+
+export function isJSONObject(value: unknown): value is JSONObject {
+  return (
+    value != null &&
+    typeof value === 'object' &&
+    Object.entries(value).every(([key, val]) => typeof key === 'string' && (val === undefined || isJSONValue(val)))
+  )
+}
@@ -0,0 +1,13 @@
+// https://github.com/vercel/ai/blob/4c44a5bea002ef0db0e1b86a1e223cd9f4837d62/packages/provider/src/json-value/json-value.ts
+
+/**
+A JSON value can be a string, number, boolean, object, array, or null.
+JSON values can be serialized and deserialized by the JSON.stringify and JSON.parse methods.
+ */
+export type JSONValue = null | string | number | boolean | JSONObject | JSONArray
+
+export type JSONObject = {
+  [key: string]: JSONValue | undefined
+}
+
+export type JSONArray = JSONValue[]
@@ -0,0 +1,543 @@
+/**
+ * Migration Tool - Phase 2 Implementation
+ * Migrates existing JSON data to new schema-based catalog system
+ */
+
+import * as fs from 'fs/promises'
+import * as path from 'path'
+
+interface ProviderEndpointsData {
+  providers: Record<
+    string,
+    {
+      display_name: string
+      endpoints: Record<string, boolean>
+      url: string
+    }
+  >
+}
+
+interface ModelPricesData {
+  [modelId: string]: {
+    litellm_provider: string
+    mode: string
+    input_cost_per_token?: number
+    output_cost_per_token?: number
+    input_cost_per_pixel?: number
+    output_cost_per_pixel?: number
+    output_cost_per_image?: number
+    max_input_tokens?: number
+    max_output_tokens?: number
+    max_tokens?: number
+    supports_function_calling?: boolean
+    supports_vision?: boolean
+    supports_parallel_function_calling?: boolean
+    supports_response_schema?: boolean
+    supports_tool_choice?: boolean
+    supports_system_messages?: boolean
+    supports_assistant_prefill?: boolean
+    supports_pdf_input?: boolean
+    supports_prompt_caching?: boolean
+    cache_creation_input_token_cost?: number
+    cache_read_input_token_cost?: number
+    metadata?: {
+      notes?: string
+    }
+    source?: string
+    supported_endpoints?: string[]
+    deprecation_date?: string
+  }
+}
+
+interface ModelConfig {
+  id: string
+  name?: string
+  owned_by?: string
+  description?: string
+  capabilities: string[]
+  input_modalities: string[]
+  output_modalities: string[]
+  context_window: number
+  max_output_tokens: number
+  max_input_tokens?: number
+  pricing?: {
+    input: { per_million_tokens: number; currency: string }
+    output: { per_million_tokens: number; currency: string }
+  }
+  parameters?: Record<string, any>
+  endpoint_types?: string[]
+  metadata?: Record<string, any>
+}
+
+interface ProviderConfig {
+  id: string
+  name: string
+  description?: string
+  authentication: string
+  supported_endpoints: string[]
+  api_compatibility?: Record<string, boolean>
+  special_config?: Record<string, any>
+  documentation?: string
+  website?: string
+  deprecated: boolean
+  maintenance_mode: boolean
+  config_version: string
+  metadata?: Record<string, any>
+}
+
+interface OverrideConfig {
+  provider_id: string
+  model_id: string
+  capabilities?: {
+    add?: string[]
+    remove?: string[]
+    force?: string[]
+  }
+  limits?: {
+    context_window?: number
+    max_output_tokens?: number
+    max_input_tokens?: number
+  }
+  pricing?: {
+    input: { per_million_tokens: number; currency: string }
+    output: { per_million_tokens: number; currency: string }
+  }
+  disabled?: boolean
+  reason?: string
+  last_updated?: string
+  updated_by?: string
+  priority?: number
+}
+
+export class MigrationTool {
+  private providerEndpointsData: ProviderEndpointsData
+  private modelPricesData: ModelPricesData
+
+  constructor(
+    private providerEndpointsPath: string,
+    private modelPricesPath: string,
+    private outputDir: string
+  ) {
+    // Initialize with empty objects to satisfy TypeScript
+    this.providerEndpointsData = { providers: {} }
+    this.modelPricesData = {}
+  }
+
+  async loadData(): Promise<void> {
+    console.log('📖 Loading existing data...')
+
+    const providerEndpointsContent = await fs.readFile(this.providerEndpointsPath, 'utf-8')
+    this.providerEndpointsData = JSON.parse(providerEndpointsContent)
+
+    const modelPricesContent = await fs.readFile(this.modelPricesPath, 'utf-8')
+    this.modelPricesData = JSON.parse(modelPricesContent)
+
+    console.log(`✅ Loaded ${Object.keys(this.providerEndpointsData.providers).length} providers`)
+    console.log(`✅ Loaded ${Object.keys(this.modelPricesData).length} model configurations`)
+  }
+
+  /**
+   * Extract base model identifier from provider-specific model ID
+   */
+  private extractBaseModelId(providerModelId: string): string {
+    // Remove provider prefixes
+    const prefixes = [
+      'azure/',
+      'bedrock/',
+      'openrouter/',
+      'vertex_ai/',
+      'sagemaker/',
+      'watsonx/',
+      'litellm_proxy/',
+      'custom/',
+      'aiml/',
+      'together_ai/',
+      'deepinfra/',
+      'hyperbolic/',
+      'fireworks_ai/',
+      'replicate/',
+      'novita/',
+      'anyscale/',
+      'runpod/',
+      'triton/',
+      'vllm/',
+      'ollama/',
+      'lm_studio/'
+    ]
+
+    let baseId = providerModelId
+    for (const prefix of prefixes) {
+      if (baseId.startsWith(prefix)) {
+        baseId = baseId.substring(prefix.length)
+        break
+      }
+    }
+
+    // Handle AWS Bedrock specific naming
+    if (baseId.includes(':')) {
+      baseId = baseId.split(':')[0]
+    }
+
+    // Handle version suffixes
+    baseId = baseId.replace(/\/v\d+$/, '').replace(/:v\d+$/, '')
+
+    return baseId
+  }
+
+  /**
+   * Determine if a model is a base model or provider-specific override
+   */
+  private isBaseModel(modelId: string, provider: string): boolean {
+    const baseId = this.extractBaseModelId(modelId)
+
+    // Official provider models are base models
+    const officialProviders = [
+      'anthropic',
+      'openai',
+      'gemini',
+      'deepseek',
+      'dashscope',
+      'volceengine',
+      'minimax',
+      'moonshotai',
+      'zai',
+      'meta',
+      'mistral',
+      'cohere',
+      'xai'
+    ]
+
+    if (officialProviders.includes(provider)) {
+      return modelId === baseId || modelId.startsWith(provider + '/')
+    }
+
+    // Third-party providers selling access to official models are overrides
+    return false
+  }
+
+  /**
+   * Convert endpoint support to provider capabilities
+   */
+  private privateConvertEndpointsToCapabilities(endpoints: Record<string, boolean>): string[] {
+    const endpointCapabilityMap: Record<string, string> = {
+      chat_completions: 'CHAT_COMPLETIONS',
+      messages: 'MESSAGES',
+      responses: 'RESPONSES',
+      completions: 'COMPLETIONS',
+      embeddings: 'EMBEDDINGS',
+      image_generations: 'IMAGE_GENERATION',
+      image_edit: 'IMAGE_EDIT',
+      audio_speech: 'AUDIO_GENERATION',
+      audio_transcriptions: 'AUDIO_TRANSCRIPT',
+      rerank: 'RERANK',
+      moderations: 'MODERATIONS',
+      ocr: 'OCR',
+      search: 'WEB_SEARCH'
+    }
+
+    const capabilities: string[] = []
+    for (const [endpoint, supported] of Object.entries(endpoints)) {
+      if (supported && endpointCapabilityMap[endpoint]) {
+        capabilities.push(endpointCapabilityMap[endpoint])
+      }
+    }
+
+    return capabilities
+  }
+
+  /**
+   * Generate provider configurations
+   */
+  private generateProviderConfigs(): ProviderConfig[] {
+    const providers: ProviderConfig[] = []
+
+    for (const [providerId, providerData] of Object.entries(this.providerEndpointsData.providers)) {
+      const supported_endpoints = this.privateConvertEndpointsToCapabilities(providerData.endpoints)
+
+      const provider: ProviderConfig = {
+        id: providerId,
+        name: providerData.display_name,
+        description: `Provider: ${providerData.display_name}`,
+        authentication: 'API_KEY',
+        supported_endpoints,
+        api_compatibility: {
+          supports_array_content: providerData.endpoints.chat_completions || false,
+          supports_stream_options: providerData.endpoints.chat_completions || false,
+          supports_developer_role: providerId === 'openai',
+          supports_service_tier: providerId === 'openai',
+          supports_thinking_control: false,
+          supports_api_version: providerId === 'openai',
+          supports_parallel_tools: providerData.endpoints.chat_completions || false,
+          supports_multimodal: providerData.endpoints.chat_completions || false
+        },
+        special_config: {},
+        documentation: providerData.url,
+        website: providerData.url,
+        deprecated: false,
+        maintenance_mode: false,
+        config_version: '1.0.0'
+      }
+
+      providers.push(provider)
+    }
+
+    return providers
+  }
+
+  /**
+   * Generate base model configurations
+   */
+  private generateBaseModels(): ModelConfig[] {
+    const baseModels = new Map<string, ModelConfig>()
+
+    for (const [modelId, modelData] of Object.entries(this.modelPricesData)) {
+      if (modelData.mode !== 'chat') continue // Skip non-chat models for now
+
+      const baseId = this.extractBaseModelId(modelId)
+      const isBase = this.isBaseModel(modelId, modelData.litellm_provider)
+
+      if (!isBase) continue // Only process base models
+
+      // Extract capabilities from model data
+      const capabilities: string[] = []
+      if (modelData.supports_function_calling) capabilities.push('FUNCTION_CALL')
+      if (modelData.supports_vision) capabilities.push('IMAGE_RECOGNITION')
+      if (modelData.supports_response_schema) capabilities.push('STRUCTURED_OUTPUT')
+      if (modelData.supports_pdf_input) capabilities.push('FILE_INPUT')
+      if (modelData.supports_tool_choice) capabilities.push('FUNCTION_CALL')
+
+      // Determine modalities
+      const input_modalities = ['TEXT']
+      const output_modalities = ['TEXT']
+      if (modelData.supports_vision) {
+        input_modalities.push('VISION')
+      }
+
+      // Convert pricing
+      let pricing
+      if (modelData.input_cost_per_token && modelData.output_cost_per_token) {
+        pricing = {
+          input: {
+            per_million_tokens: Math.round(modelData.input_cost_per_token * 1000000 * 1000) / 1000,
+            currency: 'USD'
+          },
+          output: {
+            per_million_tokens: Math.round(modelData.output_cost_per_token * 1000000 * 1000) / 1000,
+            currency: 'USD'
+          }
+        }
+      }
+
+      const baseModel: ModelConfig = {
+        id: baseId,
+        name: baseId,
+        owned_by: modelData.litellm_provider,
+        capabilities,
+        input_modalities,
+        output_modalities,
+        context_window: modelData.max_input_tokens || 4096,
+        max_output_tokens: modelData.max_output_tokens || modelData.max_tokens || 2048,
+        max_input_tokens: modelData.max_input_tokens,
+        pricing,
+        parameters: {
+          temperature: { supported: true, min: 0, max: 1, default: 1 },
+          max_tokens: true,
+          system_message: modelData.supports_system_messages || false,
+          top_p: { supported: false }
+        },
+        endpoint_types: ['CHAT_COMPLETIONS'],
+        metadata: {
+          source: 'migration',
+          original_provider: modelData.litellm_provider,
+          supports_caching: !!modelData.supports_prompt_caching
+        }
+      }
+
+      baseModels.set(baseId, baseModel)
+    }
+
+    return Array.from(baseModels.values())
+  }
+
+  /**
+   * Generate override configurations
+   */
+  private generateOverrides(): OverrideConfig[] {
+    const overrides: OverrideConfig[] = []
+
+    for (const [modelId, modelData] of Object.entries(this.modelPricesData)) {
+      if (modelData.mode !== 'chat') continue
+
+      const baseId = this.extractBaseModelId(modelId)
+      const isBase = this.isBaseModel(modelId, modelData.litellm_provider)
+
+      if (isBase) continue // Only generate overrides for non-base models
+
+      const override: OverrideConfig = {
+        provider_id: modelData.litellm_provider,
+        model_id: baseId,
+        disabled: false,
+        reason: `Provider-specific implementation of ${baseId}`,
+        last_updated: new Date().toISOString().split('T')[0],
+        updated_by: 'migration-tool',
+        priority: 100
+      }
+
+      // Add capability differences
+      const capabilities = modelData.supports_function_calling ? ['FUNCTION_CALL'] : []
+      if (modelData.supports_vision) capabilities.push('IMAGE_RECOGNITION')
+
+      if (capabilities.length > 0) {
+        override.capabilities = { add: capabilities }
+      }
+
+      // Add limit differences
+      const limits: any = {}
+      if (modelData.max_input_tokens && modelData.max_input_tokens !== 128000) {
+        limits.context_window = modelData.max_input_tokens
+      }
+      if (modelData.max_output_tokens && modelData.max_output_tokens !== 4096) {
+        limits.max_output_tokens = modelData.max_output_tokens
+      }
+
+      if (Object.keys(limits).length > 0) {
+        override.limits = limits
+      }
+
+      // Add pricing differences
+      if (modelData.input_cost_per_token && modelData.output_cost_per_token) {
+        override.pricing = {
+          input: {
+            per_million_tokens: Math.round(modelData.input_cost_per_token * 1000000 * 1000) / 1000,
+            currency: 'USD'
+          },
+          output: {
+            per_million_tokens: Math.round(modelData.output_cost_per_token * 1000000 * 1000) / 1000,
+            currency: 'USD'
+          }
+        }
+      }
+
+      overrides.push(override)
+    }
+
+    return overrides
+  }
+
+  /**
+   * Execute the full migration
+   */
+  async migrate(): Promise<void> {
+    console.log('🚀 Starting Phase 2 Migration...')
+
+    await this.loadData()
+
+    // Create output directory
+    await fs.mkdir(this.outputDir, { recursive: true })
+
+    // Generate configurations
+    console.log('📦 Generating provider configurations...')
+    const providers = this.generateProviderConfigs()
+
+    console.log('📦 Generating base model configurations...')
+    const models = this.generateBaseModels()
+
+    console.log('📦 Generating override configurations...')
+    const overrides = this.generateOverrides()
+
+    // Write single file for all providers
+    console.log('💾 Writing providers.json...')
+    await this.writeJsonFile('providers.json', {
+      version: '2025.11.24',
+      providers
+    })
+
+    // Write single file for all models
+    console.log('💾 Writing models.json...')
+    await this.writeJsonFile('models.json', {
+      version: '2025.11.24',
+      models
+    })
+
+    // Write single file for all overrides
+    console.log('💾 Writing overrides.json...')
+    await this.writeJsonFile('overrides.json', {
+      version: '2025.11.24',
+      overrides
+    })
+
+    // Generate migration report
+    const providersByType = {
+      direct: providers.filter((p) => ['anthropic', 'openai', 'google'].includes(p.id)).length,
+      cloud: providers.filter((p) => ['azure', 'bedrock', 'vertex_ai'].some((c) => p.id.includes(c))).length,
+      proxy: providers.filter((p) => ['openrouter', 'litellm_proxy', 'together_ai'].some((c) => p.id.includes(c)))
+        .length,
+      self_hosted: providers.filter((p) => ['ollama', 'lm_studio', 'vllm'].some((c) => p.id.includes(c))).length
+    }
+
+    const modelsByProvider = models.reduce(
+      (acc, model) => {
+        const provider = model.owned_by || 'unknown'
+        acc[provider] = (acc[provider] || 0) + 1
+        return acc
+      },
+      {} as Record<string, number>
+    )
+
+    const overridesByProvider = overrides.reduce(
+      (acc, override) => {
+        acc[override.provider_id] = (acc[override.provider_id] || 0) + 1
+        return acc
+      },
+      {} as Record<string, number>
+    )
+
+    const report = {
+      timestamp: new Date().toISOString(),
+      summary: {
+        total_providers: providers.length,
+        total_base_models: models.length,
+        total_overrides: overrides.length,
+        provider_categories: providersByType,
+        models_by_provider: modelsByProvider,
+        overrides_by_provider: overridesByProvider
+      },
+      files: {
+        providers: 'providers.json',
+        models: 'models.json',
+        overrides: 'overrides.json'
+      }
+    }
+
+    await this.writeJsonFile('migration-report.json', report)
+
+    console.log('\n✅ Migration completed successfully!')
+    console.log(`📊 Migration Summary:`)
+    console.log(
+      `   Providers: ${providers.length} (${providersByType.direct} direct, ${providersByType.cloud} cloud, ${providersByType.proxy} proxy, ${providersByType.self_hosted} self-hosted)`
+    )
+    console.log(`   Base Models: ${models.length}`)
+    console.log(`   Overrides: ${overrides.length}`)
+    console.log(`\n📁 Output Files:`)
+    console.log(`   ${this.outputDir}/providers.json`)
+    console.log(`   ${this.outputDir}/models.json`)
+    console.log(`   ${this.outputDir}/overrides.json`)
+    console.log(`   ${this.outputDir}/migration-report.json`)
+  }
+
+  private async writeJsonFile(filename: string, data: any): Promise<void> {
+    const filePath = path.join(this.outputDir, filename)
+    await fs.writeFile(filePath, JSON.stringify(data, null, 2), 'utf-8')
+  }
+}
+
+// CLI execution
+if (require.main === module) {
+  const tool = new MigrationTool(
+    './provider_endpoints_support.json',
+    './model_prices_and_context_window.json',
+    './migrated-data'
+  )
+
+  tool.migrate().catch(console.error)
+}
@@ -0,0 +1,88 @@
+// https://github.com/vercel/ai/blob/6306603220f9f023fcdbeb9768d1c3fc2ca6bc80/packages/provider-utils/src/parse-json.ts
+import type { JSONValue } from '../json-value'
+import type { Schema } from '../schema'
+import { safeValidateTypes, validateTypes } from '../validate-type'
+import { secureJsonParse } from './secure-json-parse'
+
+/**
+ * Parses a JSON string into an unknown object.
+ *
+ * @param text - The JSON string to parse.
+ * @returns {JSONValue} - The parsed JSON object.
+ */
+export async function parseJSON(options: { text: string; schema?: undefined }): Promise<JSONValue>
+/**
+ * Parses a JSON string into a strongly-typed object using the provided schema.
+ *
+ * @template T - The type of the object to parse the JSON into.
+ * @param {string} text - The JSON string to parse.
+ * @param {Validator<T>} schema - The schema to use for parsing the JSON.
+ * @returns {Promise<T>} - The parsed object.
+ */
+export async function parseJSON<T>(options: { text: string; schema: Schema<T> }): Promise<T>
+export async function parseJSON<T>({ text, schema }: { text: string; schema?: Schema<T> }): Promise<T> {
+  const value = secureJsonParse(text)
+
+  if (schema == null) {
+    return value
+  }
+
+  return validateTypes<T>({ value, schema })
+}
+
+export type ParseResult<T> =
+  | { success: true; value: T; rawValue: unknown }
+  | {
+      success: false
+      error: Error
+      rawValue: unknown
+    }
+
+/**
+ * Safely parses a JSON string and returns the result as an object of type `unknown`.
+ *
+ * @param text - The JSON string to parse.
+ * @returns {Promise<object>} Either an object with `success: true` and the parsed data, or an object with `success: false` and the error that occurred.
+ */
+export async function safeParseJSON(options: { text: string; schema?: undefined }): Promise<ParseResult<JSONValue>>
+/**
+ * Safely parses a JSON string into a strongly-typed object, using a provided schema to validate the object.
+ *
+ * @template T - The type of the object to parse the JSON into.
+ * @param {string} text - The JSON string to parse.
+ * @param {Validator<T>} schema - The schema to use for parsing the JSON.
+ * @returns An object with either a `success` flag and the parsed and typed data, or a `success` flag and an error object.
+ */
+export async function safeParseJSON<T>(options: { text: string; schema: Schema<T> }): Promise<ParseResult<T>>
+export async function safeParseJSON<T>({
+  text,
+  schema
+}: {
+  text: string
+  schema?: Schema<T>
+}): Promise<ParseResult<T>> {
+  try {
+    const value = secureJsonParse(text)
+
+    if (schema == null) {
+      return { success: true, value: value as T, rawValue: value }
+    }
+
+    return await safeValidateTypes<T>({ value, schema })
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error : new Error('Unknown parsing error'),
+      rawValue: undefined
+    }
+  }
+}
+
+export function isParsableJson(input: string): boolean {
+  try {
+    secureJsonParse(input)
+    return true
+  } catch {
+    return false
+  }
+}
@@ -0,0 +1,90 @@
+// https://github.com/vercel/ai/blob/32d8dbbebdb7831467c702094cc903cf93ee15ef/packages/provider-utils/src/secure-json-parse.ts
+// Licensed under BSD-3-Clause (this file only)
+// Code adapted from https://github.com/fastify/secure-json-parse/blob/783fcb1b5434709466759847cec974381939673a/index.js
+//
+// Copyright (c) Vercel, Inc. (https://vercel.com)
+// Copyright (c) 2019 The Fastify Team
+// Copyright (c) 2019, Sideway Inc, and project contributors
+// All rights reserved.
+//
+// The complete list of contributors can be found at:
+// - https://github.com/hapijs/bourne/graphs/contributors
+// - https://github.com/fastify/secure-json-parse/graphs/contributors
+// - https://github.com/vercel/ai/commits/main/packages/provider-utils/src/secure-parse-json.ts
+//
+// Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+const suspectProtoRx = /"__proto__"\s*:/
+const suspectConstructorRx = /"constructor"\s*:/
+
+function _parse(text: string) {
+  // Parse normally
+  const obj = JSON.parse(text)
+
+  // Ignore null and non-objects
+  if (obj === null || typeof obj !== 'object') {
+    return obj
+  }
+
+  if (suspectProtoRx.test(text) === false && suspectConstructorRx.test(text) === false) {
+    return obj
+  }
+
+  // Scan result for proto keys
+  return filter(obj)
+}
+
+function filter(obj: any) {
+  let next = [obj]
+
+  while (next.length) {
+    const nodes = next
+    next = []
+
+    for (const node of nodes) {
+      if (Object.prototype.hasOwnProperty.call(node, '__proto__')) {
+        throw new SyntaxError('Object contains forbidden prototype property')
+      }
+
+      if (
+        Object.prototype.hasOwnProperty.call(node, 'constructor') &&
+        Object.prototype.hasOwnProperty.call(node.constructor, 'prototype')
+      ) {
+        throw new SyntaxError('Object contains forbidden prototype property')
+      }
+
+      for (const key in node) {
+        const value = node[key]
+        if (value && typeof value === 'object') {
+          next.push(value)
+        }
+      }
+    }
+  }
+  return obj
+}
+
+export function secureJsonParse(text: string) {
+  const { stackTraceLimit } = Error
+  try {
+    // Performance optimization, see https://github.com/fastify/secure-json-parse/pull/90
+    Error.stackTraceLimit = 0
+  } catch (e) {
+    // Fallback in case Error is immutable (v8 readonly)
+    return _parse(text)
+  }
+
+  try {
+    return _parse(text)
+  } finally {
+    Error.stackTraceLimit = stackTraceLimit
+  }
+}
@@ -0,0 +1,92 @@
+// https://github.com/vercel/ai/blob/6306603220f9f023fcdbeb9768d1c3fc2ca6bc80/packages/provider-utils/src/schema.ts
+import type { JSONSchema7 } from 'json-schema'
+import * as z4 from 'zod/v4'
+
+export type ValidationResult<OBJECT> = { success: true; value: OBJECT } | { success: false; error: Error }
+
+const schemaSymbol = Symbol.for('schema')
+
+export type Schema<OBJECT = unknown> = {
+  /**
+   * Used to mark schemas so we can support both Zod and custom schemas.
+   */
+  [schemaSymbol]: true
+
+  /**
+   * Schema type for inference.
+   */
+  _type: OBJECT
+
+  /**
+   * Optional. Validates that the structure of a value matches this schema,
+   * and returns a typed version of the value if it does.
+   */
+  readonly validate?: (value: unknown) => ValidationResult<OBJECT> | PromiseLike<ValidationResult<OBJECT>>
+
+  /**
+   * The JSON Schema for the schema.
+   */
+  readonly jsonSchema: JSONSchema7 | PromiseLike<JSONSchema7>
+}
+
+export function asSchema<OBJECT>(schema: Schema<OBJECT> | undefined): Schema<OBJECT> {
+  return schema == null
+    ? jsonSchema({
+        properties: {},
+        additionalProperties: false
+      })
+    : schema
+}
+
+export function jsonSchema<OBJECT = unknown>(
+  jsonSchema: JSONSchema7 | PromiseLike<JSONSchema7> | (() => JSONSchema7 | PromiseLike<JSONSchema7>),
+  {
+    validate
+  }: {
+    validate?: (value: unknown) => ValidationResult<OBJECT> | PromiseLike<ValidationResult<OBJECT>>
+  } = {}
+): Schema<OBJECT> {
+  return {
+    [schemaSymbol]: true,
+    _type: undefined as OBJECT, // should never be used directly
+    get jsonSchema() {
+      if (typeof jsonSchema === 'function') {
+        jsonSchema = jsonSchema() // cache the function results
+      }
+      return jsonSchema
+    },
+    validate
+  }
+}
+
+export function zod4Schema<OBJECT>(
+  zodSchema: z4.core.$ZodType<OBJECT, any>,
+  options?: {
+    /**
+     * Enables support for references in the schema.
+     * This is required for recursive schemas, e.g. with `z.lazy`.
+     * However, not all language models and providers support such references.
+     * Defaults to `false`.
+     */
+    useReferences?: boolean
+  }
+): Schema<OBJECT> {
+  // default to no references (to support openapi conversion for google)
+  const useReferences = options?.useReferences ?? false
+
+  return jsonSchema(
+    // defer json schema creation to avoid unnecessary computation when only validation is needed
+    () =>
+      z4.toJSONSchema(zodSchema, {
+        target: 'draft-7',
+        io: 'output',
+        reused: useReferences ? 'ref' : 'inline'
+      }) as JSONSchema7,
+    {
+      validate: async (value) => {
+        const result = await z4.safeParseAsync(zodSchema, value)
+        return result.success ? { success: true, value: result.data } : { success: false, error: result.error }
+      }
+    }
+  )
+}
@@ -0,0 +1,75 @@
+// https://github.com/vercel/ai/blob/6306603220f9f023fcdbeb9768d1c3fc2ca6bc80/packages/provider-utils/src/validate-types.ts
+import { asSchema, type Schema } from './schema'
+
+/**
+ * Validates the types of an unknown object using a schema and
+ * return a strongly-typed object.
+ *
+ * @template T - The type of the object to validate.
+ * @param {string} options.value - The object to validate.
+ * @param {Validator<T>} options.schema - The schema to use for validating the JSON.
+ * @returns {Promise<T>} - The typed object.
+ */
+export async function validateTypes<OBJECT>({
+  value,
+  schema
+}: {
+  value: unknown
+  schema: Schema<OBJECT>
+}): Promise<OBJECT> {
+  const result = await safeValidateTypes({ value, schema })
+
+  if (!result.success) {
+    throw Error(`Validation failed: ${result.error.message}`)
+  }
+
+  return result.value
+}
+
+/**
+ * Safely validates the types of an unknown object using a schema and
+ * return a strongly-typed object.
+ *
+ * @template T - The type of the object to validate.
+ * @param {string} options.value - The JSON object to validate.
+ * @param {Validator<T>} options.schema - The schema to use for validating the JSON.
+ * @returns An object with either a `success` flag and the parsed and typed data, or a `success` flag and an error object.
+ */
+export async function safeValidateTypes<OBJECT>({ value, schema }: { value: unknown; schema: Schema<OBJECT> }): Promise<
+  | {
+      success: true
+      value: OBJECT
+      rawValue: unknown
+    }
+  | {
+      success: false
+      error: Error
+      rawValue: unknown
+    }
+> {
+  const actualSchema = asSchema(schema)
+
+  try {
+    if (actualSchema.validate == null) {
+      return { success: true, value: value as OBJECT, rawValue: value }
+    }
+
+    const result = await actualSchema.validate(value)
+
+    if (result.success) {
+      return { success: true, value: result.value, rawValue: value }
+    }
+
+    return {
+      success: false,
+      error: Error(`Validation failed: ${result.error.message}`),
+      rawValue: value
+    }
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error : new Error('Unknown validation error'),
+      rawValue: value
+    }
+  }
+}
@@ -0,0 +1,299 @@
+/**
+ * Schema Validator
+ * Provides validation functionality for all configuration schemas
+ */
+
+import * as z from 'zod'
+
+import { ModelConfigSchema, OverrideListSchema, ProviderConfigSchema } from '../schemas'
+import { zod4Schema } from '../utils/schema'
+import { safeValidateTypes } from '../utils/validate-type'
+
+export type ModelConfig = z.infer<typeof ModelConfigSchema>
+export type ProviderConfig = z.infer<typeof ProviderConfigSchema>
+export type OverrideConfig = z.infer<typeof OverrideListSchema>
+
+export interface ValidationResult<T = any> {
+  success: boolean
+  data?: T
+  errors?: z.ZodIssue['path'] extends (string | number)[] ? z.ZodIssue : z.ZodIssue[]
+  warnings?: string[]
+}
+
+export interface ValidationOptions {
+  strict?: boolean
+  includeWarnings?: boolean
+  customValidation?: (data: any) => string[]
+}
+
+export class SchemaValidator {
+  /**
+   * Validate model configuration
+   */
+  async validateModel(config: any, options: ValidationOptions = {}): Promise<ValidationResult<ModelConfig>> {
+    const { includeWarnings = true, customValidation } = options
+
+    const schema = zod4Schema(ModelConfigSchema)
+
+    const validation = await safeValidateTypes({ value: config, schema })
+
+    if (!validation.success) {
+      return {
+        success: false,
+        errors: [{ code: 'custom' as const, message: validation.error.message, path: [] }]
+      }
+    }
+
+    const model = validation.value
+
+    const warnings: string[] = []
+
+    // Basic warnings
+    if (includeWarnings) {
+      if (!model.pricing) {
+        warnings.push('No pricing information provided')
+      }
+
+      if (!model.description) {
+        warnings.push('No model description provided')
+      }
+
+      if (model.capabilities?.includes('REASONING') && !model.reasoning) {
+        warnings.push('Model has REASONING capability but no reasoning configuration')
+      }
+
+      if (model.contextWindow && model.contextWindow > 128000) {
+        warnings.push('Large context window may impact performance')
+      }
+
+      if (model.capabilities?.length === 0) {
+        warnings.push('No capabilities specified for model')
+      }
+    }
+
+    // Custom validation warnings
+    if (includeWarnings && customValidation) {
+      warnings.push(...customValidation(config))
+    }
+
+    return {
+      success: true,
+      data: model,
+      warnings: warnings.length > 0 ? warnings : undefined
+    }
+  }
+
+  /**
+   * Validate provider configuration
+   */
+  validateProvider(config: any, options: ValidationOptions = {}): ValidationResult<ProviderConfig> {
+    const { includeWarnings = true, customValidation } = options
+
+    try {
+      const result = ProviderConfigSchema.parse(config)
+
+      const warnings: string[] = []
+
+      if (includeWarnings && customValidation) {
+        warnings.push(...customValidation(config))
+      }
+
+      if (includeWarnings) {
+        if (!config.behaviors.requiresApiKeyValidation) {
+          warnings.push('Provider does not require API key validation - ensure this is intentional')
+        }
+
+        if (config.endpoints.length === 0) {
+          warnings.push('No endpoints defined for provider')
+        }
+
+        if (config.pricingModel === 'UNIFIED' && !config.behaviors.providesModelMapping) {
+          warnings.push('Unified pricing model without model mapping may cause confusion')
+        }
+      }
+
+      return {
+        success: true,
+        data: result,
+        warnings: warnings.length > 0 ? warnings : undefined
+      }
+    } catch (error) {
+      if (error instanceof z.ZodError) {
+        return {
+          success: false,
+          errors: error.issues
+        }
+      }
+
+      return {
+        success: false,
+        errors: [{ code: 'custom' as const, message: 'Unknown validation error', path: [] }]
+      }
+    }
+  }
+
+  /**
+   * Validate override configuration
+   */
+  validateOverride(config: any, options: ValidationOptions = {}): ValidationResult<OverrideConfig> {
+    const { includeWarnings = true, customValidation } = options
+
+    try {
+      const result = OverrideListSchema.parse(config)
+
+      const warnings: string[] = []
+
+      if (includeWarnings && customValidation) {
+        warnings.push(...customValidation(config))
+      }
+
+      if (includeWarnings) {
+        if (result.overrides.some((override) => !override.reason)) {
+          warnings.push('Some overrides lack reason documentation')
+        }
+
+        if (result.overrides.some((override) => override.priority > 1000)) {
+          warnings.push('Very high priority values may indicate configuration issues')
+        }
+
+        // Check for potential conflicts
+        const modelProviderPairs = result.overrides.map((o) => `${o.modelId}:${o.providerId}`)
+        const duplicates = modelProviderPairs.filter((pair, index) => modelProviderPairs.indexOf(pair) !== index)
+        if (duplicates.length > 0) {
+          warnings.push(`Duplicate override entries detected: ${duplicates.join(', ')}`)
+        }
+      }
+
+      return {
+        success: true,
+        data: result,
+        warnings: warnings.length > 0 ? warnings : undefined
+      }
+    } catch (error) {
+      if (error instanceof z.ZodError) {
+        return {
+          success: false,
+          errors: error.issues
+        }
+      }
+
+      return {
+        success: false,
+        errors: [{ code: 'custom' as const, message: 'Unknown validation error', path: [] }]
+      }
+    }
+  }
+
+  /**
+   * Validate array of configurations
+   */
+  async validateModelArray(
+    configs: any[],
+    options: ValidationOptions = {}
+  ): Promise<{
+    valid: ModelConfig[]
+    invalid: { config: any; errors: z.ZodIssue['path'] extends (string | number)[] ? z.ZodIssue : z.ZodIssue[] }[]
+    warnings: string[]
+  }> {
+    const valid: ModelConfig[] = []
+    const invalid: {
+      config: any
+      errors: z.ZodIssue['path'] extends (string | number)[] ? z.ZodIssue : z.ZodIssue[]
+    }[] = []
+    const allWarnings: string[] = []
+
+    configs.forEach(async (config, index) => {
+      const result = await this.validateModel(config, options)
+
+      if (result.success) {
+        valid.push(result.data!)
+        if (result.warnings) {
+          allWarnings.push(...result.warnings.map((w) => `Model ${index}: ${w}`))
+        }
+      } else {
+        invalid.push({ config, errors: result.errors! })
+      }
+    })
+
+    return { valid, invalid, warnings: allWarnings }
+  }
+
+  /**
+   * Validate provider array
+   */
+  validateProviderArray(
+    configs: any[],
+    options: ValidationOptions = {}
+  ): {
+    valid: ProviderConfig[]
+    invalid: { config: any; errors: z.ZodIssue['path'] extends (string | number)[] ? z.ZodIssue : z.ZodIssue[] }[]
+    warnings: string[]
+  } {
+    const valid: ProviderConfig[] = []
+    const invalid: {
+      config: any
+      errors: z.ZodIssue['path'] extends (string | number)[] ? z.ZodIssue : z.ZodIssue[]
+    }[] = []
+    const allWarnings: string[] = []
+
+    configs.forEach((config, index) => {
+      const result = this.validateProvider(config, options)
+
+      if (result.success) {
+        valid.push(result.data!)
+        if (result.warnings) {
+          allWarnings.push(...result.warnings.map((w) => `Provider ${index}: ${w}`))
+        }
+      } else {
+        invalid.push({ config, errors: result.errors! })
+      }
+    })
+
+    return { valid, invalid, warnings: allWarnings }
+  }
+
+  /**
+   * Format validation errors for display
+   */
+  formatErrors(errors: z.ZodIssue['path'] extends (string | number)[] ? z.ZodIssue : z.ZodIssue[]): string[] {
+    return errors.map((error) => {
+      const path = error.path.length > 0 ? `${error.path.join('.')}: ` : ''
+      return `${path}${error.message}`
+    })
+  }
+
+  /**
+   * Generate validation summary
+   */
+  generateSummary(results: {
+    models: {
+      valid: ModelConfig[]
+      invalid: { config: any; errors: z.ZodIssue['path'] extends (string | number)[] ? z.ZodIssue : z.ZodIssue[] }[]
+      warnings: string[]
+    }
+    providers: {
+      valid: ProviderConfig[]
+      invalid: { config: any; errors: z.ZodIssue['path'] extends (string | number)[] ? z.ZodIssue : z.ZodIssue[] }[]
+      warnings: string[]
+    }
+    overrides: ValidationResult<OverrideConfig>
+  }): {
+    totalModels: number
+    validModels: number
+    totalProviders: number
+    validProviders: number
+    overridesValid: boolean
+    allWarnings: string[]
+  } {
+    const { models, providers, overrides } = results
+
+    return {
+      totalModels: models.valid.length + models.invalid.length,
+      validModels: models.valid.length,
+      totalProviders: providers.valid.length + providers.invalid.length,
+      validProviders: providers.valid.length,
+      overridesValid: overrides.success || false,
+      allWarnings: [...models.warnings, ...providers.warnings, ...(overrides.warnings || [])]
+    }
+  }
+}
@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "allowSyntheticDefaultImports": true,
+    "declaration": true,
+    "emitDecoratorMetadata": true,
+    "esModuleInterop": true,
+    "experimentalDecorators": true,
+    "forceConsistentCasingInFileNames": true,
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "noEmitOnError": false,
+    "outDir": "./dist",
+    "resolveJsonModule": true,
+    "rootDir": "./src",
+    "skipLibCheck": true,
+    "strict": true,
+    "target": "ES2020"
+  },
+  "exclude": ["node_modules", "dist"],
+  "include": ["src/**/*", "scripts"]
+}
@@ -0,0 +1,12 @@
+import { defineConfig } from 'tsdown'
+
+export default defineConfig({
+  entry: {
+    index: 'src/index.ts'
+  },
+  outDir: 'dist',
+  format: ['esm', 'cjs'],
+  clean: true,
+  dts: true,
+  tsconfig: 'tsconfig.json'
+})
@@ -0,0 +1,41 @@
+# See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
+
+# dependencies
+/node_modules
+/.pnp
+.pnp.*
+.yarn/*
+!.yarn/patches
+!.yarn/plugins
+!.yarn/releases
+!.yarn/versions
+
+# testing
+/coverage
+
+# next.js
+/.next/
+/out/
+
+# production
+/build
+
+# misc
+.DS_Store
+*.pem
+
+# debug
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+.pnpm-debug.log*
+
+# env files (can opt-in for committing if needed)
+.env*
+
+# vercel
+.vercel
+
+# typescript
+*.tsbuildinfo
+next-env.d.ts
@@ -0,0 +1,36 @@
+This is a [Next.js](https://nextjs.org) project bootstrapped with [`create-next-app`](https://nextjs.org/docs/app/api-reference/cli/create-next-app).
+
+## Getting Started
+
+First, run the development server:
+
+```bash
+npm run dev
+# or
+yarn dev
+# or
+pnpm dev
+# or
+bun dev
+```
+
+Open [http://localhost:3000](http://localhost:3000) with your browser to see the result.
+
+You can start editing the page by modifying `app/page.tsx`. The page auto-updates as you edit the file.
+
+This project uses [`next/font`](https://nextjs.org/docs/app/building-your-application/optimizing/fonts) to automatically optimize and load [Geist](https://vercel.com/font), a new font family for Vercel.
+
+## Learn More
+
+To learn more about Next.js, take a look at the following resources:
+
+- [Next.js Documentation](https://nextjs.org/docs) - learn about Next.js features and API.
+- [Learn Next.js](https://nextjs.org/learn) - an interactive Next.js tutorial.
+
+You can check out [the Next.js GitHub repository](https://github.com/vercel/next.js) - your feedback and contributions are welcome!
+
+## Deploy on Vercel
+
+The easiest way to deploy your Next.js app is to use the [Vercel Platform](https://vercel.com/new?utm_medium=default-template&filter=next.js&utm_source=create-next-app&utm_campaign=create-next-app-readme) from the creators of Next.js.
+
+Check out our [Next.js deployment documentation](https://nextjs.org/docs/app/building-your-application/deploying) for more details.
@@ -0,0 +1,285 @@
+import { promises as fs } from 'fs'
+import type { NextRequest } from 'next/server'
+import { NextResponse } from 'next/server'
+import path from 'path'
+import { z } from 'zod'
+
+import type { Model, ProviderModelOverride, OverridesDataFile } from '@/lib/catalog-types'
+import {
+  ModelSchema,
+  ModelsDataFileSchema,
+  ProvidersDataFileSchema,
+  OverridesDataFileSchema
+} from '@/lib/catalog-types'
+import { safeParseWithValidation, validateString, ValidationError, createErrorResponse } from '@/lib/validation'
+
+const DATA_DIR = path.join(process.cwd(), '../data')
+
+// Type-safe helper function to apply overrides to base model
+function applyOverrides(baseModel: Model, override: ProviderModelOverride | null): Model {
+  if (!override) return baseModel
+
+  return {
+    ...baseModel,
+    ...(override.limits && {
+      context_window: override.limits.context_window ?? baseModel.context_window,
+      max_output_tokens: override.limits.max_output_tokens ?? baseModel.max_output_tokens
+    }),
+    ...(override.pricing && { pricing: override.pricing })
+  }
+}
+
+// Type-safe helper function to detect model modifications
+function detectModifications(
+  baseModel: Model,
+  updatedModel: Partial<Model>
+): {
+  pricing: Model['pricing'] | undefined
+  limits:
+    | {
+        context_window?: number
+        max_output_tokens?: number
+      }
+    | undefined
+} | null {
+  const modifications: {
+    pricing: Model['pricing'] | undefined
+    limits:
+      | {
+          context_window?: number
+          max_output_tokens?: number
+        }
+      | undefined
+  } = {
+    pricing: undefined,
+    limits: undefined
+  }
+
+  // Check for differences in pricing
+  if (JSON.stringify(baseModel.pricing) !== JSON.stringify(updatedModel.pricing)) {
+    modifications.pricing = updatedModel.pricing
+  }
+
+  // Check for differences in limits
+  if (
+    baseModel.context_window !== updatedModel.context_window ||
+    baseModel.max_output_tokens !== updatedModel.max_output_tokens
+  ) {
+    modifications.limits = {}
+    if (baseModel.context_window !== updatedModel.context_window) {
+      modifications.limits.context_window = updatedModel.context_window
+    }
+    if (baseModel.max_output_tokens !== updatedModel.max_output_tokens) {
+      modifications.limits.max_output_tokens = updatedModel.max_output_tokens
+    }
+  }
+
+  return modifications.pricing || modifications.limits ? modifications : null
+}
+
+export async function GET(request: NextRequest, { params }: { params: { modelId: string; providerId: string } }) {
+  try {
+    const { modelId, providerId } = params
+
+    // Validate parameters
+    const validModelId = validateString(modelId, 'modelId')
+    const validProviderId = validateString(providerId, 'providerId')
+
+    // Read and validate all data files
+    const [modelsDataRaw, providersDataRaw, overridesDataRaw] = await Promise.all([
+      fs.readFile(path.join(DATA_DIR, 'models.json'), 'utf-8'),
+      fs.readFile(path.join(DATA_DIR, 'providers.json'), 'utf-8'),
+      fs.readFile(path.join(DATA_DIR, 'overrides.json'), 'utf-8')
+    ])
+
+    const modelsData = await safeParseWithValidation(
+      modelsDataRaw,
+      ModelsDataFileSchema,
+      'Invalid models data format in file'
+    )
+    const providersData = await safeParseWithValidation(
+      providersDataRaw,
+      ProvidersDataFileSchema,
+      'Invalid providers data format in file'
+    )
+    const overridesData = await safeParseWithValidation(
+      overridesDataRaw,
+      OverridesDataFileSchema,
+      'Invalid overrides data format in file'
+    )
+
+    // Find base model
+    const baseModel = modelsData.models.find((m) => m.id === validModelId)
+    if (!baseModel) {
+      return NextResponse.json(createErrorResponse('Model not found', 404), { status: 404 })
+    }
+
+    // Find provider override for this model
+    const override = overridesData.overrides.find(
+      (o) => o.model_id === validModelId && o.provider_id === validProviderId
+    )
+
+    // Apply override if exists
+    const finalModel = applyOverrides(baseModel, override || null)
+
+    return NextResponse.json(ModelSchema.parse(finalModel))
+  } catch (error) {
+    if (error instanceof ValidationError) {
+      console.error('Validation error:', error.message, error.details)
+      return NextResponse.json(createErrorResponse(error.message, 400, error.details), { status: 400 })
+    }
+
+    console.error('Error fetching provider model:', error)
+    return NextResponse.json(
+      createErrorResponse(
+        'Failed to fetch model configuration',
+        500,
+        error instanceof Error ? error.message : 'Unknown error'
+      ),
+      { status: 500 }
+    )
+  }
+}
+
+// Response schema for provider model updates
+const ProviderModelUpdateResponseSchema = z.object({
+  updated: z.enum(['base_model', 'override', 'override_updated', 'override_removed']),
+  model: ModelSchema
+})
+
+export async function PUT(request: NextRequest, { params }: { params: { modelId: string; providerId: string } }) {
+  try {
+    const { modelId, providerId } = params
+
+    // Validate parameters
+    const validModelId = validateString(modelId, 'modelId')
+    const validProviderId = validateString(providerId, 'providerId')
+
+    // Validate request body
+    const requestBody = await request.json()
+    const updatedModel = await safeParseWithValidation(
+      JSON.stringify(requestBody),
+      ModelSchema.partial(),
+      'Invalid model data in request body'
+    )
+
+    // Read and validate current data
+    const [modelsDataRaw, providersDataRaw, overridesDataRaw] = await Promise.all([
+      fs.readFile(path.join(DATA_DIR, 'models.json'), 'utf-8'),
+      fs.readFile(path.join(DATA_DIR, 'providers.json'), 'utf-8'),
+      fs.readFile(path.join(DATA_DIR, 'overrides.json'), 'utf-8')
+    ])
+
+    const modelsData = await safeParseWithValidation(
+      modelsDataRaw,
+      ModelsDataFileSchema,
+      'Invalid models data format in file'
+    )
+    const providersData = await safeParseWithValidation(
+      providersDataRaw,
+      ProvidersDataFileSchema,
+      'Invalid providers data format in file'
+    )
+    const overridesData = await safeParseWithValidation(
+      overridesDataRaw,
+      OverridesDataFileSchema,
+      'Invalid overrides data format in file'
+    )
+
+    // Find base model and existing override
+    const baseModelIndex = modelsData.models.findIndex((m) => m.id === validModelId)
+    const existingOverrideIndex = overridesData.overrides.findIndex(
+      (o) => o.model_id === validModelId && o.provider_id === validProviderId
+    )
+
+    if (baseModelIndex === -1) {
+      return NextResponse.json(createErrorResponse('Base model not found', 404), { status: 404 })
+    }
+
+    const baseModel = modelsData.models[baseModelIndex]
+
+    // Detect what needs to be overridden
+    const modifications = detectModifications(baseModel, updatedModel)
+
+    let updated: 'base_model' | 'override' | 'override_updated' | 'override_removed' = 'base_model'
+    let overrideCreated = false
+
+    if (modifications) {
+      // Create or update override
+      const override: ProviderModelOverride = {
+        provider_id: validProviderId,
+        model_id: validModelId,
+        disabled: false,
+        reason: 'Manual configuration update',
+        last_updated: new Date().toISOString().split('T')[0],
+        updated_by: 'web-interface',
+        priority: 100,
+        ...modifications
+      }
+
+      const updatedOverrides = [...overridesData.overrides]
+
+      if (existingOverrideIndex >= 0) {
+        updatedOverrides[existingOverrideIndex] = {
+          ...updatedOverrides[existingOverrideIndex],
+          ...override,
+          last_updated: new Date().toISOString().split('T')[0]
+        }
+      } else {
+        updatedOverrides.push(override)
+        overrideCreated = true
+      }
+
+      const updatedOverridesData: OverridesDataFile = {
+        ...overridesData,
+        overrides: updatedOverrides
+      }
+
+      updated = overrideCreated ? 'override' : 'override_updated'
+
+      // Save changes to overrides file
+      await fs.writeFile(path.join(DATA_DIR, 'overrides.json'), JSON.stringify(updatedOverridesData, null, 2), 'utf-8')
+    } else if (existingOverrideIndex >= 0) {
+      // Remove override if no differences exist
+      const updatedOverrides = overridesData.overrides.filter((_, index) => index !== existingOverrideIndex)
+
+      const updatedOverridesData: OverridesDataFile = {
+        ...overridesData,
+        overrides: updatedOverrides
+      }
+
+      updated = 'override_removed'
+
+      // Save changes to overrides file
+      await fs.writeFile(path.join(DATA_DIR, 'overrides.json'), JSON.stringify(updatedOverridesData, null, 2), 'utf-8')
+    }
+
+    // Return the final model configuration
+    const finalOverride = overridesData.overrides.find(
+      (o) => o.model_id === validModelId && o.provider_id === validProviderId
+    )
+    const finalModel = applyOverrides(baseModel, finalOverride || null)
+
+    const response = ProviderModelUpdateResponseSchema.parse({
+      updated,
+      model: finalModel
+    })
+
+    return NextResponse.json(response)
+  } catch (error) {
+    if (error instanceof ValidationError) {
+      console.error('Validation error:', error.message, error.details)
+      return NextResponse.json(createErrorResponse(error.message, 400, error.details), { status: 400 })
+    }
+
+    console.error('Error updating provider model:', error)
+    return NextResponse.json(
+      createErrorResponse(
+        'Failed to update model configuration',
+        500,
+        error instanceof Error ? error.message : 'Unknown error'
+      ),
+      { status: 500 }
+    )
+  }
+}
@@ -0,0 +1,113 @@
+import { promises as fs } from 'fs'
+import type { NextRequest } from 'next/server'
+import { NextResponse } from 'next/server'
+import path from 'path'
+
+import type { ModelsDataFile } from '@/lib/catalog-types'
+import { ModelSchema, ModelsDataFileSchema, ModelUpdateResponseSchema } from '@/lib/catalog-types'
+import { createErrorResponse, safeParseWithValidation, ValidationError } from '@/lib/validation'
+
+const DATA_DIR = path.join(process.cwd(), '../data')
+
+export async function GET(request: NextRequest, { params }: { params: { modelId: string } }) {
+  try {
+    const { modelId } = params
+
+    // Read and validate models data using Zod
+    const modelsDataPath = path.join(DATA_DIR, 'models.json')
+    const modelsDataRaw = await fs.readFile(modelsDataPath, 'utf-8')
+    const modelsData = await safeParseWithValidation(
+      modelsDataRaw,
+      ModelsDataFileSchema,
+      'Invalid models data format in file'
+    )
+
+    // Find the model with type safety
+    const model = modelsData.models.find((m) => m.id === modelId)
+    if (!model) {
+      return NextResponse.json(createErrorResponse('Model not found', 404), { status: 404 })
+    }
+
+    return NextResponse.json(model)
+  } catch (error) {
+    if (error instanceof ValidationError) {
+      console.error('Validation error:', error.message, error.details)
+      return NextResponse.json(createErrorResponse(error.message, 400, error.details), { status: 400 })
+    }
+
+    console.error('Error fetching model:', error)
+    return NextResponse.json(
+      createErrorResponse('Failed to fetch model', 500, error instanceof Error ? error.message : 'Unknown error'),
+      { status: 500 }
+    )
+  }
+}
+
+export async function PUT(request: NextRequest, { params }: { params: { modelId: string } }) {
+  try {
+    const { modelId } = params
+
+    // Read and validate request body using Zod
+    const requestBody = await request.json()
+    const updatedModel = await safeParseWithValidation(
+      JSON.stringify(requestBody),
+      ModelSchema,
+      'Invalid model data in request body'
+    )
+
+    // Validate that the model ID matches
+    if (updatedModel.id !== modelId) {
+      return NextResponse.json(createErrorResponse('Model ID in request body must match URL parameter', 400), {
+        status: 400
+      })
+    }
+
+    // Read current models data using Zod
+    const modelsDataPath = path.join(DATA_DIR, 'models.json')
+    const modelsDataRaw = await fs.readFile(modelsDataPath, 'utf-8')
+    const modelsData = await safeParseWithValidation(
+      modelsDataRaw,
+      ModelsDataFileSchema,
+      'Invalid models data format in file'
+    )
+
+    // Find and update the model
+    const modelIndex = modelsData.models.findIndex((m) => m.id === modelId)
+    if (modelIndex === -1) {
+      return NextResponse.json(createErrorResponse('Model not found', 404), { status: 404 })
+    }
+
+    // Create updated models array (immutability)
+    const updatedModels = [
+      ...modelsData.models.slice(0, modelIndex),
+      updatedModel,
+      ...modelsData.models.slice(modelIndex + 1)
+    ]
+
+    const updatedModelsData: ModelsDataFile = {
+      ...modelsData,
+      models: updatedModels
+    }
+
+    // Write back to file
+    await fs.writeFile(modelsDataPath, JSON.stringify(updatedModelsData, null, 2), 'utf-8')
+
+    const response = ModelUpdateResponseSchema.parse({
+      success: true,
+      model: updatedModel
+    })
+
+    return NextResponse.json(response)
+  } catch (error) {
+    if (error instanceof ValidationError) {
+      console.error('Validation error:', error.message, error.details)
+      return NextResponse.json(createErrorResponse(error.message, 400, error.details), { status: 400 })
+    }
+
+    console.error('Error updating model:', error)
+    return NextResponse.json(
+      createErrorResponse('Failed to update model', 500, error instanceof Error ? error.message : 'Unknown error'),
+      { status: 500 }
+    )
+  }
+}
@@ -0,0 +1,156 @@
+import { promises as fs } from 'fs'
+import type { NextRequest } from 'next/server'
+import { NextResponse } from 'next/server'
+import path from 'path'
+
+import type { Model } from '@/lib/catalog-types'
+import {
+  ModelSchema,
+  ModelsDataFileSchema
+} from '@/lib/catalog-types'
+import {
+  createErrorResponse,
+  safeParseWithValidation,
+  validatePaginatedResponse,
+  validateQueryParams,
+  ValidationError
+} from '@/lib/validation'
+
+const DATA_DIR = path.join(process.cwd(), '../data')
+
+function filterModels(
+  models: readonly Model[],
+  search?: string,
+  capabilities?: string[],
+  providers?: string[]
+): Model[] {
+  let filtered = [...models]
+
+  if (search) {
+    const searchLower = search.toLowerCase()
+    filtered = filtered.filter(
+      (model) =>
+        model.id.toLowerCase().includes(searchLower) ||
+        model.name?.toLowerCase().includes(searchLower) ||
+        model.owned_by?.toLowerCase().includes(searchLower)
+    )
+  }
+
+  if (capabilities && capabilities.length > 0) {
+    filtered = filtered.filter((model) => capabilities.some((cap) => model.capabilities.includes(cap)))
+  }
+
+  if (providers && providers.length > 0) {
+    filtered = filtered.filter((model) => model.owned_by && providers.includes(model.owned_by))
+  }
+
+  return filtered
+}
+
+function paginateItems<T>(
+  items: readonly T[],
+  page: number,
+  limit: number
+): {
+  items: T[]
+  pagination: {
+    page: number
+    limit: number
+    total: number
+    totalPages: number
+    hasNext: boolean
+    hasPrev: boolean
+  }
+} {
+  const total = items.length
+  const totalPages = Math.ceil(total / limit)
+  const offset = (page - 1) * limit
+  const paginatedItems = items.slice(offset, offset + limit)
+
+  return {
+    items: paginatedItems,
+    pagination: {
+      page,
+      limit,
+      total,
+      totalPages,
+      hasNext: page < totalPages,
+      hasPrev: page > 1
+    }
+  }
+}
+
+export async function GET(request: NextRequest) {
+  try {
+    const { searchParams } = new URL(request.url)
+
+    // Validate query parameters using Zod
+    const validatedParams = validateQueryParams(searchParams)
+
+    // Read and validate models data using Zod
+    const modelsDataPath = path.join(DATA_DIR, 'models.json')
+    const modelsDataRaw = await fs.readFile(modelsDataPath, 'utf-8')
+    const modelsData = await safeParseWithValidation(
+      modelsDataRaw,
+      ModelsDataFileSchema,
+      'Invalid models data format in file'
+    )
+
+    // Filter models with type safety
+    const filteredModels = filterModels(
+      modelsData.models,
+      validatedParams.search,
+      validatedParams.capabilities,
+      validatedParams.providers
+    )
+
+    // Paginate results
+    const { items, pagination } = paginateItems(filteredModels, validatedParams.page, validatedParams.limit)
+
+    // Create paginated response using Zod schema
+    const response = validatePaginatedResponse({ data: items, pagination }, ModelSchema)
+
+    return NextResponse.json(response)
+  } catch (error) {
+    if (error instanceof ValidationError) {
+      console.error('Validation error:', error.message, error.details)
+      return NextResponse.json(createErrorResponse(error.message, 400, error.details), { status: 400 })
+    }
+
+    console.error('Error fetching models:', error)
+    return NextResponse.json(
+      createErrorResponse('Failed to fetch models', 500, error instanceof Error ? error.message : 'Unknown error'),
+      { status: 500 }
+    )
+  }
+}
+
+export async function PUT(request: NextRequest) {
+  try {
+    const body = await request.json()
+
+    // Validate the data structure using Zod
+    const validatedData = await safeParseWithValidation(
+      JSON.stringify(body),
+      ModelsDataFileSchema,
+      'Invalid models data format in request body'
+    )
+
+    // Write validated data back to file
+    const modelsDataPath = path.join(DATA_DIR, 'models.json')
+    await fs.writeFile(modelsDataPath, JSON.stringify(validatedData, null, 2), 'utf-8')
+
+    return NextResponse.json({ success: true })
+  } catch (error) {
+    if (error instanceof ValidationError) {
+      console.error('Validation error:', error.message, error.details)
+      return NextResponse.json(createErrorResponse(error.message, 400, error.details), { status: 400 })
+    }
+
+    console.error('Error updating models:', error)
+    return NextResponse.json(
+      createErrorResponse('Failed to update models', 500, error instanceof Error ? error.message : 'Unknown error'),
+      { status: 500 }
+    )
+  }
+}
@@ -0,0 +1,113 @@
+import { promises as fs } from 'fs'
+import type { NextRequest } from 'next/server'
+import { NextResponse } from 'next/server'
+import path from 'path'
+
+import type { ProvidersDataFile } from '@/lib/catalog-types'
+import { ProviderSchema, ProvidersDataFileSchema, ProviderUpdateResponseSchema } from '@/lib/catalog-types'
+import { createErrorResponse, safeParseWithValidation, ValidationError } from '@/lib/validation'
+
+const DATA_DIR = path.join(process.cwd(), '../data')
+
+export async function GET(request: NextRequest, { params }: { params: { providerId: string } }) {
+  try {
+    const { providerId } = params
+
+    // Read and validate providers data using Zod
+    const providersDataPath = path.join(DATA_DIR, 'providers.json')
+    const providersDataRaw = await fs.readFile(providersDataPath, 'utf-8')
+    const providersData = await safeParseWithValidation(
+      providersDataRaw,
+      ProvidersDataFileSchema,
+      'Invalid providers data format in file'
+    )
+
+    // Find the provider with type safety
+    const provider = providersData.providers.find((p) => p.id === providerId)
+    if (!provider) {
+      return NextResponse.json(createErrorResponse('Provider not found', 404), { status: 404 })
+    }
+
+    return NextResponse.json(provider)
+  } catch (error) {
+    if (error instanceof ValidationError) {
+      console.error('Validation error:', error.message, error.details)
+      return NextResponse.json(createErrorResponse(error.message, 400, error.details), { status: 400 })
+    }
+
+    console.error('Error fetching provider:', error)
+    return NextResponse.json(
+      createErrorResponse('Failed to fetch provider', 500, error instanceof Error ? error.message : 'Unknown error'),
+      { status: 500 }
+    )
+  }
+}
+
+export async function PUT(request: NextRequest, { params }: { params: { providerId: string } }) {
+  try {
+    const { providerId } = params
+
+    // Read and validate request body using Zod
+    const requestBody = await request.json()
+    const updatedProvider = await safeParseWithValidation(
+      JSON.stringify(requestBody),
+      ProviderSchema,
+      'Invalid provider data in request body'
+    )
+
+    // Validate that the provider ID matches
+    if (updatedProvider.id !== providerId) {
+      return NextResponse.json(createErrorResponse('Provider ID in request body must match URL parameter', 400), {
+        status: 400
+      })
+    }
+
+    // Read current providers data using Zod
+    const providersDataPath = path.join(DATA_DIR, 'providers.json')
+    const providersDataRaw = await fs.readFile(providersDataPath, 'utf-8')
+    const providersData = await safeParseWithValidation(
+      providersDataRaw,
+      ProvidersDataFileSchema,
+      'Invalid providers data format in file'
+    )
+
+    // Find and update the provider
+    const providerIndex = providersData.providers.findIndex((p) => p.id === providerId)
+    if (providerIndex === -1) {
+      return NextResponse.json(createErrorResponse('Provider not found', 404), { status: 404 })
+    }
+
+    // Create updated providers array (immutability)
+    const updatedProviders = [
+      ...providersData.providers.slice(0, providerIndex),
+      updatedProvider,
+      ...providersData.providers.slice(providerIndex + 1)
+    ]
+
+    const updatedProvidersData: ProvidersDataFile = {
+      ...providersData,
+      providers: updatedProviders
+    }
+
+    // Write back to file
+    await fs.writeFile(providersDataPath, JSON.stringify(updatedProvidersData, null, 2), 'utf-8')
+
+    const response = ProviderUpdateResponseSchema.parse({
+      success: true,
+      provider: updatedProvider
+    })
+
+    return NextResponse.json(response)
+  } catch (error) {
+    if (error instanceof ValidationError) {
+      console.error('Validation error:', error.message, error.details)
+      return NextResponse.json(createErrorResponse(error.message, 400, error.details), { status: 400 })
+    }
+
+    console.error('Error updating provider:', error)
+    return NextResponse.json(
+      createErrorResponse('Failed to update provider', 500, error instanceof Error ? error.message : 'Unknown error'),
+      { status: 500 }
+    )
+  }
+}
@@ -0,0 +1,146 @@
+import { promises as fs } from 'fs'
+import type { NextRequest } from 'next/server'
+import { NextResponse } from 'next/server'
+import path from 'path'
+
+import type { Provider } from '@/lib/catalog-types'
+import {
+  ProviderSchema,
+  ProvidersDataFileSchema
+} from '@/lib/catalog-types'
+import {
+  createErrorResponse,
+  safeParseWithValidation,
+  validatePaginatedResponse,
+  validateQueryParams,
+  ValidationError
+} from '@/lib/validation'
+
+const DATA_DIR = path.join(process.cwd(), '../data')
+
+function filterProviders(providers: readonly Provider[], search?: string, authentication?: string[]): Provider[] {
+  let filtered = [...providers]
+
+  if (search) {
+    const searchLower = search.toLowerCase()
+    filtered = filtered.filter(
+      (provider) =>
+        provider.id.toLowerCase().includes(searchLower) ||
+        provider.name.toLowerCase().includes(searchLower) ||
+        provider.description?.toLowerCase().includes(searchLower)
+    )
+  }
+
+  if (authentication && authentication.length > 0) {
+    filtered = filtered.filter((provider) => authentication.includes(provider.authentication))
+  }
+
+  return filtered
+}
+
+function paginateItems<T>(
+  items: readonly T[],
+  page: number,
+  limit: number
+): {
+  items: T[]
+  pagination: {
+    page: number
+    limit: number
+    total: number
+    totalPages: number
+    hasNext: boolean
+    hasPrev: boolean
+  }
+} {
+  const total = items.length
+  const totalPages = Math.ceil(total / limit)
+  const offset = (page - 1) * limit
+  const paginatedItems = items.slice(offset, offset + limit)
+
+  return {
+    items: paginatedItems,
+    pagination: {
+      page,
+      limit,
+      total,
+      totalPages,
+      hasNext: page < totalPages,
+      hasPrev: page > 1
+    }
+  }
+}
+
+export async function GET(request: NextRequest) {
+  try {
+    const { searchParams } = new URL(request.url)
+
+    // Validate query parameters using Zod
+    const validatedParams = validateQueryParams(searchParams)
+
+    // Read and validate providers data using Zod
+    const providersDataPath = path.join(DATA_DIR, 'providers.json')
+    const providersDataRaw = await fs.readFile(providersDataPath, 'utf-8')
+    const providersData = await safeParseWithValidation(
+      providersDataRaw,
+      ProvidersDataFileSchema,
+      'Invalid providers data format in file'
+    )
+
+    // Filter providers with type safety
+    const filteredProviders = filterProviders(
+      providersData.providers,
+      validatedParams.search,
+      validatedParams.authentication
+    )
+
+    // Paginate results
+    const { items, pagination } = paginateItems(filteredProviders, validatedParams.page, validatedParams.limit)
+
+    // Create paginated response using Zod schema
+    const response = validatePaginatedResponse({ data: items, pagination }, ProviderSchema)
+
+    return NextResponse.json(response)
+  } catch (error) {
+    if (error instanceof ValidationError) {
+      console.error('Validation error:', error.message, error.details)
+      return NextResponse.json(createErrorResponse(error.message, 400, error.details), { status: 400 })
+    }
+
+    console.error('Error fetching providers:', error)
+    return NextResponse.json(
+      createErrorResponse('Failed to fetch providers', 500, error instanceof Error ? error.message : 'Unknown error'),
+      { status: 500 }
+    )
+  }
+}
+
+export async function PUT(request: NextRequest) {
+  try {
+    const body = await request.json()
+
+    // Validate the data structure using Zod
+    const validatedData = await safeParseWithValidation(
+      JSON.stringify(body),
+      ProvidersDataFileSchema,
+      'Invalid providers data format in request body'
+    )
+
+    // Write validated data back to file
+    const providersDataPath = path.join(DATA_DIR, 'providers.json')
+    await fs.writeFile(providersDataPath, JSON.stringify(validatedData, null, 2), 'utf-8')
+
+    return NextResponse.json({ success: true })
+  } catch (error) {
+    if (error instanceof ValidationError) {
+      console.error('Validation error:', error.message, error.details)
+      return NextResponse.json(createErrorResponse(error.message, 400, error.details), { status: 400 })
+    }
+
+    console.error('Error updating providers:', error)
+    return NextResponse.json(
+      createErrorResponse('Failed to update providers', 500, error instanceof Error ? error.message : 'Unknown error'),
+      { status: 500 }
+    )
+  }
+}
@@ -0,0 +1,70 @@
+import { promises as fs } from 'fs'
+import { NextResponse } from 'next/server'
+import path from 'path'
+import { z } from 'zod'
+
+// Define schema for stats response
+const StatsResponseSchema = z.object({
+  total_models: z.number(),
+  total_providers: z.number(),
+  total_overrides: z.number(),
+  last_updated: z.string().optional(),
+  migration_status: z.enum(['completed', 'in_progress', 'failed']).optional()
+})
+
+const DATA_DIR = path.join(process.cwd(), '../data')
+
+// Define schema for migration report
+const MigrationReportSchema = z.object({
+  summary: z.object({
+    total_base_models: z.number(),
+    total_providers: z.number(),
+    total_overrides: z.number()
+  })
+})
+
+const ModelsDataSchema = z.object({
+  version: z.string(),
+  models: z.array(z.any())
+})
+
+export async function GET() {
+  try {
+    // Read migration report for stats with Zod validation
+    const reportData = await fs.readFile(path.join(DATA_DIR, 'migration-report.json'), 'utf-8')
+    const report = MigrationReportSchema.parse(JSON.parse(reportData))
+
+    // Read actual data for last updated timestamp with Zod validation
+    const modelsData = await fs.readFile(path.join(DATA_DIR, 'models.json'), 'utf-8')
+    const models = ModelsDataSchema.parse(JSON.parse(modelsData))
+
+    const stats = {
+      total_models: report.summary.total_base_models,
+      total_providers: report.summary.total_providers,
+      total_overrides: report.summary.total_overrides,
+      last_updated: new Date().toISOString(),
+      version: models.version
+    }
+
+    // Validate response with Zod schema
+    const validatedStats = StatsResponseSchema.parse(stats)
+
+    return NextResponse.json(validatedStats)
+  } catch (error) {
+    console.error('Error fetching stats:', error)
+
+    // Try to provide a minimal fallback response
+    const fallbackStats = {
+      total_models: 0,
+      total_providers: 0,
+      total_overrides: 0
+    }
+
+    try {
+      const validatedFallback = StatsResponseSchema.parse(fallbackStats)
+      return NextResponse.json(validatedFallback)
+    } catch {
+      return NextResponse.json({ error: 'Failed to fetch stats' }, { status: 500 })
+    }
+  }
+}
@@ -0,0 +1,26 @@
+@import 'tailwindcss';
+
+:root {
+  --background: #ffffff;
+  --foreground: #171717;
+}
+
+@theme inline {
+  --color-background: var(--background);
+  --color-foreground: var(--foreground);
+  --font-sans: var(--font-geist-sans);
+  --font-mono: var(--font-geist-mono);
+}
+
+@media (prefers-color-scheme: dark) {
+  :root {
+    --background: #0a0a0a;
+    --foreground: #ededed;
+  }
+}
+
+body {
+  background: var(--background);
+  color: var(--foreground);
+  font-family: Arial, Helvetica, sans-serif;
+}
@@ -0,0 +1,31 @@
+import './globals.css'
+
+import type { Metadata } from 'next'
+import { Geist, Geist_Mono } from 'next/font/google'
+
+const geistSans = Geist({
+  variable: '--font-geist-sans',
+  subsets: ['latin']
+})
+
+const geistMono = Geist_Mono({
+  variable: '--font-geist-mono',
+  subsets: ['latin']
+})
+
+export const metadata: Metadata = {
+  title: 'Create Next App',
+  description: 'Generated by create next app'
+}
+
+export default function RootLayout({
+  children
+}: Readonly<{
+  children: React.ReactNode
+}>) {
+  return (
+    <html lang="en">
+      <body className={`${geistSans.variable} ${geistMono.variable} antialiased`}>{children}</body>
+    </html>
+  )
+}
@@ -0,0 +1,348 @@
+'use client'
+
+import { useState } from 'react'
+
+import { Navigation } from '@/components/navigation'
+import { Alert, AlertDescription } from '@/components/ui/alert'
+import { Badge } from '@/components/ui/badge'
+import { Button } from '@/components/ui/button'
+import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card'
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogHeader,
+  DialogTitle,
+  DialogTrigger
+} from '@/components/ui/dialog'
+import { Input } from '@/components/ui/input'
+import { Separator } from '@/components/ui/separator'
+import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from '@/components/ui/table'
+import { Textarea } from '@/components/ui/textarea'
+// Import SWR hooks and utilities
+import { getErrorMessage, useDebounce, useModels, useUpdateModel } from '@/lib/api-client'
+import type { CapabilityType, Model } from '@/lib/catalog-types'
+
+// Type-safe capabilities list
+const CAPABILITIES: readonly CapabilityType[] = [
+  'FUNCTION_CALL',
+  'REASONING',
+  'IMAGE_RECOGNITION',
+  'IMAGE_GENERATION',
+  'AUDIO_RECOGNITION',
+  'AUDIO_GENERATION',
+  'EMBEDDING',
+  'RERANK',
+  'AUDIO_TRANSCRIPT',
+  'VIDEO_RECOGNITION',
+  'VIDEO_GENERATION',
+  'STRUCTURED_OUTPUT',
+  'FILE_INPUT',
+  'WEB_SEARCH',
+  'CODE_EXECUTION',
+  'FILE_SEARCH',
+  'COMPUTER_USE'
+] as const
+
+// Simple Pagination Component
+function SimplePagination({
+  currentPage,
+  totalPages,
+  onPageChange
+}: {
+  currentPage: number
+  totalPages: number
+  onPageChange: (page: number) => void
+}) {
+  const pages = Array.from({ length: Math.min(5, totalPages) }, (_, i) => {
+    if (totalPages <= 5) return i + 1
+    if (currentPage <= 3) return i + 1
+    if (currentPage >= totalPages - 2) return totalPages - 4 + i
+    return currentPage - 2 + i
+  })
+
+  return (
+    <div className="flex items-center gap-2">
+      <Button variant="outline" size="sm" onClick={() => onPageChange(currentPage - 1)} disabled={currentPage <= 1}>
+        Previous
+      </Button>
+      {pages.map((page) => (
+        <Button
+          key={page}
+          variant={currentPage === page ? 'default' : 'outline'}
+          size="sm"
+          onClick={() => onPageChange(page)}>
+          {page}
+        </Button>
+      ))}
+      <Button
+        variant="outline"
+        size="sm"
+        onClick={() => onPageChange(currentPage + 1)}
+        disabled={currentPage >= totalPages}>
+        Next
+      </Button>
+    </div>
+  )
+}
+
+export default function CatalogReview() {
+  // Form state
+  const [search, setSearch] = useState('')
+  const [selectedCapabilities, setSelectedCapabilities] = useState<string[]>([])
+  const [selectedProviders, setSelectedProviders] = useState<string[]>([])
+  const [currentPage, setCurrentPage] = useState(1)
+  const [editingModel, setEditingModel] = useState<Model | null>(null)
+  const [jsonContent, setJsonContent] = useState('')
+
+  // Debounce search to avoid excessive API calls
+  const debouncedSearch = useDebounce(search, 300)
+
+  // SWR hook for fetching models
+  const {
+    data: modelsData,
+    error,
+    isLoading
+  } = useModels({
+    page: currentPage,
+    limit: 20,
+    search: debouncedSearch,
+    capabilities: selectedCapabilities.length > 0 ? selectedCapabilities : undefined,
+    providers: selectedProviders.length > 0 ? selectedProviders : undefined
+  })
+
+  // SWR mutation for updating models
+  const { trigger: updateModel, isMutating: isUpdating } = useUpdateModel()
+
+  // Extract data from SWR response
+  const models = modelsData?.data || []
+  const pagination = modelsData?.pagination || {
+    page: 1,
+    limit: 20,
+    total: 0,
+    totalPages: 0,
+    hasNext: false,
+    hasPrev: false
+  }
+
+  const handleEdit = (model: Model) => {
+    setEditingModel(model)
+    setJsonContent(JSON.stringify(model, null, 2))
+  }
+
+  const handleSave = async () => {
+    if (!editingModel) return
+
+    try {
+      // Validate JSON before sending
+      const updatedModel = JSON.parse(jsonContent) as unknown
+
+      // Basic validation - the API will do thorough validation
+      if (!updatedModel || typeof updatedModel !== 'object') {
+        throw new Error('Invalid JSON format')
+      }
+
+      // Use SWR mutation for optimistic update
+      await updateModel({
+        id: editingModel.id,
+        data: updatedModel as Partial<Model>
+      })
+
+      // Close dialog and reset form
+      setEditingModel(null)
+      setJsonContent('')
+    } catch (error) {
+      console.error('Error saving model:', error)
+      // Error will be handled by SWR and displayed in UI
+    }
+  }
+
+  // Type-safe function to extract unique providers
+  const getUniqueProviders = (): string[] => {
+    return [
+      ...new Set(models.map((model) => model.owned_by).filter((provider): provider is string => Boolean(provider)))
+    ]
+  }
+
+  return (
+    <div className="container mx-auto p-6 space-y-6">
+      <div className="flex items-center justify-between">
+        <div>
+          <h1 className="text-3xl font-bold">Catalog Review</h1>
+          <p className="text-muted-foreground">Review and validate model configurations after migration</p>
+        </div>
+        <Navigation />
+      </div>
+
+      <Card>
+        <CardHeader>
+          <CardTitle>Filters</CardTitle>
+          <CardDescription>Filter models to review specific configurations</CardDescription>
+        </CardHeader>
+        <CardContent className="space-y-4">
+          <div className="flex gap-4">
+            <Input
+              placeholder="Search models..."
+              value={search}
+              onChange={(e) => setSearch(e.target.value)}
+              className="max-w-sm"
+            />
+          </div>
+
+          <div>
+            <label className="text-sm font-medium mb-2 block">Capabilities</label>
+            <div className="flex flex-wrap gap-2">
+              {CAPABILITIES.map((capability) => (
+                <Badge
+                  key={capability}
+                  variant={selectedCapabilities.includes(capability) ? 'default' : 'outline'}
+                  className="cursor-pointer"
+                  onClick={() => {
+                    setSelectedCapabilities((prev) =>
+                      prev.includes(capability) ? prev.filter((c) => c !== capability) : [...prev, capability]
+                    )
+                  }}>
+                  {capability.replace('_', ' ')}
+                </Badge>
+              ))}
+            </div>
+          </div>
+
+          <div>
+            <label className="text-sm font-medium mb-2 block">Providers</label>
+            <div className="flex flex-wrap gap-2">
+              {getUniqueProviders().map((provider) => (
+                <Badge
+                  key={provider}
+                  variant={selectedProviders.includes(provider) ? 'default' : 'outline'}
+                  className="cursor-pointer"
+                  onClick={() => {
+                    setSelectedProviders((prev) =>
+                      prev.includes(provider) ? prev.filter((p) => p !== provider) : [...prev, provider]
+                    )
+                  }}>
+                  {provider}
+                </Badge>
+              ))}
+            </div>
+          </div>
+        </CardContent>
+      </Card>
+
+      {/* Error Display */}
+      {error && (
+        <Alert variant="destructive">
+          <AlertDescription>{getErrorMessage(error)}</AlertDescription>
+        </Alert>
+      )}
+
+      <Card>
+        <CardHeader>
+          <CardTitle>Models ({pagination.total})</CardTitle>
+          <CardDescription>Review migrated model configurations</CardDescription>
+        </CardHeader>
+        <CardContent>
+          {isLoading ? (
+            <div className="text-center py-8">
+              <div className="animate-pulse">Loading models...</div>
+            </div>
+          ) : (
+            <>
+              <Table>
+                <TableHeader>
+                  <TableRow>
+                    <TableHead>ID</TableHead>
+                    <TableHead>Name</TableHead>
+                    <TableHead>Provider</TableHead>
+                    <TableHead>Capabilities</TableHead>
+                    <TableHead>Context Window</TableHead>
+                    <TableHead>Modalities</TableHead>
+                    <TableHead>Actions</TableHead>
+                  </TableRow>
+                </TableHeader>
+                <TableBody>
+                  {models.map((model) => (
+                    <TableRow key={model.id}>
+                      <TableCell className="font-mono text-sm">{model.id}</TableCell>
+                      <TableCell>{model.name || model.id}</TableCell>
+                      <TableCell>
+                        <Badge variant="outline">{model.owned_by}</Badge>
+                      </TableCell>
+                      <TableCell>
+                        <div className="flex flex-wrap gap-1 max-w-xs">
+                          {model.capabilities.slice(0, 3).map((cap) => (
+                            <Badge key={cap} variant="secondary" className="text-xs">
+                              {cap.replace('_', ' ')}
+                            </Badge>
+                          ))}
+                          {model.capabilities.length > 3 && (
+                            <Badge variant="secondary" className="text-xs">
+                              +{model.capabilities.length - 3}
+                            </Badge>
+                          )}
+                        </div>
+                      </TableCell>
+                      <TableCell>{model.context_window.toLocaleString()}</TableCell>
+                      <TableCell>
+                        <div className="text-sm">
+                          <div>In: {model.input_modalities?.join(', ')}</div>
+                          <div>Out: {model.output_modalities?.join(', ')}</div>
+                        </div>
+                      </TableCell>
+                      <TableCell>
+                        <Dialog>
+                          <DialogTrigger asChild>
+                            <Button variant="outline" size="sm" onClick={() => handleEdit(model)}>
+                              Edit
+                            </Button>
+                          </DialogTrigger>
+                          <DialogContent className="max-w-4xl max-h-[80vh] overflow-auto">
+                            <DialogHeader>
+                              <DialogTitle>Edit Model Configuration</DialogTitle>
+                              <DialogDescription>
+                                Modify the JSON configuration for {model.name || model.id}
+                              </DialogDescription>
+                            </DialogHeader>
+                            <div className="space-y-4">
+                              <Textarea
+                                value={jsonContent}
+                                onChange={(e) => setJsonContent(e.target.value)}
+                                className="min-h-[400px] font-mono text-sm"
+                              />
+                              <div className="flex gap-2 justify-end">
+                                <Button variant="outline" onClick={() => setEditingModel(null)}>
+                                  Cancel
+                                </Button>
+                                <Button onClick={handleSave} disabled={isUpdating}>
+                                  {isUpdating ? 'Saving...' : 'Save Changes'}
+                                </Button>
+                              </div>
+                            </div>
+                          </DialogContent>
+                        </Dialog>
+                      </TableCell>
+                    </TableRow>
+                  ))}
+                </TableBody>
+              </Table>
+
+              <Separator className="my-4" />
+
+              <div className="flex items-center justify-between">
+                <div className="text-sm text-muted-foreground">
+                  Showing {(pagination.page - 1) * pagination.limit + 1} to{' '}
+                  {Math.min(pagination.page * pagination.limit, pagination.total)} of {pagination.total} models
+                </div>
+                <SimplePagination
+                  currentPage={pagination.page}
+                  totalPages={pagination.totalPages}
+                  onPageChange={setCurrentPage}
+                />
+              </div>
+            </>
+          )}
+        </CardContent>
+      </Card>
+    </div>
+  )
+}
@@ -0,0 +1,323 @@
+'use client'
+
+import { useState } from 'react'
+
+import { Navigation } from '@/components/navigation'
+import { Alert, AlertDescription } from '@/components/ui/alert'
+import { Badge } from '@/components/ui/badge'
+import { Button } from '@/components/ui/button'
+import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card'
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogHeader,
+  DialogTitle,
+  DialogTrigger
+} from '@/components/ui/dialog'
+import { Input } from '@/components/ui/input'
+import { Separator } from '@/components/ui/separator'
+import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from '@/components/ui/table'
+import { Textarea } from '@/components/ui/textarea'
+// Import SWR hooks and utilities
+import { getErrorMessage, useDebounce, useProviders, useUpdateProvider } from '@/lib/api-client'
+import type { Provider } from '@/lib/catalog-types'
+
+// Simple Pagination Component
+function SimplePagination({
+  currentPage,
+  totalPages,
+  onPageChange
+}: {
+  currentPage: number
+  totalPages: number
+  onPageChange: (page: number) => void
+}) {
+  const pages = Array.from({ length: Math.min(5, totalPages) }, (_, i) => {
+    if (totalPages <= 5) return i + 1
+    if (currentPage <= 3) return i + 1
+    if (currentPage >= totalPages - 2) return totalPages - 4 + i
+    return currentPage - 2 + i
+  })
+
+  return (
+    <div className="flex items-center gap-2">
+      <Button variant="outline" size="sm" onClick={() => onPageChange(currentPage - 1)} disabled={currentPage <= 1}>
+        Previous
+      </Button>
+      {pages.map((page) => (
+        <Button
+          key={page}
+          variant={currentPage === page ? 'default' : 'outline'}
+          size="sm"
+          onClick={() => onPageChange(page)}>
+          {page}
+        </Button>
+      ))}
+      <Button
+        variant="outline"
+        size="sm"
+        onClick={() => onPageChange(currentPage + 1)}
+        disabled={currentPage >= totalPages}>
+        Next
+      </Button>
+    </div>
+  )
+}
+
+export default function ProvidersPage() {
+  // Form state
+  const [search, setSearch] = useState('')
+  const [currentPage, setCurrentPage] = useState(1)
+  const [editingProvider, setEditingProvider] = useState<Provider | null>(null)
+  const [jsonContent, setJsonContent] = useState('')
+
+  // Debounce search to avoid excessive API calls
+  const debouncedSearch = useDebounce(search, 300)
+
+  // SWR hook for fetching providers
+  const {
+    data: providersData,
+    error,
+    isLoading,
+    mutate: refetchProviders
+  } = useProviders({
+    page: currentPage,
+    limit: 20,
+    search: debouncedSearch
+  })
+
+  // SWR mutation for updating providers
+  const { trigger: updateProvider, isMutating: isUpdating } = useUpdateProvider()
+
+  // Extract data from SWR response
+  const providers = providersData?.data || []
+  const pagination = providersData?.pagination || {
+    page: 1,
+    limit: 20,
+    total: 0,
+    totalPages: 0,
+    hasNext: false,
+    hasPrev: false
+  }
+
+  const handleEdit = (provider: Provider) => {
+    setEditingProvider(provider)
+    setJsonContent(JSON.stringify(provider, null, 2))
+  }
+
+  const handleSave = async () => {
+    if (!editingProvider) return
+
+    try {
+      // Validate JSON before sending
+      const updatedProvider = JSON.parse(jsonContent) as unknown
+
+      // Basic validation - the API will do thorough validation
+      if (!updatedProvider || typeof updatedProvider !== 'object') {
+        throw new Error('Invalid JSON format')
+      }
+
+      // Use SWR mutation for optimistic update
+      await updateProvider({
+        id: editingProvider.id,
+        data: updatedProvider as Partial<Provider>
+      })
+
+      // Close dialog and reset form
+      setEditingProvider(null)
+      setJsonContent('')
+    } catch (error) {
+      console.error('Error saving provider:', error)
+      // Error will be handled by SWR and displayed in UI
+    }
+  }
+
+  // Type-safe function to extract provider capabilities
+  const getCapabilities = (behaviors: Record<string, unknown>): string[] => {
+    return Object.entries(behaviors)
+      .filter(([_, value]) => value === true)
+      .map(([key, _]) => key.replace(/_/g, ' ').replace(/\b\w/g, (letter) => letter.toUpperCase()))
+  }
+
+  return (
+    <div className="container mx-auto p-6 space-y-6">
+      <div className="flex items-center justify-between">
+        <div>
+          <h1 className="text-3xl font-bold">Provider Management</h1>
+          <p className="text-muted-foreground">Review and validate provider configurations</p>
+        </div>
+        <Navigation />
+      </div>
+
+      <Card>
+        <CardHeader>
+          <CardTitle>Filters</CardTitle>
+          <CardDescription>Filter providers to review specific configurations</CardDescription>
+        </CardHeader>
+        <CardContent className="space-y-4">
+          <div className="flex gap-4">
+            <Input
+              placeholder="Search providers..."
+              value={search}
+              onChange={(e) => setSearch(e.target.value)}
+              className="max-w-sm"
+            />
+          </div>
+        </CardContent>
+      </Card>
+
+      {/* Error Display */}
+      {error && (
+        <Alert variant="destructive">
+          <AlertDescription>{getErrorMessage(error)}</AlertDescription>
+        </Alert>
+      )}
+
+      <Card>
+        <CardHeader>
+          <CardTitle>Providers ({pagination.total})</CardTitle>
+          <CardDescription>Review provider configurations and capabilities</CardDescription>
+        </CardHeader>
+        <CardContent>
+          {isLoading ? (
+            <div className="text-center py-8">
+              <div className="animate-pulse">Loading providers...</div>
+            </div>
+          ) : (
+            <>
+              <Table>
+                <TableHeader>
+                  <TableRow>
+                    <TableHead>ID</TableHead>
+                    <TableHead>Name</TableHead>
+                    <TableHead>Authentication</TableHead>
+                    <TableHead>Pricing Model</TableHead>
+                    <TableHead>Endpoints</TableHead>
+                    <TableHead>Capabilities</TableHead>
+                    <TableHead>Status</TableHead>
+                    <TableHead>Actions</TableHead>
+                  </TableRow>
+                </TableHeader>
+                <TableBody>
+                  {providers.map((provider) => (
+                    <TableRow key={provider.id}>
+                      <TableCell className="font-mono text-sm">{provider.id}</TableCell>
+                      <TableCell>
+                        <div>
+                          <div className="font-medium">{provider.name}</div>
+                          {provider.description && (
+                            <div className="text-sm text-muted-foreground">{provider.description}</div>
+                          )}
+                        </div>
+                      </TableCell>
+                      <TableCell>
+                        <Badge variant="outline">{provider.authentication}</Badge>
+                      </TableCell>
+                      <TableCell>
+                        <Badge variant="secondary">{provider.pricing_model}</Badge>
+                      </TableCell>
+                      <TableCell>
+                        <div className="flex flex-wrap gap-1 max-w-xs">
+                          {provider.supported_endpoints.slice(0, 2).map((endpoint) => (
+                            <Badge key={endpoint} variant="outline" className="text-xs">
+                              {endpoint}
+                            </Badge>
+                          ))}
+                          {provider.supported_endpoints.length > 2 && (
+                            <Badge variant="outline" className="text-xs">
+                              +{provider.supported_endpoints.length - 2}
+                            </Badge>
+                          )}
+                        </div>
+                      </TableCell>
+                      <TableCell>
+                        <div className="flex flex-wrap gap-1 max-w-xs">
+                          {getCapabilities(provider.behaviors)
+                            .slice(0, 2)
+                            .map((capability) => (
+                              <Badge key={capability} variant="secondary" className="text-xs">
+                                {capability}
+                              </Badge>
+                            ))}
+                          {getCapabilities(provider.behaviors).length > 2 && (
+                            <Badge variant="secondary" className="text-xs">
+                              +{getCapabilities(provider.behaviors).length - 2}
+                            </Badge>
+                          )}
+                        </div>
+                      </TableCell>
+                      <TableCell>
+                        <div className="space-y-1">
+                          {provider.deprecated && (
+                            <Badge variant="destructive" className="text-xs">
+                              Deprecated
+                            </Badge>
+                          )}
+                          {provider.maintenance_mode && (
+                            <Badge variant="outline" className="text-xs">
+                              Maintenance
+                            </Badge>
+                          )}
+                          {!provider.deprecated && !provider.maintenance_mode && (
+                            <Badge variant="default" className="text-xs">
+                              Active
+                            </Badge>
+                          )}
+                        </div>
+                      </TableCell>
+                      <TableCell>
+                        <Dialog>
+                          <DialogTrigger asChild>
+                            <Button variant="outline" size="sm" onClick={() => handleEdit(provider)}>
+                              Edit
+                            </Button>
+                          </DialogTrigger>
+                          <DialogContent className="max-w-4xl max-h-[80vh] overflow-auto">
+                            <DialogHeader>
+                              <DialogTitle>Edit Provider Configuration</DialogTitle>
+                              <DialogDescription>Modify the JSON configuration for {provider.name}</DialogDescription>
+                            </DialogHeader>
+                            <div className="space-y-4">
+                              <Textarea
+                                value={jsonContent}
+                                onChange={(e) => setJsonContent(e.target.value)}
+                                className="min-h-[400px] font-mono text-sm"
+                              />
+                              <div className="flex gap-2 justify-end">
+                                <Button variant="outline" onClick={() => setEditingProvider(null)}>
+                                  Cancel
+                                </Button>
+                                <Button onClick={handleSave} disabled={isUpdating}>
+                                  {isUpdating ? 'Saving...' : 'Save Changes'}
+                                </Button>
+                              </div>
+                            </div>
+                          </DialogContent>
+                        </Dialog>
+                      </TableCell>
+                    </TableRow>
+                  ))}
+                </TableBody>
+              </Table>
+
+              <Separator className="my-4" />
+
+              <div className="flex items-center justify-between">
+                <div className="text-sm text-muted-foreground">
+                  Showing {(pagination.page - 1) * pagination.limit + 1} to{' '}
+                  {Math.min(pagination.page * pagination.limit, pagination.total)} of {pagination.total} providers
+                </div>
+                <SimplePagination
+                  currentPage={pagination.page}
+                  totalPages={pagination.totalPages}
+                  onPageChange={setCurrentPage}
+                />
+              </div>
+            </>
+          )}
+        </CardContent>
+      </Card>
+    </div>
+  )
+}
@@ -0,0 +1,20 @@
+{
+  "$schema": "https://ui.shadcn.com/schema.json",
+  "style": "new-york",
+  "rsc": true,
+  "tsx": true,
+  "tailwind": {
+    "config": "tailwind.config.ts",
+    "css": "app/globals.css",
+    "baseColor": "slate",
+    "cssVariables": true,
+    "prefix": ""
+  },
+  "aliases": {
+    "components": "@/components",
+    "utils": "@/lib/utils",
+    "ui": "@/components/ui",
+    "lib": "@/lib",
+    "hooks": "@/hooks"
+  }
+}
@@ -0,0 +1,32 @@
+'use client'
+
+import Link from 'next/link'
+import { usePathname } from 'next/navigation'
+
+import { cn } from '@/lib/utils'
+
+const navigation = [
+  { name: 'Models', href: '/' },
+  { name: 'Providers', href: '/providers' },
+  { name: 'Overrides', href: '/overrides' }
+]
+
+export function Navigation() {
+  const pathname = usePathname()
+
+  return (
+    <nav className="flex space-x-8">
+      {navigation.map((item) => (
+        <Link
+          key={item.name}
+          href={item.href}
+          className={cn(
+            'text-sm font-medium transition-colors hover:text-primary',
+            pathname === item.href ? 'text-foreground' : 'text-muted-foreground'
+          )}>
+          {item.name}
+        </Link>
+      ))}
+    </nav>
+  )
+}
@@ -0,0 +1,59 @@
+import * as React from "react"
+import { cva, type VariantProps } from "class-variance-authority"
+
+import { cn } from "@/lib/utils"
+
+const alertVariants = cva(
+  "relative w-full rounded-lg border px-4 py-3 text-sm [&>svg+div]:translate-y-[-3px] [&>svg]:absolute [&>svg]:left-4 [&>svg]:top-4 [&>svg]:text-foreground [&>svg~*]:pl-7",
+  {
+    variants: {
+      variant: {
+        default: "bg-background text-foreground",
+        destructive:
+          "border-destructive/50 text-destructive dark:border-destructive [&>svg]:text-destructive",
+      },
+    },
+    defaultVariants: {
+      variant: "default",
+    },
+  }
+)
+
+const Alert = React.forwardRef<
+  HTMLDivElement,
+  React.HTMLAttributes<HTMLDivElement> & VariantProps<typeof alertVariants>
+>(({ className, variant, ...props }, ref) => (
+  <div
+    ref={ref}
+    role="alert"
+    className={cn(alertVariants({ variant }), className)}
+    {...props}
+  />
+))
+Alert.displayName = "Alert"
+
+const AlertTitle = React.forwardRef<
+  HTMLParagraphElement,
+  React.HTMLAttributes<HTMLHeadingElement>
+>(({ className, ...props }, ref) => (
+  <h5
+    ref={ref}
+    className={cn("mb-1 font-medium leading-none tracking-tight", className)}
+    {...props}
+  />
+))
+AlertTitle.displayName = "AlertTitle"
+
+const AlertDescription = React.forwardRef<
+  HTMLParagraphElement,
+  React.HTMLAttributes<HTMLParagraphElement>
+>(({ className, ...props }, ref) => (
+  <div
+    ref={ref}
+    className={cn("text-sm [&_p]:leading-relaxed", className)}
+    {...props}
+  />
+))
+AlertDescription.displayName = "AlertDescription"
+
+export { Alert, AlertTitle, AlertDescription }
@@ -0,0 +1,29 @@
+import { cva, type VariantProps } from 'class-variance-authority'
+import * as React from 'react'
+
+import { cn } from '@/lib/utils'
+
+const badgeVariants = cva(
+  'inline-flex items-center rounded-md border px-2.5 py-0.5 text-xs font-semibold transition-colors focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2',
+  {
+    variants: {
+      variant: {
+        default: 'border-transparent bg-primary text-primary-foreground shadow hover:bg-primary/80',
+        secondary: 'border-transparent bg-secondary text-secondary-foreground hover:bg-secondary/80',
+        destructive: 'border-transparent bg-destructive text-destructive-foreground shadow hover:bg-destructive/80',
+        outline: 'text-foreground'
+      }
+    },
+    defaultVariants: {
+      variant: 'default'
+    }
+  }
+)
+
+export interface BadgeProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof badgeVariants> {}
+
+function Badge({ className, variant, ...props }: BadgeProps) {
+  return <div className={cn(badgeVariants({ variant }), className)} {...props} />
+}
+
+export { Badge, badgeVariants }
@@ -0,0 +1,52 @@
+import { Slot } from '@radix-ui/react-slot'
+import { cva, type VariantProps } from 'class-variance-authority'
+import * as React from 'react'
+
+import { cn } from '@/lib/utils'
+
+const buttonVariants = cva(
+  'inline-flex items-center justify-center gap-2 whitespace-nowrap rounded-md text-sm font-medium transition-colors focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring disabled:pointer-events-none disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:size-4 [&_svg]:shrink-0',
+  {
+    variants: {
+      variant: {
+        default: 'bg-primary text-primary-foreground shadow hover:bg-primary/90',
+        destructive: 'bg-destructive text-destructive-foreground shadow-sm hover:bg-destructive/90',
+        outline: 'border border-input bg-background shadow-sm hover:bg-accent hover:text-accent-foreground',
+        secondary: 'bg-secondary text-secondary-foreground shadow-sm hover:bg-secondary/80',
+        ghost: 'hover:bg-accent hover:text-accent-foreground',
+        link: 'text-primary underline-offset-4 hover:underline'
+      },
+      size: {
+        default: 'h-9 px-4 py-2',
+        sm: 'h-8 rounded-md px-3 text-xs',
+        lg: 'h-10 rounded-md px-8',
+        icon: 'h-9 w-9'
+      }
+    },
+    defaultVariants: {
+      variant: 'default',
+      size: 'default'
+    }
+  }
+)
+
+export interface ButtonProps
+  extends React.ButtonHTMLAttributes<HTMLButtonElement>,
+    VariantProps<typeof buttonVariants> {
+  asChild?: boolean
+}
+
+const Button = ({
+  ref,
+  className,
+  variant,
+  size,
+  asChild = false,
+  ...props
+}: ButtonProps & { ref?: React.RefObject<HTMLButtonElement | null> }) => {
+  const Comp = asChild ? Slot : 'button'
+  return <Comp className={cn(buttonVariants({ variant, size, className }))} ref={ref} {...props} />
+}
+Button.displayName = 'Button'
+
+export { Button, buttonVariants }
@@ -0,0 +1,59 @@
+import * as React from 'react'
+
+import { cn } from '@/lib/utils'
+
+const Card = ({
+  ref,
+  className,
+  ...props
+}: React.HTMLAttributes<HTMLDivElement> & { ref?: React.RefObject<HTMLDivElement | null> }) => (
+  <div ref={ref} className={cn('rounded-xl border bg-card text-card-foreground shadow', className)} {...props} />
+)
+Card.displayName = 'Card'
+
+const CardHeader = ({
+  ref,
+  className,
+  ...props
+}: React.HTMLAttributes<HTMLDivElement> & { ref?: React.RefObject<HTMLDivElement | null> }) => (
+  <div ref={ref} className={cn('flex flex-col space-y-1.5 p-6', className)} {...props} />
+)
+CardHeader.displayName = 'CardHeader'
+
+const CardTitle = ({
+  ref,
+  className,
+  ...props
+}: React.HTMLAttributes<HTMLDivElement> & { ref?: React.RefObject<HTMLDivElement | null> }) => (
+  <div ref={ref} className={cn('font-semibold leading-none tracking-tight', className)} {...props} />
+)
+CardTitle.displayName = 'CardTitle'
+
+const CardDescription = ({
+  ref,
+  className,
+  ...props
+}: React.HTMLAttributes<HTMLDivElement> & { ref?: React.RefObject<HTMLDivElement | null> }) => (
+  <div ref={ref} className={cn('text-sm text-muted-foreground', className)} {...props} />
+)
+CardDescription.displayName = 'CardDescription'
+
+const CardContent = ({
+  ref,
+  className,
+  ...props
+}: React.HTMLAttributes<HTMLDivElement> & { ref?: React.RefObject<HTMLDivElement | null> }) => (
+  <div ref={ref} className={cn('p-6 pt-0', className)} {...props} />
+)
+CardContent.displayName = 'CardContent'
+
+const CardFooter = ({
+  ref,
+  className,
+  ...props
+}: React.HTMLAttributes<HTMLDivElement> & { ref?: React.RefObject<HTMLDivElement | null> }) => (
+  <div ref={ref} className={cn('flex items-center p-6 pt-0', className)} {...props} />
+)
+CardFooter.displayName = 'CardFooter'
+
+export { Card, CardContent, CardDescription, CardFooter, CardHeader, CardTitle }
@@ -0,0 +1,107 @@
+'use client'
+
+import * as DialogPrimitive from '@radix-ui/react-dialog'
+import { Cross2Icon } from '@radix-ui/react-icons'
+import * as React from 'react'
+
+import { cn } from '@/lib/utils'
+
+const Dialog = DialogPrimitive.Root
+
+const DialogTrigger = DialogPrimitive.Trigger
+
+const DialogPortal = DialogPrimitive.Portal
+
+const DialogClose = DialogPrimitive.Close
+
+const DialogOverlay = ({
+  ref,
+  className,
+  ...props
+}: React.ComponentPropsWithoutRef<typeof DialogPrimitive.Overlay> & {
+  ref?: React.RefObject<React.ElementRef<typeof DialogPrimitive.Overlay> | null>
+}) => (
+  <DialogPrimitive.Overlay
+    ref={ref}
+    className={cn(
+      'fixed inset-0 z-50 bg-black/80  data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0',
+      className
+    )}
+    {...props}
+  />
+)
+DialogOverlay.displayName = DialogPrimitive.Overlay.displayName
+
+const DialogContent = ({
+  ref,
+  className,
+  children,
+  ...props
+}: React.ComponentPropsWithoutRef<typeof DialogPrimitive.Content> & {
+  ref?: React.RefObject<React.ElementRef<typeof DialogPrimitive.Content> | null>
+}) => (
+  <DialogPortal>
+    <DialogOverlay />
+    <DialogPrimitive.Content
+      ref={ref}
+      className={cn(
+        'fixed left-[50%] top-[50%] z-50 grid w-full max-w-lg translate-x-[-50%] translate-y-[-50%] gap-4 border bg-background p-6 shadow-lg duration-200 data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[state=closed]:slide-out-to-left-1/2 data-[state=closed]:slide-out-to-top-[48%] data-[state=open]:slide-in-from-left-1/2 data-[state=open]:slide-in-from-top-[48%] sm:rounded-lg',
+        className
+      )}
+      {...props}>
+      {children}
+      <DialogPrimitive.Close className="absolute right-4 top-4 rounded-sm opacity-70 ring-offset-background transition-opacity hover:opacity-100 focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2 disabled:pointer-events-none data-[state=open]:bg-accent data-[state=open]:text-muted-foreground">
+        <Cross2Icon className="h-4 w-4" />
+        <span className="sr-only">Close</span>
+      </DialogPrimitive.Close>
+    </DialogPrimitive.Content>
+  </DialogPortal>
+)
+DialogContent.displayName = DialogPrimitive.Content.displayName
+
+const DialogHeader = ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>) => (
+  <div className={cn('flex flex-col space-y-1.5 text-center sm:text-left', className)} {...props} />
+)
+DialogHeader.displayName = 'DialogHeader'
+
+const DialogFooter = ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>) => (
+  <div className={cn('flex flex-col-reverse sm:flex-row sm:justify-end sm:space-x-2', className)} {...props} />
+)
+DialogFooter.displayName = 'DialogFooter'
+
+const DialogTitle = ({
+  ref,
+  className,
+  ...props
+}: React.ComponentPropsWithoutRef<typeof DialogPrimitive.Title> & {
+  ref?: React.RefObject<React.ElementRef<typeof DialogPrimitive.Title> | null>
+}) => (
+  <DialogPrimitive.Title
+    ref={ref}
+    className={cn('text-lg font-semibold leading-none tracking-tight', className)}
+    {...props}
+  />
+)
+DialogTitle.displayName = DialogPrimitive.Title.displayName
+
+const DialogDescription = ({
+  ref,
+  className,
+  ...props
+}: React.ComponentPropsWithoutRef<typeof DialogPrimitive.Description> & {
+  ref?: React.RefObject<React.ElementRef<typeof DialogPrimitive.Description> | null>
+}) => <DialogPrimitive.Description ref={ref} className={cn('text-sm text-muted-foreground', className)} {...props} />
+DialogDescription.displayName = DialogPrimitive.Description.displayName
+
+export {
+  Dialog,
+  DialogClose,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogOverlay,
+  DialogPortal,
+  DialogTitle,
+  DialogTrigger
+}
@@ -0,0 +1,25 @@
+import * as React from 'react'
+
+import { cn } from '@/lib/utils'
+
+const Input = ({
+  ref,
+  className,
+  type,
+  ...props
+}: React.ComponentProps<'input'> & { ref?: React.RefObject<HTMLInputElement | null> }) => {
+  return (
+    <input
+      type={type}
+      className={cn(
+        'flex h-9 w-full rounded-md border border-input bg-transparent px-3 py-1 text-base shadow-sm transition-colors file:border-0 file:bg-transparent file:text-sm file:font-medium file:text-foreground placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring disabled:cursor-not-allowed disabled:opacity-50 md:text-sm',
+        className
+      )}
+      ref={ref}
+      {...props}
+    />
+  )
+}
+Input.displayName = 'Input'
+
+export { Input }
@@ -0,0 +1,88 @@
+import { ChevronLeftIcon, ChevronRightIcon, DotsHorizontalIcon } from '@radix-ui/react-icons'
+import * as React from 'react'
+
+import type { ButtonProps } from '@/components/ui/button'
+import { buttonVariants } from '@/components/ui/button'
+import { cn } from '@/lib/utils'
+
+const Pagination = ({ className, ...props }: React.ComponentProps<'nav'>) => (
+  <nav
+    role="navigation"
+    aria-label="pagination"
+    className={cn('mx-auto flex w-full justify-center', className)}
+    {...props}
+  />
+)
+Pagination.displayName = 'Pagination'
+
+const PaginationContent = ({
+  ref,
+  className,
+  ...props
+}: React.ComponentProps<'ul'> & { ref?: React.RefObject<HTMLUListElement | null> }) => (
+  <ul ref={ref} className={cn('flex flex-row items-center gap-1', className)} {...props} />
+)
+PaginationContent.displayName = 'PaginationContent'
+
+const PaginationItem = ({
+  ref,
+  className,
+  ...props
+}: React.ComponentProps<'li'> & { ref?: React.RefObject<HTMLLIElement | null> }) => (
+  <li ref={ref} className={cn('', className)} {...props} />
+)
+PaginationItem.displayName = 'PaginationItem'
+
+type PaginationLinkProps = {
+  isActive?: boolean
+} & Pick<ButtonProps, 'size'> &
+  React.ComponentProps<'a'>
+
+const PaginationLink = ({ className, isActive, size = 'icon', ...props }: PaginationLinkProps) => (
+  <a
+    aria-current={isActive ? 'page' : undefined}
+    className={cn(
+      buttonVariants({
+        variant: isActive ? 'outline' : 'ghost',
+        size
+      }),
+      className
+    )}
+    {...props}
+  />
+)
+PaginationLink.displayName = 'PaginationLink'
+
+const PaginationPrevious = ({ className, ...props }: React.ComponentProps<typeof PaginationLink>) => (
+  <PaginationLink aria-label="Go to previous page" size="default" className={cn('gap-1 pl-2.5', className)} {...props}>
+    <ChevronLeftIcon className="h-4 w-4" />
+    <span>Previous</span>
+  </PaginationLink>
+)
+PaginationPrevious.displayName = 'PaginationPrevious'
+
+const PaginationNext = ({ className, ...props }: React.ComponentProps<typeof PaginationLink>) => (
+  <PaginationLink aria-label="Go to next page" size="default" className={cn('gap-1 pr-2.5', className)} {...props}>
+    <span>Next</span>
+    <ChevronRightIcon className="h-4 w-4" />
+  </PaginationLink>
+)
+PaginationNext.displayName = 'PaginationNext'
+
+const PaginationEllipsis = ({ className, ...props }: React.ComponentProps<'span'>) => (
+  <span aria-hidden className={cn('flex h-9 w-9 items-center justify-center', className)} {...props}>
+    <DotsHorizontalIcon className="h-4 w-4" />
+    <span className="sr-only">More pages</span>
+  </span>
+)
+PaginationEllipsis.displayName = 'PaginationEllipsis'
+
+export {
+  Pagination,
+  PaginationContent,
+  PaginationEllipsis,
+  PaginationItem,
+  PaginationLink,
+  PaginationNext,
+  PaginationPrevious
+}
@@ -0,0 +1,27 @@
+'use client'
+
+import * as SeparatorPrimitive from '@radix-ui/react-separator'
+import * as React from 'react'
+
+import { cn } from '@/lib/utils'
+
+const Separator = ({
+  ref,
+  className,
+  orientation = 'horizontal',
+  decorative = true,
+  ...props
+}: React.ComponentPropsWithoutRef<typeof SeparatorPrimitive.Root> & {
+  ref?: React.RefObject<React.ElementRef<typeof SeparatorPrimitive.Root> | null>
+}) => (
+  <SeparatorPrimitive.Root
+    ref={ref}
+    decorative={decorative}
+    orientation={orientation}
+    className={cn('shrink-0 bg-border', orientation === 'horizontal' ? 'h-[1px] w-full' : 'h-full w-[1px]', className)}
+    {...props}
+  />
+)
+Separator.displayName = SeparatorPrimitive.Root.displayName
+
+export { Separator }
@@ -0,0 +1,94 @@
+import * as React from 'react'
+
+import { cn } from '@/lib/utils'
+
+const Table = ({
+  ref,
+  className,
+  ...props
+}: React.HTMLAttributes<HTMLTableElement> & { ref?: React.RefObject<HTMLTableElement | null> }) => (
+  <div className="relative w-full overflow-auto">
+    <table ref={ref} className={cn('w-full caption-bottom text-sm', className)} {...props} />
+  </div>
+)
+Table.displayName = 'Table'
+
+const TableHeader = ({
+  ref,
+  className,
+  ...props
+}: React.HTMLAttributes<HTMLTableSectionElement> & { ref?: React.RefObject<HTMLTableSectionElement | null> }) => (
+  <thead ref={ref} className={cn('[&_tr]:border-b', className)} {...props} />
+)
+TableHeader.displayName = 'TableHeader'
+
+const TableBody = ({
+  ref,
+  className,
+  ...props
+}: React.HTMLAttributes<HTMLTableSectionElement> & { ref?: React.RefObject<HTMLTableSectionElement | null> }) => (
+  <tbody ref={ref} className={cn('[&_tr:last-child]:border-0', className)} {...props} />
+)
+TableBody.displayName = 'TableBody'
+
+const TableFooter = ({
+  ref,
+  className,
+  ...props
+}: React.HTMLAttributes<HTMLTableSectionElement> & { ref?: React.RefObject<HTMLTableSectionElement | null> }) => (
+  <tfoot ref={ref} className={cn('border-t bg-muted/50 font-medium [&>tr]:last:border-b-0', className)} {...props} />
+)
+TableFooter.displayName = 'TableFooter'
+
+const TableRow = ({
+  ref,
+  className,
+  ...props
+}: React.HTMLAttributes<HTMLTableRowElement> & { ref?: React.RefObject<HTMLTableRowElement | null> }) => (
+  <tr
+    ref={ref}
+    className={cn('border-b transition-colors hover:bg-muted/50 data-[state=selected]:bg-muted', className)}
+    {...props}
+  />
+)
+TableRow.displayName = 'TableRow'
+
+const TableHead = ({
+  ref,
+  className,
+  ...props
+}: React.ThHTMLAttributes<HTMLTableCellElement> & { ref?: React.RefObject<HTMLTableCellElement | null> }) => (
+  <th
+    ref={ref}
+    className={cn(
+      'h-10 px-2 text-left align-middle font-medium text-muted-foreground [&:has([role=checkbox])]:pr-0 [&>[role=checkbox]]:translate-y-[2px]',
+      className
+    )}
+    {...props}
+  />
+)
+TableHead.displayName = 'TableHead'
+
+const TableCell = ({
+  ref,
+  className,
+  ...props
+}: React.TdHTMLAttributes<HTMLTableCellElement> & { ref?: React.RefObject<HTMLTableCellElement | null> }) => (
+  <td
+    ref={ref}
+    className={cn('p-2 align-middle [&:has([role=checkbox])]:pr-0 [&>[role=checkbox]]:translate-y-[2px]', className)}
+    {...props}
+  />
+)
+TableCell.displayName = 'TableCell'
+
+const TableCaption = ({
+  ref,
+  className,
+  ...props
+}: React.HTMLAttributes<HTMLTableCaptionElement> & { ref?: React.RefObject<HTMLTableCaptionElement | null> }) => (
+  <caption ref={ref} className={cn('mt-4 text-sm text-muted-foreground', className)} {...props} />
+)
+TableCaption.displayName = 'TableCaption'
+
+export { Table, TableBody, TableCaption, TableCell, TableFooter, TableHead, TableHeader, TableRow }
@@ -0,0 +1,23 @@
+import * as React from 'react'
+
+import { cn } from '@/lib/utils'
+
+const Textarea = ({
+  ref,
+  className,
+  ...props
+}: React.ComponentProps<'textarea'> & { ref?: React.RefObject<HTMLTextAreaElement | null> }) => {
+  return (
+    <textarea
+      className={cn(
+        'flex min-h-[60px] w-full rounded-md border border-input bg-transparent px-3 py-2 text-base shadow-sm placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring disabled:cursor-not-allowed disabled:opacity-50 md:text-sm',
+        className
+      )}
+      ref={ref}
+      {...props}
+    />
+  )
+}
+Textarea.displayName = 'Textarea'
+
+export { Textarea }
@@ -0,0 +1,18 @@
+import { defineConfig, globalIgnores } from 'eslint/config'
+import nextVitals from 'eslint-config-next/core-web-vitals'
+import nextTs from 'eslint-config-next/typescript'
+
+const eslintConfig = defineConfig([
+  ...nextVitals,
+  ...nextTs,
+  // Override default ignores of eslint-config-next.
+  globalIgnores([
+    // Default ignores of eslint-config-next:
+    '.next/**',
+    'out/**',
+    'build/**',
+    'next-env.d.ts'
+  ])
+])
+
+export default eslintConfig
@@ -0,0 +1,299 @@
+/**
+ * API Client with SWR integration for catalog management
+ *
+ * This file provides:
+ * - Custom SWR fetchers with Zod validation
+ * - Mutations for CRUD operations with optimistic updates
+ * - Error handling utilities
+ * - Type-safe API interactions
+ */
+
+import { useEffect, useState } from 'react'
+import type { SWRConfiguration, SWRResponse } from 'swr'
+import useSWR from 'swr'
+import useSWRMutation from 'swr/mutation'
+import type { z } from 'zod'
+
+// Import catalog types and schemas
+import type { Model, PaginatedResponse, Provider } from './catalog-types'
+import {
+  ModelSchema,
+  ModelUpdateResponseSchema,
+  PaginatedResponseSchema,
+  ProviderSchema,
+  ProviderUpdateResponseSchema
+} from './catalog-types'
+
+// API base configuration
+const API_BASE = '/api/catalog'
+
+// Extended error interface for better error handling
+export interface ExtendedApiError {
+  error: string
+  status?: number
+  info?: unknown
+}
+
+// Generic API fetcher with Zod validation
+async function apiFetcher<T extends z.ZodType>(url: string, schema: T, options?: RequestInit): Promise<z.infer<T>> {
+  const response = await fetch(url, {
+    headers: {
+      'Content-Type': 'application/json',
+      ...options?.headers
+    },
+    ...options
+  })
+
+  if (!response.ok) {
+    const errorData = response.headers.get('content-type')?.includes('application/json')
+      ? await response.json()
+      : { error: response.statusText }
+
+    const error: ExtendedApiError = {
+      error: errorData.error || `HTTP ${response.status}`,
+      status: response.status,
+      info: errorData
+    }
+
+    throw error
+  }
+
+  const data = await response.json()
+  return schema.parse(data)
+}
+
+// API Client class for organized endpoint management
+export class ApiClient {
+  // Models endpoints
+  static models = {
+    // Get models with pagination and filtering
+    list: (
+      params: { page?: number; limit?: number; search?: string; capabilities?: string[]; providers?: string[] } = {}
+    ) => {
+      const searchParams = new URLSearchParams()
+
+      if (params.page) searchParams.set('page', params.page.toString())
+      if (params.limit) searchParams.set('limit', params.limit.toString())
+      if (params.search) searchParams.set('search', params.search)
+      if (params.capabilities?.length) searchParams.set('capabilities', params.capabilities.join(','))
+      if (params.providers?.length) searchParams.set('providers', params.providers.join(','))
+
+      return `${API_BASE}/models?${searchParams.toString()}`
+    },
+
+    // Update a model
+    update: (id: string, data: Partial<Model>) => ({
+      url: `${API_BASE}/models/${id}`,
+      method: 'PUT',
+      body: data
+    }),
+
+    // Delete a model (if implemented)
+    delete: (id: string) => ({
+      url: `${API_BASE}/models/${id}`,
+      method: 'DELETE'
+    })
+  }
+
+  // Providers endpoints
+  static providers = {
+    // Get providers with pagination and filtering
+    list: (params: { page?: number; limit?: number; search?: string } = {}) => {
+      const searchParams = new URLSearchParams()
+
+      if (params.page) searchParams.set('page', params.page.toString())
+      if (params.limit) searchParams.set('limit', params.limit.toString())
+      if (params.search) searchParams.set('search', params.search)
+
+      return `${API_BASE}/providers?${searchParams.toString()}`
+    },
+
+    // Update a provider
+    update: (id: string, data: Partial<Provider>) => ({
+      url: `${API_BASE}/providers/${id}`,
+      method: 'PUT',
+      body: data
+    }),
+
+    // Delete a provider (if implemented)
+    delete: (id: string) => ({
+      url: `${API_BASE}/providers/${id}`,
+      method: 'DELETE'
+    })
+  }
+}
+
+// SWR Hooks for Models
+export function useModels(
+  params: {
+    page?: number
+    limit?: number
+    search?: string
+    capabilities?: string[]
+    providers?: string[]
+  } = {},
+  config?: SWRConfiguration<PaginatedResponse<Model>, ExtendedApiError>
+): SWRResponse<PaginatedResponse<Model>, ExtendedApiError> {
+  const url = ApiClient.models.list(params)
+
+  return useSWR<PaginatedResponse<Model>, ExtendedApiError>(
+    url,
+    (url) => apiFetcher(url, PaginatedResponseSchema(ModelSchema)),
+    {
+      revalidateOnFocus: true,
+      revalidateOnReconnect: true,
+      dedupingInterval: 5000,
+      errorRetryCount: 3,
+      errorRetryInterval: 1000,
+      ...config
+    }
+  )
+}
+
+// SWR Hooks for Providers
+export function useProviders(
+  params: {
+    page?: number
+    limit?: number
+    search?: string
+  } = {},
+  config?: SWRConfiguration<PaginatedResponse<Provider>, ExtendedApiError>
+): SWRResponse<PaginatedResponse<Provider>, ExtendedApiError> {
+  const url = ApiClient.providers.list(params)
+
+  return useSWR<PaginatedResponse<Provider>, ExtendedApiError>(
+    url,
+    (url) => apiFetcher(url, PaginatedResponseSchema(ProviderSchema)),
+    {
+      revalidateOnFocus: true,
+      revalidateOnReconnect: true,
+      dedupingInterval: 5000,
+      errorRetryCount: 3,
+      errorRetryInterval: 1000,
+      ...config
+    }
+  )
+}
+
+// Mutation for updating models
+export function useUpdateModel() {
+  return useSWRMutation(
+    '/api/catalog/models',
+    async (url: string, { arg }: { arg: { id: string; data: Partial<Model> } }) => {
+      const response = await fetch(`${url}/${arg.id}`, {
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(arg.data)
+      })
+
+      if (!response.ok) {
+        const errorData = await response.json()
+        const error: ExtendedApiError = {
+          error: errorData.error || 'Failed to update model',
+          status: response.status,
+          info: errorData
+        }
+        throw error
+      }
+
+      const data = await response.json()
+      return ModelUpdateResponseSchema.parse(data)
+    }
+  )
+}
+
+// Mutation for updating providers
+export function useUpdateProvider() {
+  return useSWRMutation(
+    '/api/catalog/providers',
+    async (url: string, { arg }: { arg: { id: string; data: Partial<Provider> } }) => {
+      const response = await fetch(`${url}/${arg.id}`, {
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(arg.data)
+      })
+
+      if (!response.ok) {
+        const errorData = await response.json()
+        const error: ExtendedApiError = {
+          error: errorData.error || 'Failed to update provider',
+          status: response.status,
+          info: errorData
+        }
+        throw error
+      }
+
+      const data = await response.json()
+      return ProviderUpdateResponseSchema.parse(data)
+    }
+  )
+}
+
+// Utility function for global error handling
+export function handleApiError(error: unknown): ExtendedApiError {
+  if (error && typeof error === 'object' && 'error' in error) {
+    return error as ExtendedApiError
+  }
+
+  return {
+    error: error instanceof Error ? error.message : 'Unknown error occurred'
+  }
+}
+
+// Utility function to get user-friendly error messages
+export function getErrorMessage(error: unknown): string {
+  const apiError = handleApiError(error)
+
+  // Map common error codes to user-friendly messages
+  switch (apiError.status) {
+    case 400:
+      return 'Invalid request. Please check your input and try again.'
+    case 401:
+      return 'Authentication required. Please log in and try again.'
+    case 403:
+      return 'You do not have permission to perform this action.'
+    case 404:
+      return 'The requested resource was not found.'
+    case 429:
+      return 'Too many requests. Please wait a moment and try again.'
+    case 500:
+      return 'Server error. Please try again later.'
+    default:
+      return apiError.error || 'An unexpected error occurred.'
+  }
+}
+
+// Custom hook for debounced search
+export function useDebounce<T>(value: T, delay: number): T {
+  const [debouncedValue, setDebouncedValue] = useState(value)
+
+  useEffect(() => {
+    const handler = setTimeout(() => {
+      setDebouncedValue(value)
+    }, delay)
+
+    return () => {
+      clearTimeout(handler)
+    }
+  }, [value, delay])
+
+  return debouncedValue
+}
+
+// Export all types for use in components
+export type { SWRResponse }
+
+// Re-export SWR types for convenience
+export type { SWRConfiguration } from 'swr'
+
+// Legacy API Error class for backward compatibility
+export class ApiError extends Error {
+  constructor(
+    message: string,
+    public status: number,
+    public details?: unknown
+  ) {
+    super(message)
+    this.name = 'ApiError'
+  }
+}
@@ -0,0 +1,86 @@
+/**
+ * Type definitions for catalog management system
+ * Now using Zod inferred types for complete type safety
+ *
+ * This file serves as the main export point for all types and schemas.
+ * Types are now inferred from Zod schemas to ensure compile-time and runtime consistency.
+ */
+
+// Import all types from Zod validation schemas
+export type {
+  // Response and error types
+  ApiError,
+  AuthenticationType,
+  // Utility enum types
+  CapabilityType,
+  EndpointType,
+  ModalityType,
+  // Core data types (inferred from Zod schemas)
+  Model,
+  ModelListRequest,
+  ModelsDataFile,
+  ModelUpdateResponse,
+  OverridesDataFile,
+  PaginatedResponse,
+  // Pagination and response types
+  PaginationInfo,
+  Provider,
+  ProviderListRequest,
+  ProviderModelOverride,
+  ProvidersDataFile,
+  ProviderUpdateResponse,
+  SuccessResponse
+} from './validation'
+
+// Import Zod schemas for direct use if needed
+export {
+  ApiErrorSchema,
+  AuthenticationTypeSchema,
+  // Utility schemas
+  CapabilityTypeSchema,
+  EndpointTypeSchema,
+  ModalityTypeSchema,
+  ModelListRequestSchema,
+  // Core schemas
+  ModelSchema,
+  ModelsDataFileSchema,
+  ModelUpdateResponseSchema,
+  OverridesDataFileSchema,
+  PaginatedResponseSchema,
+  ProviderModelOverrideSchema,
+  // Response schemas
+  PaginationInfoSchema,
+  ProviderListRequestSchema,
+  ProviderSchema,
+  ProvidersDataFileSchema,
+  ProviderUpdateResponseSchema,
+  QueryParamsSchema,
+  SuccessResponseSchema
+} from './validation'
+
+// Import validation utilities for easy access
+export {
+  createErrorResponse,
+  formatZodError,
+  // Type guard functions (powered by Zod)
+  isModel,
+  isModelsDataFile,
+  isProvider,
+  isProvidersDataFile,
+  safeParseWithValidation,
+  safeTypeCast,
+  validatePaginatedResponse,
+  validateQueryParams,
+  validateString,
+  // Validation functions
+  ValidationError
+} from './validation'
+
+// Legacy convenience types (for backward compatibility)
+// These are now re-exports of the Zod-inferred types above
+export type {
+  // Re-export core types with legacy names for compatibility
+  Model as CatalogModel,
+  Provider as CatalogProvider,
+  PaginatedResponse as CatalogResponse
+} from './validation'
@@ -0,0 +1,6 @@
+import { type ClassValue, clsx } from 'clsx'
+import { twMerge } from 'tailwind-merge'
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs))
+}
@@ -0,0 +1,431 @@
+/**
+ * Zod v4 schemas for comprehensive runtime type validation
+ * Replaces manual validation with strict type-safe schemas
+ */
+
+//TODO: 从catalog导入
+
+import * as z from 'zod'
+
+// Base parameter schemas
+const ParameterRangeSchema = z.object({
+  supported: z.literal(true),
+  min: z.number().positive(),
+  max: z.number().positive(),
+  default: z.number().positive()
+})
+
+const ParameterBooleanSchema = z.object({
+  supported: z.boolean()
+})
+
+const ParameterUnsupportedSchema = z.object({
+  supported: z.literal(false)
+})
+
+const ParameterValueSchema = z.union([ParameterRangeSchema, ParameterBooleanSchema, ParameterUnsupportedSchema])
+
+// Model parameters schema
+const ModelParametersSchema = z
+  .object({
+    temperature: ParameterValueSchema.optional(),
+    max_tokens: z.union([
+      z.boolean(), // Simple boolean support indicator
+      z.object({
+        supported: z.literal(true),
+        default: z.number().positive().optional()
+      })
+    ]).optional(),
+    system_message: z.boolean().optional(), // Simple boolean support indicator
+    top_p: z.union([ParameterValueSchema, ParameterUnsupportedSchema]).optional()
+  })
+  .loose() // Allow additional parameter types
+
+// Pricing schema
+const PricingInfoSchema = z.object({
+  input: z.object({
+    per_million_tokens: z.number().nonnegative(),
+    currency: z.string().length(3) // ISO 4217 currency codes
+  }),
+  output: z.object({
+    per_million_tokens: z.number().nonnegative(),
+    currency: z.string().length(3)
+  })
+})
+
+// Model metadata schema
+const ModelMetadataSchema = z
+  .object({
+    source: z.string().optional(),
+    original_provider: z.string().optional(),
+    supports_caching: z.boolean().optional()
+  })
+  .loose() // Allow additional metadata
+
+// Complete Model schema
+export const ModelSchema = z.object({
+  id: z.string().min(1),
+  name: z.string().optional(),
+  owned_by: z.string().optional(),
+  capabilities: z.array(z.string()),
+  input_modalities: z.array(z.string()),
+  output_modalities: z.array(z.string()),
+  context_window: z.number().positive(),
+  max_output_tokens: z.number().positive(),
+  max_input_tokens: z.number().positive().optional(),
+  pricing: PricingInfoSchema.optional(),
+  parameters: ModelParametersSchema.optional(),
+  endpoint_types: z.array(z.string()).optional(),
+  metadata: ModelMetadataSchema.optional()
+})
+
+// Provider behaviors schema
+const ProviderBehaviorsSchema = z
+  .object({
+    supports_custom_models: z.boolean(),
+    provides_model_mapping: z.boolean(),
+    supports_model_versioning: z.boolean(),
+    provides_fallback_routing: z.boolean(),
+    has_auto_retry: z.boolean(),
+    supports_health_check: z.boolean(),
+    has_real_time_metrics: z.boolean(),
+    provides_usage_analytics: z.boolean(),
+    supports_webhook_events: z.boolean(),
+    requires_api_key_validation: z.boolean(),
+    supports_rate_limiting: z.boolean(),
+    provides_usage_limits: z.boolean(),
+    supports_streaming: z.boolean(),
+    supports_batch_processing: z.boolean(),
+    supports_model_fine_tuning: z.boolean()
+  })
+  .loose() // Allow extensions
+
+// API compatibility schema
+const ApiCompatibilitySchema = z
+  .object({
+    supports_array_content: z.boolean().optional(),
+    supports_stream_options: z.boolean().optional(),
+    supports_developer_role: z.boolean().optional(),
+    supports_service_tier: z.boolean().optional(),
+    supports_thinking_control: z.boolean().optional(),
+    supports_api_version: z.boolean().optional(),
+    supports_parallel_tools: z.boolean().optional(),
+    supports_multimodal: z.boolean().optional()
+  })
+  .loose()
+
+// Special configuration schema (flexible)
+const SpecialConfigSchema = z.record(z.string(), z.unknown())
+
+// Provider metadata schema
+const ProviderMetadataSchema = z
+  .object({
+    source: z.string().optional(),
+    tags: z.array(z.string()).optional(),
+    reliability: z.enum(['low', 'medium', 'high']).optional()
+  })
+  .loose()
+
+// Complete Provider schema
+export const ProviderSchema = z.object({
+  id: z.string().min(1),
+  name: z.string().min(1),
+  description: z.string().optional(),
+  authentication: z.string().min(1),
+  pricing_model: z.string().min(1),
+  model_routing: z.string().min(1),
+  behaviors: ProviderBehaviorsSchema,
+  supported_endpoints: z.array(z.string()),
+  api_compatibility: ApiCompatibilitySchema.optional(),
+  default_api_host: z.url().optional(),
+  default_rate_limit: z.number().positive().optional(),
+  model_id_patterns: z.array(z.string()).optional(),
+  alias_model_ids: z.record(z.string(), z.string()).optional(),
+  documentation: z.string().url().optional(),
+  website: z.string().url().optional(),
+  deprecated: z.boolean(),
+  maintenance_mode: z.boolean(),
+  config_version: z.string().min(1),
+  special_config: SpecialConfigSchema.optional(),
+  metadata: ProviderMetadataSchema.optional()
+})
+
+// Data file schemas
+export const ModelsDataFileSchema = z.object({
+  version: z.string().min(1),
+  models: z.array(ModelSchema)
+})
+
+export const ProvidersDataFileSchema = z.object({
+  version: z.string().min(1),
+  providers: z.array(ProviderSchema)
+})
+
+// Override schemas
+const OverrideLimitsSchema = z.object({
+  context_window: z.number().positive().optional(),
+  max_output_tokens: z.number().positive().optional()
+})
+
+export const ProviderModelOverrideSchema = z.object({
+  provider_id: z.string().min(1),
+  model_id: z.string().min(1),
+  disabled: z.boolean().default(false),
+  reason: z.string().optional(),
+  last_updated: z.string().optional(),
+  updated_by: z.string().optional(),
+  priority: z.number().default(100),
+  limits: OverrideLimitsSchema.optional(),
+  pricing: PricingInfoSchema.optional()
+})
+
+export const OverridesDataFileSchema = z.object({
+  version: z.string().min(1),
+  overrides: z.array(ProviderModelOverrideSchema)
+})
+
+// Pagination schemas
+export const PaginationInfoSchema = z.object({
+  page: z.number().positive(),
+  limit: z.number().positive().max(100),
+  total: z.number().nonnegative(),
+  totalPages: z.number().nonnegative(),
+  hasNext: z.boolean(),
+  hasPrev: z.boolean()
+})
+
+export const PaginatedResponseSchema = <T extends z.ZodType>(itemSchema: T) =>
+  z.object({
+    data: z.array(itemSchema),
+    pagination: PaginationInfoSchema
+  })
+
+// Query parameter schemas
+export const QueryParamsSchema = z.object({
+  page: z.coerce.number().positive().default(1),
+  limit: z.coerce.number().positive().max(100).default(20),
+  search: z.string().trim().optional(),
+  capabilities: z.array(z.string()).optional(),
+  providers: z.array(z.string()).optional(),
+  authentication: z.array(z.string()).optional()
+})
+
+// Request schemas for API endpoints
+export const ModelListRequestSchema = QueryParamsSchema.extend({
+  capabilities: z.array(z.string()).optional(),
+  providers: z.array(z.string()).optional()
+})
+
+export const ProviderListRequestSchema = QueryParamsSchema.extend({
+  authentication: z.array(z.string()).optional()
+})
+
+// Response schemas
+export const ApiErrorSchema = z.object({
+  error: z.string(),
+  details: z.unknown().optional()
+})
+
+export const SuccessResponseSchema = z.object({
+  success: z.literal(true)
+})
+
+export const ModelUpdateResponseSchema = SuccessResponseSchema.extend({
+  model: ModelSchema
+})
+
+export const ProviderUpdateResponseSchema = SuccessResponseSchema.extend({
+  provider: ProviderSchema
+})
+
+// Utility types for strict typing
+export const CapabilityTypeSchema = z.enum([
+  'FUNCTION_CALL',
+  'REASONING',
+  'IMAGE_RECOGNITION',
+  'IMAGE_GENERATION',
+  'AUDIO_RECOGNITION',
+  'AUDIO_GENERATION',
+  'EMBEDDING',
+  'RERANK',
+  'AUDIO_TRANSCRIPT',
+  'VIDEO_RECOGNITION',
+  'VIDEO_GENERATION',
+  'STRUCTURED_OUTPUT',
+  'FILE_INPUT',
+  'WEB_SEARCH',
+  'CODE_EXECUTION',
+  'FILE_SEARCH',
+  'COMPUTER_USE'
+])
+
+export const ModalityTypeSchema = z.enum(['TEXT', 'VISION', 'AUDIO', 'VIDEO'])
+
+export const AuthenticationTypeSchema = z.enum(['API_KEY', 'OAUTH', 'NONE', 'CUSTOM'])
+
+export const EndpointTypeSchema = z.enum(['CHAT_COMPLETIONS', 'MESSAGES', 'RESPONSES', 'EMBEDDINGS', 'RERANK'])
+
+// Validation utilities using Zod
+
+// Custom error class for Zod validation errors
+export class ValidationError extends Error {
+  constructor(
+    message: string,
+    public details?: unknown,
+    public zodError?: z.ZodError
+  ) {
+    super(message)
+    this.name = 'ValidationError'
+  }
+}
+
+// String validation function
+export function validateString(value: string, fieldName: string): string {
+  if (typeof value !== 'string' || value.trim().length === 0) {
+    throw new ValidationError(`${fieldName} must be a non-empty string`)
+  }
+  return value.trim()
+}
+
+// Safe JSON parsing with Zod validation
+export async function safeParseWithValidation<T>(
+  jsonString: string,
+  schema: z.ZodType<T>,
+  errorMessage: string
+): Promise<T> {
+  try {
+    const parsed = JSON.parse(jsonString)
+    const result = schema.safeParse(parsed)
+
+    if (!result.success) {
+      throw new ValidationError(`${errorMessage}: ${result.error.message}`, result.error.issues, result.error)
+    }
+
+    return result.data
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      throw new ValidationError('Invalid JSON format', { originalError: error.message })
+    }
+    if (error instanceof ValidationError) {
+      throw error
+    }
+    throw new ValidationError(
+      `Unexpected error during validation: ${error instanceof Error ? error.message : 'Unknown error'}`
+    )
+  }
+}
+
+// Validate API response structure using Zod
+export function validatePaginatedResponse<T>(
+  data: unknown,
+  itemSchema: z.ZodType<T>
+): z.infer<ReturnType<typeof PaginatedResponseSchema<typeof itemSchema>>> {
+  const schema = PaginatedResponseSchema(itemSchema)
+  const result = schema.safeParse(data)
+
+  if (!result.success) {
+    throw new ValidationError(`Invalid response format: ${result.error.message}`, result.error.issues, result.error)
+  }
+
+  return result.data
+}
+
+// Validate and sanitize query parameters using Zod
+export function validateQueryParams(params: URLSearchParams): z.infer<typeof QueryParamsSchema> {
+  const queryParams: Record<string, string | string[]> = {}
+
+  // Handle all parameters - Array.from() for compatibility
+  Array.from(params.entries()).forEach(([key, value]) => {
+    if (['capabilities', 'providers', 'authentication'].includes(key)) {
+      if (!queryParams[key]) {
+        queryParams[key] = []
+      }
+      ;(queryParams[key] as string[]).push(value)
+    } else {
+      queryParams[key] = value
+    }
+  })
+
+  const result = QueryParamsSchema.safeParse(queryParams)
+
+  if (!result.success) {
+    throw new ValidationError(`Invalid query parameters: ${result.error.message}`, result.error.issues, result.error)
+  }
+
+  return result.data
+}
+
+// Type-safe error response creation
+export function createErrorResponse(
+  message: string,
+  status: number = 500,
+  details?: unknown
+): z.infer<typeof ApiErrorSchema> {
+  const error: z.infer<typeof ApiErrorSchema> = { error: message }
+  if (details !== undefined) {
+    ;(error as any).details = details
+  }
+  return error
+}
+
+// Safe type casting utility using Zod
+export function safeTypeCast<T>(value: unknown, schema: z.ZodType<T>, typeName?: string): T {
+  const result = schema.safeParse(value)
+  if (!result.success) {
+    throw new ValidationError(
+      `Expected ${typeName || schema.description || 'valid type'}, but validation failed: ${result.error.message}`,
+      result.error.issues,
+      result.error
+    )
+  }
+  return result.data
+}
+
+// Utility function to extract validation error details
+export function formatZodError(error: z.ZodError): string {
+  return error.issues
+    .map((issue) => {
+      const path = issue.path.join('.')
+      return `${path ? `${path}: ` : ''}${issue.message}`
+    })
+    .join('; ')
+}
+
+// Export inferred types
+export type Model = z.infer<typeof ModelSchema>
+export type Provider = z.infer<typeof ProviderSchema>
+export type ProviderModelOverride = z.infer<typeof ProviderModelOverrideSchema>
+export type ModelsDataFile = z.infer<typeof ModelsDataFileSchema>
+export type ProvidersDataFile = z.infer<typeof ProvidersDataFileSchema>
+export type OverridesDataFile = z.infer<typeof OverridesDataFileSchema>
+export type PaginationInfo = z.infer<typeof PaginationInfoSchema>
+export type PaginatedResponse<T> = z.infer<ReturnType<typeof PaginatedResponseSchema<z.ZodType<T>>>>
+export type ModelListRequest = z.infer<typeof ModelListRequestSchema>
+export type ProviderListRequest = z.infer<typeof ProviderListRequestSchema>
+export type ApiError = z.infer<typeof ApiErrorSchema>
+export type SuccessResponse = z.infer<typeof SuccessResponseSchema>
+export type ModelUpdateResponse = z.infer<typeof ModelUpdateResponseSchema>
+export type ProviderUpdateResponse = z.infer<typeof ProviderUpdateResponseSchema>
+
+// Export enum types for convenience
+export type CapabilityType = z.infer<typeof CapabilityTypeSchema>
+export type ModalityType = z.infer<typeof ModalityTypeSchema>
+export type AuthenticationType = z.infer<typeof AuthenticationTypeSchema>
+export type EndpointType = z.infer<typeof EndpointTypeSchema>
+
+// Legacy compatibility type guards (now using Zod internally)
+export function isModel(obj: unknown): obj is Model {
+  return ModelSchema.safeParse(obj).success
+}
+
+export function isProvider(obj: unknown): obj is Provider {
+  return ProviderSchema.safeParse(obj).success
+}
+
+export function isModelsDataFile(obj: unknown): obj is ModelsDataFile {
+  return ModelsDataFileSchema.safeParse(obj).success
+}
+
+export function isProvidersDataFile(obj: unknown): obj is ProvidersDataFile {
+  return ProvidersDataFileSchema.safeParse(obj).success
+}
@@ -0,0 +1,40 @@
+import type { NextConfig } from 'next'
+
+const nextConfig: NextConfig = {
+  // Configure static file serving from external directory
+  async rewrites() {
+    return [
+      // Proxy API requests to the catalog API
+      {
+        source: '/api/catalog/:path*',
+        destination: 'http://localhost:3001/api/catalog/:path*'
+      }
+    ]
+  },
+  // Add custom headers for static files
+  async headers() {
+    return [
+      {
+        source: '/data/:path*',
+        headers: [
+          {
+            key: 'Cache-Control',
+            value: 'public, max-age=3600, must-revalidate'
+          },
+          {
+            key: 'Access-Control-Allow-Origin',
+            value: '*'
+          }
+        ]
+      }
+    ]
+  },
+  // Configure serving static files from outside public directory
+  outputFileTracingExcludes: {
+    '*': ['./**/__tests__/**/*']
+  },
+  // Basic Turbopack configuration to silence warning
+  turbopack: {}
+}
+
+export default nextConfig
@@ -0,0 +1,32 @@
+{
+  "name": "@cherrystudio/catalog-web",
+  "version": "0.1.0",
+  "private": true,
+  "scripts": {
+    "dev": "next dev",
+    "build": "next build",
+    "start": "next start",
+    "lint": "eslint"
+  },
+  "dependencies": {
+    "@radix-ui/react-dialog": "^1.1.15",
+    "@radix-ui/react-icons": "^1.3.2",
+    "@radix-ui/react-separator": "^1.1.8",
+    "@radix-ui/react-slot": "^1.2.4",
+    "next": "16.0.6",
+    "react": "19.2.0",
+    "react-dom": "19.2.0",
+    "swr": "^2.3.7",
+    "zod": "^4.0.0"
+  },
+  "devDependencies": {
+    "@tailwindcss/postcss": "^4",
+    "@types/node": "^20",
+    "@types/react": "^19",
+    "@types/react-dom": "^19",
+    "eslint": "^9",
+    "eslint-config-next": "16.0.6",
+    "tailwindcss": "^4",
+    "typescript": "^5"
+  }
+}
@@ -0,0 +1,7 @@
+const config = {
+  plugins: {
+    '@tailwindcss/postcss': {}
+  }
+}
+
+export default config
@@ -0,0 +1 @@
+<svg fill="none" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg"><path d="M14.5 13.5V5.41a1 1 0 0 0-.3-.7L9.8.29A1 1 0 0 0 9.08 0H1.5v13.5A2.5 2.5 0 0 0 4 16h8a2.5 2.5 0 0 0 2.5-2.5m-1.5 0v-7H8v-5H3v12a1 1 0 0 0 1 1h8a1 1 0 0 0 1-1M9.5 5V2.12L12.38 5zM5.13 5h-.62v1.25h2.12V5zm-.62 3h7.12v1.25H4.5zm.62 3h-.62v1.25h7.12V11z" clip-rule="evenodd" fill="#666" fill-rule="evenodd"/></svg>
@@ -0,0 +1 @@
+<svg fill="none" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 16"><g clip-path="url(#a)"><path fill-rule="evenodd" clip-rule="evenodd" d="M10.27 14.1a6.5 6.5 0 0 0 3.67-3.45q-1.24.21-2.7.34-.31 1.83-.97 3.1M8 16A8 8 0 1 0 8 0a8 8 0 0 0 0 16m.48-1.52a7 7 0 0 1-.96 0H7.5a4 4 0 0 1-.84-1.32q-.38-.89-.63-2.08a40 40 0 0 0 3.92 0q-.25 1.2-.63 2.08a4 4 0 0 1-.84 1.31zm2.94-4.76q1.66-.15 2.95-.43a7 7 0 0 0 0-2.58q-1.3-.27-2.95-.43a18 18 0 0 1 0 3.44m-1.27-3.54a17 17 0 0 1 0 3.64 39 39 0 0 1-4.3 0 17 17 0 0 1 0-3.64 39 39 0 0 1 4.3 0m1.1-1.17q1.45.13 2.69.34a6.5 6.5 0 0 0-3.67-3.44q.65 1.26.98 3.1M8.48 1.5l.01.02q.41.37.84 1.31.38.89.63 2.08a40 40 0 0 0-3.92 0q.25-1.2.63-2.08a4 4 0 0 1 .85-1.32 7 7 0 0 1 .96 0m-2.75.4a6.5 6.5 0 0 0-3.67 3.44 29 29 0 0 1 2.7-.34q.31-1.83.97-3.1M4.58 6.28q-1.66.16-2.95.43a7 7 0 0 0 0 2.58q1.3.27 2.95.43a18 18 0 0 1 0-3.44m.17 4.71q-1.45-.12-2.69-.34a6.5 6.5 0 0 0 3.67 3.44q-.65-1.27-.98-3.1" fill="#666"/></g><defs><clipPath id="a"><path fill="#fff" d="M0 0h16v16H0z"/></clipPath></defs></svg>
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 394 80"><path fill="#000" d="M262 0h68.5v12.7h-27.2v66.6h-13.6V12.7H262V0ZM149 0v12.7H94v20.4h44.3v12.6H94v21h55v12.6H80.5V0h68.7zm34.3 0h-17.8l63.8 79.4h17.9l-32-39.7 32-39.6h-17.9l-23 28.6-23-28.6zm18.3 56.7-9-11-27.1 33.7h17.8l18.3-22.7z"/><path fill="#000" d="M81 79.3 17 0H0v79.3h13.6V17l50.2 62.3H81Zm252.6-.4c-1 0-1.8-.4-2.5-1s-1.1-1.6-1.1-2.6.3-1.8 1-2.5 1.6-1 2.6-1 1.8.3 2.5 1a3.4 3.4 0 0 1 .6 4.3 3.7 3.7 0 0 1-3 1.8zm23.2-33.5h6v23.3c0 2.1-.4 4-1.3 5.5a9.1 9.1 0 0 1-3.8 3.5c-1.6.8-3.5 1.3-5.7 1.3-2 0-3.7-.4-5.3-1s-2.8-1.8-3.7-3.2c-.9-1.3-1.4-3-1.4-5h6c.1.8.3 1.6.7 2.2s1 1.2 1.6 1.5c.7.4 1.5.5 2.4.5 1 0 1.8-.2 2.4-.6a4 4 0 0 0 1.6-1.8c.3-.8.5-1.8.5-3V45.5zm30.9 9.1a4.4 4.4 0 0 0-2-3.3 7.5 7.5 0 0 0-4.3-1.1c-1.3 0-2.4.2-3.3.5-.9.4-1.6 1-2 1.6a3.5 3.5 0 0 0-.3 4c.3.5.7.9 1.3 1.2l1.8 1 2 .5 3.2.8c1.3.3 2.5.7 3.7 1.2a13 13 0 0 1 3.2 1.8 8.1 8.1 0 0 1 3 6.5c0 2-.5 3.7-1.5 5.1a10 10 0 0 1-4.4 3.5c-1.8.8-4.1 1.2-6.8 1.2-2.6 0-4.9-.4-6.8-1.2-2-.8-3.4-2-4.5-3.5a10 10 0 0 1-1.7-5.6h6a5 5 0 0 0 3.5 4.6c1 .4 2.2.6 3.4.6 1.3 0 2.5-.2 3.5-.6 1-.4 1.8-1 2.4-1.7a4 4 0 0 0 .8-2.4c0-.9-.2-1.6-.7-2.2a11 11 0 0 0-2.1-1.4l-3.2-1-3.8-1c-2.8-.7-5-1.7-6.6-3.2a7.2 7.2 0 0 1-2.4-5.7 8 8 0 0 1 1.7-5 10 10 0 0 1 4.3-3.5c2-.8 4-1.2 6.4-1.2 2.3 0 4.4.4 6.2 1.2 1.8.8 3.2 2 4.3 3.4 1 1.4 1.5 3 1.5 5h-5.8z"/></svg>
@@ -0,0 +1 @@
+<svg fill="none" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1155 1000"><path d="m577.3 0 577.4 1000H0z" fill="#fff"/></svg>
@@ -0,0 +1 @@
+<svg fill="none" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 16"><path fill-rule="evenodd" clip-rule="evenodd" d="M1.5 2.5h13v10a1 1 0 0 1-1 1h-11a1 1 0 0 1-1-1zM0 1h16v11.5a2.5 2.5 0 0 1-2.5 2.5h-11A2.5 2.5 0 0 1 0 12.5zm3.75 4.5a.75.75 0 1 0 0-1.5.75.75 0 0 0 0 1.5M7 4.75a.75.75 0 1 1-1.5 0 .75.75 0 0 1 1.5 0m1.75.75a.75.75 0 1 0 0-1.5.75.75 0 0 0 0 1.5" fill="#666"/></svg>
@@ -0,0 +1,27 @@
+{
+  "compilerOptions": {
+    "target": "ES2017",
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "react-jsx",
+    "incremental": true,
+    "plugins": [
+      {
+        "name": "next"
+      }
+    ],
+    "paths": {
+      "@/*": ["./*"]
+    }
+  },
+  "include": ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts", ".next/dev/types/**/*.ts", "**/*.mts"],
+  "exclude": ["node_modules"]
+}
@@ -33,8 +33,9 @@
      "@cherrystudio/ai-sdk-provider": ["./packages/ai-sdk-provider/src/index.ts"],
      "@cherrystudio/ui/icons": ["./packages/ui/src/components/icons/index.ts"],
      "@cherrystudio/ui": ["./packages/ui/src/index.ts"],
-      "@cherrystudio/ui/*": ["./packages/ui/src/*"]
-
+      "@cherrystudio/ui/*": ["./packages/ui/src/*"],
+      "@cherrystudio/catalog": ["./packages/catalog/src/index.ts"],
+      "@cherrystudio/catalog/*": ["./packages/catalog/src/*"]
    },
    "experimentalDecorators": true,
    "emitDecoratorMetadata": true,
Author	SHA1	Message	Date
suyao	67f726afb7	feat: implement API client with SWR integration for catalog management - Added a new Textarea component for user input. - Configured ESLint with custom rules and global ignores. - Developed a comprehensive API client with CRUD operations and error handling. - Defined catalog types and schemas using Zod for type safety. - Created utility functions for class name merging and validation. - Established Next.js configuration for API rewrites and static file headers. - Set up package.json with necessary dependencies and scripts. - Configured PostCSS for Tailwind CSS integration. - Added SVG assets for UI components. - Configured TypeScript with strict settings and module resolution.	2025-12-01 13:07:23 +08:00
suyao	d98d69e28d	simplify config	2025-11-24 14:48:02 +08:00
suyao	3f671ba6be	initial migrate	2025-11-24 08:55:12 +08:00
suyao	78e593fac4	feat: Add comprehensive type test - Introduced unified export for all catalog schemas and types in `index.ts`. - Defined model configuration schemas in `model.ts`, including modalities, capabilities, reasoning, parameter support, and pricing. - Created provider model override schemas in `override.ts` to manage provider-specific configurations. - Established provider configuration schemas in `provider.ts`, detailing endpoint types, authentication methods, pricing models, and behavior characteristics. - Implemented utility functions for JSON value validation and parsing in `json-value` and `parse-json` modules. - Developed a schema validation utility in `SchemaValidator.ts` to validate model, provider, and override configurations with detailed error handling and warnings.	2025-11-24 07:36:33 +08:00
suyao	9933b0b12f	feat: Add comprehensive schema definitions for catalog system - Introduced common types and validation utilities in common.types.ts - Unified export of all schemas in index.ts for easier access - Defined model configuration schemas including capabilities, pricing, and reasoning in model.schema.ts - Created provider model override schemas to manage provider-specific configurations in override.schema.ts - Established provider configuration schemas detailing metadata, capabilities, and behaviors in provider.schema.ts	2025-11-24 06:12:45 +08:00
suyao	bceeef5190	Initial Prompt	2025-11-24 01:40:20 +08:00
				`@@ -0,0 +1 @@`
				`<svg fill="none" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg"><path d="M14.5 13.5V5.41a1 1 0 0 0-.3-.7L9.8.29A1 1 0 0 0 9.08 0H1.5v13.5A2.5 2.5 0 0 0 4 16h8a2.5 2.5 0 0 0 2.5-2.5m-1.5 0v-7H8v-5H3v12a1 1 0 0 0 1 1h8a1 1 0 0 0 1-1M9.5 5V2.12L12.38 5zM5.13 5h-.62v1.25h2.12V5zm-.62 3h7.12v1.25H4.5zm.62 3h-.62v1.25h7.12V11z" clip-rule="evenodd" fill="#666" fill-rule="evenodd"/></svg>`
				`@@ -0,0 +1 @@`
				<svg fill="none" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 16"><g clip-path="url(#a)"><path fill-rule="evenodd" clip-rule="evenodd" d="M10.27 14.1a6.5 6.5 0 0 0 3.67-3.45q-1.24.21-2.7.34-.31 1.83-.97 3.1M8 16A8 8 0 1 0 8 0a8 8 0 0 0 0 16m.48-1.52a7 7 0 0 1-.96 0H7.5a4 4 0 0 1-.84-1.32q-.38-.89-.63-2.08a40 40 0 0 0 3.92 0q-.25 1.2-.63 2.08a4 4 0 0 1-.84 1.31zm2.94-4.76q1.66-.15 2.95-.43a7 7 0 0 0 0-2.58q-1.3-.27-2.95-.43a18 18 0 0 1 0 3.44m-1.27-3.54a17 17 0 0 1 0 3.64 39 39 0 0 1-4.3 0 17 17 0 0 1 0-3.64 39 39 0 0 1 4.3 0m1.1-1.17q1.45.13 2.69.34a6.5 6.5 0 0 0-3.67-3.44q.65 1.26.98 3.1M8.48 1.5l.01.02q.41.37.84 1.31.38.89.63 2.08a40 40 0 0 0-3.92 0q.25-1.2.63-2.08a4 4 0 0 1 .85-1.32 7 7 0 0 1 .96 0m-2.75.4a6.5 6.5 0 0 0-3.67 3.44 29 29 0 0 1 2.7-.34q.31-1.83.97-3.1M4.58 6.28q-1.66.16-2.95.43a7 7 0 0 0 0 2.58q1.3.27 2.95.43a18 18 0 0 1 0-3.44m.17 4.71q-1.45-.12-2.69-.34a6.5 6.5 0 0 0 3.67 3.44q-.65-1.27-.98-3.1" fill="#666"/></g><defs><clipPath id="a"><path fill="#fff" d="M0 0h16v16H0z"/></clipPath></defs></svg>
				`@@ -0,0 +1 @@`
				<svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 394 80"><path fill="#000" d="M262 0h68.5v12.7h-27.2v66.6h-13.6V12.7H262V0ZM149 0v12.7H94v20.4h44.3v12.6H94v21h55v12.6H80.5V0h68.7zm34.3 0h-17.8l63.8 79.4h17.9l-32-39.7 32-39.6h-17.9l-23 28.6-23-28.6zm18.3 56.7-9-11-27.1 33.7h17.8l18.3-22.7z"/><path fill="#000" d="M81 79.3 17 0H0v79.3h13.6V17l50.2 62.3H81Zm252.6-.4c-1 0-1.8-.4-2.5-1s-1.1-1.6-1.1-2.6.3-1.8 1-2.5 1.6-1 2.6-1 1.8.3 2.5 1a3.4 3.4 0 0 1 .6 4.3 3.7 3.7 0 0 1-3 1.8zm23.2-33.5h6v23.3c0 2.1-.4 4-1.3 5.5a9.1 9.1 0 0 1-3.8 3.5c-1.6.8-3.5 1.3-5.7 1.3-2 0-3.7-.4-5.3-1s-2.8-1.8-3.7-3.2c-.9-1.3-1.4-3-1.4-5h6c.1.8.3 1.6.7 2.2s1 1.2 1.6 1.5c.7.4 1.5.5 2.4.5 1 0 1.8-.2 2.4-.6a4 4 0 0 0 1.6-1.8c.3-.8.5-1.8.5-3V45.5zm30.9 9.1a4.4 4.4 0 0 0-2-3.3 7.5 7.5 0 0 0-4.3-1.1c-1.3 0-2.4.2-3.3.5-.9.4-1.6 1-2 1.6a3.5 3.5 0 0 0-.3 4c.3.5.7.9 1.3 1.2l1.8 1 2 .5 3.2.8c1.3.3 2.5.7 3.7 1.2a13 13 0 0 1 3.2 1.8 8.1 8.1 0 0 1 3 6.5c0 2-.5 3.7-1.5 5.1a10 10 0 0 1-4.4 3.5c-1.8.8-4.1 1.2-6.8 1.2-2.6 0-4.9-.4-6.8-1.2-2-.8-3.4-2-4.5-3.5a10 10 0 0 1-1.7-5.6h6a5 5 0 0 0 3.5 4.6c1 .4 2.2.6 3.4.6 1.3 0 2.5-.2 3.5-.6 1-.4 1.8-1 2.4-1.7a4 4 0 0 0 .8-2.4c0-.9-.2-1.6-.7-2.2a11 11 0 0 0-2.1-1.4l-3.2-1-3.8-1c-2.8-.7-5-1.7-6.6-3.2a7.2 7.2 0 0 1-2.4-5.7 8 8 0 0 1 1.7-5 10 10 0 0 1 4.3-3.5c2-.8 4-1.2 6.4-1.2 2.3 0 4.4.4 6.2 1.2 1.8.8 3.2 2 4.3 3.4 1 1.4 1.5 3 1.5 5h-5.8z"/></svg>
				`@@ -0,0 +1 @@`
				`<svg fill="none" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1155 1000"><path d="m577.3 0 577.4 1000H0z" fill="#fff"/></svg>`