@renxqoo/renx-code 0.0.7 → 0.0.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@renxqoo/renx-code",
-  "version": "0.0.7",
+  "version": "0.0.8",
   "module": "src/index.tsx",
   "type": "module",
   "private": false,

package/vendor/agent-root/src/config/__tests__/load-config-to-env.test.ts

@@ -25,6 +25,7 @@ describe('loadConfigToEnv', () => {
     delete process.env.AGENT_TOOL_CONFIRMATION_MODE;
     delete process.env.AGENT_MODEL;
     delete process.env.AGENT_MAX_STEPS;
+    delete process.env.RENX_CUSTOM_MODELS_JSON;
   });
 
   afterEach(() => {
@@ -126,4 +127,112 @@ describe('loadConfigToEnv', () => {
     expect(process.env.AGENT_MODEL).toBe('qwen3.5-max');
     expect(process.env.AGENT_MAX_STEPS).toBe('100');
   });
+
+  it('should merge custom models into RENX_CUSTOM_MODELS_JSON', () => {
+    fs.mkdirSync(globalDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(globalDir, 'config.json'),
+      JSON.stringify({
+        models: {
+          'shared-model': {
+            provider: 'openai',
+            name: 'Shared Model',
+            baseURL: 'https://global.example.com/v1',
+            endpointPath: '/chat/completions',
+            envApiKey: 'SHARED_API_KEY',
+            envBaseURL: 'SHARED_API_BASE',
+            model: 'shared-global',
+            max_tokens: 4096,
+            LLMMAX_TOKENS: 64000,
+            features: ['streaming'],
+          },
+        },
+      })
+    );
+
+    const projectConfigDir = path.join(tmpDir, '.renx');
+    fs.mkdirSync(projectConfigDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(projectConfigDir, 'config.json'),
+      JSON.stringify({
+        models: {
+          'shared-model': {
+            baseURL: 'https://project.example.com/v1',
+            model: 'shared-project',
+          },
+          'project-model': {
+            provider: 'openai',
+            name: 'Project Model',
+            baseURL: 'https://project-only.example.com/v1',
+            endpointPath: '/responses',
+            envApiKey: 'PROJECT_API_KEY',
+            envBaseURL: 'PROJECT_API_BASE',
+            model: 'project-model',
+            max_tokens: 8000,
+            LLMMAX_TOKENS: 128000,
+            features: ['streaming', 'function-calling'],
+          },
+        },
+      })
+    );
+
+    loadConfigToEnv({ projectRoot: tmpDir, globalDir });
+
+    const models = JSON.parse(process.env.RENX_CUSTOM_MODELS_JSON ?? '{}') as Record<
+      string,
+      Record<string, unknown>
+    >;
+
+    expect(models['shared-model']).toMatchObject({
+      provider: 'openai',
+      baseURL: 'https://project.example.com/v1',
+      model: 'shared-project',
+    });
+    expect(models['project-model']).toMatchObject({
+      endpointPath: '/responses',
+    });
+  });
+
+  it('should keep existing RENX_CUSTOM_MODELS_JSON values over config files', () => {
+    process.env.RENX_CUSTOM_MODELS_JSON = JSON.stringify({
+      'shared-model': {
+        baseURL: 'https://env.example.com/v1',
+        model: 'env-model',
+      },
+    });
+
+    fs.mkdirSync(globalDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(globalDir, 'config.json'),
+      JSON.stringify({
+        models: {
+          'shared-model': {
+            provider: 'openai',
+            name: 'Shared Model',
+            baseURL: 'https://global.example.com/v1',
+            endpointPath: '/chat/completions',
+            envApiKey: 'SHARED_API_KEY',
+            envBaseURL: 'SHARED_API_BASE',
+            model: 'shared-global',
+            max_tokens: 4096,
+            LLMMAX_TOKENS: 64000,
+            features: ['streaming'],
+          },
+        },
+      })
+    );
+
+    loadConfigToEnv({ projectRoot: tmpDir, globalDir });
+
+    const models = JSON.parse(process.env.RENX_CUSTOM_MODELS_JSON ?? '{}') as Record<
+      string,
+      Record<string, unknown>
+    >;
+    expect(models['shared-model']).toMatchObject({
+      baseURL: 'https://env.example.com/v1',
+      model: 'env-model',
+      provider: 'openai',
+      envApiKey: 'SHARED_API_KEY',
+    });
+  });
 });

