@openchambery/web 2.0.0-beta.1 → 2.0.0-beta.4

package/server/lib/small-model/summary-settings.test.js

@@ -7,50 +7,51 @@ const tempRoot = await fsPromises.mkdtemp(path.join(os.tmpdir(), 'oc-summary-set
 const originalDataDir = process.env.OPENCHAMBER_DATA_DIR;
 process.env.OPENCHAMBER_DATA_DIR = tempRoot;
 
-vi.mock('../opencode/auth.js', () => ({
-  readAuthFile: vi.fn(() => ({})),
-}));
-
 vi.mock('../opencode/shared.js', () => ({
   readConfigLayers: vi.fn(() => ({ mergedConfig: {} })),
 }));
 
-vi.mock('./call.js', () => ({
-  callSmallModel: vi.fn(async () => 'Generated summary'),
-}));
-
-vi.mock('./opencode-session.js', () => ({
-  generateViaOpenCodeSession: vi.fn(async () => 'Session path summary'),
-  stop: vi.fn(async () => {}),
+vi.mock('./custom-api.js', async (importOriginal) => ({
+  ...(await importOriginal()),
+  generateCustomSummaryText: vi.fn(async () => 'Generated summary'),
 }));
 
 const { createSmallModelService } = await import('./index.js');
-const { callSmallModel } = await import('./call.js');
-const { generateViaOpenCodeSession } = await import('./opencode-session.js');
-const { readAuthFile } = await import('../opencode/auth.js');
-
-const createService = (catalog = {}, connected = null) => createSmallModelService({
-  buildOpenCodeUrl: () => 'http://127.0.0.1:4096/',
-  getOpenCodeAuthHeaders: () => ({}),
-  getModelCatalog: async () => catalog,
-  getConnectedCatalog: async () => {
-    if (connected === null) throw new Error('connected catalog unavailable');
-    return { connected, providers: [], models: [] };
-  },
+const { generateCustomSummaryText } = await import('./custom-api.js');
+
+const writeSettings = (settings) => fsPromises.writeFile(
+  path.join(tempRoot, 'settings.json'),
+  JSON.stringify(settings),
+  'utf8',
+);
+
+const completionOf = (text) => ({
+  completion: { choices: [{ message: { role: 'assistant', content: text } }] },
 });
 
+const createService = ({ catalog = {}, defaultModel = null } = {}) => {
+  const createChatCompletion = vi.fn(async () => completionOf('Gateway summary'));
+  const modelDefault = vi.fn(async () => ({ data: defaultModel }));
+  const service = createSmallModelService({
+    buildOpenCodeUrl: () => 'http://127.0.0.1:4096/',
+    getOpenCodeAuthHeaders: () => ({}),
+    getModelCatalog: async () => catalog,
+    openCodeClientFactory: () => ({ model: { default: modelDefault } }),
+    createChatCompletion,
+  });
+  return { ...service, createChatCompletion, modelDefault };
+};
+
 describe('summary AI settings', () => {
   beforeEach(async () => {
-    vi.mocked(callSmallModel).mockClear();
-    vi.mocked(generateViaOpenCodeSession).mockClear();
-    vi.mocked(readAuthFile).mockReturnValue({});
-    await fsPromises.writeFile(path.join(tempRoot, 'settings.json'), JSON.stringify({
+    vi.mocked(generateCustomSummaryText).mockClear();
+    await writeSettings({
       summaryModelMode: 'custom',
       summaryCustomBaseURL: 'https://summary.example.test/v1',
       summaryModelID: 'summary-model',
       summaryCustomAPIToken: 'summary-token',
       summaryCommitPrompt: 'Return commit JSON.',
-    }), 'utf8');
+    });
   });
 
   afterAll(async () => {
@@ -63,7 +64,7 @@ describe('summary AI settings', () => {
   });
 
   it('uses a persisted custom API and prompt for commit summaries', async () => {
-    const { generateSmallModelText } = createService();
+    const { generateSmallModelText, createChatCompletion } = createService();
     const result = await generateSmallModelText({
       purpose: 'commit',
       prompt: 'Diff content',
@@ -71,16 +72,15 @@ describe('summary AI settings', () => {
       maxOutputTokens: 64,
     });
 
-    expect(callSmallModel).toHaveBeenCalledWith(expect.objectContaining({
-      providerID: 'custom',
+    expect(createChatCompletion).not.toHaveBeenCalled();
+    expect(generateCustomSummaryText).toHaveBeenCalledWith({
+      baseURL: 'https://summary.example.test/v1',
+      apiToken: 'summary-token',
       modelID: 'summary-model',
+      prompt: 'Diff content',
       system: 'Return commit JSON.',
-      custom: {
-        baseURL: 'https://summary.example.test/v1',
-        apiToken: 'summary-token',
-        modelID: 'summary-model',
-      },
-    }));
+      maxOutputTokens: 64,
+    });
     expect(result).toEqual({
       text: 'Generated summary',
       providerID: 'custom',
@@ -90,251 +90,105 @@ describe('summary AI settings', () => {
     expect(JSON.stringify(result)).not.toContain('summary-token');
   });
 
-  it('uses the displayed default Summary AI model across session providers', async () => {
-    vi.mocked(readAuthFile).mockReturnValue({
-      openai: {
-        type: 'oauth',
-        access: 'openai-access-token',
-      },
+  it('routes a saved provider model through the Assistant LLM gateway', async () => {
+    await writeSettings({
+      summaryModelMode: 'provider',
+      summaryProviderID: 'openai',
+      summaryModelID: 'gpt-5.4-mini',
+      summaryCommitPrompt: 'Return commit JSON.',
     });
-    await fsPromises.writeFile(path.join(tempRoot, 'settings.json'), JSON.stringify({}), 'utf8');
 
-    const { generateSmallModelText } = createService();
+    const { generateSmallModelText, createChatCompletion, modelDefault } = createService();
     const result = await generateSmallModelText({
-      purpose: 'session-title',
-      prompt: 'Conversation content',
-      preferredProviderID: 'anthropic',
-      preferredModelID: 'claude-sonnet-4-5',
-      restrictToPreferredProvider: true,
+      purpose: 'commit',
+      prompt: 'Diff content',
+      system: 'Fallback system prompt',
     });
 
-    expect(callSmallModel).toHaveBeenCalledWith(expect.objectContaining({
-      providerID: 'openai',
-      modelID: 'gpt-5.4-mini',
+    expect(modelDefault).not.toHaveBeenCalled();
+    expect(generateCustomSummaryText).not.toHaveBeenCalled();
+    expect(createChatCompletion).toHaveBeenCalledWith(expect.objectContaining({
+      body: {
+        providerID: 'openai',
+        modelID: 'gpt-5.4-mini',
+        messages: [
+          { role: 'system', content: 'Return commit JSON.' },
+          { role: 'user', content: 'Diff content' },
+        ],
+      },
     }));
     expect(result).toEqual({
-      text: 'Generated summary',
+      text: 'Gateway summary',
       providerID: 'openai',
       modelID: 'gpt-5.4-mini',
-      source: 'summary-default',
-    });
-  });
-
-  it('excludes dedicated providers with unsupported auth types from callable lists', async () => {
-    vi.mocked(readAuthFile).mockReturnValue({
-      openai: { type: 'wellknown', token: 'openai-wellknown-token' },
-      anthropic: { type: 'oauth', access: 'anthropic-access', refresh: 'anthropic-refresh', expires: 0 },
-      google: { type: 'oauth', access: 'google-access', refresh: 'google-refresh', expires: 0 },
-      mistral: { type: 'api', key: 'mistral-key' },
-    });
-
-    const catalog = {
-      mistral: {
-        id: 'mistral',
-        name: 'Mistral',
-        models: {
-          'mistral-small': {
-            id: 'mistral-small',
-            api: { url: 'https://api.mistral.ai/v1' },
-          },
-        },
-      },
-      anthropic: {
-        id: 'anthropic',
-        name: 'Anthropic',
-        models: {
-          'claude-haiku-4-5': { id: 'claude-haiku-4-5', family: 'claude-haiku' },
-        },
-      },
-    };
-
-    const { listCallableProviders, listCallableModels } = createService(catalog);
-    const providers = await listCallableProviders();
-    const models = await listCallableModels();
-
-    expect(providers).toEqual(['mistral']);
-    expect(models).toEqual({ mistral: ['mistral-small'] });
-    expect(providers).not.toContain('openai');
-    expect(providers).not.toContain('anthropic');
-    expect(providers).not.toContain('google');
-  });
-
-  it('lists OpenAI api/oauth, Anthropic/Google api keys, and Copilot aliases as callable', async () => {
-    vi.mocked(readAuthFile).mockReturnValue({
-      openai: { type: 'api', key: 'sk-openai' },
-      anthropic: { type: 'api', key: 'sk-anthropic' },
-      google: { type: 'api', key: 'google-key' },
-      copilot: { type: 'oauth', access: 'copilot-token', refresh: 'copilot-token', expires: 0 },
-    });
-
-    const catalog = {
-      openai: {
-        id: 'openai',
-        name: 'OpenAI',
-        models: { 'gpt-4.1-nano': { id: 'gpt-4.1-nano', family: 'gpt-nano' } },
-      },
-      anthropic: {
-        id: 'anthropic',
-        name: 'Anthropic',
-        models: { 'claude-haiku-4-5': { id: 'claude-haiku-4-5', family: 'claude-haiku' } },
-      },
-      google: {
-        id: 'google',
-        name: 'Google',
-        models: { 'gemini-2.5-flash': { id: 'gemini-2.5-flash', family: 'gemini-flash' } },
-      },
-    };
-
-    const { listCallableProviders, listCallableModels } = createService(catalog);
-    const providers = await listCallableProviders();
-    const models = await listCallableModels();
-
-    expect(providers.sort()).toEqual(['anthropic', 'github-copilot', 'google', 'openai']);
-    expect(models.openai).toEqual(['gpt-4.1-nano']);
-    expect(models.anthropic).toEqual(['claude-haiku-4-5']);
-    expect(models.google).toEqual(['gemini-2.5-flash']);
-    expect(models['github-copilot']).toEqual(['gpt-5.4-nano']);
-  });
-
-  it('keeps OpenAI oauth callable with the codex small model only', async () => {
-    vi.mocked(readAuthFile).mockReturnValue({
-      openai: { type: 'oauth', access: 'openai-access', refresh: 'openai-refresh', expires: 0 },
-    });
-
-    const { listCallableProviders, listCallableModels } = createService({});
-    expect(await listCallableProviders()).toEqual(['openai']);
-    expect(await listCallableModels()).toEqual({ openai: ['gpt-5.4-mini'] });
-  });
-
-  it('lists logged-in providers with catalog models even without api.url', async () => {
-    vi.mocked(readAuthFile).mockReturnValue({
-      mistral: { type: 'api', key: 'mistral-key' },
-      deepseek: { type: 'api', key: 'deepseek-key' },
-      emptyplug: { type: 'api', key: 'empty-key' },
-    });
-
-    const catalog = {
-      mistral: {
-        id: 'mistral',
-        name: 'Mistral',
-        models: {
-          'mistral-small': { id: 'mistral-small' },
-        },
-      },
-      deepseek: {
-        id: 'deepseek',
-        name: 'DeepSeek',
-        models: {
-          'deepseek-chat': {
-            id: 'deepseek-chat',
-            api: { url: 'https://api.deepseek.com/v1' },
-          },
-        },
-      },
-      emptyplug: {
-        id: 'emptyplug',
-        name: 'Empty',
-        models: {},
-      },
-    };
-
-    const { listCallableProviders, listCallableModels } = createService(catalog);
-    expect((await listCallableProviders()).sort()).toEqual(['deepseek', 'mistral']);
-    expect(await listCallableModels()).toEqual({
-      mistral: ['mistral-small'],
-      deepseek: ['deepseek-chat'],
+      source: 'summary-provider',
     });
   });
 
-  it('routes non-dedicated providers through the OpenCode session path', async () => {
-    vi.mocked(readAuthFile).mockReturnValue({
-      codebuddy: { type: 'api', key: 'codebuddy-key' },
+  it('follows the OpenCode default model when no summary model is saved', async () => {
+    await writeSettings({});
+    const { generateSmallModelText, createChatCompletion } = createService({
+      defaultModel: { id: 'claude-sonnet-4-5', modelID: 'internal-pack', providerID: 'anthropic' },
     });
-    await fsPromises.writeFile(path.join(tempRoot, 'settings.json'), JSON.stringify({
-      summaryModelMode: 'provider',
-      summaryProviderID: 'codebuddy',
-      summaryModelID: 'codebuddy-flash',
-    }), 'utf8');
-
-    const catalog = {
-      codebuddy: {
-        id: 'codebuddy',
-        name: 'CodeBuddy',
-        models: {
-          'codebuddy-flash': { id: 'codebuddy-flash' },
-        },
-      },
-    };
 
-    const { generateSmallModelText } = createService(catalog);
     const result = await generateSmallModelText({
-      purpose: 'commit',
-      prompt: 'Diff content',
-      system: 'Fallback system prompt',
+      purpose: 'session-title',
+      prompt: 'Conversation content',
+      system: 'Title system prompt',
+      preferredProviderID: 'openai',
+      restrictToPreferredProvider: true,
     });
 
-    expect(callSmallModel).not.toHaveBeenCalled();
-    expect(generateViaOpenCodeSession).toHaveBeenCalledWith(expect.objectContaining({
-      providerID: 'codebuddy',
-      modelID: 'codebuddy-flash',
-      purpose: 'commit',
+    expect(createChatCompletion).toHaveBeenCalledWith(expect.objectContaining({
+      body: expect.objectContaining({ providerID: 'anthropic', modelID: 'claude-sonnet-4-5' }),
     }));
-    expect(result).toEqual({
-      text: 'Session path summary',
-      providerID: 'codebuddy',
-      modelID: 'codebuddy-flash',
-      source: 'summary-provider',
+    expect(result).toMatchObject({
+      providerID: 'anthropic',
+      modelID: 'claude-sonnet-4-5',
+      source: 'summary-default',
     });
   });
 
-  it('lists connected plugin providers that have no auth.json entry', async () => {
-    vi.mocked(readAuthFile).mockReturnValue({});
-    const catalog = {
-      codebuddy: {
-        id: 'codebuddy',
-        name: 'CodeBuddy',
-        models: { 'codebuddy-flash': { id: 'codebuddy-flash' } },
-      },
-    };
-
-    const { listCallableProviders, listCallableModels } = createService(catalog, ['codebuddy']);
-    expect(await listCallableProviders()).toEqual(['codebuddy']);
-    expect(await listCallableModels()).toEqual({ codebuddy: ['codebuddy-flash'] });
-  });
+  it('fails explicitly when OpenCode has no default model', async () => {
+    await writeSettings({ summaryModelMode: 'provider' });
+    const { generateSmallModelText, createChatCompletion } = createService();
 
-  it('does not list auth.json plugin providers that are not connected', async () => {
-    vi.mocked(readAuthFile).mockReturnValue({
-      mistral: { type: 'api', key: 'mistral-key' },
+    await expect(generateSmallModelText({
+      purpose: 'commit',
+      prompt: 'Diff content',
+    })).rejects.toMatchObject({
+      message: 'No OpenCode default model is configured',
+      statusCode: 404,
     });
-    const catalog = {
-      mistral: {
-        id: 'mistral',
-        name: 'Mistral',
-        models: { 'mistral-small': { id: 'mistral-small' } },
-      },
-    };
-
-    const { listCallableProviders, listCallableModels } = createService(catalog, []);
-    expect(await listCallableProviders()).toEqual([]);
-    expect(await listCallableModels()).toEqual({});
+    expect(createChatCompletion).not.toHaveBeenCalled();
   });
 
-  it('keeps dedicated providers callable from auth.json even when they are not connected', async () => {
-    vi.mocked(readAuthFile).mockReturnValue({
-      openai: { type: 'oauth', access: 'openai-access', refresh: 'openai-refresh', expires: 0 },
+  it('surfaces gateway failures instead of falling back to another model', async () => {
+    await writeSettings({
+      summaryModelMode: 'provider',
+      summaryProviderID: 'openai',
+      summaryModelID: 'missing-model',
     });
+    const { generateSmallModelText, createChatCompletion } = createService();
+    createChatCompletion.mockRejectedValueOnce(Object.assign(
+      new Error('No connected OpenCode provider for openai/missing-model'),
+      { statusCode: 400, code: 'no_provider' },
+    ));
 
-    const { listCallableProviders, listCallableModels } = createService({}, []);
-    expect(await listCallableProviders()).toEqual(['openai']);
-    expect(await listCallableModels()).toEqual({ openai: ['gpt-5.4-mini'] });
+    await expect(generateSmallModelText({
+      purpose: 'commit',
+      prompt: 'Diff content',
+    })).rejects.toMatchObject({ statusCode: 400, code: 'no_provider' });
+    expect(createChatCompletion).toHaveBeenCalledTimes(1);
+    expect(generateCustomSummaryText).not.toHaveBeenCalled();
   });
 
   it('requires a custom base URL, model ID, and token before enabling custom mode', async () => {
-    await fsPromises.writeFile(path.join(tempRoot, 'settings.json'), JSON.stringify({
+    await writeSettings({
       summaryModelMode: 'custom',
       summaryCustomBaseURL: 'https://summary.example.test/v1',
       summaryModelID: 'summary-model',
-    }), 'utf8');
+    });
 
     const { generateSmallModelText } = createService();
     await expect(generateSmallModelText({
@@ -347,13 +201,13 @@ describe('summary AI settings', () => {
   });
 
   it('prefers summaryCustomModelID over the shared summaryModelID for custom calls', async () => {
-    await fsPromises.writeFile(path.join(tempRoot, 'settings.json'), JSON.stringify({
+    await writeSettings({
       summaryModelMode: 'custom',
       summaryCustomBaseURL: 'https://summary.example.test/v1',
       summaryModelID: 'provider-model',
       summaryCustomModelID: 'custom-model',
       summaryCustomAPIToken: 'summary-token',
-    }), 'utf8');
+    });
 
     const { generateSmallModelText } = createService();
     await generateSmallModelText({
@@ -361,9 +215,59 @@ describe('summary AI settings', () => {
       prompt: 'Diff content',
     });
 
-    expect(callSmallModel).toHaveBeenCalledWith(expect.objectContaining({
+    expect(generateCustomSummaryText).toHaveBeenCalledWith(expect.objectContaining({
       modelID: 'custom-model',
-      custom: expect.objectContaining({ modelID: 'custom-model' }),
     }));
   });
+
+  it('sends explicit non-summary models through the same gateway', async () => {
+    await writeSettings({ summaryModelMode: 'provider', summaryProviderID: 'openai', summaryModelID: 'gpt-5.4' });
+
+    const { generateSmallModelText, createChatCompletion } = createService({
+      catalog: { codebuddy: { id: 'codebuddy', name: 'CodeBuddy', models: { 'codebuddy-flash': { id: 'codebuddy-flash' } } } },
+    });
+    const result = await generateSmallModelText({
+      purpose: 'goal',
+      prompt: 'Goal content',
+      model: 'codebuddy/codebuddy-flash',
+    });
+
+    expect(createChatCompletion).toHaveBeenCalledWith(expect.objectContaining({
+      body: expect.objectContaining({ providerID: 'codebuddy', modelID: 'codebuddy-flash' }),
+    }));
+    expect(result).toMatchObject({ providerID: 'codebuddy', modelID: 'codebuddy-flash', source: 'request' });
+  });
+
+  it('resolves non-summary purposes from the connected catalog on the session provider', async () => {
+    await writeSettings({});
+    const { generateSmallModelText, createChatCompletion } = createService({
+      catalog: {
+        openai: { id: 'openai', models: { 'gpt-5.5': { id: 'gpt-5.5' } } },
+        google: { id: 'google', models: { 'gemini-2.5-flash': { id: 'gemini-2.5-flash', family: 'gemini-flash' } } },
+      },
+    });
+    const result = await generateSmallModelText({
+      purpose: 'goal',
+      prompt: 'Goal content',
+      preferredProviderID: 'openai',
+      preferredModelID: 'gpt-5.5',
+      restrictToPreferredProvider: true,
+    });
+
+    expect(createChatCompletion).toHaveBeenCalledWith(expect.objectContaining({
+      body: expect.objectContaining({ providerID: 'openai', modelID: 'gpt-5.5' }),
+    }));
+    expect(result).toMatchObject({ source: 'session-model' });
+  });
+
+  it('fails explicitly when no connected provider has a model', async () => {
+    await writeSettings({});
+    const { generateSmallModelText, createChatCompletion } = createService({ catalog: {} });
+
+    await expect(generateSmallModelText({
+      purpose: 'goal',
+      prompt: 'Goal content',
+    })).rejects.toMatchObject({ statusCode: 404 });
+    expect(createChatCompletion).not.toHaveBeenCalled();
+  });
 });

package/server/opencode-proxy.test.js

@@ -379,6 +379,7 @@ describe('OpenCode proxy SSE forwarding', () => {
         isOpenCodeReady: true,
         openCodeNotReadySince: 0,
         isRestartingOpenCode: false,
+        runtimeContract: { executionAllowed: true },
       }),
       getOpenCodeAuthHeaders: () => ({ Authorization: 'Bearer replay-token' }),
       buildOpenCodeUrl: (requestPath) => `${externalBaseUrl}${requestPath}`,
@@ -618,6 +619,7 @@ describe('OpenCode proxy SSE forwarding', () => {
         isOpenCodeReady: true,
         openCodeNotReadySince: 0,
         isRestartingOpenCode: false,
+        runtimeContract: { executionAllowed: true },
       }),
       getOpenCodeAuthHeaders: () => ({}),
       buildOpenCodeUrl: (requestPath) => `${externalBaseUrl}${requestPath}`,