@renxqoo/renx-code 0.0.7 → 0.0.9

package/README.md

@@ -1,6 +1,6 @@
 # Renx
 
-`renx` is a terminal AI coding assistant.
+`renx` is a terminal AI coding assistant for reading code, editing files, fixing errors, and working directly inside your current project.
 
 - npm package: `@renxqoo/renx-code`
 - command: `renx`
@@ -23,24 +23,24 @@ Start:
 renx
 ```
 
-No separate Bun installation is required for published npm installs.
+## Quick Start
 
-## Basic Usage
-
-Run `renx` inside any project directory:
+Open a project directory and run:
 
 ```bash
+cd your-project
 renx
 ```
 
 `renx` uses the current terminal directory as the workspace by default.
 
-Common things you can do:
+Common things you can ask it to do:
 
-- read and explain code
-- modify files
-- investigate errors
-- work inside the current project directory
+- explain a codebase or a single file
+- fix build or runtime errors
+- modify files directly
+- help write features, tests, and scripts
+- investigate logs and terminal output
 
 Built-in commands:
 
@@ -71,37 +71,19 @@ Default user data locations:
 - `RENX_HOME/task/`
 - `RENX_HOME/data.db`
 
-## Environment Variables
-
-Runtime:
-
-- `RENX_HOME`
-- `AGENT_MODEL`
-- `AGENT_MAX_STEPS`
-- `AGENT_MAX_RETRY_COUNT`
-- `AGENT_TOOL_CONFIRMATION_MODE`
-- `AGENT_CONVERSATION_ID`
-- `AGENT_SESSION_ID`
-
-Logging:
-
-- `AGENT_LOG_LEVEL`
-- `AGENT_LOG_FORMAT`
-- `AGENT_LOG_CONSOLE`
-- `AGENT_LOG_FILE_ENABLED`
-
-File history:
+Project config example:
 
-- `AGENT_FILE_HISTORY_ENABLED`
-- `AGENT_FILE_HISTORY_MAX_PER_FILE`
-- `AGENT_FILE_HISTORY_MAX_AGE_DAYS`
-- `AGENT_FILE_HISTORY_MAX_TOTAL_MB`
+```text
+your-project/.renx/config.json
+```
 
-Provider API keys are still passed through their own environment variables, for example:
+Global config example:
 
-- `GLM_API_KEY`
+```text
+~/.renx/config.json
+```
 
-## Config Example
+## Basic Config Example
 
 ```json
 {
@@ -127,14 +109,92 @@ Provider API keys are still passed through their own environment variables, for
 }
 ```
 
-Project config example:
+## Custom Model Config
 
-```text
-your-project/.renx/config.json
+You can define your own model in global or project `config.json` and then point `agent.defaultModel` to it.
+
+Example:
+
+```json
+{
+  "agent": {
+    "defaultModel": "my-openai-compatible"
+  },
+  "models": {
+    "my-openai-compatible": {
+      "provider": "openai",
+      "name": "My OpenAI Compatible",
+      "baseURL": "https://example.com/v1",
+      "endpointPath": "/chat/completions",
+      "envApiKey": "MY_API_KEY",
+      "envBaseURL": "MY_API_BASE",
+      "model": "my-model",
+      "max_tokens": 8000,
+      "LLMMAX_TOKENS": 128000,
+      "features": ["streaming", "function-calling"]
+    },
+    "gpt-5.4": {
+      "baseURL": "https://my-proxy.example.com/v1"
+    }
+  }
+}
 ```
 
-Global config example:
+This supports both:
 
-```text
-~/.renx/config.json
+- adding a completely new model
+- overriding part of a built-in model, such as `baseURL`
+
+## Environment Variables
+
+Runtime:
+
+- `RENX_HOME`
+- `AGENT_MODEL`
+- `AGENT_MAX_STEPS`
+- `AGENT_MAX_RETRY_COUNT`
+- `AGENT_TOOL_CONFIRMATION_MODE`
+- `AGENT_CONVERSATION_ID`
+- `AGENT_SESSION_ID`
+
+Logging:
+
+- `AGENT_LOG_LEVEL`
+- `AGENT_LOG_FORMAT`
+- `AGENT_LOG_CONSOLE`
+- `AGENT_LOG_FILE_ENABLED`
+
+File history:
+
+- `AGENT_FILE_HISTORY_ENABLED`
+- `AGENT_FILE_HISTORY_MAX_PER_FILE`
+- `AGENT_FILE_HISTORY_MAX_AGE_DAYS`
+- `AGENT_FILE_HISTORY_MAX_TOTAL_MB`
+
+Custom models:
+
+- `RENX_CUSTOM_MODELS_JSON`
+
+Provider API keys are passed through their own environment variables, for example:
+
+- `OPENAI_API_KEY`
+- `GLM_API_KEY`
+- `QWEN_API_KEY`
+
+## Publish
+
+Useful local release commands:
+
+```bash
+npm run pack:dry
+npm run pack:tgz
+npm run publish:patch
+npm run publish:minor
+npm run publish:major
 ```
+
+Version rules:
+
+- `publish:patch`: small fix, `0.0.1`
+- `publish:minor`: new feature, `0.1.0`
+- `publish:major`: breaking change or refactor, `1.0.0`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@renxqoo/renx-code",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "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;