codeep 2.1.0 → 2.1.2

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
@@ -1295,3 +1296,25 @@ The chat sidebar now surfaces two extra ACP signals that previously only the TUI
 - **Diff preview on permission prompts** — manual-mode permission cards now show a `-` / `+` diff for `edit_file`, a content preview for `write_file`, and the full `$ command` + `cwd` for `execute_command`, so users can verify before clicking *Allow*. Payload is truncated (~4 KB per field, 200 lines per file) with a visible marker. Other ACP clients (Zed, etc.) ignore the extra fields silently.
 - **`@file` mentions** — type `@` in the chat input to open a workspace-wide file picker. Pick with arrow keys + Enter; the file's content is inlined into the prompt as an `[Attached files]` preamble. Files over 200 KB are skipped with a marker. Multiple mentions in one message are deduplicated.
 - **Auto-reconnect** — if the CLI process exits unexpectedly (crash, OOM kill, parent restart), the extension reconnects on its own with exponential backoff (1s → 2s → 4s → 8s → 16s → 30s, capped at 6 attempts). The status bar shows the countdown. Configurable idle-watchdog timeout (`codeep.requestTimeoutMinutes`, default 5 min) replaces the old fixed cap so slow reasoning models don't get killed mid-thought.
+
+### Editor-native actions (new in 2.2)
+
+- **Code Actions (lightbulb)** — select code and press `Ctrl+.` for **Explain**, **Improve / refactor**, **Add tests**, and **Add doc comment**. On a line with an error/warning, a **Fix this problem** quick-fix sends the diagnostic plus the code to Codeep. Everything routes through the chat, so the full agent (file edits via the diff preview, MCP tools) is available.
+- **Model picker in the status bar** — click `Codeep · <model>` (or run **Codeep: Select Provider & Model**) to switch provider + model from a quick-pick. Providers with open-ended catalogs (OpenRouter, Ollama, custom endpoints) let you type a model id.
+- **Self-hosted endpoints from settings** — point the extension at vLLM / LiteLLM / LM Studio / text-generation-webui with `codeep.baseUrl` (e.g. `http://localhost:8000/v1`), plus `codeep.provider` (`custom` or `openai`) and `codeep.model`. The `codeep.provider` / `codeep.model` settings are applied on every connect, so they stay authoritative.
+- **Get Started walkthrough** — a native VS Code walkthrough (Help → Get Started) covering CLI install, opening the chat, editor actions, and choosing a model.
+
+> The 2.2 model picker and `custom`-provider settings need CLI **2.1.2+**; they degrade gracefully on older CLIs (free-text model input, and `codeep.baseUrl` still works for the `openai` provider via `OPENAI_BASE_URL`).
+
+### Native chat & agent integration (new in 2.3)
+
+- **`@codeep` chat participant** — invoke Codeep from VS Code's built-in Chat view: type `@codeep` and ask, or `@codeep /explain` / `@codeep /review` with a selection. Answers come from your configured Codeep provider/model via the CLI (not VS Code's model picker), on an independent session.
+- **`#codeepSkills` language-model tool** — exposes your workspace's Codeep skill bundles (`.codeep/skills/*/SKILL.md`) to VS Code agent mode and `#`-references, so the native agent can follow your project's own workflows.
+- Requires VS Code **1.95+** (for the stable Chat Participant + Language Model Tools APIs).
+
+### Source control & sidebar (new in 2.3)
+
+- **Generate Commit Message** — a sparkle button in the Source Control panel (and `Codeep: Generate Commit Message` in the palette) reads your staged diff and writes a Conventional Commits message into the commit box. Falls back to the working-tree diff if nothing is staged; asks before replacing a message you've already typed.
+- **Sessions tree view** — a native **Sessions** view in the Codeep sidebar lists saved conversations (title + age). Click to load into the chat, inline-delete, or start a New Session from the title bar.
+- **MCP config validation** — `.codeep/mcp_servers.json` (project and global) gets JSON schema validation + autocomplete, so a mistyped `command` / `args` / `env` is caught before a session starts.
+- **Workspace Trust** — declares limited support for untrusted workspaces, with a reminder to review permission prompts carefully (Codeep runs a local agent that can edit files and run commands).

package/dist/acp/server.js

@@ -752,6 +752,18 @@ export function startAcpServer() {
                 config.set('model', value);
             }
         }
+        else if (configId === 'provider' && typeof value === 'string') {
+            // Switch provider without specifying a model — picks the provider's
+            // default model + protocol. Used by editor clients that pin a provider
+            // in their settings (e.g. the VS Code `codeep.provider` setting).
+            setProvider(value);
+        }
+        else if (configId === 'customBaseUrl' && typeof value === 'string') {
+            // Base URL for the `custom` (OpenAI-compatible) provider — lets editor
+            // clients point Codeep at a self-hosted endpoint (vLLM/LiteLLM/LM Studio)
+            // without hand-editing ~/.codeep/config.json.
+            config.set('customBaseUrl', value);
+        }
         else if (configId === 'language' && typeof value === 'string') {
             config.set('language', value);
         }
@@ -837,6 +849,14 @@ export function startAcpServer() {
             hint: p.hint ?? p.description,
             requiresKey: !p.noApiKey,
             subscribeUrl: p.subscribeUrl,
+            // Model metadata so ACP clients (e.g. the VS Code model picker) can
+            // offer a provider → model selector without hardcoding a catalog.
+            // `dynamicModels` flags providers whose model list is open-ended
+            // (OpenRouter, Ollama, custom endpoints) — clients should let the
+            // user type a model id rather than only pick from `models`.
+            models: p.models.map((m) => ({ id: m.id, name: m.name })),
+            defaultModel: p.defaultModel,
+            dynamicModels: p.dynamicModels ?? false,
         }));
         transport.respond(msg.id, { providers });
     }

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.2",
   "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",