Feat/generic OpenAI provider (#68)

* feat: added a generic openai endpoint provider for self-hosted models

* feat: proper vision and tool checkbox for generic endpoint

---------

Co-authored-by: hugo <hugoms@me.com>

tests/engine/ai-sdk-phase2.test.ts

@@ -140,15 +140,15 @@ describe('ProviderRegistry', () => {
     });
 
     it('getProviderStatus() reports all providers', () => {
-      expect(registry.getProviderStatus()).toEqual({ opencode: false, mistral: false, ollama: false, lmstudio: false, offlineMode: false });
+      expect(registry.getProviderStatus()).toEqual({ opencode: false, mistral: false, ollama: false, lmstudio: false, genericOpenAI: false, offlineMode: false });
       registry.setOpencodeKey('test');
-      expect(registry.getProviderStatus()).toEqual({ opencode: true, mistral: false, ollama: false, lmstudio: false, offlineMode: false });
+      expect(registry.getProviderStatus()).toEqual({ opencode: true, mistral: false, ollama: false, lmstudio: false, genericOpenAI: false, offlineMode: false });
       registry.setMistralKey('test2');
-      expect(registry.getProviderStatus()).toEqual({ opencode: true, mistral: true, ollama: false, lmstudio: false, offlineMode: false });
+      expect(registry.getProviderStatus()).toEqual({ opencode: true, mistral: true, ollama: false, lmstudio: false, genericOpenAI: false, offlineMode: false });
       registry.setOllamaEnabled(true);
-      expect(registry.getProviderStatus()).toEqual({ opencode: true, mistral: true, ollama: true, lmstudio: false, offlineMode: false });
+      expect(registry.getProviderStatus()).toEqual({ opencode: true, mistral: true, ollama: true, lmstudio: false, genericOpenAI: false, offlineMode: false });
       registry.setLmstudioEnabled(true);
-      expect(registry.getProviderStatus()).toEqual({ opencode: true, mistral: true, ollama: true, lmstudio: true, offlineMode: false });
+      expect(registry.getProviderStatus()).toEqual({ opencode: true, mistral: true, ollama: true, lmstudio: true, genericOpenAI: false, offlineMode: false });
     });
 
     it('isProviderKeySet() checks per-provider', () => {

tests/engine/generic-openai-chat-service.test.ts

@@ -0,0 +1,106 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const { mockStreamText, mockGenerateText } = vi.hoisted(() => ({
+  mockStreamText: vi.fn(),
+  mockGenerateText: vi.fn(),
+}));
+
+vi.mock('ai', async () => {
+  const actual = await vi.importActual<typeof import('ai')>('ai');
+  return {
+    ...actual,
+    streamText: mockStreamText,
+    generateText: mockGenerateText,
+    stepCountIs: vi.fn(() => undefined),
+  };
+});
+
+vi.mock('../../src/main/engine/ModelCatalogEngine', () => ({
+  ModelCatalogEngine: class {
+    getAll = vi.fn().mockResolvedValue([]);
+    getContextWindow = vi.fn().mockResolvedValue(8192);
+  },
+}));
+
+import { ChatService } from '../../src/main/engine/ai/chat';
+import { ProviderRegistry } from '../../src/main/engine/ai/providers';
+
+function createChatEngine() {
+  return {
+    getConversation: vi.fn(async () => ({
+      id: 'conv-1',
+      title: 'Untitled',
+      model: 'generic-model',
+      createdAt: new Date(),
+      messages: [],
+    })),
+    addMessage: vi.fn(async () => undefined),
+    getDefaultSystemPrompt: vi.fn(async () => 'You are a helpful assistant'),
+    getSetting: vi.fn(async (key: string) => {
+      if (key === 'chat_title_model') {
+        return 'generic-model';
+      }
+      return null;
+    }),
+    updateConversation: vi.fn(async () => undefined),
+  } as any;
+}
+
+describe('ChatService generic OpenAI endpoint support', () => {
+  let registry: ProviderRegistry;
+  let chatEngine: ReturnType<typeof createChatEngine>;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+
+    mockStreamText.mockResolvedValue({
+      response: Promise.resolve(),
+      usage: Promise.resolve(undefined),
+      text: Promise.resolve('assistant reply'),
+    });
+    mockGenerateText.mockResolvedValue({ text: 'Generic Title' });
+
+    registry = new ProviderRegistry();
+    registry.setGenericOpenAIEnabled(true);
+    registry.setGenericOpenAIBaseURL('http://localhost:4000/v1');
+    registry.registerGenericOpenAIModel('generic-model');
+    vi.spyOn(registry, 'resolveModel').mockReturnValue({ modelId: 'generic-model' } as any);
+
+    chatEngine = createChatEngine();
+  });
+
+  it('skips tools for generic models when tools capability is disabled', async () => {
+    registry.setGenericOpenAIModelCapabilities('generic-model', { tools: false, vision: false });
+
+    const service = new ChatService(chatEngine, registry, {
+      postEngine: {} as any,
+      mediaEngine: {} as any,
+      postMediaEngine: {} as any,
+    }, () => null);
+
+    const result = await service.sendMessage('conv-1', 'Hello');
+
+    expect(result.success).toBe(true);
+    expect(mockStreamText).toHaveBeenCalledWith(expect.objectContaining({
+      tools: undefined,
+    }));
+  });
+
+  it('generates a title with the configured generic endpoint title model', async () => {
+    registry.setGenericOpenAIModelCapabilities('generic-model', { tools: false, vision: false });
+
+    const service = new ChatService(chatEngine, registry, {
+      postEngine: {} as any,
+      mediaEngine: {} as any,
+      postMediaEngine: {} as any,
+    }, () => null);
+
+    await (service as any).generateConversationTitle('conv-1', 'Hello');
+
+    expect(mockGenerateText).toHaveBeenCalledWith(expect.objectContaining({
+      model: expect.anything(),
+      prompt: 'Topic: Hello',
+    }));
+    expect(chatEngine.updateConversation).toHaveBeenCalledWith('conv-1', { title: 'Generic Title' });
+  });
+});

tests/engine/generic-openai-provider.test.ts

@@ -0,0 +1,58 @@
+/**
+ * Tests for generic OpenAI-compatible endpoint support in ProviderRegistry.
+ */
+
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { ProviderRegistry } from '../../src/main/engine/ai/providers';
+
+vi.mock('../../src/main/engine/ModelCatalogEngine', () => ({
+  ModelCatalogEngine: class {
+    getAll = vi.fn().mockResolvedValue([]);
+    getContextWindow = vi.fn().mockResolvedValue(null);
+  },
+}));
+
+describe('generic OpenAI-compatible provider support', () => {
+  let registry: ProviderRegistry;
+
+  beforeEach(() => {
+    registry = new ProviderRegistry();
+  });
+
+  it('fetchGenericOpenAIModels does not duplicate the v1 path when base URL already ends with /v1', async () => {
+    registry.setGenericOpenAIEnabled(true);
+    registry.setGenericOpenAIBaseURL('http://localhost:4000/v1');
+
+    const mockFetch = vi.fn().mockResolvedValue({
+      ok: true,
+      json: async () => ({
+        data: [{ id: 'custom-model' }],
+      }),
+    });
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = mockFetch;
+
+    try {
+      const models = await registry.fetchGenericOpenAIModels();
+      expect(mockFetch).toHaveBeenCalledWith(
+        'http://localhost:4000/v1/models',
+        expect.objectContaining({ method: 'GET', signal: expect.any(AbortSignal) }),
+      );
+      expect(models).toHaveLength(1);
+      expect(models[0]).toMatchObject({ id: 'custom-model', provider: 'generic-openai' });
+    } finally {
+      globalThis.fetch = originalFetch;
+    }
+  });
+
+  it('does not treat generic endpoint models as local when airplane mode is active', () => {
+    registry.setGenericOpenAIEnabled(true);
+    registry.setGenericOpenAIBaseURL('http://localhost:4000/v1');
+    registry.registerGenericOpenAIModel('custom-model');
+    registry.setOfflineMode(true);
+
+    expect(registry.isReady()).toBe(false);
+    expect(registry.getKnownLocalModels()).toEqual([]);
+    expect(() => registry.resolveModel('custom-model')).toThrow(/not available offline/i);
+  });
+});