package/vendor/agent-root/src/config/__tests__/loader.test.ts

@@ -144,6 +144,74 @@ describe('Renx Config Loader', () => {
       expect(config.sources.global).toBe(path.join(globalDir, 'config.json'));
       expect(config.sources.project).toBe(path.join(projectConfigDir, 'config.json'));
     });
+
+    it('should merge custom models from global and project config', () => {
+      fs.mkdirSync(globalDir, { recursive: true });
+      fs.writeFileSync(
+        path.join(globalDir, 'config.json'),
+        JSON.stringify({
+          models: {
+            'shared-model': {
+              provider: 'openai',
+              name: 'Shared Model',
+              baseURL: 'https://global.example.com/v1',
+              endpointPath: '/chat/completions',
+              envApiKey: 'SHARED_API_KEY',
+              envBaseURL: 'SHARED_API_BASE',
+              model: 'shared-global',
+              max_tokens: 4096,
+              LLMMAX_TOKENS: 32000,
+              features: ['streaming'],
+            },
+          },
+        })
+      );
+
+      const projectConfigDir = path.join(tmpDir, '.renx');
+      fs.mkdirSync(projectConfigDir, { recursive: true });
+      fs.writeFileSync(
+        path.join(projectConfigDir, 'config.json'),
+        JSON.stringify({
+          models: {
+            'shared-model': {
+              baseURL: 'https://project.example.com/v1',
+              model: 'shared-project',
+            },
+            'project-model': {
+              provider: 'openai',
+              name: 'Project Model',
+              baseURL: 'https://project-only.example.com/v1',
+              endpointPath: '/responses',
+              envApiKey: 'PROJECT_API_KEY',
+              envBaseURL: 'PROJECT_API_BASE',
+              model: 'project-model',
+              max_tokens: 8000,
+              LLMMAX_TOKENS: 128000,
+              features: ['streaming', 'function-calling'],
+            },
+          },
+        })
+      );
+
+      const config = loadConfig({
+        projectRoot: tmpDir,
+        globalDir,
+        loadEnv: false,
+        env: { RENX_HOME: renxHome },
+      });
+
+      expect(config.models['shared-model']).toMatchObject({
+        provider: 'openai',
+        name: 'Shared Model',
+        baseURL: 'https://project.example.com/v1',
+        model: 'shared-project',
+        envApiKey: 'SHARED_API_KEY',
+      });
+      expect(config.models['project-model']).toMatchObject({
+        provider: 'openai',
+        endpointPath: '/responses',
+      });
+    });
   });
 
   describe('loadConfig with env overrides', () => {
@@ -190,6 +258,52 @@ describe('Renx Config Loader', () => {
       expect(config.log.format).toBe('json');
       expect(config.agent.confirmationMode).toBe('auto-deny');
     });
+
+    it('should let RENX_CUSTOM_MODELS_JSON override file-based model config', () => {
+      const projectConfigDir = path.join(tmpDir, '.renx');
+      fs.mkdirSync(projectConfigDir, { recursive: true });
+      fs.writeFileSync(
+        path.join(projectConfigDir, 'config.json'),
+        JSON.stringify({
+          models: {
+            'custom-openai': {
+              provider: 'openai',
+              name: 'Custom OpenAI',
+              baseURL: 'https://file.example.com/v1',
+              endpointPath: '/chat/completions',
+              envApiKey: 'CUSTOM_API_KEY',
+              envBaseURL: 'CUSTOM_API_BASE',
+              model: 'file-model',
+              max_tokens: 4096,
+              LLMMAX_TOKENS: 64000,
+              features: ['streaming'],
+            },
+          },
+        })
+      );
+
+      const config = loadConfig({
+        projectRoot: tmpDir,
+        globalDir,
+        env: {
+          RENX_HOME: renxHome,
+          RENX_CUSTOM_MODELS_JSON: JSON.stringify({
+            'custom-openai': {
+              baseURL: 'https://env.example.com/v1',
+              model: 'env-model',
+              features: ['streaming', 'function-calling'],
+            },
+          }),
+        },
+      });
+
+      expect(config.models['custom-openai']).toMatchObject({
+        provider: 'openai',
+        baseURL: 'https://env.example.com/v1',
+        model: 'env-model',
+        features: ['streaming', 'function-calling'],
+      });
+    });
   });
 
   describe('writeProjectConfig', () => {

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

@@ -19,6 +19,7 @@ export type {
   StorageConfig,
   FileHistoryConfig,
   AgentConfig,
+  ConfigModelDefinition,
 } from './types';
 
 // Config loaders

package/vendor/agent-root/src/config/loader.ts

@@ -7,10 +7,17 @@ import {
   resolveRenxLogsDir,
   resolveRenxStorageRoot,
 } from './paths';
-import type { LoadConfigOptions, LogConfig, RenxConfig, ResolvedConfig } from './types';
+import type {
+  ConfigModelDefinition,
+  LoadConfigOptions,
+  LogConfig,
+  RenxConfig,
+  ResolvedConfig,
+} from './types';
 
 const PROJECT_DIR_NAME = '.renx';
 const CONFIG_FILENAME = 'config.json';
+const CUSTOM_MODELS_ENV_VAR = 'RENX_CUSTOM_MODELS_JSON';
 
 const DEFAULTS: RenxConfig = {
   log: {
@@ -57,6 +64,37 @@ function readJsonFile<T>(filePath: string): T | null {
   }
 }
 
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function parseCustomModelsEnv(
+  raw: string | undefined
+): Record<string, ConfigModelDefinition> | null {
+  if (!raw) {
+    return null;
+  }
+
+  try {
+    const parsed = JSON.parse(raw) as unknown;
+    if (!isPlainObject(parsed)) {
+      return null;
+    }
+
+    const result: Record<string, ConfigModelDefinition> = {};
+    for (const [modelId, modelConfig] of Object.entries(parsed)) {
+      if (!isPlainObject(modelConfig)) {
+        continue;
+      }
+      result[modelId] = modelConfig as ConfigModelDefinition;
+    }
+
+    return result;
+  } catch {
+    return null;
+  }
+}
+
 function parseLogLevelValue(raw: string | undefined): LogLevel | null {
   if (!raw) {
     return null;
@@ -242,6 +280,11 @@ function applyEnvOverrides(config: RenxConfig, env: NodeJS.ProcessEnv): RenxConf
     }
   }
 
+  const customModels = parseCustomModelsEnv(env[CUSTOM_MODELS_ENV_VAR]);
+  if (customModels) {
+    result.models = deepMerge(result.models ?? {}, customModels);
+  }
+
   return result;
 }
 
@@ -281,6 +324,7 @@ function resolveConfig(
       confirmationMode: merged.agent?.confirmationMode ?? 'manual',
       defaultModel: merged.agent?.defaultModel ?? 'qwen3.5-plus',
     },
+    models: merged.models ?? {},
     sources,
   };
 }
