@renxqoo/renx-code 0.0.6 → 0.0.8

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';