@vantran-se/openchamber-web 1.24.3 → 2.0.1

package/server/lib/opencode/plugins.test.js

@@ -45,19 +45,21 @@ describe('opencode plugins data layer', () => {
     delete process.env.OPENCODE_CONFIG;
   });
 
-  test('parses raw plugin entries', () => {
+  test('parses v1 tuples and v2 objects into the same entry', () => {
     expect(plugins.parsePluginRaw('foo')).toEqual({ spec: 'foo' });
     expect(plugins.parsePluginRaw('foo@1.0.0')).toEqual({ spec: 'foo@1.0.0' });
     expect(plugins.parsePluginRaw(['foo', { a: 1 }])).toEqual({ spec: 'foo', options: { a: 1 } });
-    expect(plugins.parsePluginRaw(['foo', {}])).toEqual({ spec: 'foo', options: {} });
+    expect(plugins.parsePluginRaw(['foo', {}])).toEqual({ spec: 'foo' });
+    expect(plugins.parsePluginRaw({ package: 'foo', options: { a: 1 } })).toEqual({ spec: 'foo', options: { a: 1 } });
+    expect(plugins.parsePluginRaw({ package: 'foo' })).toEqual({ spec: 'foo' });
     expect(() => plugins.parsePluginRaw(123)).toThrow('Plugin spec');
   });
 
-  test('serializes plugin entries', () => {
+  test('serializes plugin entries in v2 shape, never a tuple', () => {
     expect(plugins.serializePluginEntry({ spec: 'foo' })).toBe('foo');
     expect(plugins.serializePluginEntry({ spec: 'foo', options: undefined })).toBe('foo');
     expect(plugins.serializePluginEntry({ spec: 'foo', options: {} })).toBe('foo');
-    expect(plugins.serializePluginEntry({ spec: 'foo', options: { a: 1 } })).toEqual(['foo', { a: 1 }]);
+    expect(plugins.serializePluginEntry({ spec: 'foo', options: { a: 1 } })).toEqual({ package: 'foo', options: { a: 1 } });
   });
 
   test('rejects invalid specs and file names', () => {
@@ -69,11 +71,12 @@ describe('opencode plugins data layer', () => {
     expect(() => plugins.writePluginDirFile({ fileName: 'foo.txt', content: '', scope: 'project' }, projectDir)).toThrow('Plugin file name');
   });
 
-  test('creates string and tuple entries with duplicate rejection', () => {
+  test('creates string and object entries with duplicate rejection', () => {
     plugins.createPluginEntry({ spec: 'plain-plugin', scope: 'user' }, projectDir);
     plugins.createPluginEntry({ spec: 'tuple-plugin', options: { apiKey: 'x' }, scope: 'user' }, projectDir);
 
-    expect(readJson(userConfigPath).plugin).toEqual(['plain-plugin', ['tuple-plugin', { apiKey: 'x' }]]);
+    expect(readJson(userConfigPath).plugins).toEqual(['plain-plugin', { package: 'tuple-plugin', options: { apiKey: 'x' } }]);
+    expect(readJson(userConfigPath).plugin).toBeUndefined();
     expect(() => plugins.createPluginEntry({ spec: 'plain-plugin', scope: 'user' }, projectDir)).toThrow('already exists');
     expect(thrownBy(() => plugins.createPluginEntry({ spec: 'plain-plugin', scope: 'user' }, projectDir))).toHaveProperty('code', 'ENTRY_EXISTS');
   });
@@ -82,8 +85,8 @@ describe('opencode plugins data layer', () => {
     plugins.createPluginEntry({ spec: 'user-plugin', scope: 'user' }, projectDir);
     plugins.createPluginEntry({ spec: 'project-plugin', scope: 'project' }, projectDir);
 
-    expect(readJson(userConfigPath).plugin).toEqual(['user-plugin']);
-    expect(readJson(path.join(projectDir, '.opencode', 'opencode.json')).plugin).toEqual(['project-plugin']);
+    expect(readJson(userConfigPath).plugins).toEqual(['user-plugin']);
+    expect(readJson(path.join(projectDir, '.opencode', 'opencode.json')).plugins).toEqual(['project-plugin']);
   });
 
   test('re-resolves custom config env between calls', () => {
@@ -98,24 +101,34 @@ describe('opencode plugins data layer', () => {
     plugins.createPluginEntry({ spec: 'second-plugin', scope: 'user' }, projectDir);
     plugins.writePluginDirFile({ fileName: 'second.js', content: 'two', scope: 'user' }, projectDir);
 
-    expect(readJson(firstConfigPath).plugin).toEqual(['first-plugin']);
-    expect(readJson(secondConfigPath).plugin).toEqual(['second-plugin']);
+    expect(readJson(firstConfigPath).plugins).toEqual(['first-plugin']);
+    expect(readJson(secondConfigPath).plugins).toEqual(['second-plugin']);
     expect(fs.existsSync(path.join(path.dirname(firstConfigPath), 'plugins', 'first.js'))).toBe(true);
     expect(fs.existsSync(path.join(path.dirname(secondConfigPath), 'plugins', 'second.js'))).toBe(true);
   });
 
-  test('updates entries in place and transitions between string and tuple', () => {
+  test('rewrites a v1 plugin array into v2 plugins when one entry is updated', () => {
     writeJson(userConfigPath, { plugin: ['first', ['second', { a: 1 }], 'third'] });
 
     plugins.updatePluginEntry(plugins.encodePluginId('config', 'user:second'), { spec: 'second-new', options: {} }, projectDir);
-    expect(readJson(userConfigPath).plugin).toEqual(['first', 'second-new', 'third']);
+    const migrated = readJson(userConfigPath);
+    expect(migrated.plugin).toBeUndefined();
+    expect(migrated.plugins).toEqual(['first', 'second-new', 'third']);
 
     plugins.updatePluginEntry(plugins.encodePluginId('config', 'user:first'), { spec: 'first-new', options: { b: 2 } }, projectDir);
-    expect(readJson(userConfigPath).plugin).toEqual([['first-new', { b: 2 }], 'second-new', 'third']);
+    expect(readJson(userConfigPath).plugins).toEqual([{ package: 'first-new', options: { b: 2 } }, 'second-new', 'third']);
   });
 
-  test('deletes entries and prunes empty plugin key', () => {
-    writeJson(userConfigPath, { plugin: ['only'] });
+  test('reads a v2 plugins array and updates it in place', () => {
+    writeJson(userConfigPath, { plugins: ['alpha', { package: 'beta', options: { a: 1 } }] });
+
+    expect(plugins.listPluginEntries(projectDir).map((entry) => entry.spec)).toEqual(['alpha', 'beta']);
+    plugins.updatePluginEntry(plugins.encodePluginId('config', 'user:beta'), { options: { a: 2 } }, projectDir);
+    expect(readJson(userConfigPath).plugins).toEqual(['alpha', { package: 'beta', options: { a: 2 } }]);
+  });
+
+  test('deletes entries and prunes the empty plugins key', () => {
+    writeJson(userConfigPath, { plugins: ['only'] });
 
     plugins.deletePluginEntry(plugins.encodePluginId('config', 'user:only'), projectDir);
     expect(readJson(userConfigPath)).toEqual({});

package/server/lib/opencode/providers.js

@@ -5,6 +5,15 @@ import {
   getConfigForPath,
   writeConfig,
 } from './shared.js';
+import {
+  readSectionEntry,
+  writeSectionEntry,
+  deleteSectionEntry,
+  toModelVariants,
+  toProviderEntity,
+  toProviderPackage,
+  toNpmPackage,
+} from './config-v2.js';
 
 const PROVIDER_ID_PATTERN = /^[a-z0-9][a-z0-9-_]*$/;
 const BASE_URL_PATTERN = /^https?:\/\//;
@@ -15,34 +24,25 @@ const CUSTOM_PROVIDER_NPM_PACKAGES = new Set([
   '@ai-sdk/anthropic',
 ]);
 
+// OpenCode 2 keeps providers under `providers` with `package: "aisdk:<npm>"`,
+// `settings.baseURL`, and `models.<id>.modelID`. The v1 `provider` map with
+// `npm`/`api`/`options` is still decoded, so reads accept it; every write is v2.
+
+function providerExistsIn(config, providerId) {
+  return readSectionEntry(config, 'providers', providerId).value !== undefined;
+}
+
 function getProviderSources(providerId, workingDirectory) {
   const layers = readConfigLayers(workingDirectory);
   const { userConfig, projectConfig, customConfig, paths } = layers;
 
-  const customProviders = isPlainObject(customConfig?.provider) ? customConfig.provider : {};
-  const customProvidersAlias = isPlainObject(customConfig?.providers) ? customConfig.providers : {};
-  const projectProviders = isPlainObject(projectConfig?.provider) ? projectConfig.provider : {};
-  const projectProvidersAlias = isPlainObject(projectConfig?.providers) ? projectConfig.providers : {};
-  const userProviders = isPlainObject(userConfig?.provider) ? userConfig.provider : {};
-  const userProvidersAlias = isPlainObject(userConfig?.providers) ? userConfig.providers : {};
-
-  const customExists =
-    Object.prototype.hasOwnProperty.call(customProviders, providerId) ||
-    Object.prototype.hasOwnProperty.call(customProvidersAlias, providerId);
-  const projectExists =
-    Object.prototype.hasOwnProperty.call(projectProviders, providerId) ||
-    Object.prototype.hasOwnProperty.call(projectProvidersAlias, providerId);
-  const userExists =
-    Object.prototype.hasOwnProperty.call(userProviders, providerId) ||
-    Object.prototype.hasOwnProperty.call(userProvidersAlias, providerId);
-
   return {
     sources: {
       auth: { exists: false },
-      user: { exists: userExists, path: paths.userPath },
-      project: { exists: projectExists, path: paths.projectPath || null },
-      custom: { exists: customExists, path: paths.customPath }
-    }
+      user: { exists: providerExistsIn(userConfig, providerId), path: paths.userPath },
+      project: { exists: providerExistsIn(projectConfig, providerId), path: paths.projectPath || null },
+      custom: { exists: providerExistsIn(customConfig, providerId), path: paths.customPath },
+    },
   };
 }
 
@@ -50,6 +50,9 @@ function getProviderSources(providerId, workingDirectory) {
  * Validate a custom provider config payload before persistence.
  * Returns { ok: true, value } or { ok: false, error }.
  *
+ * Accepts the v2 spelling (`package`, `settings.baseURL`) and the v1 spelling
+ * (`npm`, `options.baseURL`); the normalized value is always v2.
+ *
  * Credentials: either config.env contains a variable name, or hasStoredAuth is true
  * (auth.json already has a key — typically after auth.set, or when editing).
  */
@@ -67,17 +70,19 @@ function validateCustomProviderConfig(providerId, config, options = {}) {
     return { ok: false, error: 'Provider name is required' };
   }
 
-  const npm = typeof config.npm === 'string' ? config.npm.trim() : OPENAI_COMPATIBLE_NPM;
+  const npm = toNpmPackage(config.package ?? config.npm) || OPENAI_COMPATIBLE_NPM;
   if (!CUSTOM_PROVIDER_NPM_PACKAGES.has(npm)) {
     return { ok: false, error: 'Custom providers must use @ai-sdk/openai-compatible, @ai-sdk/openai, or @ai-sdk/anthropic' };
   }
 
-  const optionsBlock = isPlainObject(config.options) ? config.options : null;
-  if (!optionsBlock) {
-    return { ok: false, error: 'Provider options are required' };
+  const settingsBlock = isPlainObject(config.settings)
+    ? config.settings
+    : (isPlainObject(config.options) ? config.options : null);
+  if (!settingsBlock) {
+    return { ok: false, error: 'Provider settings are required' };
   }
 
-  const baseURL = typeof optionsBlock.baseURL === 'string' ? optionsBlock.baseURL.trim() : '';
+  const baseURL = typeof settingsBlock.baseURL === 'string' ? settingsBlock.baseURL.trim() : '';
   if (!baseURL) {
     return { ok: false, error: 'Base URL is required' };
   }
@@ -103,15 +108,17 @@ function validateCustomProviderConfig(providerId, config, options = {}) {
     if (!modelName) {
       return { ok: false, error: `Model "${trimmedId}" requires a name` };
     }
-    normalizedModels[trimmedId] = { name: modelName };
+    normalizedModels[trimmedId] = { modelID: trimmedId, name: modelName };
+    // Present means the caller owns the levels; an empty list removes them.
+    if (Array.isArray(modelValue.variants)) {
+      normalizedModels[trimmedId].variants = toModelVariants(modelValue.variants);
+    }
   }
 
   const normalized = {
-    npm,
+    package: toProviderPackage(npm),
     name,
-    options: {
-      baseURL,
-    },
+    settings: { baseURL },
     models: normalizedModels,
   };
 
@@ -133,9 +140,10 @@ function validateCustomProviderConfig(providerId, config, options = {}) {
     };
   }
 
-  if (isPlainObject(optionsBlock.headers)) {
+  const headerSource = isPlainObject(config.headers) ? config.headers : settingsBlock.headers;
+  if (isPlainObject(headerSource)) {
     const headers = {};
-    for (const [headerKey, headerValue] of Object.entries(optionsBlock.headers)) {
+    for (const [headerKey, headerValue] of Object.entries(headerSource)) {
       if (typeof headerKey !== 'string' || !headerKey.trim()) {
         continue;
       }
@@ -145,7 +153,7 @@ function validateCustomProviderConfig(providerId, config, options = {}) {
       headers[headerKey.trim()] = headerValue.trim();
     }
     if (Object.keys(headers).length > 0) {
-      normalized.options.headers = headers;
+      normalized.headers = headers;
     }
   }
 
@@ -153,34 +161,38 @@ function validateCustomProviderConfig(providerId, config, options = {}) {
 }
 
 function mergeCustomProviderConfig(existingValue, normalizedConfig) {
-  const existing = isPlainObject(existingValue) ? existingValue : {};
-  const existingOptions = isPlainObject(existing.options) ? existing.options : {};
-  const normalizedOptions = isPlainObject(normalizedConfig.options) ? normalizedConfig.options : {};
-  const mergedOptions = { ...existingOptions, ...normalizedOptions };
-  if (!Object.prototype.hasOwnProperty.call(normalizedOptions, 'headers')) {
-    delete mergedOptions.headers;
-  }
+  // Read the existing entry through the v2 projection so a legacy
+  // `npm`/`api`/`options` block is carried forward in native shape.
+  const existing = toProviderEntity(existingValue);
+  const mergedSettings = { ...(existing.settings ?? {}), ...(normalizedConfig.settings ?? {}) };
 
   const existingModels = isPlainObject(existing.models) ? existing.models : {};
   const normalizedModels = isPlainObject(normalizedConfig.models) ? normalizedConfig.models : {};
   const mergedModels = Object.fromEntries(
     Object.entries(normalizedModels).map(([modelId, normalizedModel]) => {
       const existingModel = isPlainObject(existingModels[modelId]) ? existingModels[modelId] : {};
-      const nextModel = isPlainObject(normalizedModel) ? normalizedModel : {};
-      return [modelId, { ...existingModel, ...nextModel }];
+      const mergedModel = { ...existingModel, ...normalizedModel };
+      if (Array.isArray(mergedModel.variants) && mergedModel.variants.length === 0) {
+        delete mergedModel.variants;
+      }
+      return [modelId, mergedModel];
     }),
   );
 
   const merged = {
     ...existing,
     ...normalizedConfig,
-    options: mergedOptions,
+    settings: mergedSettings,
     models: mergedModels,
   };
+  // Headers and env are explicit removals when the form omits them.
+  if (!Object.prototype.hasOwnProperty.call(normalizedConfig, 'headers')) {
+    delete merged.headers;
+  }
   if (!Object.prototype.hasOwnProperty.call(normalizedConfig, 'env')) {
     delete merged.env;
   }
-  return merged;
+  return toProviderEntity(merged);
 }
 
 /**
@@ -213,20 +225,11 @@ function upsertProviderConfig(providerId, config, workingDirectory, scope = 'use
   }
 
   const targetConfig = getConfigForPath(layers, targetPath);
-  const providerConfig = isPlainObject(targetConfig.provider) ? { ...targetConfig.provider } : {};
-  const providersAlias = isPlainObject(targetConfig.providers) ? { ...targetConfig.providers } : {};
-  const existingProvider = providerConfig[validated.value.providerId] ?? providersAlias[validated.value.providerId];
-  const mergedConfig = mergeCustomProviderConfig(existingProvider, validated.value.config);
-  providerConfig[validated.value.providerId] = mergedConfig;
-  targetConfig.provider = providerConfig;
-  if (Object.prototype.hasOwnProperty.call(providersAlias, validated.value.providerId)) {
-    delete providersAlias[validated.value.providerId];
-    if (Object.keys(providersAlias).length === 0) {
-      delete targetConfig.providers;
-    } else {
-      targetConfig.providers = providersAlias;
-    }
-  }
+  const existing = readSectionEntry(targetConfig, 'providers', validated.value.providerId).value;
+  const mergedConfig = mergeCustomProviderConfig(existing, validated.value.config);
+  // Writes `providers`; a legacy `provider.<id>` in the same file is dropped so
+  // the two spellings cannot disagree.
+  writeSectionEntry(targetConfig, 'providers', validated.value.providerId, mergedConfig);
 
   if (Array.isArray(targetConfig.disabled_providers)) {
     targetConfig.disabled_providers = targetConfig.disabled_providers.filter(
@@ -265,33 +268,10 @@ function removeProviderConfig(providerId, workingDirectory, scope = 'user') {
   }
 
   const targetConfig = getConfigForPath(layers, targetPath);
-  const providerConfig = isPlainObject(targetConfig.provider) ? targetConfig.provider : {};
-  const providersConfig = isPlainObject(targetConfig.providers) ? targetConfig.providers : {};
-  const removedProvider = Object.prototype.hasOwnProperty.call(providerConfig, providerId);
-  const removedProviders = Object.prototype.hasOwnProperty.call(providersConfig, providerId);
-
-  if (!removedProvider && !removedProviders) {
+  if (!deleteSectionEntry(targetConfig, 'providers', providerId)) {
     return false;
   }
 
-  if (removedProvider) {
-    delete providerConfig[providerId];
-    if (Object.keys(providerConfig).length === 0) {
-      delete targetConfig.provider;
-    } else {
-      targetConfig.provider = providerConfig;
-    }
-  }
-
-  if (removedProviders) {
-    delete providersConfig[providerId];
-    if (Object.keys(providersConfig).length === 0) {
-      delete targetConfig.providers;
-    } else {
-      targetConfig.providers = providersConfig;
-    }
-  }
-
   writeConfig(targetConfig, targetPath || CONFIG_FILE);
   console.log(`Removed provider ${providerId} from config: ${targetPath}`);
   return true;

package/server/lib/opencode/providers.test.js

@@ -82,7 +82,7 @@ describe('custom provider config persistence', () => {
         models: { m: { name: 'M' } },
       });
       expect(result.ok).toBe(true);
-      expect(result.value.config.npm).toBe(npm);
+      expect(result.value.config.package).toBe(`aisdk:${npm}`);
     }
   });
 
@@ -118,16 +118,15 @@ describe('custom provider config persistence', () => {
     expect(result.path.startsWith(projectDir)).toBe(true);
 
     const written = readJson(result.path);
-    expect(written.provider['campus-llm']).toEqual({
-      npm: '@ai-sdk/openai-compatible',
+    expect(written.provider).toBeUndefined();
+    expect(written.providers['campus-llm']).toEqual({
       name: 'Campus LLM',
+      package: 'aisdk:@ai-sdk/openai-compatible',
       env: ['CAMPUS_KEY'],
-      options: {
-        baseURL: 'https://llm.example.edu/v1',
-        headers: { 'X-Campus': '1' },
-      },
+      settings: { baseURL: 'https://llm.example.edu/v1' },
+      headers: { 'X-Campus': '1' },
       models: {
-        'fast-model': { name: 'Fast' },
+        'fast-model': { modelID: 'fast-model', name: 'Fast' },
       },
     });
 
@@ -136,8 +135,32 @@ describe('custom provider config persistence', () => {
     expect(sources.sources.project.path).toBe(result.path);
   });
 
+  test('upsertProviderConfig writes, keeps and clears model variants', () => {
+    const base = {
+      name: 'Campus LLM',
+      npm: '@ai-sdk/openai-compatible',
+      options: { baseURL: 'https://llm.example.edu/v1' },
+      env: ['CAMPUS_KEY'],
+    };
+    const result = upsertProviderConfig('campus-llm', {
+      ...base,
+      models: { m: { name: 'M', variants: [{ id: 'low', settings: { reasoningEffort: 'low' } }] } },
+    }, projectDir, 'project');
+    expect(readJson(result.path).providers['campus-llm'].models.m.variants).toEqual([
+      { id: 'low', settings: { reasoningEffort: 'low' } },
+    ]);
+
+    upsertProviderConfig('campus-llm', { ...base, models: { m: { name: 'M' } } }, projectDir, 'project');
+    expect(readJson(result.path).providers['campus-llm'].models.m.variants).toEqual([
+      { id: 'low', settings: { reasoningEffort: 'low' } },
+    ]);
+
+    upsertProviderConfig('campus-llm', { ...base, models: { m: { name: 'M', variants: [] } } }, projectDir, 'project');
+    expect(readJson(result.path).providers['campus-llm'].models.m).toEqual({ modelID: 'm', name: 'M' });
+  });
+
   test('upsertProviderConfig updates existing entry and clears disabled_providers', () => {
-    const configPath = path.join(projectDir, 'opencode.json');
+    const configPath = path.join(projectDir, '.opencode', 'opencode.json');
     writeJson(configPath, {
       provider: {
         'campus-llm': {
@@ -158,13 +181,14 @@ describe('custom provider config persistence', () => {
     }, projectDir, 'project');
 
     const written = readJson(configPath);
-    expect(written.provider['campus-llm'].name).toBe('Campus LLM');
-    expect(written.provider['campus-llm'].models).toEqual({ b: { name: 'B' } });
+    expect(written.provider).toBeUndefined();
+    expect(written.providers['campus-llm'].name).toBe('Campus LLM');
+    expect(written.providers['campus-llm'].models).toEqual({ b: { modelID: 'b', name: 'B' } });
     expect(written.disabled_providers).toEqual(['other']);
   });
 
   test('upsertProviderConfig preserves unmanaged provider and model metadata', () => {
-    const configPath = path.join(projectDir, 'opencode.json');
+    const configPath = path.join(projectDir, '.opencode', 'opencode.json');
     writeJson(configPath, {
       provider: {
         'campus-llm': {
@@ -210,69 +234,116 @@ describe('custom provider config persistence', () => {
       },
     }, projectDir, 'project', { hasStoredAuth: true });
 
-    const written = readJson(configPath).provider['campus-llm'];
-    expect(written).toEqual({
-      npm: '@ai-sdk/openai-compatible',
+    // A legacy `provider` entry is rewritten in place into `providers` in v2
+    // shape: `npm` -> `package`, `options` -> `settings`, `tool_call`/
+    // `modalities` -> `capabilities`, variants map -> variants array. Fields v2
+    // accepts but ignores (`reasoning`, `attachment`) are dropped.
+    const config = readJson(configPath);
+    expect(config.provider).toBeUndefined();
+    expect(config.providers['campus-llm']).toEqual({
       name: 'Campus LLM',
-      customProviderField: { owner: 'user' },
-      options: {
+      package: 'aisdk:@ai-sdk/openai-compatible',
+      settings: {
         baseURL: 'https://new.example.edu/v1',
         timeout: 45_000,
       },
       models: {
         retained: {
+          modelID: 'retained',
           name: 'Retained model',
-          reasoning: true,
-          attachment: true,
-          tool_call: true,
-          modalities: { input: ['text', 'image', 'pdf'], output: ['text'] },
+          settings: { instructions: 'Keep this instruction' },
+          capabilities: { tools: true, input: ['text', 'image', 'pdf'], output: ['text'] },
+          variants: [
+            { id: 'low', settings: { reasoningEffort: 'low' } },
+            { id: 'high', settings: { reasoningEffort: 'high' } },
+          ],
           limit: { context: 1_050_000, input: 922_000, output: 128_000 },
-          options: { instructions: 'Keep this instruction' },
-          variants: {
-            low: { reasoningEffort: 'low' },
-            high: { reasoningEffort: 'high' },
+        },
+        added: { modelID: 'added', name: 'Added model' },
+      },
+    });
+  });
+
+  test('renaming a provider keeps canonical and model compatibility', () => {
+    const configPath = path.join(projectDir, '.opencode', 'opencode.json');
+    writeJson(configPath, {
+      providers: {
+        'openai-proxy': {
+          canonical: 'openai',
+          name: 'Old name',
+          package: 'aisdk:@ai-sdk/openai-compatible',
+          env: ['PROXY_KEY'],
+          settings: { baseURL: 'https://proxy.example.com/v1' },
+          models: {
+            'gpt-5': {
+              modelID: 'gpt-5',
+              name: 'GPT-5',
+              compatibility: { reasoningField: 'reasoning_content', requireReasoning: true, maxTokensField: 'max_tokens' },
+            },
           },
-          customModelField: { source: 'manual' },
         },
-        added: { name: 'Added model' },
+      },
+    });
+
+    upsertProviderConfig('openai-proxy', {
+      name: 'New name',
+      env: ['PROXY_KEY'],
+      settings: { baseURL: 'https://proxy.example.com/v1' },
+      models: { 'gpt-5': { name: 'GPT-5' } },
+    }, projectDir, 'project');
+
+    expect(readJson(configPath).providers['openai-proxy']).toEqual({
+      canonical: 'openai',
+      name: 'New name',
+      package: 'aisdk:@ai-sdk/openai-compatible',
+      env: ['PROXY_KEY'],
+      settings: { baseURL: 'https://proxy.example.com/v1' },
+      models: {
+        'gpt-5': {
+          modelID: 'gpt-5',
+          name: 'GPT-5',
+          compatibility: { reasoningField: 'reasoning_content', requireReasoning: true, maxTokensField: 'max_tokens' },
+        },
       },
     });
   });
 
-  test('upsertProviderConfig preserves metadata while migrating the legacy providers alias', () => {
-    const configPath = path.join(projectDir, 'opencode.json');
+  test('accepts a native v2 payload and keeps the entry in providers', () => {
+    const configPath = path.join(projectDir, '.opencode', 'opencode.json');
     writeJson(configPath, {
       providers: {
-        legacy: {
-          name: 'Legacy provider',
-          options: { baseURL: 'https://old.example.com/v1', timeout: 30_000 },
-          models: { model: { name: 'Old model', reasoning: true } },
+        native: {
+          name: 'Native provider',
+          package: 'aisdk:@ai-sdk/openai-compatible',
+          settings: { baseURL: 'https://old.example.com/v1', timeout: 30_000 },
+          models: { model: { modelID: 'model', name: 'Old model' } },
         },
       },
     });
 
-    upsertProviderConfig('legacy', {
+    upsertProviderConfig('native', {
       name: 'Updated provider',
-      options: { baseURL: 'https://new.example.com/v1' },
+      package: 'aisdk:@ai-sdk/openai-compatible',
+      settings: { baseURL: 'https://new.example.com/v1' },
       models: { model: { name: 'Updated model' } },
     }, projectDir, 'project', { hasStoredAuth: true });
 
     const written = readJson(configPath);
-    expect(written.providers).toBeUndefined();
-    expect(written.provider.legacy).toEqual({
-      npm: '@ai-sdk/openai-compatible',
+    expect(written.provider).toBeUndefined();
+    expect(written.providers.native).toEqual({
       name: 'Updated provider',
-      options: { baseURL: 'https://new.example.com/v1', timeout: 30_000 },
-      models: { model: { name: 'Updated model', reasoning: true } },
+      package: 'aisdk:@ai-sdk/openai-compatible',
+      settings: { baseURL: 'https://new.example.com/v1', timeout: 30_000 },
+      models: { model: { modelID: 'model', name: 'Updated model' } },
     });
   });
 
-  test('migrating one legacy providers entry keeps the other legacy entries', () => {
-    const configPath = path.join(projectDir, 'opencode.json');
+  test('rewriting one legacy provider entry leaves the other legacy entries alone', () => {
+    const configPath = path.join(projectDir, '.opencode', 'opencode.json');
     writeJson(configPath, {
-      providers: {
-        legacy: { name: 'Legacy provider', options: { baseURL: 'https://old.example.com/v1' }, models: { model: { name: 'Old model' } } },
-        untouched: { name: 'Untouched', options: { baseURL: 'https://other.example.com/v1' }, models: { model: { name: 'Other model' } } },
+      provider: {
+        legacy: { npm: '@ai-sdk/openai-compatible', name: 'Legacy provider', options: { baseURL: 'https://old.example.com/v1' }, models: { model: { name: 'Old model' } } },
+        untouched: { npm: '@ai-sdk/openai-compatible', name: 'Untouched', options: { baseURL: 'https://other.example.com/v1' }, models: { model: { name: 'Other model' } } },
       },
     });
 
@@ -283,10 +354,10 @@ describe('custom provider config persistence', () => {
     }, projectDir, 'project', { hasStoredAuth: true });
 
     const written = readJson(configPath);
-    expect(written.providers).toEqual({
-      untouched: { name: 'Untouched', options: { baseURL: 'https://other.example.com/v1' }, models: { model: { name: 'Other model' } } },
+    expect(written.provider).toEqual({
+      untouched: { npm: '@ai-sdk/openai-compatible', name: 'Untouched', options: { baseURL: 'https://other.example.com/v1' }, models: { model: { name: 'Other model' } } },
     });
-    expect(written.provider.legacy.name).toBe('Updated provider');
+    expect(written.providers.legacy.name).toBe('Updated provider');
   });
 
   test('upsert then remove restores absence', () => {
@@ -303,7 +374,7 @@ describe('custom provider config persistence', () => {
   });
 
   test('failed validation does not write config', () => {
-    const configPath = path.join(projectDir, 'opencode.json');
+    const configPath = path.join(projectDir, '.opencode', 'opencode.json');
     expect(() => upsertProviderConfig('ok', {
       name: 'X',
       options: { baseURL: 'not-a-url' },
@@ -326,7 +397,7 @@ describe('custom provider config persistence', () => {
 
   test('project-scope edit updates project layer without creating a user entry', () => {
     const providerId = `proj-scope-${Date.now()}`;
-    const configPath = path.join(projectDir, 'opencode.json');
+    const configPath = path.join(projectDir, '.opencode', 'opencode.json');
 
     upsertProviderConfig(providerId, {
       name: 'Project Scoped',
@@ -341,14 +412,12 @@ describe('custom provider config persistence', () => {
     }, projectDir, 'project', { hasStoredAuth: true });
 
     const written = readJson(configPath);
-    expect(written.provider[providerId]).toEqual({
-      npm: '@ai-sdk/openai-compatible',
+    expect(written.providers[providerId]).toEqual({
       name: 'Project Scoped Updated',
-      options: {
-        baseURL: 'https://project.example.com/v2',
-        headers: { 'X-Project': '1' },
-      },
-      models: { m: { name: 'M2' } },
+      package: 'aisdk:@ai-sdk/openai-compatible',
+      settings: { baseURL: 'https://project.example.com/v2' },
+      headers: { 'X-Project': '1' },
+      models: { m: { modelID: 'm', name: 'M2' } },
     });
 
     const sources = getProviderSources(providerId, projectDir);
@@ -387,8 +456,8 @@ describe('custom provider config persistence', () => {
       }, projectDir, 'custom', { hasStoredAuth: true });
 
       const written = readJson(customPath);
-      expect(written.provider[providerId].name).toBe('Custom Scoped Updated');
-      expect(written.provider[providerId].options.baseURL).toBe('https://custom.example.com/v2');
+      expect(written.providers[providerId].name).toBe('Custom Scoped Updated');
+      expect(written.providers[providerId].settings.baseURL).toBe('https://custom.example.com/v2');
 
       const sources = getProviderSources(providerId, projectDir);
       expect(sources.sources.custom.exists).toBe(true);