@@ -324,25 +368,30 @@ export function loadConfigToEnv(options: LoadConfigOptions = {}): string[] {
   const loadedFiles: string[] = [];
 
   const protectedEnvKeys = new Set(Object.keys(process.env));
+  const protectedCustomModels = parseCustomModelsEnv(process.env[CUSTOM_MODELS_ENV_VAR]) ?? {};
 
   const globalConfigPath = ensureGlobalConfigFile(globalDir);
   const globalConfig = readJsonFile<RenxConfig>(globalConfigPath);
   if (globalConfig) {
-    applyConfigToEnv(globalConfig, protectedEnvKeys);
+    applyConfigToEnv(globalConfig, protectedEnvKeys, protectedCustomModels);
     loadedFiles.push(globalConfigPath);
   }
 
   const projectConfigPath = path.join(projectRoot, PROJECT_DIR_NAME, CONFIG_FILENAME);
   const projectConfig = readJsonFile<RenxConfig>(projectConfigPath);
   if (projectConfig) {
-    applyConfigToEnv(projectConfig, protectedEnvKeys);
+    applyConfigToEnv(projectConfig, protectedEnvKeys, protectedCustomModels);
     loadedFiles.push(projectConfigPath);
   }
 
   return loadedFiles;
 }
 
-function applyConfigToEnv(config: RenxConfig, protectedEnvKeys: Set<string>): void {
+function applyConfigToEnv(
+  config: RenxConfig,
+  protectedEnvKeys: Set<string>,
+  protectedCustomModels: Record<string, ConfigModelDefinition>
+): void {
   const setIfUnset = (key: string, value: string | undefined) => {
     if (value !== undefined && !protectedEnvKeys.has(key)) {
       process.env[key] = value;
@@ -397,6 +446,20 @@ function applyConfigToEnv(config: RenxConfig, protectedEnvKeys: Set<string>): vo
       config.agent.maxSteps !== undefined ? String(config.agent.maxSteps) : undefined
     );
   }
+
+  if (config.models && Object.keys(config.models).length > 0) {
+    const existingModels = parseCustomModelsEnv(process.env[CUSTOM_MODELS_ENV_VAR]) ?? {};
+    const mergedModels = deepMerge(existingModels, config.models);
+
+    if (protectedEnvKeys.has(CUSTOM_MODELS_ENV_VAR)) {
+      process.env[CUSTOM_MODELS_ENV_VAR] = JSON.stringify(
+        deepMerge(mergedModels, protectedCustomModels)
+      );
+      return;
+    }
+
+    process.env[CUSTOM_MODELS_ENV_VAR] = JSON.stringify(mergedModels);
+  }
 }
 
 export function getGlobalConfigDir(): string {

package/vendor/agent-root/src/config/types.ts

@@ -1,4 +1,5 @@
 import type { LogLevel } from '../logger';
+import type { ProviderType } from '../providers/types';
 
 export interface LogConfig {
   level?: 'TRACE' | 'DEBUG' | 'INFO' | 'WARN' | 'ERROR' | 'FATAL';
@@ -24,10 +25,34 @@ export interface AgentConfig {
   defaultModel?: string;
 }
 
+export interface ConfigModelDefinition {
+  provider?: ProviderType;
+  name?: string;
+  endpointPath?: string;
+  envApiKey?: string;
+  envBaseURL?: string;
+  baseURL?: string;
+  model?: string;
+  max_tokens?: number;
+  LLMMAX_TOKENS?: number;
+  features?: string[];
+  modalities?: {
+    image?: boolean;
+    audio?: boolean;
+    video?: boolean;
+  };
+  temperature?: number;
+  tool_stream?: boolean;
+  thinking?: boolean;
+  timeout?: number;
+  model_reasoning_effort?: 'low' | 'medium' | 'high';
+}
+
 export interface RenxConfig {
   log?: LogConfig;
   storage?: StorageConfig;
   agent?: AgentConfig;
+  models?: Record<string, ConfigModelDefinition>;
 }
 
 export interface ResolvedConfig {
@@ -56,6 +81,7 @@ export interface ResolvedConfig {
     confirmationMode: 'manual' | 'auto-approve' | 'auto-deny';
     defaultModel: string;
   };
+  models: Record<string, ConfigModelDefinition>;
   sources: {
     global: string | null;
     project: string | null;

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,

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

@@ -6,11 +6,11 @@
  */
 
 import { ProviderFactory } from './registry/provider-factory';
-import { MODEL_DEFINITIONS } from './registry/model-config';
+import { getResolvedModelDefinitions, MODEL_DEFINITIONS } from './registry/model-config';
 import type { ModelConfig, ModelId, ProviderType } from './types';
 
 // 导出类型
-export type { ProviderType, ModelId, ModelConfig } from './types';
+export type { ProviderType, BuiltinModelId, ModelId, ModelConfig } from './types';
 
 // 导出模型配置
 export { MODEL_DEFINITIONS as MODEL_CONFIGS } from './registry/model-config';
@@ -47,7 +47,7 @@ export class ProviderRegistry {
    * 获取所有模型配置
    */
   static listModels(): ModelConfig[] {
-    return Object.values(MODEL_DEFINITIONS).map((config) => ({
+    return Object.values(getResolvedModelDefinitions()).map((config) => ({
       ...config,
       apiKey: undefined,
     }));
@@ -57,7 +57,7 @@ export class ProviderRegistry {
    * 获取指定厂商的所有模型
    */
   static listModelsByProvider(provider: ProviderType): ModelConfig[] {
-    return Object.values(MODEL_DEFINITIONS)
+    return Object.values(getResolvedModelDefinitions())
       .filter((m) => m.provider === provider)
       .map((config) => ({
         ...config,
@@ -69,14 +69,14 @@ export class ProviderRegistry {
    * 获取所有模型 ID
    */
   static getModelIds(): ModelId[] {
-    return Object.keys(MODEL_DEFINITIONS) as ModelId[];
+    return Object.keys(getResolvedModelDefinitions()) as ModelId[];
   }
 
   /**
    * 获取指定模型的配置
    */
   static getModelConfig(modelId: ModelId): ModelConfig {
-    const config = MODEL_DEFINITIONS[modelId];
+    const config = getResolvedModelDefinitions()[modelId];
     if (!config) {
       throw new Error(`Unknown model: ${modelId}`);
     }
@@ -87,7 +87,7 @@ export class ProviderRegistry {
    * 获取模型显示名称
    */
   static getModelName(modelId: ModelId): string {
-    return MODEL_DEFINITIONS[modelId]?.name || modelId;
+    return getResolvedModelDefinitions()[modelId]?.name || modelId;
   }
 
   /**
@@ -95,7 +95,7 @@ export class ProviderRegistry {
    */
   static getProviders(): ProviderType[] {
     const providers = new Set<ProviderType>();
-    Object.values(MODEL_DEFINITIONS).forEach((m) => providers.add(m.provider));
+    Object.values(getResolvedModelDefinitions()).forEach((m) => providers.add(m.provider));
     return Array.from(providers);
   }
 }

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

@@ -69,4 +69,4 @@ export {
 export type { BackoffConfig } from './errors';
 
 // Registry 相关类型
-export type { ProviderType, ModelId, ModelConfig } from './registry';
+export type { ProviderType, BuiltinModelId, ModelId, ModelConfig } from './registry';

package/vendor/agent-root/src/providers/types/registry.ts

@@ -1,11 +1,9 @@
 /**
- * Registry 相关类型定义
- *
- * Provider Registry 相关的类型定义
+ * Registry related type definitions.
  */
 
 /**
- * Provider 厂商类型
+ * Supported provider types.
  */
 export type ProviderType =
   | 'anthropic'
@@ -18,22 +16,14 @@ export type ProviderType =
   | 'qwen';
 
 /**
- * 模型唯一标识
+ * Built-in model IDs shipped with the CLI.
  */
-export type ModelId =
-  // Anthropic 系列
+export type BuiltinModelId =
   | 'claude-opus-4.6'
-  // GLM 系列
   | 'glm-4.7'
-  // MiniMax 系列
   | 'minimax-2.5'
-  // Kimi 系列
   | 'kimi-k2.5'
-  // DeepSeek 系列
-  // | 'deepseek-chat'
-  // GLM 5.0 系列
   | 'glm-5'
-  // Qwen 系列
   | 'qwen3.5-plus'
   | 'qwen-kimi-k2.5'
   | 'qwen-glm-5'
@@ -45,42 +35,32 @@ export type ModelId =
   | 'openrouter/hunter-alpha';
 
 /**
- * 模型配置
+ * Model IDs can include built-ins and user-defined config.json entries.
+ */
+export type ModelId = BuiltinModelId | (string & {});
+
+/**
+ * Model configuration.
  */
 export interface ModelConfig {
-  /** 模型唯一标识 */
   id: ModelId;
-  /** 所属厂商 */
   provider: ProviderType;
-  /** 显示名称 */
   name: string;
-  /** API 端点路径 */
   endpointPath: string;
-  /** API Key 环境变量名 */
   envApiKey: string;
-  /** Base URL 环境变量名 */
   envBaseURL: string;
-  /** API 基础 URL */
   baseURL: string;
-  /** API 模型名称 */
   model: string;
-  /** 最大输出 token 数 */
   max_tokens: number;
-  /** 最大上下文 token 数 */
   LLMMAX_TOKENS: number;
-  /** 支持的特性 */
   features: string[];
-  /** 多模态输入能力 */
   modalities?: {
     image?: boolean;
     audio?: boolean;
     video?: boolean;
   };
-  /** API 密钥（可选） */
   apiKey?: string;
-  /** 温度（可选） */
   temperature?: number;
-  /** 默认工具流式输出（可选） */
   tool_stream?: boolean;
   thinking?: boolean;
   timeout?: number;