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);
+  });
+});

tests/ipc/chatHandlersKeychain.test.ts

@@ -24,9 +24,11 @@ const secureKeyStoreInstances: Array<Record<string, any>> = [];
 
 // Per-test overrides for SecureKeyStore mock behavior
 let secureKeyStoreRetrieveResult: string | null = 'encrypted-stored-key';
+let secureKeyStoreRetrieveByKey = new Map<string, string | null>();
 let secureKeyStoreStoreError: Error | null = null;
 let secureKeyStoreRetrieveError: Error | null = null;
 let secureKeyStoreCleanupError: Error | null = null;
+let chatEngineSettingValues = new Map<string, string | null>();
 
 vi.mock('electron', () => ({
   BrowserWindow: {
@@ -55,7 +57,7 @@ vi.mock('../../src/main/engine/ChatEngine', () => ({
   ChatEngine: class {
     constructor() {
       const instance = {
-        getSetting: vi.fn(async () => null),
+        getSetting: vi.fn(async (key: string) => chatEngineSettingValues.get(key) ?? null),
         setSetting: vi.fn(async () => undefined),
         deleteSetting: vi.fn(async () => undefined),
         getSelectedModel: vi.fn(async () => 'gpt-5'),
@@ -75,8 +77,11 @@ vi.mock('../../src/main/engine/SecureKeyStore', () => ({
         store: vi.fn(async (_key: string, _value: string) => {
           if (secureKeyStoreStoreError) throw secureKeyStoreStoreError;
         }),
-        retrieve: vi.fn(async () => {
+        retrieve: vi.fn(async (key: string) => {
           if (secureKeyStoreRetrieveError) throw secureKeyStoreRetrieveError;
+          if (secureKeyStoreRetrieveByKey.has(key)) {
+            return secureKeyStoreRetrieveByKey.get(key) ?? null;
+          }
           return secureKeyStoreRetrieveResult;
         }),
         remove: vi.fn(async () => undefined),
@@ -98,9 +103,17 @@ vi.mock('../../src/main/engine/ai/providers', () => ({
         getOpencodeKey: vi.fn(() => 'abc12345'),
         setMistralKey: vi.fn(),
         getMistralKey: vi.fn(() => ''),
+        setGenericOpenAIEnabled: vi.fn(),
+        isGenericOpenAIEnabled: vi.fn(() => false),
+        setGenericOpenAIBaseURL: vi.fn(),
+        getGenericOpenAIBaseURL: vi.fn(() => ''),
+        setGenericOpenAIApiKey: vi.fn(),
+        getGenericOpenAIApiKey: vi.fn(() => ''),
+        loadGenericOpenAIModelCapabilities: vi.fn(),
+        registerGenericOpenAIModel: vi.fn(),
         isReady: vi.fn(() => true),
         isProviderKeySet: vi.fn(() => true),
-        getProviderStatus: vi.fn(() => ({ opencode: true, mistral: false })),
+        getProviderStatus: vi.fn(() => ({ opencode: true, mistral: false, ollama: false, lmstudio: false, genericOpenAI: false, offlineMode: false })),
         resolveModel: vi.fn(),
         getAvailableModels: vi.fn(async () => []),
         validateOpencodeKey: vi.fn(async () => ({ isValid: true, models: [] })),
@@ -141,9 +154,11 @@ describe('chatHandlers keychain integration', () => {
     providerRegistryInstances.length = 0;
     secureKeyStoreInstances.length = 0;
     secureKeyStoreRetrieveResult = 'encrypted-stored-key';
+    secureKeyStoreRetrieveByKey = new Map();
     secureKeyStoreStoreError = null;
     secureKeyStoreRetrieveError = null;
     secureKeyStoreCleanupError = null;
+    chatEngineSettingValues = new Map();
     vi.resetModules();
   });
 
@@ -282,6 +297,42 @@ describe('chatHandlers keychain integration', () => {
     expect(registry.setOpencodeKey).toHaveBeenCalledWith('encrypted-stored-key');
   });
 
+  it('restores generic endpoint settings from storage on init', async () => {
+    chatEngineSettingValues = new Map([
+      ['generic_openai_enabled', 'true'],
+      ['generic_openai_base_url', 'http://localhost:4000/v1'],
+      ['generic_openai_model_capabilities', JSON.stringify({
+        'custom-model': { tools: true, vision: false },
+      })],
+      ['generic_openai_known_model_ids', JSON.stringify(['custom-model'])],
+    ]);
+    secureKeyStoreRetrieveByKey = new Map([
+      ['opencode_api_key', 'encrypted-stored-key'],
+      ['mistral_api_key', null],
+      ['generic_openai_api_key', 'generic-secret'],
+    ]);
+
+    const mod = await import('../../src/main/ipc/chatHandlers');
+    const mockBundle = { postEngine: {}, mediaEngine: {}, postMediaEngine: {} };
+    mod.initializeChatHandlers(() => mainWindowMock as never, mockBundle as any);
+    mod.registerChatHandlers();
+
+    const handler = registeredHandlers.get('chat:checkReady');
+    await handler!(undefined);
+
+    const registry = providerRegistryInstances[0];
+    expect(registry.setGenericOpenAIEnabled).toHaveBeenCalledWith(true);
+    expect(registry.setGenericOpenAIBaseURL).toHaveBeenCalledWith('http://localhost:4000/v1');
+    expect(registry.setGenericOpenAIApiKey).toHaveBeenCalledWith('generic-secret');
+    expect(registry.loadGenericOpenAIModelCapabilities).toHaveBeenCalledWith({
+      'custom-model': { tools: true, vision: false },
+    });
+    expect(registry.registerGenericOpenAIModel).toHaveBeenCalledWith('custom-model');
+
+    const keyStore = secureKeyStoreInstances[0];
+    expect(keyStore.retrieve).toHaveBeenCalledWith('generic_openai_api_key');
+  });
+
   it('returns error and rolls back in-memory key when store() throws on chat:setApiKey', async () => {
     secureKeyStoreStoreError = new Error('encryption unavailable');
 

tests/renderer/components/SettingsView.test.tsx

@@ -1,6 +1,6 @@
 import React from 'react';
 import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { render, screen, fireEvent, waitFor, act } from '@testing-library/react';
+import { render, screen, fireEvent, waitFor, act, within } from '@testing-library/react';
 import { SettingsView } from '../../../src/renderer/components/SettingsView/SettingsView';
 import { useAppStore } from '../../../src/renderer/store';
 
@@ -24,6 +24,8 @@ describe('MCPAgentButton uninstall', () => {
       app: { getDefaultProjectPath: vi.fn().mockResolvedValue('/repo') },
       meta: {
         getCategories: vi.fn().mockResolvedValue(['article']),
+        getPublishingPreferences: vi.fn().mockResolvedValue(null),
+        setPublishingPreferences: vi.fn().mockResolvedValue({}),
         getProjectMetadata: vi.fn().mockResolvedValue({
           maxPostsPerPage: 75,
           publicUrl: 'https://example.com',
@@ -36,6 +38,17 @@ describe('MCPAgentButton uninstall', () => {
         getApiKey: vi.fn().mockResolvedValue({ hasKey: false, maskedKey: '' }),
         getAvailableModels: vi.fn().mockResolvedValue({ success: true, models: [], selectedModel: '' }),
         getMistralApiKey: vi.fn().mockResolvedValue({ hasKey: false, maskedKey: '' }),
+        getOllamaEnabled: vi.fn().mockResolvedValue(false),
+        getLmstudioEnabled: vi.fn().mockResolvedValue(false),
+        getGenericOpenAIEnabled: vi.fn().mockResolvedValue(false),
+        getGenericOpenAIBaseURL: vi.fn().mockResolvedValue(''),
+        getGenericOpenAIApiKey: vi.fn().mockResolvedValue({ hasKey: false, maskedKey: '' }),
+        getGenericOpenAIModelCapabilities: vi.fn().mockResolvedValue({}),
+        getGenericOpenAIModels: vi.fn().mockResolvedValue([]),
+        getOfflineMode: vi.fn().mockResolvedValue(false),
+        getOfflineChatModel: vi.fn().mockResolvedValue({ success: true, modelId: null }),
+        getOfflineTitleModel: vi.fn().mockResolvedValue({ success: true, modelId: null }),
+        getOfflineImageAnalysisModel: vi.fn().mockResolvedValue({ success: true, modelId: null }),
         getTitleModel: vi.fn().mockResolvedValue({ success: true, modelId: 'claude-haiku-4-5' }),
         getImageAnalysisModel: vi.fn().mockResolvedValue({ success: true, modelId: 'claude-sonnet-4-5' }),
         getModelCatalog: vi.fn().mockResolvedValue({ success: true, entries: [] }),
@@ -114,6 +127,8 @@ describe('SettingsView Diff Preferences', () => {
       meta: {
         ...(window as any).electronAPI?.meta,
         getCategories: vi.fn().mockResolvedValue(['article', 'picture', 'aside', 'page']),
+        getPublishingPreferences: vi.fn().mockResolvedValue(null),
+        setPublishingPreferences: vi.fn().mockResolvedValue({}),
         getProjectMetadata: vi.fn().mockResolvedValue({
           maxPostsPerPage: 75,
           publicUrl: 'https://example.com',
@@ -131,6 +146,17 @@ describe('SettingsView Diff Preferences', () => {
         getSystemPrompt: vi.fn().mockResolvedValue({ success: true, prompt: '' }),
         getApiKey: vi.fn().mockResolvedValue({ hasKey: false, maskedKey: '' }),
         getAvailableModels: vi.fn().mockResolvedValue({ success: true, models: [], selectedModel: '' }),
+        getOllamaEnabled: vi.fn().mockResolvedValue(false),
+        getLmstudioEnabled: vi.fn().mockResolvedValue(false),
+        getGenericOpenAIEnabled: vi.fn().mockResolvedValue(false),
+        getGenericOpenAIBaseURL: vi.fn().mockResolvedValue(''),
+        getGenericOpenAIApiKey: vi.fn().mockResolvedValue({ hasKey: false, maskedKey: '' }),
+        getGenericOpenAIModelCapabilities: vi.fn().mockResolvedValue({}),
+        getGenericOpenAIModels: vi.fn().mockResolvedValue([]),
+        getOfflineMode: vi.fn().mockResolvedValue(false),
+        getOfflineChatModel: vi.fn().mockResolvedValue({ success: true, modelId: null }),
+        getOfflineTitleModel: vi.fn().mockResolvedValue({ success: true, modelId: null }),
+        getOfflineImageAnalysisModel: vi.fn().mockResolvedValue({ success: true, modelId: null }),
       },
       templates: {
         ...(window as any).electronAPI?.templates,
@@ -395,3 +421,101 @@ describe('SettingsView Diff Preferences', () => {
     );
   });
 });
+
+describe('SettingsView generic endpoint refresh', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    useAppStore.setState({
+      activeProject: {
+        id: 'project-1',
+        name: 'Test Project',
+        slug: 'test-project',
+        isActive: true,
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+      },
+      gitDiffPreferences: {
+        wordWrap: true,
+        viewStyle: 'inline',
+        hideUnchangedRegions: false,
+      },
+    });
+
+    (window as any).electronAPI = {
+      ...(window as any).electronAPI,
+      app: {
+        ...(window as any).electronAPI?.app,
+        getDefaultProjectPath: vi.fn().mockResolvedValue('/repo/path'),
+      },
+      meta: {
+        ...(window as any).electronAPI?.meta,
+        getCategories: vi.fn().mockResolvedValue(['article']),
+        getPublishingPreferences: vi.fn().mockResolvedValue(null),
+        setPublishingPreferences: vi.fn().mockResolvedValue({}),
+        getProjectMetadata: vi.fn().mockResolvedValue({
+          maxPostsPerPage: 75,
+          publicUrl: 'https://example.com',
+          categorySettings: { article: { renderInLists: true, showTitle: true } },
+        }),
+        updateProjectMetadata: vi.fn().mockResolvedValue({}),
+      },
+      chat: {
+        ...(window as any).electronAPI?.chat,
+        getSystemPrompt: vi.fn().mockResolvedValue({ success: true, prompt: '' }),
+        getApiKey: vi.fn().mockResolvedValue({ hasKey: false, maskedKey: '' }),
+        getAvailableModels: vi.fn().mockResolvedValue({ success: true, models: [], selectedModel: '' }),
+        getMistralApiKey: vi.fn().mockResolvedValue({ hasKey: false, maskedKey: '' }),
+        getTitleModel: vi.fn().mockResolvedValue({ success: true, modelId: null }),
+        getImageAnalysisModel: vi.fn().mockResolvedValue({ success: true, modelId: null }),
+        getModelCatalog: vi.fn().mockResolvedValue({ success: true, entries: [] }),
+        getOllamaEnabled: vi.fn().mockResolvedValue(false),
+        getLmstudioEnabled: vi.fn().mockResolvedValue(false),
+        getGenericOpenAIEnabled: vi.fn().mockResolvedValue(true),
+        getGenericOpenAIBaseURL: vi.fn().mockResolvedValue('http://localhost:4000/v1'),
+        getGenericOpenAIApiKey: vi.fn().mockResolvedValue({ hasKey: false, maskedKey: '' }),
+        getGenericOpenAIModelCapabilities: vi.fn().mockResolvedValue({}),
+        getGenericOpenAIModels: vi.fn()
+          .mockResolvedValueOnce([])
+          .mockResolvedValueOnce([{ id: 'generic-model', name: 'Generic Model' }]),
+        setGenericOpenAIBaseURL: vi.fn().mockResolvedValue({ success: true }),
+        getOfflineMode: vi.fn().mockResolvedValue(false),
+        getOfflineChatModel: vi.fn().mockResolvedValue({ success: true, modelId: null }),
+        getOfflineTitleModel: vi.fn().mockResolvedValue({ success: true, modelId: null }),
+        getOfflineImageAnalysisModel: vi.fn().mockResolvedValue({ success: true, modelId: null }),
+      },
+      templates: {
+        ...(window as any).electronAPI?.templates,
+        getEnabledByKind: vi.fn().mockResolvedValue([]),
+      },
+      projects: {
+        ...(window as any).electronAPI?.projects,
+        update: vi.fn().mockResolvedValue({}),
+      },
+      mcp: {
+        ...(window as any).electronAPI?.mcp,
+        getAgents: vi.fn().mockResolvedValue([]),
+        isConfigured: vi.fn().mockResolvedValue(false),
+        getPort: vi.fn().mockResolvedValue(4124),
+      },
+    };
+  });
+
+  it('reloads generic models after saving the generic endpoint base URL', async () => {
+    render(<SettingsView />);
+
+    const baseUrlInput = await screen.findByLabelText(/base url/i);
+    const field = baseUrlInput.closest('.setting-field');
+    expect(field).not.toBeNull();
+
+    const saveButton = within(field as HTMLElement).getByRole('button', { name: /save/i });
+
+    await act(async () => {
+      fireEvent.click(saveButton);
+    });
+
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    expect((window as any).electronAPI.chat.getAvailableModels).toHaveBeenCalledTimes(2);
+    expect((window as any).electronAPI.chat.getGenericOpenAIModels).toHaveBeenCalledTimes(2);
+  });
+});