@renxqoo/renx-code 0.0.7 → 0.0.9

package/vendor/agent-root/src/providers/__tests__/registry.test.ts

@@ -15,6 +15,7 @@ describe('ProviderRegistry', () => {
   beforeEach(() => {
     vi.resetModules();
     process.env = { ...originalEnv };
+    delete process.env.RENX_CUSTOM_MODELS_JSON;
   });
 
   afterEach(() => {
@@ -69,12 +70,12 @@ describe('ProviderRegistry', () => {
       expect(MODEL_CONFIGS['claude-opus-4.6'].endpointPath).toBe('/v1/messages');
     });
 
-    it('should use responses endpoint for gpt-5.3 compatibility gateway', () => {
-      expect(MODEL_CONFIGS['gpt-5.3'].baseURL).toBe('https://gmncode.cn/v1');
+    it('should use responses endpoint for gpt-5.3 official OpenAI API', () => {
+      expect(MODEL_CONFIGS['gpt-5.3'].baseURL).toBe('https://api.openai.com/v1');
       expect(MODEL_CONFIGS['gpt-5.3'].endpointPath).toBe('/responses');
       expect(MODEL_CONFIGS['gpt-5.3'].model).toBe('gpt-5.3-codex');
-      expect(MODEL_CONFIGS['gpt-5.3'].max_tokens).toBe(128 * 1000);
-      expect(MODEL_CONFIGS['gpt-5.3'].LLMMAX_TOKENS).toBe(400 * 1000);
+      expect(MODEL_CONFIGS['gpt-5.3'].max_tokens).toBe(1000 * 32);
+      expect(MODEL_CONFIGS['gpt-5.3'].LLMMAX_TOKENS).toBe(258 * 1000);
       expect(MODEL_CONFIGS['gpt-5.3'].features).toContain('reasoning');
     });
   });
@@ -132,20 +133,45 @@ describe('ProviderRegistry', () => {
       expect(provider.adapter).toBeInstanceOf(StandardAdapter);
     });
 
-    it('should create gpt-5.3 provider with gmn-compatible defaults', () => {
+    it('should create gpt-5.3 provider with official OpenAI defaults', () => {
       process.env.OPENAI_API_KEY = 'test-openai-key';
       delete process.env.OPENAI_API_BASE;
 
       const provider = ProviderRegistry.createFromEnv('gpt-5.3');
 
       expect(provider.config.apiKey).toBe('test-openai-key');
-      expect(provider.config.baseURL).toBe('https://gmncode.cn/v1');
+      expect(provider.config.baseURL).toBe('https://api.openai.com/v1');
       expect(provider.config.model).toBe('gpt-5.3-codex');
-      expect(provider.config.max_tokens).toBe(128 * 1000);
-      expect(provider.config.LLMMAX_TOKENS).toBe(400 * 1000);
+      expect(provider.config.max_tokens).toBe(1000 * 32);
+      expect(provider.config.LLMMAX_TOKENS).toBe(258 * 1000);
       expect(provider.adapter).toBeInstanceOf(ResponsesAdapter);
     });
 
+    it('should create provider for a custom model from RENX_CUSTOM_MODELS_JSON', () => {
+      process.env.CUSTOM_OPENAI_API_KEY = 'custom-key';
+      process.env.RENX_CUSTOM_MODELS_JSON = JSON.stringify({
+        'custom-openai': {
+          provider: 'openai',
+          name: 'Custom OpenAI',
+          baseURL: 'https://custom.example.com/v1',
+          endpointPath: '/chat/completions',
+          envApiKey: 'CUSTOM_OPENAI_API_KEY',
+          envBaseURL: 'CUSTOM_OPENAI_API_BASE',
+          model: 'custom-model',
+          max_tokens: 4096,
+          LLMMAX_TOKENS: 64000,
+          features: ['streaming', 'function-calling'],
+        },
+      });
+
+      const provider = ProviderRegistry.createFromEnv('custom-openai');
+
+      expect(provider.config.apiKey).toBe('custom-key');
+      expect(provider.config.baseURL).toBe('https://custom.example.com/v1');
+      expect(provider.config.model).toBe('custom-model');
+      expect(provider.adapter).toBeInstanceOf(StandardAdapter);
+    });
+
     it('should use default baseURL when env var not set', () => {
       process.env.GLM_API_KEY = 'test-key';
       delete process.env.GLM_API_BASE;
@@ -164,6 +190,20 @@ describe('ProviderRegistry', () => {
       expect(provider.config.baseURL).toBe('https://custom.example.com');
     });
 
+    it('should allow custom model config to override a built-in baseURL', () => {
+      process.env.OPENAI_API_KEY = 'test-openai-key';
+      process.env.RENX_CUSTOM_MODELS_JSON = JSON.stringify({
+        'gpt-5.4': {
+          baseURL: 'https://proxy.example.com/v1',
+        },
+      });
+
+      const provider = ProviderRegistry.createFromEnv('gpt-5.4');
+
+      expect(provider.config.baseURL).toBe('https://proxy.example.com/v1');
+      expect(provider.adapter).toBeInstanceOf(ResponsesAdapter);
+    });
+
     it('should accept config overrides', () => {
       process.env.GLM_API_KEY = 'test-key';
 
@@ -355,6 +395,25 @@ describe('ProviderRegistry', () => {
 
       expect(Array.isArray(ids)).toBe(true);
     });
+
+    it('should include custom model IDs from env config', () => {
+      process.env.RENX_CUSTOM_MODELS_JSON = JSON.stringify({
+        'custom-openai': {
+          provider: 'openai',
+          name: 'Custom OpenAI',
+          baseURL: 'https://custom.example.com/v1',
+          endpointPath: '/chat/completions',
+          envApiKey: 'CUSTOM_OPENAI_API_KEY',
+          envBaseURL: 'CUSTOM_OPENAI_API_BASE',
+          model: 'custom-model',
+          max_tokens: 4096,
+          LLMMAX_TOKENS: 64000,
+          features: ['streaming'],
+        },
+      });
+
+      expect(ProviderRegistry.getModelIds()).toContain('custom-openai');
+    });
   });
 
   describe('getModelConfig', () => {
@@ -379,6 +438,21 @@ describe('ProviderRegistry', () => {
         ProviderRegistry.getModelConfig('unknown' as ModelId);
       }).toThrow('Unknown model: unknown');
     });
+
+    it('should reflect built-in overrides from custom env config', () => {
+      process.env.RENX_CUSTOM_MODELS_JSON = JSON.stringify({
+        'gpt-5.4': {
+          baseURL: 'https://proxy.example.com/v1',
+          name: 'GPT-5.4 Proxy',
+        },
+      });
+
+      const config = ProviderRegistry.getModelConfig('gpt-5.4');
+
+      expect(config.baseURL).toBe('https://proxy.example.com/v1');
+      expect(config.name).toBe('GPT-5.4 Proxy');
+      expect(config.envApiKey).toBe('OPENAI_API_KEY');
+    });
   });
 
   describe('getModelName', () => {

package/vendor/agent-root/src/providers/index.ts

@@ -4,7 +4,7 @@
 
 // Registry 相关
 export { Models, MODEL_CONFIGS, ProviderRegistry } from './registry';
-export type { ProviderType, ModelId } from './registry';
+export type { ProviderType, BuiltinModelId, ModelId } from './registry';
 
 // Provider 相关
 export { LLMProvider } from './types';

package/vendor/agent-root/src/providers/registry/model-config.ts

@@ -1,21 +1,34 @@
 /**
- * 模型配置存储
- *
- * 集中管理所有模型的配置信息，可从外部加载
+ * Central model configuration storage.
  */
 
-import type { ModelConfig, ModelId } from '../types';
+import type { ModelConfig, ModelId, BuiltinModelId, ProviderType } from '../types';
+
+const CUSTOM_MODELS_ENV_VAR = 'RENX_CUSTOM_MODELS_JSON';
+
+export type ModelDefinition = Omit<ModelConfig, 'apiKey'>;
+type PartialModelDefinition = Partial<ModelDefinition>;
+
+const VALID_PROVIDERS: ProviderType[] = [
+  'anthropic',
+  'kimi',
+  'deepseek',
+  'glm',
+  'minimax',
+  'openai',
+  'openrouter',
+  'qwen',
+];
 
 /**
- * 模型配置表（以模型 ID 为键，不包含 apiKey 的配置）
+ * Built-in model definitions.
  */
-export const MODEL_DEFINITIONS: Record<ModelId, Omit<ModelConfig, 'apiKey'>> = {
-  // Anthropic 系列
+export const MODEL_DEFINITIONS: Record<BuiltinModelId, ModelDefinition> = {
   'claude-opus-4.6': {
     id: 'claude-opus-4.6',
     provider: 'anthropic',
     name: 'Claude Opus 4.6',
-    baseURL: '',
+    baseURL: 'https://api.anthropic.com',
     endpointPath: '/v1/messages',
     envApiKey: 'ANTHROPIC_API_KEY',
     envBaseURL: 'ANTHROPIC_API_BASE',
@@ -25,8 +38,6 @@ export const MODEL_DEFINITIONS: Record<ModelId, Omit<ModelConfig, 'apiKey'>> = {
     features: ['streaming', 'function-calling', 'vision'],
     modalities: { image: true },
   },
-
-  // GLM 系列
   'glm-4.7': {
     id: 'glm-4.7',
     provider: 'glm',
@@ -41,7 +52,6 @@ export const MODEL_DEFINITIONS: Record<ModelId, Omit<ModelConfig, 'apiKey'>> = {
     features: ['streaming', 'function-calling', 'vision'],
     modalities: { image: true },
   },
-  // GLM 系列
   'glm-5': {
     id: 'glm-5',
     provider: 'glm',
@@ -56,7 +66,6 @@ export const MODEL_DEFINITIONS: Record<ModelId, Omit<ModelConfig, 'apiKey'>> = {
     features: ['streaming', 'function-calling', 'vision'],
     modalities: { image: true },
   },
-  // MiniMax 系列
   'minimax-2.5': {
     id: 'minimax-2.5',
     provider: 'minimax',
@@ -70,7 +79,6 @@ export const MODEL_DEFINITIONS: Record<ModelId, Omit<ModelConfig, 'apiKey'>> = {
     LLMMAX_TOKENS: 200 * 1000,
     features: ['streaming', 'function-calling'],
   },
-  // Kimi 系列
   'kimi-k2.5': {
     id: 'kimi-k2.5',
     provider: 'kimi',
@@ -86,7 +94,6 @@ export const MODEL_DEFINITIONS: Record<ModelId, Omit<ModelConfig, 'apiKey'>> = {
     temperature: 0.6,
     thinking: false,
   },
-  // DeepSeek 系列
   'deepseek-reasoner': {
     id: 'deepseek-reasoner',
     provider: 'deepseek',
@@ -100,12 +107,11 @@ export const MODEL_DEFINITIONS: Record<ModelId, Omit<ModelConfig, 'apiKey'>> = {
     LLMMAX_TOKENS: 128 * 1000,
     features: ['streaming', 'function-calling'],
   },
-  // Qwen 系列
   'qwen3.5-plus': {
     id: 'qwen3.5-plus',
     provider: 'qwen',
     name: 'Qwen 3.5 Plus',
-    baseURL: 'https://coding.dashscope.aliyuncs.com/v1',
+    baseURL: 'https://dashscope.aliyuncs.com/compatible-mode/v1',
     endpointPath: '/chat/completions',
     envApiKey: 'QWEN_API_KEY',
     envBaseURL: 'QWEN_API_BASE',
@@ -115,12 +121,11 @@ export const MODEL_DEFINITIONS: Record<ModelId, Omit<ModelConfig, 'apiKey'>> = {
     features: ['streaming', 'function-calling'],
     modalities: { image: true },
   },
-  // Qwen 系列
   'qwen3.5-max': {
     id: 'qwen3.5-max',
     provider: 'qwen',
     name: 'Qwen 3.5 Max',
-    baseURL: 'https://coding.dashscope.aliyuncs.com/v1',
+    baseURL: 'https://dashscope.aliyuncs.com/compatible-mode/v1',
     endpointPath: '/chat/completions',
     envApiKey: 'QWEN_API_KEY',
     envBaseURL: 'QWEN_API_BASE',
@@ -133,12 +138,12 @@ export const MODEL_DEFINITIONS: Record<ModelId, Omit<ModelConfig, 'apiKey'>> = {
     id: 'qwen-kimi-k2.5',
     provider: 'qwen',
     name: 'qwen kimi k2.5',
-    baseURL: 'https://coding.dashscope.aliyuncs.com/v1',
+    baseURL: 'https://dashscope.aliyuncs.com/compatible-mode/v1',
     endpointPath: '/chat/completions',
     envApiKey: 'QWEN_API_KEY',
     envBaseURL: 'QWEN_API_BASE',
     model: 'kimi-k2.5',
-    max_tokens: 8000,
+    max_tokens: 1000 * 32,
     LLMMAX_TOKENS: 200 * 1000,
     features: ['streaming', 'function-calling'],
   },
@@ -146,12 +151,12 @@ export const MODEL_DEFINITIONS: Record<ModelId, Omit<ModelConfig, 'apiKey'>> = {
     id: 'qwen-glm-5',
     provider: 'qwen',
     name: 'Qwen GLM 5',
-    baseURL: 'https://coding.dashscope.aliyuncs.com/v1',
+    baseURL: 'https://dashscope.aliyuncs.com/compatible-mode/v1',
     endpointPath: '/chat/completions',
     envApiKey: 'QWEN_API_KEY',
     envBaseURL: 'QWEN_API_BASE',
     model: 'glm-5',
-    max_tokens: 8000,
+    max_tokens: 1000 * 32,
     LLMMAX_TOKENS: 200 * 1000,
     features: ['streaming', 'function-calling'],
   },
@@ -159,40 +164,26 @@ export const MODEL_DEFINITIONS: Record<ModelId, Omit<ModelConfig, 'apiKey'>> = {
     id: 'qwen-minimax-2.5',
     provider: 'qwen',
     name: 'Qwen MiniMax 2.5',
-    baseURL: 'https://coding.dashscope.aliyuncs.com/v1',
+    baseURL: 'https://dashscope.aliyuncs.com/compatible-mode/v1',
     endpointPath: '/chat/completions',
     envApiKey: 'QWEN_API_KEY',
     envBaseURL: 'QWEN_API_BASE',
     model: 'MiniMax-M2.5',
-    max_tokens: 8000,
+    max_tokens: 1000 * 32,
     LLMMAX_TOKENS: 200 * 1000,
     features: ['streaming', 'function-calling'],
   },
-  // 'claude-4.6': {
-  //   id: 'wr-claude-4.6',
-  //   provider: 'openai',
-  //   name: 'Claude Opus 4.6',
-  //   baseURL: '',
-  //   endpointPath: '/chat/completions',
-  //   envApiKey: 'ANTHROPIC_API_KEY',
-  //   envBaseURL: 'ANTHROPIC_API_BASE',
-  //   model: 'claude-opus-4-6',
-  //   max_tokens: 16384,
-  //   LLMMAX_TOKENS: 1000 * 1000,
-  //   features: ['streaming', 'function-calling', 'vision'],
-  //   modalities: { image: true },
-  // },
   'gpt-5.3': {
     id: 'gpt-5.3',
     provider: 'openai',
     name: 'GPT-5.3',
-    baseURL: 'https://gmncode.cn/v1',
+    baseURL: 'https://api.openai.com/v1',
     endpointPath: '/responses',
     envApiKey: 'OPENAI_API_KEY',
     envBaseURL: 'OPENAI_API_BASE',
     model: 'gpt-5.3-codex',
-    max_tokens: 128 * 1000,
-    LLMMAX_TOKENS: 400 * 1000,
+    max_tokens: 1000 * 32,
+    LLMMAX_TOKENS: 258 * 1000,
     model_reasoning_effort: 'high',
     features: ['streaming', 'function-calling', 'reasoning'],
     modalities: { image: true },
@@ -201,12 +192,12 @@ export const MODEL_DEFINITIONS: Record<ModelId, Omit<ModelConfig, 'apiKey'>> = {
     id: 'gpt-5.4',
     provider: 'openai',
     name: 'GPT-5.4',
-    baseURL: 'https://gmncode.cn/v1',
+    baseURL: 'https://api.openai.com/v1',
     endpointPath: '/responses',
     envApiKey: 'OPENAI_API_KEY',
     envBaseURL: 'OPENAI_API_BASE',
     model: 'gpt-5.4',
-    max_tokens: 10000,
+    max_tokens: 1000 * 32,
     LLMMAX_TOKENS: 200 * 1000,
     model_reasoning_effort: 'high',
     features: ['streaming', 'function-calling'],
@@ -221,10 +212,266 @@ export const MODEL_DEFINITIONS: Record<ModelId, Omit<ModelConfig, 'apiKey'>> = {
     envApiKey: 'OPENROUTER_API_KEY',
     envBaseURL: 'OPENROUTER_API_BASE',
     model: 'openrouter/hunter-alpha',
-    max_tokens: 32 * 10,
+    max_tokens: 1000 * 32,
     LLMMAX_TOKENS: 200 * 1000,
     model_reasoning_effort: 'high',
     features: ['streaming', 'function-calling'],
     modalities: { image: true },
   },
 };
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function isValidProvider(value: unknown): value is ProviderType {
+  return typeof value === 'string' && VALID_PROVIDERS.includes(value as ProviderType);
+}
+
+function isValidNumber(value: unknown): value is number {
+  return typeof value === 'number' && Number.isFinite(value) && value > 0;
+}
+
+function isValidReasoningEffort(
+  value: unknown
+): value is NonNullable<ModelDefinition['model_reasoning_effort']> {
+  return value === 'low' || value === 'medium' || value === 'high';
+}
+
+function sanitizeModalities(value: unknown): ModelDefinition['modalities'] | undefined {
+  if (value === undefined) {
+    return undefined;
+  }
+
+  if (!isPlainObject(value)) {
+    return undefined;
+  }
+
+  const result: NonNullable<ModelDefinition['modalities']> = {};
+
+  if (typeof value.image === 'boolean') {
+    result.image = value.image;
+  }
+  if (typeof value.audio === 'boolean') {
+    result.audio = value.audio;
+  }
+  if (typeof value.video === 'boolean') {
+    result.video = value.video;
+  }
+
+  return Object.keys(result).length > 0 ? result : {};
+}
+
+function sanitizePartialModelDefinition(
+  modelId: string,
+  value: unknown
+): PartialModelDefinition | null {
+  if (!isPlainObject(value)) {
+    return null;
+  }
+
+  const sanitized: PartialModelDefinition = { id: modelId as ModelId };
+
+  if (value.provider !== undefined) {
+    if (!isValidProvider(value.provider)) {
+      return null;
+    }
+    sanitized.provider = value.provider;
+  }
+
+  if (value.name !== undefined) {
+    if (typeof value.name !== 'string' || value.name.trim() === '') {
+      return null;
+    }
+    sanitized.name = value.name;
+  }
+
+  if (value.endpointPath !== undefined) {
+    if (typeof value.endpointPath !== 'string' || value.endpointPath.trim() === '') {
+      return null;
+    }
+    sanitized.endpointPath = value.endpointPath;
+  }
+
+  if (value.envApiKey !== undefined) {
+    if (typeof value.envApiKey !== 'string' || value.envApiKey.trim() === '') {
+      return null;
+    }
+    sanitized.envApiKey = value.envApiKey;
+  }
+
+  if (value.envBaseURL !== undefined) {
+    if (typeof value.envBaseURL !== 'string' || value.envBaseURL.trim() === '') {
+      return null;
+    }
+    sanitized.envBaseURL = value.envBaseURL;
+  }
+
+  if (value.baseURL !== undefined) {
+    if (typeof value.baseURL !== 'string' || value.baseURL.trim() === '') {
+      return null;
+    }
+    sanitized.baseURL = value.baseURL;
+  }
+
+  if (value.model !== undefined) {
+    if (typeof value.model !== 'string' || value.model.trim() === '') {
+      return null;
+    }
+    sanitized.model = value.model;
+  }
+
+  if (value.max_tokens !== undefined) {
+    if (!isValidNumber(value.max_tokens)) {
+      return null;
+    }
+    sanitized.max_tokens = value.max_tokens;
+  }
+
+  if (value.LLMMAX_TOKENS !== undefined) {
+    if (!isValidNumber(value.LLMMAX_TOKENS)) {
+      return null;
+    }
+    sanitized.LLMMAX_TOKENS = value.LLMMAX_TOKENS;
+  }
+
+  if (value.features !== undefined) {
+    if (!Array.isArray(value.features) || value.features.some((feature) => typeof feature !== 'string')) {
+      return null;
+    }
+    sanitized.features = [...value.features];
+  }
+
+  if (value.modalities !== undefined) {
+    const modalities = sanitizeModalities(value.modalities);
+    if (modalities === undefined) {
+      return null;
+    }
+    sanitized.modalities = modalities;
+  }
+
+  if (value.temperature !== undefined) {
+    if (typeof value.temperature !== 'number' || !Number.isFinite(value.temperature)) {
+      return null;
+    }
+    sanitized.temperature = value.temperature;
+  }
+
+  if (value.tool_stream !== undefined) {
+    if (typeof value.tool_stream !== 'boolean') {
+      return null;
+    }
+    sanitized.tool_stream = value.tool_stream;
+  }
+
+  if (value.thinking !== undefined) {
+    if (typeof value.thinking !== 'boolean') {
+      return null;
+    }
+    sanitized.thinking = value.thinking;
+  }
+
+  if (value.timeout !== undefined) {
+    if (!isValidNumber(value.timeout)) {
+      return null;
+    }
+    sanitized.timeout = value.timeout;
+  }
+
+  if (value.model_reasoning_effort !== undefined) {
+    if (!isValidReasoningEffort(value.model_reasoning_effort)) {
+      return null;
+    }
+    sanitized.model_reasoning_effort = value.model_reasoning_effort;
+  }
+
+  return sanitized;
+}
+
+function isCompleteModelDefinition(value: PartialModelDefinition): value is ModelDefinition {
+  return (
+    typeof value.id === 'string' &&
+    isValidProvider(value.provider) &&
+    typeof value.name === 'string' &&
+    typeof value.endpointPath === 'string' &&
+    typeof value.envApiKey === 'string' &&
+    typeof value.envBaseURL === 'string' &&
+    typeof value.baseURL === 'string' &&
+    typeof value.model === 'string' &&
+    isValidNumber(value.max_tokens) &&
+    isValidNumber(value.LLMMAX_TOKENS) &&
+    Array.isArray(value.features) &&
+    value.features.every((feature) => typeof feature === 'string')
+  );
+}
+
+function mergeModelDefinition(
+  modelId: string,
+  base: PartialModelDefinition,
+  override: PartialModelDefinition
+): ModelDefinition | null {
+  const merged: PartialModelDefinition = {
+    ...base,
+    ...override,
+    id: modelId as ModelId,
+  };
+
+  if (base.modalities || override.modalities) {
+    merged.modalities = {
+      ...(base.modalities ?? {}),
+      ...(override.modalities ?? {}),
+    };
+  }
+
+  if (!isCompleteModelDefinition(merged)) {
+    return null;
+  }
+
+  return merged;
+}
+
+export function readCustomModelDefinitionsFromEnv(
+  env: NodeJS.ProcessEnv = process.env
+): Record<string, PartialModelDefinition> {
+  const raw = env[CUSTOM_MODELS_ENV_VAR];
+  if (!raw) {
+    return {};
+  }
+
+  try {
+    const parsed = JSON.parse(raw) as unknown;
+    if (!isPlainObject(parsed)) {
+      return {};
+    }
+
+    const result: Record<string, PartialModelDefinition> = {};
+    for (const [modelId, modelConfig] of Object.entries(parsed)) {
+      const sanitized = sanitizePartialModelDefinition(modelId, modelConfig);
+      if (sanitized) {
+        result[modelId] = sanitized;
+      }
+    }
+
+    return result;
+  } catch {
+    return {};
+  }
+}
+
+export function getResolvedModelDefinitions(
+  env: NodeJS.ProcessEnv = process.env
+): Record<ModelId, ModelDefinition> {
+  const customDefinitions = readCustomModelDefinitionsFromEnv(env);
+  const resolved: Record<string, ModelDefinition> = { ...MODEL_DEFINITIONS };
+
+  for (const [modelId, customDefinition] of Object.entries(customDefinitions)) {
+    const baseDefinition = resolved[modelId] ?? ({ id: modelId as ModelId } as PartialModelDefinition);
+    const mergedDefinition = mergeModelDefinition(modelId, baseDefinition, customDefinition);
+
+    if (mergedDefinition) {
+      resolved[modelId] = mergedDefinition;
+    }
+  }
+
+  return resolved as Record<ModelId, ModelDefinition>;
+}

package/vendor/agent-root/src/providers/registry/provider-factory.ts

@@ -9,7 +9,7 @@ import { AnthropicAdapter } from '../adapters/anthropic';
 import { OpenAICompatibleProvider, OpenAICompatibleConfig } from '../openai-compatible';
 import type { BaseProviderConfig, ModelId } from '../types';
 import type { BaseAPIAdapter } from '../adapters/base';
-import { MODEL_DEFINITIONS } from './model-config';
+import { getResolvedModelDefinitions } from './model-config';
 import { KimiAdapter } from '../adapters/kimi';
 import { ResponsesAdapter } from '../adapters/responses';
 
@@ -32,7 +32,7 @@ export class ProviderFactory {
       throw new Error('ModelId is required.');
     }
 
-    const modelConfig = MODEL_DEFINITIONS[modelId];
+    const modelConfig = getResolvedModelDefinitions()[modelId];
     if (!modelConfig) {
       throw new Error(`Unknown model: ${modelId}`);
     }
@@ -73,7 +73,7 @@ export class ProviderFactory {
    * @returns OpenAI Compatible Provider 实例
    */
   static create(modelId: ModelId, config: BaseProviderConfig): OpenAICompatibleProvider {
-    const modelConfig = MODEL_DEFINITIONS[modelId];
+    const modelConfig = getResolvedModelDefinitions()[modelId];
     if (!modelConfig) {
       throw new Error(`Unknown model: ${modelId}`);
     }
@@ -92,7 +92,11 @@ export class ProviderFactory {
     modelId: ModelId,
     logger?: OpenAICompatibleConfig['logger']
   ): BaseAPIAdapter {
-    const modelConfig = MODEL_DEFINITIONS[modelId];
+    const modelConfig = getResolvedModelDefinitions()[modelId];
+    if (!modelConfig) {
+      throw new Error(`Unknown model: ${modelId}`);
+    }
+
     if (modelConfig.provider === 'anthropic') {
       return new AnthropicAdapter({
         defaultModel: modelConfig.model,