@gengjiawen/os-init 1.18.1 → 1.19.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## [1.19.0](https://github.com/gengjiawen/os-init/compare/v1.18.1...v1.19.0) (2026-03-19)
+
+
+### Features
+
+* refresh codex model catalog during setup ([9ed724a](https://github.com/gengjiawen/os-init/commit/9ed724accda9901a813bb9265895db6879d406bb))
+
+
+### Bug Fixes
+
+* add model metadata to opencode config ([59ade2c](https://github.com/gengjiawen/os-init/commit/59ade2c9e9daa307de56d30968a1c3e8977ea945))
+
 ## [1.18.1](https://github.com/gengjiawen/os-init/compare/v1.18.0...v1.18.1) (2026-03-16)
 
 

package/bin/bin.js

@@ -65,9 +65,11 @@ program
       return
     }
     try {
-      const { configPath, authPath } = writeCodexConfig(apiKey)
+      const { configPath, authPath, catalogPath } =
+        await writeCodexConfig(apiKey)
       console.log(`Codex config written to: ${configPath}`)
       console.log(`Codex auth written to: ${authPath}`)
+      console.log(`Codex model catalog written to: ${catalogPath}`)
       await installCodexDeps()
     } catch (err) {
       console.error('Failed to setup Codex:', err.message)
@@ -146,7 +148,7 @@ program
           : 'Setting up Claude Code + Codex + OpenCode...\n'
       )
 
-      const result = writeAllAgentsConfig(apiKey, { full })
+      const result = await writeAllAgentsConfig(apiKey, { full })
 
       console.log('Claude Code:')
       console.log(`  Settings written to: ${result.claude.settingsPath}`)
@@ -157,6 +159,7 @@ program
       console.log('\nCodex:')
       console.log(`  Config written to: ${result.codex.configPath}`)
       console.log(`  Auth written to: ${result.codex.authPath}`)
+      console.log(`  Model catalog written to: ${result.codex.catalogPath}`)
 
       console.log('\nOpenCode:')
       console.log(`  Config written to: ${result.opencode.configPath}`)

package/build/all-agents.d.ts

@@ -9,6 +9,7 @@ export interface AllAgentsResult {
     codex: {
         configPath: string;
         authPath: string;
+        catalogPath: string;
     };
     opencode: {
         configPath: string;
@@ -18,5 +19,5 @@ export interface AllAgentsResult {
         settingsPath: string;
     };
 }
-export declare function writeAllAgentsConfig(apiKey: string, options?: AllAgentsOptions): AllAgentsResult;
+export declare function writeAllAgentsConfig(apiKey: string, options?: AllAgentsOptions): Promise<AllAgentsResult>;
 export declare function installAllAgentsDeps(options?: AllAgentsOptions): Promise<void>;

package/build/all-agents.js

@@ -6,9 +6,9 @@ const claude_code_1 = require("./claude-code");
 const codex_1 = require("./codex");
 const gemini_cli_1 = require("./gemini-cli");
 const opencode_1 = require("./opencode");
-function writeAllAgentsConfig(apiKey, options = {}) {
+async function writeAllAgentsConfig(apiKey, options = {}) {
     const claudeResult = (0, claude_code_1.writeClaudeConfig)(apiKey);
-    const codexResult = (0, codex_1.writeCodexConfig)(apiKey);
+    const codexResult = await (0, codex_1.writeCodexConfig)(apiKey);
     const opencodeResult = (0, opencode_1.writeOpencodeConfig)(apiKey);
     const result = {
         claude: claudeResult,

package/build/codex.d.ts

@@ -1,5 +1,6 @@
-export declare function writeCodexConfig(apiKey: string): {
+export declare function writeCodexConfig(apiKey: string): Promise<{
     configPath: string;
     authPath: string;
-};
+    catalogPath: string;
+}>;
 export declare function installCodexDeps(): Promise<void>;

package/build/codex.js

@@ -8,10 +8,17 @@ const os = require("os");
 const TOML = require("@iarna/toml");
 const execa_1 = require("execa");
 const utils_1 = require("./utils");
+const CODEX_BASE_URL = 'https://ai.gengjiawen.com/api/openai';
+const CODEX_MODEL_CATALOG_CONFIG_PATH = '~/.codex/remote-model-catalog.json';
+const CODEX_MODEL_CATALOG_FILENAME = 'remote-model-catalog.json';
 function getCodexConfigDir() {
     return path.join(os.homedir(), '.codex');
 }
-const CODEX_CONFIG_TOML_TEMPLATE = `model_provider = "jw"
+function getCodexModelCatalogPath() {
+    return path.join(getCodexConfigDir(), CODEX_MODEL_CATALOG_FILENAME);
+}
+function getCodexConfigTomlTemplate() {
+    return `model_provider = "jw"
 model = "gpt-5.4"
 model_reasoning_effort = "high"
 plan_mode_reasoning_effort = "xhigh"
@@ -19,12 +26,14 @@ model_auto_compact_token_limit = 131072
 disable_response_storage = true
 preferred_auth_method = "apikey"
 service_tier = "fast"
+model_catalog_json = "${CODEX_MODEL_CATALOG_CONFIG_PATH}"
 
 [model_providers.jw]
 name = "jw"
-base_url = "https://ai.gengjiawen.com/api/openai"
+base_url = "${CODEX_BASE_URL}"
 wire_api = "responses"
 `;
+}
 function isTomlTable(value) {
     return (value !== undefined &&
         typeof value === 'object' &&
@@ -44,21 +53,44 @@ function mergeTomlTables(existingConfig, templateConfig) {
 }
 function getMergedCodexConfig(existingContent) {
     const existingConfig = TOML.parse(existingContent);
-    const templateConfig = TOML.parse(CODEX_CONFIG_TOML_TEMPLATE);
+    const templateConfig = TOML.parse(getCodexConfigTomlTemplate());
     return TOML.stringify(mergeTomlTables(existingConfig, templateConfig));
 }
-function writeCodexConfig(apiKey) {
+async function refreshCodexModelCatalog(apiKey) {
+    if (typeof fetch !== 'function') {
+        throw new Error('Global fetch API is unavailable in this Node.js runtime.');
+    }
+    const response = await fetch(`${CODEX_BASE_URL}/models`, {
+        headers: {
+            Accept: 'application/json',
+            Authorization: `Bearer ${apiKey}`,
+            'User-Agent': '@gengjiawen/os-init',
+        },
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to refresh Codex model catalog: ${response.status} ${response.statusText}`);
+    }
+    const catalog = (await response.json());
+    if (!Array.isArray(catalog?.models) || catalog.models.length === 0) {
+        throw new Error('Failed to refresh Codex model catalog: response does not contain any models.');
+    }
+    const catalogPath = getCodexModelCatalogPath();
+    fs.writeFileSync(catalogPath, `${JSON.stringify(catalog, null, 2)}\n`);
+    return catalogPath;
+}
+async function writeCodexConfig(apiKey) {
     const configDir = getCodexConfigDir();
     (0, utils_1.ensureDir)(configDir);
+    const catalogPath = await refreshCodexModelCatalog(apiKey);
     const configPath = path.join(configDir, 'config.toml');
     const configContent = fs.existsSync(configPath)
         ? getMergedCodexConfig(fs.readFileSync(configPath, 'utf8'))
-        : CODEX_CONFIG_TOML_TEMPLATE;
+        : getCodexConfigTomlTemplate();
     fs.writeFileSync(configPath, configContent);
     const authPath = path.join(configDir, 'auth.json');
     const authContent = JSON.stringify({ OPENAI_API_KEY: apiKey }, null, 2);
     fs.writeFileSync(authPath, authContent);
-    return { configPath, authPath };
+    return { configPath, authPath, catalogPath };
 }
 async function installCodexDeps() {
     const packages = ['@openai/codex'];

package/build/opencode.js

@@ -12,6 +12,16 @@ const OPENCODE_MODEL_ID = 'code';
 const OPENCODE_GLM_MODEL_ID = 'glm';
 const OPENCODE_KIMI_MODEL_ID = 'kimi';
 const OPENCODE_BASE_URL = 'https://ai.gengjiawen.com/api/openai/v1';
+function createOpencodeModelConfig(modelId) {
+    return {
+        name: modelId,
+        attachment: true,
+        modalities: {
+            input: ['text', 'image'],
+            output: ['text'],
+        },
+    };
+}
 function getOpencodeConfigDir() {
     return path.join(os.homedir(), '.config', 'opencode');
 }
@@ -29,15 +39,9 @@ function writeOpencodeConfig(apiKey) {
                     apiKey,
                 },
                 models: {
-                    [OPENCODE_MODEL_ID]: {
-                        name: OPENCODE_MODEL_ID,
-                    },
-                    [OPENCODE_GLM_MODEL_ID]: {
-                        name: OPENCODE_GLM_MODEL_ID,
-                    },
-                    [OPENCODE_KIMI_MODEL_ID]: {
-                        name: OPENCODE_KIMI_MODEL_ID,
-                    },
+                    [OPENCODE_MODEL_ID]: createOpencodeModelConfig(OPENCODE_MODEL_ID),
+                    [OPENCODE_GLM_MODEL_ID]: createOpencodeModelConfig(OPENCODE_GLM_MODEL_ID),
+                    [OPENCODE_KIMI_MODEL_ID]: createOpencodeModelConfig(OPENCODE_KIMI_MODEL_ID),
                 },
             },
         },

package/libs/all-agents.test.ts

@@ -12,12 +12,18 @@ describe('writeAllAgentsConfig', () => {
   let tempHome: string
   let homedirSpy: jest.SpiedFunction<typeof os.homedir>
   let originalAppData: string | undefined
+  let originalFetch: typeof global.fetch | undefined
 
   beforeEach(() => {
     tempHome = fs.mkdtempSync(path.join(os.tmpdir(), 'os-init-all-agents-'))
     homedirSpy = jest.spyOn(os, 'homedir').mockReturnValue(tempHome)
     originalAppData = process.env.APPDATA
+    originalFetch = global.fetch
     process.env.APPDATA = path.join(tempHome, 'AppData', 'Roaming')
+    global.fetch = jest.fn().mockResolvedValue({
+      ok: true,
+      json: async () => ({ models: [{ id: 'gpt-5.4' }] }),
+    }) as unknown as typeof global.fetch
   })
 
   afterEach(() => {
@@ -27,21 +33,27 @@ describe('writeAllAgentsConfig', () => {
     } else {
       process.env.APPDATA = originalAppData
     }
+    if (originalFetch === undefined) {
+      global.fetch = undefined as unknown as typeof global.fetch
+    } else {
+      global.fetch = originalFetch
+    }
     fs.rmSync(tempHome, { recursive: true, force: true })
   })
 
-  test('writes Claude, Codex and OpenCode config by default', () => {
-    const result = writeAllAgentsConfig('test-api-key')
+  test('writes Claude, Codex and OpenCode config by default', async () => {
+    const result = await writeAllAgentsConfig('test-api-key')
 
     expect(fs.existsSync(result.claude.settingsPath)).toBe(true)
     expect(fs.existsSync(result.codex.configPath)).toBe(true)
     expect(fs.existsSync(result.codex.authPath)).toBe(true)
+    expect(fs.existsSync(result.codex.catalogPath)).toBe(true)
     expect(fs.existsSync(result.opencode.configPath)).toBe(true)
     expect(result.gemini).toBeUndefined()
   })
 
-  test('includes Gemini config when full option is enabled', () => {
-    const result = writeAllAgentsConfig('test-api-key', { full: true })
+  test('includes Gemini config when full option is enabled', async () => {
+    const result = await writeAllAgentsConfig('test-api-key', { full: true })
 
     expect(result.gemini).toBeDefined()
     expect(fs.existsSync(result.gemini!.envPath)).toBe(true)

package/libs/all-agents.ts

@@ -10,18 +10,18 @@ export interface AllAgentsOptions {
 
 export interface AllAgentsResult {
   claude: { settingsPath: string; vscodeSettingsPath: string }
-  codex: { configPath: string; authPath: string }
+  codex: { configPath: string; authPath: string; catalogPath: string }
   opencode: { configPath: string }
   gemini?: { envPath: string; settingsPath: string }
 }
 
 /** Write configuration for the combined setup (Claude Code + Codex + OpenCode, optional Gemini CLI). */
-export function writeAllAgentsConfig(
+export async function writeAllAgentsConfig(
   apiKey: string,
   options: AllAgentsOptions = {}
-): AllAgentsResult {
+): Promise<AllAgentsResult> {
   const claudeResult = writeClaudeConfig(apiKey)
-  const codexResult = writeCodexConfig(apiKey)
+  const codexResult = await writeCodexConfig(apiKey)
   const opencodeResult = writeOpencodeConfig(apiKey)
 
   const result: AllAgentsResult = {

package/libs/codex.test.ts

@@ -12,27 +12,51 @@ import { writeCodexConfig } from './codex'
 describe('writeCodexConfig', () => {
   let tempHome: string
   let homedirSpy: jest.SpiedFunction<typeof os.homedir>
+  let originalFetch: typeof global.fetch | undefined
+
+  function mockCatalogFetch(
+    catalog: { models: Array<Record<string, unknown>> } = {
+      models: [{ id: 'gpt-5.4' }],
+    }
+  ): jest.Mock {
+    const fetchMock = jest.fn().mockResolvedValue({
+      ok: true,
+      json: async () => catalog,
+    })
+    global.fetch = fetchMock as unknown as typeof global.fetch
+    return fetchMock
+  }
 
   beforeEach(() => {
     tempHome = fs.mkdtempSync(path.join(os.tmpdir(), 'os-init-codex-'))
     homedirSpy = jest.spyOn(os, 'homedir').mockReturnValue(tempHome)
+    originalFetch = global.fetch
+    mockCatalogFetch()
   })
 
   afterEach(() => {
     homedirSpy.mockRestore()
+    if (originalFetch === undefined) {
+      global.fetch = undefined as unknown as typeof global.fetch
+    } else {
+      global.fetch = originalFetch
+    }
     fs.rmSync(tempHome, { recursive: true, force: true })
   })
 
-  test('writes config with 128k auto compact threshold', () => {
-    const result = writeCodexConfig('test-api-key')
+  test('writes config with 128k auto compact threshold', async () => {
+    const result = await writeCodexConfig('test-api-key')
     const config = TOML.parse(fs.readFileSync(result.configPath, 'utf8')) as {
       model_auto_compact_token_limit: number
+      model_catalog_json: string
     }
 
     expect(config.model_auto_compact_token_limit).toBe(131072)
+    expect(config.model_catalog_json).toBe('~/.codex/remote-model-catalog.json')
+    expect(fs.existsSync(result.catalogPath)).toBe(true)
   })
 
-  test('merges template keys and keeps custom config', () => {
+  test('merges template keys and keeps custom config', async () => {
     const configDir = path.join(tempHome, '.codex')
     fs.mkdirSync(configDir, { recursive: true })
     const configPath = path.join(configDir, 'config.toml')
@@ -48,11 +72,12 @@ custom_model = "keep-me"
 `
     )
 
-    writeCodexConfig('test-api-key')
+    await writeCodexConfig('test-api-key')
     const config = TOML.parse(fs.readFileSync(configPath, 'utf8')) as {
       service_tier: string
       custom_flag: boolean
       model: string
+      model_catalog_json: string
       preferred_auth_method: string
       model_providers: {
         jw: {
@@ -66,6 +91,7 @@ custom_model = "keep-me"
     expect(config.service_tier).toBe('fast')
     expect(config.custom_flag).toBe(true)
     expect(config.model).toBe('gpt-5.4')
+    expect(config.model_catalog_json).toBe('~/.codex/remote-model-catalog.json')
     expect(config.preferred_auth_method).toBe('apikey')
     expect(config.model_providers.jw.base_url).toBe(
       'https://ai.gengjiawen.com/api/openai'
@@ -74,7 +100,7 @@ custom_model = "keep-me"
     expect(config.model_providers.jw.name).toBe('jw')
   })
 
-  test('adds missing keys without removing custom config', () => {
+  test('adds missing keys without removing custom config', async () => {
     const configDir = path.join(tempHome, '.codex')
     fs.mkdirSync(configDir, { recursive: true })
     const configPath = path.join(configDir, 'config.toml')
@@ -88,9 +114,10 @@ base_url = "https://example.com"
 `
     )
 
-    writeCodexConfig('test-api-key')
+    await writeCodexConfig('test-api-key')
     const config = TOML.parse(fs.readFileSync(configPath, 'utf8')) as {
       model: string
+      model_catalog_json: string
       preferred_auth_method: string
       service_tier: string
       model_providers: {
@@ -102,8 +129,66 @@ base_url = "https://example.com"
     }
 
     expect(config.model).toBe('gpt-5.4')
+    expect(config.model_catalog_json).toBe('~/.codex/remote-model-catalog.json')
     expect(config.preferred_auth_method).toBe('apikey')
     expect(config.model_providers.jw.name).toBe('jw')
     expect(config.service_tier).toBe('fast')
   })
+
+  test('refreshes remote model catalog after writing config', async () => {
+    const fetchMock = mockCatalogFetch({
+      models: [
+        { id: 'gpt-5.4' },
+        { id: 'gpt-5.4-mini' },
+        { id: 'gpt-5.3-codex' },
+      ],
+    })
+
+    const result = await writeCodexConfig('test-api-key')
+
+    expect(fetchMock).toHaveBeenCalledWith(
+      'https://ai.gengjiawen.com/api/openai/models',
+      {
+        headers: {
+          Accept: 'application/json',
+          Authorization: 'Bearer test-api-key',
+          'User-Agent': '@gengjiawen/os-init',
+        },
+      }
+    )
+
+    const catalog = JSON.parse(fs.readFileSync(result.catalogPath, 'utf8')) as {
+      models: Array<{ id: string }>
+    }
+
+    expect(catalog).toEqual({
+      models: [
+        { id: 'gpt-5.4' },
+        { id: 'gpt-5.4-mini' },
+        { id: 'gpt-5.3-codex' },
+      ],
+    })
+  })
+
+  test('throws when refreshing the remote model catalog fails', async () => {
+    global.fetch = jest.fn().mockResolvedValue({
+      ok: false,
+      status: 503,
+      statusText: 'Service Unavailable',
+    }) as unknown as typeof global.fetch
+
+    await expect(writeCodexConfig('test-api-key')).rejects.toThrow(
+      'Failed to refresh Codex model catalog: 503 Service Unavailable'
+    )
+
+    expect(fs.existsSync(path.join(tempHome, '.codex', 'config.toml'))).toBe(
+      false
+    )
+    expect(fs.existsSync(path.join(tempHome, '.codex', 'auth.json'))).toBe(
+      false
+    )
+    expect(
+      fs.existsSync(path.join(tempHome, '.codex', 'remote-model-catalog.json'))
+    ).toBe(false)
+  })
 })

package/libs/codex.ts

@@ -6,14 +6,23 @@ import { execa } from 'execa'
 import { ensureDir, commandExists, PNPM_INSTALL_ENV } from './utils'
 
 type TomlTable = ReturnType<typeof TOML.parse>
+type CodexModelCatalog = { models: unknown[] }
+
+const CODEX_BASE_URL = 'https://ai.gengjiawen.com/api/openai'
+const CODEX_MODEL_CATALOG_CONFIG_PATH = '~/.codex/remote-model-catalog.json'
+const CODEX_MODEL_CATALOG_FILENAME = 'remote-model-catalog.json'
 
 /** Return Codex configuration directory path */
 function getCodexConfigDir(): string {
   return path.join(os.homedir(), '.codex')
 }
 
-/** Template for Codex config.toml */
-const CODEX_CONFIG_TOML_TEMPLATE = `model_provider = "jw"
+function getCodexModelCatalogPath(): string {
+  return path.join(getCodexConfigDir(), CODEX_MODEL_CATALOG_FILENAME)
+}
+
+function getCodexConfigTomlTemplate(): string {
+  return `model_provider = "jw"
 model = "gpt-5.4"
 model_reasoning_effort = "high"
 plan_mode_reasoning_effort = "xhigh"
@@ -21,12 +30,14 @@ model_auto_compact_token_limit = 131072
 disable_response_storage = true
 preferred_auth_method = "apikey"
 service_tier = "fast"
+model_catalog_json = "${CODEX_MODEL_CATALOG_CONFIG_PATH}"
 
 [model_providers.jw]
 name = "jw"
-base_url = "https://ai.gengjiawen.com/api/openai"
+base_url = "${CODEX_BASE_URL}"
 wire_api = "responses"
 `
+}
 
 function isTomlTable(value: unknown): value is TomlTable {
   return (
@@ -57,30 +68,66 @@ function mergeTomlTables(
 
 function getMergedCodexConfig(existingContent: string): string {
   const existingConfig = TOML.parse(existingContent) as TomlTable
-  const templateConfig = TOML.parse(CODEX_CONFIG_TOML_TEMPLATE) as TomlTable
+  const templateConfig = TOML.parse(getCodexConfigTomlTemplate()) as TomlTable
 
   return TOML.stringify(mergeTomlTables(existingConfig, templateConfig))
 }
 
+async function refreshCodexModelCatalog(apiKey: string): Promise<string> {
+  if (typeof fetch !== 'function') {
+    throw new Error('Global fetch API is unavailable in this Node.js runtime.')
+  }
+
+  const response = await fetch(`${CODEX_BASE_URL}/models`, {
+    headers: {
+      Accept: 'application/json',
+      Authorization: `Bearer ${apiKey}`,
+      'User-Agent': '@gengjiawen/os-init',
+    },
+  })
+
+  if (!response.ok) {
+    throw new Error(
+      `Failed to refresh Codex model catalog: ${response.status} ${response.statusText}`
+    )
+  }
+
+  const catalog = (await response.json()) as CodexModelCatalog
+
+  if (!Array.isArray(catalog?.models) || catalog.models.length === 0) {
+    throw new Error(
+      'Failed to refresh Codex model catalog: response does not contain any models.'
+    )
+  }
+
+  const catalogPath = getCodexModelCatalogPath()
+  fs.writeFileSync(catalogPath, `${JSON.stringify(catalog, null, 2)}\n`)
+
+  return catalogPath
+}
+
 /** Write Codex config.toml and auth.json */
-export function writeCodexConfig(apiKey: string): {
+export async function writeCodexConfig(apiKey: string): Promise<{
   configPath: string
   authPath: string
-} {
+  catalogPath: string
+}> {
   const configDir = getCodexConfigDir()
   ensureDir(configDir)
 
+  const catalogPath = await refreshCodexModelCatalog(apiKey)
+
   const configPath = path.join(configDir, 'config.toml')
   const configContent = fs.existsSync(configPath)
     ? getMergedCodexConfig(fs.readFileSync(configPath, 'utf8'))
-    : CODEX_CONFIG_TOML_TEMPLATE
+    : getCodexConfigTomlTemplate()
   fs.writeFileSync(configPath, configContent)
 
   const authPath = path.join(configDir, 'auth.json')
   const authContent = JSON.stringify({ OPENAI_API_KEY: apiKey }, null, 2)
   fs.writeFileSync(authPath, authContent)
 
-  return { configPath, authPath }
+  return { configPath, authPath, catalogPath }
 }
 
 /** Install Codex dependency */

package/libs/opencode.test.ts

@@ -12,6 +12,15 @@ describe('writeOpencodeConfig', () => {
   let tempHome: string
   let homedirSpy: jest.SpiedFunction<typeof os.homedir>
 
+  const expectedModelConfig = (name: string) => ({
+    name,
+    attachment: true,
+    modalities: {
+      input: ['text', 'image'],
+      output: ['text'],
+    },
+  })
+
   beforeEach(() => {
     tempHome = fs.mkdtempSync(path.join(os.tmpdir(), 'os-init-opencode-'))
     homedirSpy = jest.spyOn(os, 'homedir').mockReturnValue(tempHome)
@@ -40,15 +49,15 @@ describe('writeOpencodeConfig', () => {
       'https://ai.gengjiawen.com/api/openai/v1'
     )
     expect(config.provider.MyCustomProvider.options.apiKey).toBe('test-api-key')
-    expect(config.provider.MyCustomProvider.models.code).toEqual({
-      name: 'code',
-    })
-    expect(config.provider.MyCustomProvider.models.glm).toEqual({
-      name: 'glm',
-    })
-    expect(config.provider.MyCustomProvider.models.kimi).toEqual({
-      name: 'kimi',
-    })
+    expect(config.provider.MyCustomProvider.models.code).toEqual(
+      expectedModelConfig('code')
+    )
+    expect(config.provider.MyCustomProvider.models.glm).toEqual(
+      expectedModelConfig('glm')
+    )
+    expect(config.provider.MyCustomProvider.models.kimi).toEqual(
+      expectedModelConfig('kimi')
+    )
     expect(config.model).toBe('MyCustomProvider/code')
     expect(config.small_model).toBe('MyCustomProvider/code')
   })

package/libs/opencode.ts

@@ -10,6 +10,17 @@ const OPENCODE_GLM_MODEL_ID = 'glm'
 const OPENCODE_KIMI_MODEL_ID = 'kimi'
 const OPENCODE_BASE_URL = 'https://ai.gengjiawen.com/api/openai/v1'
 
+function createOpencodeModelConfig(modelId: string) {
+  return {
+    name: modelId,
+    attachment: true,
+    modalities: {
+      input: ['text', 'image'],
+      output: ['text'],
+    },
+  }
+}
+
 /** Return OpenCode configuration directory path */
 function getOpencodeConfigDir(): string {
   return path.join(os.homedir(), '.config', 'opencode')
@@ -31,15 +42,13 @@ export function writeOpencodeConfig(apiKey: string): { configPath: string } {
           apiKey,
         },
         models: {
-          [OPENCODE_MODEL_ID]: {
-            name: OPENCODE_MODEL_ID,
-          },
-          [OPENCODE_GLM_MODEL_ID]: {
-            name: OPENCODE_GLM_MODEL_ID,
-          },
-          [OPENCODE_KIMI_MODEL_ID]: {
-            name: OPENCODE_KIMI_MODEL_ID,
-          },
+          [OPENCODE_MODEL_ID]: createOpencodeModelConfig(OPENCODE_MODEL_ID),
+          [OPENCODE_GLM_MODEL_ID]: createOpencodeModelConfig(
+            OPENCODE_GLM_MODEL_ID
+          ),
+          [OPENCODE_KIMI_MODEL_ID]: createOpencodeModelConfig(
+            OPENCODE_KIMI_MODEL_ID
+          ),
         },
       },
     },

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@gengjiawen/os-init",
   "private": false,
-  "version": "1.18.1",
+  "version": "1.19.0",
   "description": "",
   "main": "index.js",
   "bin": {