codeep 2.1.0 → 2.1.1

package/README.md

@@ -56,6 +56,7 @@ custom slash commands, lifecycle hooks, checkpoints, `/cost`,
 - **MiniMax** — MiniMax M2.7, M2.5, M2.1, M2 — Coding Plan & pay-per-use API (international & China)
 - **Ollama** — Run any model locally or on a remote server, no API key required. Models are fetched dynamically from your Ollama instance.
 - **OpenRouter** — One key, 100+ models from Anthropic, OpenAI, Google, Meta, Mistral, DeepSeek, Qwen, xAI and more. Per-call cost reported directly by OpenRouter (matches their dashboard exactly). Use `openrouter/auto` to let OpenRouter pick the best model. Tune routing with `/openrouter prefer|ignore|fallbacks|privacy`.
+- **Custom (OpenAI-compatible)** — Point Codeep at any self-hosted or proxied OpenAI-compatible endpoint (vLLM, LiteLLM, LM Studio, text-generation-webui). Set the base URL in `/settings` → **Custom Base URL** (config key `customBaseUrl`, e.g. `http://host:8000/v1`), then pick your model with `/model` (fetched from the server's `/models`). No API key required unless your endpoint enforces one. The `openai` provider also honors the `OPENAI_BASE_URL` env var for proxies that serve `gpt-*` model names.
 - Switch between providers with `/provider`
 - Configure different API keys per provider
 - Both OpenAI-compatible and Anthropic API protocols supported

package/dist/api/index.js

@@ -1,6 +1,6 @@
 import * as http from 'node:http';
 import * as https from 'node:https';
-import { config, getApiKey } from '../config/index.js';
+import { config, getApiKey, resolveBaseUrl } from '../config/index.js';
 import { withRetry, isNetworkError } from '../utils/retry.js';
 import { getProvider, getProviderBaseUrl, getProviderAuthHeader, usesMaxCompletionTokens, requiresDefaultTemperature } from '../config/providers.js';
 import { logApiRequest, logApiResponse } from '../utils/logger.js';
@@ -336,14 +336,11 @@ async function chatOpenAI(message, history, model, apiKey, onChunk, abortSignal)
     const timeout = config.get('apiTimeout');
     const temperature = config.get('temperature');
     const maxTokens = config.get('maxTokens');
-    // Get provider-specific URL and auth
+    // Get provider-specific URL and auth. resolveBaseUrl applies user
+    // overrides: Ollama (ollamaUrl), Custom (customBaseUrl), and OpenAI
+    // (OPENAI_BASE_URL env) — so self-hosted / OpenAI-compatible endpoints work.
     const providerId = config.get('provider');
-    let baseUrl = getProviderBaseUrl(providerId, 'openai');
-    // For Ollama, use the configured URL (can't use lazy require in ESM providers.ts)
-    if (providerId === 'ollama') {
-        const ollamaUrl = (config.get('ollamaUrl') || 'http://localhost:11434').replace(/\/$/, '');
-        baseUrl = `${ollamaUrl}/v1`;
-    }
+    let baseUrl = resolveBaseUrl(providerId, 'openai');
     const authHeader = getProviderAuthHeader(providerId, 'openai');
     const useCompletionTokens = usesMaxCompletionTokens(providerId);
     const omitTemperature = requiresDefaultTemperature(providerId);
@@ -747,11 +744,7 @@ export async function validateApiKey(apiKey, providerId) {
     }
     // Determine which protocol to use for validation
     const protocol = providerConfig.defaultProtocol;
-    let baseUrl = getProviderBaseUrl(provider, protocol);
-    if (provider === 'ollama' && protocol === 'openai') {
-        const ollamaUrl = (config.get('ollamaUrl') || 'http://localhost:11434').replace(/\/$/, '');
-        baseUrl = `${ollamaUrl}/v1`;
-    }
+    const baseUrl = resolveBaseUrl(provider, protocol);
     const authHeader = getProviderAuthHeader(provider, protocol);
     const model = providerConfig.defaultModel;
     if (!baseUrl) {

package/dist/config/index.d.ts

@@ -35,6 +35,7 @@ interface ConfigSchema {
     rateLimitCommands: number;
     agentMode: AgentMode;
     ollamaUrl: string;
+    customBaseUrl: string;
     agentConfirmation: 'always' | 'dangerous' | 'never';
     agentConfirmDeleteFile: boolean;
     agentConfirmExecuteCommand: boolean;
@@ -134,6 +135,26 @@ export declare function fetchOllamaModels(baseUrl?: string): Promise<{
     name: string;
     description: string;
 }[] | null>;
+/**
+ * Fetch the model list from an OpenAI-compatible server's `/models`
+ * endpoint (vLLM, LiteLLM, LM Studio, etc.). `baseUrl` is the full base
+ * (e.g. http://host:8000/v1). Returns null on error.
+ */
+export declare function fetchOpenAiCompatibleModels(baseUrl: string, apiKey?: string): Promise<{
+    id: string;
+    name: string;
+    description: string;
+}[] | null>;
+/**
+ * Resolve the effective OpenAI-protocol base URL for a provider, honoring
+ * user overrides the static provider table can't express:
+ *   - ollama  → configured `ollamaUrl` + /v1
+ *   - custom  → configured `customBaseUrl` (full base, e.g. http://host:8000/v1)
+ *   - openai  → the OPENAI_BASE_URL env var, if set (OpenAI-SDK convention)
+ * Falls back to the provider's hardcoded base URL. Only the `openai`
+ * protocol takes overrides; the anthropic protocol uses the static table.
+ */
+export declare function resolveBaseUrl(providerId: string, protocol: 'openai' | 'anthropic'): string | null;
 export { PROVIDERS } from './providers';
 export declare function getCurrentSessionId(): string;
 export declare function startNewSession(): string;

package/dist/config/index.js

@@ -2,7 +2,7 @@ import Conf from 'conf';
 import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync, unlinkSync, statSync } from 'fs';
 import { join, dirname } from 'path';
 import { randomUUID } from 'crypto';
-import { PROVIDERS, getProvider } from './providers.js';
+import { PROVIDERS, getProvider, getProviderBaseUrl } from './providers.js';
 import { logSession } from '../utils/logger.js';
 // We'll initialize GLOBAL_SESSIONS_DIR after config is created (to use config.path)
 /**
@@ -144,6 +144,7 @@ function createConfig() {
         model: 'glm-5.1',
         agentMode: 'on',
         ollamaUrl: 'http://localhost:11434',
+        customBaseUrl: '',
         agentConfirmation: 'dangerous',
         agentConfirmDeleteFile: true,
         agentConfirmExecuteCommand: true,
@@ -531,6 +532,59 @@ export async function fetchOllamaModels(baseUrl) {
         return null;
     }
 }
+/**
+ * Fetch the model list from an OpenAI-compatible server's `/models`
+ * endpoint (vLLM, LiteLLM, LM Studio, etc.). `baseUrl` is the full base
+ * (e.g. http://host:8000/v1). Returns null on error.
+ */
+export async function fetchOpenAiCompatibleModels(baseUrl, apiKey) {
+    const base = (baseUrl || '').trim().replace(/\/+$/, '');
+    if (!base)
+        return null;
+    try {
+        const headers = {};
+        if (apiKey)
+            headers['Authorization'] = `Bearer ${apiKey}`;
+        const res = await fetch(`${base}/models`, { headers, signal: AbortSignal.timeout(5000) });
+        if (!res.ok)
+            return null;
+        const data = await res.json();
+        if (!Array.isArray(data.data))
+            return null;
+        return data.data.map(m => ({ id: m.id, name: m.id, description: '' }));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Resolve the effective OpenAI-protocol base URL for a provider, honoring
+ * user overrides the static provider table can't express:
+ *   - ollama  → configured `ollamaUrl` + /v1
+ *   - custom  → configured `customBaseUrl` (full base, e.g. http://host:8000/v1)
+ *   - openai  → the OPENAI_BASE_URL env var, if set (OpenAI-SDK convention)
+ * Falls back to the provider's hardcoded base URL. Only the `openai`
+ * protocol takes overrides; the anthropic protocol uses the static table.
+ */
+export function resolveBaseUrl(providerId, protocol) {
+    const fallback = getProviderBaseUrl(providerId, protocol);
+    if (protocol !== 'openai')
+        return fallback;
+    if (providerId === 'ollama') {
+        const u = (config.get('ollamaUrl') || 'http://localhost:11434').replace(/\/+$/, '');
+        return `${u}/v1`;
+    }
+    if (providerId === 'custom') {
+        const u = (config.get('customBaseUrl') || '').trim().replace(/\/+$/, '');
+        return u || fallback;
+    }
+    if (providerId === 'openai') {
+        const env = (process.env.OPENAI_BASE_URL || '').trim().replace(/\/+$/, '');
+        if (env)
+            return env;
+    }
+    return fallback;
+}
 // Re-export PROVIDERS for convenience
 export { PROVIDERS } from './providers.js';
 // Generate unique session ID

package/dist/config/providers.js

@@ -331,6 +331,24 @@ export const PROVIDERS = {
         groupLabel: 'Ollama (local)',
         hint: 'Runs locally — no API key or account needed.',
     },
+    'custom': {
+        name: 'Custom (OpenAI-compatible)',
+        description: 'Any OpenAI-compatible endpoint — vLLM, LiteLLM, LM Studio',
+        protocols: {
+            openai: {
+                baseUrl: 'http://localhost:8000/v1',
+                authHeader: 'Bearer',
+                supportsNativeTools: true,
+            },
+        },
+        models: [],
+        defaultModel: '',
+        defaultProtocol: 'openai',
+        noApiKey: true, // key optional — sent as Bearer only if you set one
+        dynamicModels: true,
+        groupLabel: 'Custom',
+        hint: 'Point at any OpenAI-compatible server. Set the URL in /settings (Custom Base URL) or the OPENAI_BASE_URL env var, then pick your model with /model.',
+    },
 };
 export function getProvider(id) {
     return PROVIDERS[id] || null;
@@ -354,6 +372,7 @@ const DISPLAY_ORDER = [
     'minimax',
     'minimax-api',
     'ollama',
+    'custom',
     'z.ai-cn',
     'z.ai-cn-api',
     'minimax-cn',

package/dist/renderer/commands.js

@@ -120,6 +120,23 @@ export async function handleCommand(command, args, ctx) {
                     });
                     break;
                 }
+                if (providerId === 'custom') {
+                    const base = config.get('customBaseUrl') || 'http://localhost:8000/v1';
+                    ctx.app.notify(`Fetching models from ${base}…`);
+                    const { fetchOpenAiCompatibleModels, getApiKey: _getKey } = await import('../config/index.js');
+                    const models = await fetchOpenAiCompatibleModels(base, _getKey('custom') || undefined);
+                    if (!models || models.length === 0) {
+                        ctx.app.notify(`Could not list models from ${base}. Set the base URL in /settings, or set the model directly (config key "model").`);
+                        break;
+                    }
+                    const modelItems = models.map(m => ({ key: m.id, label: m.name, description: '' }));
+                    const currentModel = config.get('model');
+                    ctx.app.showSelect(`Select Model (${models.length})`, modelItems, currentModel, (item) => {
+                        config.set('model', item.key);
+                        ctx.app.notify(`Model: ${item.key}`);
+                    });
+                    break;
+                }
                 const { fetchOllamaModels } = await import('../config/index.js');
                 ctx.app.notify('Fetching models from Ollama...');
                 const ollamaModels = await fetchOllamaModels();

package/dist/renderer/components/Settings.js

@@ -131,6 +131,12 @@ export const SETTINGS = [
         getValue: () => config.get('ollamaUrl') || 'http://localhost:11434',
         type: 'text',
     },
+    {
+        key: 'customBaseUrl',
+        label: 'Custom Base URL',
+        getValue: () => config.get('customBaseUrl') || '',
+        type: 'text',
+    },
     {
         key: 'agentApiTimeout',
         label: 'Agent API Timeout (ms)',

package/dist/renderer/main.js

@@ -252,6 +252,14 @@ async function showLoginFlow() {
                 else if (event.key === 'enter') {
                     selectedProvider = providers[selectedProviderIndex];
                     setProvider(selectedProvider.id);
+                    // Providers that don't need a key (Ollama, Custom OpenAI-compatible)
+                    // skip the API-key prompt entirely. Configure their endpoint in
+                    // /settings (Ollama URL / Custom Base URL) once inside the app.
+                    if (selectedProvider.noApiKey) {
+                        cleanup();
+                        resolve('ollama'); // non-null sentinel so the caller proceeds
+                        return;
+                    }
                     currentStep = 'apikey';
                     loginScreen = new LoginScreen(screen, input, {
                         providerName: selectedProvider.name,

package/dist/utils/agentChat.js

@@ -13,10 +13,10 @@
  */
 import { existsSync, readFileSync, writeFileSync } from 'fs';
 import { join } from 'path';
-import { config, getApiKey } from '../config/index.js';
+import { config, getApiKey, resolveBaseUrl } from '../config/index.js';
 import { loadProjectIntelligence, generateContextFromIntelligence } from './projectIntelligence.js';
 import { syncProgress, generateProjectId } from './codeepCloud.js';
-import { getProviderBaseUrl, getProviderAuthHeader, supportsNativeTools, getEffectiveMaxTokens, usesMaxCompletionTokens, requiresDefaultTemperature, isNoApiKeyProvider } from '../config/providers.js';
+import { getProviderAuthHeader, supportsNativeTools, getEffectiveMaxTokens, usesMaxCompletionTokens, requiresDefaultTemperature, isNoApiKeyProvider } from '../config/providers.js';
 import { recordTokenUsage, extractOpenAIUsage, extractAnthropicUsage } from './tokenTracker.js';
 import { parseOpenAIToolCalls, parseAnthropicToolCalls, parseToolCalls } from './toolParsing.js';
 import { formatToolDefinitions, getOpenAITools, getAnthropicTools } from './tools.js';
@@ -239,11 +239,7 @@ additionalTools) {
     const model = config.get('model');
     const providerId = config.get('provider');
     const apiKey = getApiKey() || (isNoApiKeyProvider(providerId) ? 'ollama' : null);
-    let baseUrl = getProviderBaseUrl(providerId, protocol);
-    if (providerId === 'ollama' && protocol === 'openai') {
-        const ollamaUrl = (config.get('ollamaUrl') || 'http://localhost:11434').replace(/\/$/, '');
-        baseUrl = `${ollamaUrl}/v1`;
-    }
+    let baseUrl = resolveBaseUrl(providerId, protocol);
     const authHeader = getProviderAuthHeader(providerId, protocol);
     if (!baseUrl)
         throw new Error(`Provider ${providerId} does not support ${protocol} protocol`);
@@ -413,11 +409,7 @@ export async function agentChatFallback(messages, systemPrompt, onChunk, abortSi
     const model = config.get('model');
     const providerId = config.get('provider');
     const apiKey = getApiKey() || (isNoApiKeyProvider(providerId) ? 'ollama' : null);
-    let baseUrl = getProviderBaseUrl(providerId, protocol);
-    if (providerId === 'ollama' && protocol === 'openai') {
-        const ollamaUrl = (config.get('ollamaUrl') || 'http://localhost:11434').replace(/\/$/, '');
-        baseUrl = `${ollamaUrl}/v1`;
-    }
+    let baseUrl = resolveBaseUrl(providerId, protocol);
     const authHeader = getProviderAuthHeader(providerId, protocol);
     if (!baseUrl)
         throw new Error(`Provider ${providerId} does not support ${protocol} protocol`);

package/dist/utils/taskPlanner.js

@@ -1,8 +1,8 @@
 /**
  * Task Planning - breaks down complex tasks into subtasks
  */
-import { config, getApiKey } from '../config/index.js';
-import { getProviderBaseUrl, getProviderAuthHeader, requiresDefaultTemperature } from '../config/providers.js';
+import { config, getApiKey, resolveBaseUrl } from '../config/index.js';
+import { getProviderAuthHeader, requiresDefaultTemperature } from '../config/providers.js';
 /**
  * Ask AI to break down a complex task into subtasks
  */
@@ -43,7 +43,7 @@ Break this down into subtasks. Each task = one file or one logical unit. Respond
         const protocol = config.get('protocol');
         const provider = config.get('provider');
         const model = config.get('model');
-        const baseUrl = getProviderBaseUrl(provider, protocol);
+        const baseUrl = resolveBaseUrl(provider, protocol);
         const authHeaderType = getProviderAuthHeader(provider, protocol);
         const messages = [
             { role: 'user', content: systemPrompt }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeep",
-  "version": "2.1.0",
+  "version": "2.1.1",
   "description": "AI-powered coding assistant built for the terminal. Multiple LLM providers, project-aware context, and a seamless development workflow.",
   "type": "module",
   "main": "dist/index.js",