codeep 2.3.1 → 2.4.1

package/README.md

@@ -48,12 +48,12 @@ custom slash commands, lifecycle hooks, checkpoints, `/cost`,
 ## Features
 
 ### Multi-Provider Support
-- **Z.AI (ZhipuAI)** — GLM-5.1, GLM-5, GLM-5 Turbo, GLM-4.5 Air — Coding Plan & pay-per-use API (international & China)
-- **OpenAI** — GPT-5.5, GPT-5.4, GPT-5.4 Mini, GPT-5.4 Nano
-- **Anthropic** — Claude Opus 4.7, Claude Opus 4.6, Claude Sonnet 4.6, Claude Haiku 4.5
-- **DeepSeek** — DeepSeek V4 Pro, DeepSeek V4 Flash
-- **Google AI** — Gemini 3.1 Pro Preview, Gemini 3 Flash Preview, Gemini 2.5 Pro, Gemini 2.5 Flash
-- **MiniMax** — MiniMax M2.7, M2.5, M2.1, M2 — Coding Plan & pay-per-use API (international & China)
+- **Z.AI (ZhipuAI)** — GLM models (Coding Plan & pay-per-use API, international & China)
+- **OpenAI** — GPT models (flagship, Mini, Nano)
+- **Anthropic** — Claude models (Opus, Sonnet, Haiku)
+- **DeepSeek** — DeepSeek models (Pro, Flash)
+- **Google AI** — Gemini models (Pro, Flash)
+- **MiniMax** — MiniMax models (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.
@@ -1016,6 +1016,8 @@ In `dangerous` mode, configure which tools require confirmation via `/settings`:
 | `/memory remove <n>` | Remove note by index |
 | `/memory clear` | Clear all notes |
 | `/model pull <name>` | Pull an Ollama model (local Ollama only) |
+| `/model browse` | Browse a curated catalog of local coding models and pull one (Ollama) |
+| `/model rm <name>` | Remove a locally-installed Ollama model (local only) |
 
 ### Skills
 

package/dist/api/index.js

@@ -394,6 +394,30 @@ async function chatOpenAI(message, history, model, apiKey, onChunk, abortSignal)
         ...(openRouterProvider ? { provider: openRouterProvider } : {}),
     });
     try {
+        // Opt-in native Ollama transport (plain chat). When `ollamaNativeApi` is on,
+        // route through /api/chat so num_ctx + keep_alive apply and the real context
+        // window is used. OFF by default → falls through to the /v1 shim below
+        // unchanged. Plain chat sends no tools, so the native call is simple here.
+        if (providerId === 'ollama' && config.get('ollamaNativeApi') === true) {
+            const { streamOllamaNativeChat, getOllamaContextLength } = await import('./ollamaNative.js');
+            const ollamaUrl = config.get('ollamaUrl') || 'http://localhost:11434';
+            const cfgCtx = Number(config.get('ollamaNumCtx')) || 0;
+            const numCtx = cfgCtx > 0 ? cfgCtx : ((await getOllamaContextLength(model, ollamaUrl)) ?? undefined);
+            const result = await streamOllamaNativeChat({
+                baseUrl: ollamaUrl,
+                model,
+                messages,
+                numCtx,
+                keepAlive: config.get('ollamaKeepAlive') || undefined,
+                temperature: omitTemperature ? undefined : temperature,
+                timeoutMs: timeout,
+                onChunk: stream ? onChunk : undefined,
+            });
+            if (result.promptTokens != null && result.completionTokens != null) {
+                recordTokenUsage({ promptTokens: result.promptTokens, completionTokens: result.completionTokens, totalTokens: result.promptTokens + result.completionTokens }, model, providerId);
+            }
+            return stripThinkTags(result.text);
+        }
         // Use node:http for Ollama — bypasses undici connection pooling (AggregateError in Node v24)
         if (providerId === 'ollama') {
             const nodeStream = await httpRequest(`${baseUrl}/chat/completions`, {

package/dist/api/ollamaNative.d.ts

@@ -0,0 +1,117 @@
+/**
+ * Native Ollama `/api/chat` transport.
+ *
+ * Why this exists: Codeep normally talks to Ollama through its OpenAI-compatible
+ * `/v1/chat/completions` shim, which silently IGNORES Ollama-native options like
+ * `num_ctx` (context window) and `keep_alive` (model residency). The shim also
+ * defaults to a small context (~2-4k) regardless of the model's real window, so
+ * long sessions get silently truncated server-side.
+ *
+ * The native `/api/chat` endpoint accepts those options and streams
+ * newline-delimited JSON (NOT SSE). Each line is a full JSON object:
+ *   {"message":{"role":"assistant","content":"…"},"done":false}
+ *   …
+ *   {"message":{"content":""},"done":true,"prompt_eval_count":N,"eval_count":M}
+ *
+ * This module keeps the line-parsing as PURE functions so they can be unit
+ * tested without a live server. The networking wrapper lives at the bottom.
+ */
+/** A tool call as Ollama's native /api/chat returns it: `function.arguments`
+ *  is a JSON OBJECT (unlike OpenAI's JSON-string form). */
+export interface OllamaToolCall {
+    name: string;
+    arguments: Record<string, unknown>;
+}
+export interface OllamaStreamDelta {
+    /** Text chunk from this line (may be empty). */
+    content: string;
+    /** True on the terminating line. */
+    done: boolean;
+    /** Tool calls present on this line (Ollama emits them on one message). */
+    toolCalls?: OllamaToolCall[];
+    /** Prompt (input) tokens — only present on the final line. */
+    promptTokens?: number;
+    /** Completion (output) tokens — only present on the final line. */
+    completionTokens?: number;
+}
+/** Extract + normalize `message.tool_calls` from a parsed message. Returns
+ *  undefined when none. Tolerates missing/malformed entries (never throws). */
+export declare function extractOllamaToolCalls(msg: unknown): OllamaToolCall[] | undefined;
+/**
+ * Parse a single newline-delimited JSON line from `/api/chat`. Returns null for
+ * blank lines or unparseable keepalives (never throws). Tolerates both the
+ * streaming shape (`message.content`) and the non-stream shape.
+ */
+export declare function parseOllamaChatLine(line: string): OllamaStreamDelta | null;
+export interface OllamaAccumulator {
+    text: string;
+    toolCalls: OllamaToolCall[];
+    promptTokens?: number;
+    completionTokens?: number;
+    done: boolean;
+}
+/**
+ * Fold a parsed delta into a running accumulator. Pure — no I/O. The caller
+ * feeds each line's parse result here and reads `text` / token counts at the end.
+ */
+export declare function foldOllamaDelta(acc: OllamaAccumulator, delta: OllamaStreamDelta | null): OllamaAccumulator;
+/**
+ * Split a buffer into complete lines + a trailing remainder. Pure helper so the
+ * stream reader can carry partial lines across chunk boundaries correctly.
+ * Returns { lines, rest } where `rest` is the unfinished tail (no newline yet).
+ */
+export declare function splitOllamaLines(buffer: string): {
+    lines: string[];
+    rest: string;
+};
+export declare const initialOllamaAccumulator: () => OllamaAccumulator;
+/**
+ * Pull the real context_length out of an `/api/show` response's `model_info`.
+ * The key is architecture-prefixed (e.g. `llama.context_length`,
+ * `qwen2.context_length`), so we scan for any key ending in `.context_length`
+ * (or the bare `context_length`). Pure + tolerant — returns null when absent.
+ */
+export declare function extractContextLength(showResponse: unknown): number | null;
+/**
+ * Fetch a model's real maximum context window via `/api/show`. Cached per model;
+ * returns null on any error (caller falls back to its default). Never throws.
+ */
+export declare function getOllamaContextLength(model: string, ollamaBaseUrl: string): Promise<number | null>;
+/** Test seam — reset the per-model context cache. */
+export declare function _clearOllamaContextCache(): void;
+export interface OllamaChatOptions {
+    /** Ollama base URL (without /v1), e.g. http://localhost:11434 */
+    baseUrl: string;
+    model: string;
+    /** Messages in OpenAI shape {role, content} — Ollama /api/chat accepts these. */
+    messages: {
+        role: string;
+        content: string;
+    }[];
+    /** num_ctx — the context window to allocate. 0/undefined = let Ollama decide. */
+    numCtx?: number;
+    /** keep_alive — how long to keep the model resident, e.g. "30m". */
+    keepAlive?: string;
+    temperature?: number;
+    timeoutMs?: number;
+    onChunk?: (text: string) => void;
+    /** Tool definitions in OpenAI function format. Ollama's /api/chat accepts the
+     *  same `{type:'function',function:{...}}` shape and returns `tool_calls`. */
+    tools?: unknown[];
+    /** Pass-through for non-string message parts (tool results carry tool_call_id
+     *  etc.). When set, used verbatim instead of `messages`. */
+    rawMessages?: unknown[];
+}
+export interface OllamaChatResult {
+    text: string;
+    toolCalls: OllamaToolCall[];
+    promptTokens?: number;
+    completionTokens?: number;
+}
+/**
+ * Stream a chat completion from Ollama's native `/api/chat`. Uses node:http to
+ * sidestep undici's connection pooling (which throws AggregateError against
+ * localhost Ollama on Node 24). Parses the newline-JSON stream via the pure
+ * helpers above. Resolves with the full text + token usage.
+ */
+export declare function streamOllamaNativeChat(opts: OllamaChatOptions): Promise<OllamaChatResult>;

package/dist/api/ollamaNative.js

@@ -0,0 +1,228 @@
+/**
+ * Native Ollama `/api/chat` transport.
+ *
+ * Why this exists: Codeep normally talks to Ollama through its OpenAI-compatible
+ * `/v1/chat/completions` shim, which silently IGNORES Ollama-native options like
+ * `num_ctx` (context window) and `keep_alive` (model residency). The shim also
+ * defaults to a small context (~2-4k) regardless of the model's real window, so
+ * long sessions get silently truncated server-side.
+ *
+ * The native `/api/chat` endpoint accepts those options and streams
+ * newline-delimited JSON (NOT SSE). Each line is a full JSON object:
+ *   {"message":{"role":"assistant","content":"…"},"done":false}
+ *   …
+ *   {"message":{"content":""},"done":true,"prompt_eval_count":N,"eval_count":M}
+ *
+ * This module keeps the line-parsing as PURE functions so they can be unit
+ * tested without a live server. The networking wrapper lives at the bottom.
+ */
+import http from 'http';
+import https from 'https';
+/** Extract + normalize `message.tool_calls` from a parsed message. Returns
+ *  undefined when none. Tolerates missing/malformed entries (never throws). */
+export function extractOllamaToolCalls(msg) {
+    const raw = msg?.tool_calls;
+    if (!Array.isArray(raw) || raw.length === 0)
+        return undefined;
+    const out = [];
+    for (const tc of raw) {
+        const fn = tc?.function;
+        const name = typeof fn?.name === 'string' ? fn.name : '';
+        if (!name)
+            continue;
+        let args = {};
+        const a = fn?.arguments;
+        if (a && typeof a === 'object')
+            args = a;
+        else if (typeof a === 'string') {
+            try {
+                args = JSON.parse(a);
+            }
+            catch {
+                args = {};
+            }
+        }
+        out.push({ name, arguments: args });
+    }
+    return out.length > 0 ? out : undefined;
+}
+/**
+ * Parse a single newline-delimited JSON line from `/api/chat`. Returns null for
+ * blank lines or unparseable keepalives (never throws). Tolerates both the
+ * streaming shape (`message.content`) and the non-stream shape.
+ */
+export function parseOllamaChatLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed)
+        return null;
+    let json;
+    try {
+        json = JSON.parse(trimmed);
+    }
+    catch {
+        return null;
+    }
+    const msg = json.message;
+    const content = typeof msg?.content === 'string' ? msg.content : '';
+    const done = json.done === true;
+    const out = { content, done };
+    const toolCalls = extractOllamaToolCalls(msg);
+    if (toolCalls)
+        out.toolCalls = toolCalls;
+    if (typeof json.prompt_eval_count === 'number')
+        out.promptTokens = json.prompt_eval_count;
+    if (typeof json.eval_count === 'number')
+        out.completionTokens = json.eval_count;
+    return out;
+}
+/**
+ * Fold a parsed delta into a running accumulator. Pure — no I/O. The caller
+ * feeds each line's parse result here and reads `text` / token counts at the end.
+ */
+export function foldOllamaDelta(acc, delta) {
+    if (!delta)
+        return acc;
+    return {
+        text: acc.text + delta.content,
+        toolCalls: delta.toolCalls ? [...acc.toolCalls, ...delta.toolCalls] : acc.toolCalls,
+        promptTokens: delta.promptTokens ?? acc.promptTokens,
+        completionTokens: delta.completionTokens ?? acc.completionTokens,
+        done: acc.done || delta.done,
+    };
+}
+/**
+ * Split a buffer into complete lines + a trailing remainder. Pure helper so the
+ * stream reader can carry partial lines across chunk boundaries correctly.
+ * Returns { lines, rest } where `rest` is the unfinished tail (no newline yet).
+ */
+export function splitOllamaLines(buffer) {
+    const parts = buffer.split('\n');
+    const rest = parts.pop() ?? '';
+    return { lines: parts, rest };
+}
+export const initialOllamaAccumulator = () => ({ text: '', toolCalls: [], done: false });
+/**
+ * Pull the real context_length out of an `/api/show` response's `model_info`.
+ * The key is architecture-prefixed (e.g. `llama.context_length`,
+ * `qwen2.context_length`), so we scan for any key ending in `.context_length`
+ * (or the bare `context_length`). Pure + tolerant — returns null when absent.
+ */
+export function extractContextLength(showResponse) {
+    const info = showResponse?.model_info;
+    if (!info || typeof info !== 'object')
+        return null;
+    for (const [key, value] of Object.entries(info)) {
+        if ((key === 'context_length' || key.endsWith('.context_length')) && typeof value === 'number' && value > 0) {
+            return value;
+        }
+    }
+    return null;
+}
+// Per-model context-length cache so we hit /api/show at most once per model.
+const contextLengthCache = new Map();
+/**
+ * Fetch a model's real maximum context window via `/api/show`. Cached per model;
+ * returns null on any error (caller falls back to its default). Never throws.
+ */
+export async function getOllamaContextLength(model, ollamaBaseUrl) {
+    if (contextLengthCache.has(model))
+        return contextLengthCache.get(model) ?? null;
+    const base = ollamaBaseUrl.replace(/\/+$/, '').replace(/\/v1$/, '');
+    try {
+        const res = await fetch(`${base}/api/show`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ name: model }),
+            signal: AbortSignal.timeout(5000),
+        });
+        if (!res.ok) {
+            contextLengthCache.set(model, null);
+            return null;
+        }
+        const data = await res.json();
+        const ctx = extractContextLength(data);
+        contextLengthCache.set(model, ctx);
+        return ctx;
+    }
+    catch {
+        contextLengthCache.set(model, null);
+        return null;
+    }
+}
+/** Test seam — reset the per-model context cache. */
+export function _clearOllamaContextCache() {
+    contextLengthCache.clear();
+}
+/**
+ * Stream a chat completion from Ollama's native `/api/chat`. Uses node:http to
+ * sidestep undici's connection pooling (which throws AggregateError against
+ * localhost Ollama on Node 24). Parses the newline-JSON stream via the pure
+ * helpers above. Resolves with the full text + token usage.
+ */
+export function streamOllamaNativeChat(opts) {
+    const base = opts.baseUrl.replace(/\/+$/, '').replace(/\/v1$/, '');
+    const url = `${base}/api/chat`;
+    const options = {};
+    if (opts.numCtx && opts.numCtx > 0)
+        options.num_ctx = opts.numCtx;
+    if (typeof opts.temperature === 'number')
+        options.temperature = opts.temperature;
+    // When tools are present, Ollama only emits tool_calls in non-streaming mode
+    // reliably; streaming tool_calls support varies by version. We stream when
+    // there are no tools (plain chat) and fall to non-stream when tools are sent.
+    const useStream = !opts.tools || opts.tools.length === 0;
+    const body = JSON.stringify({
+        model: opts.model,
+        messages: opts.rawMessages ?? opts.messages,
+        stream: useStream,
+        ...(opts.tools && opts.tools.length ? { tools: opts.tools } : {}),
+        ...(Object.keys(options).length ? { options } : {}),
+        ...(opts.keepAlive ? { keep_alive: opts.keepAlive } : {}),
+    });
+    return new Promise((resolve, reject) => {
+        const u = new URL(url);
+        const lib = u.protocol === 'https:' ? https : http;
+        const req = lib.request({
+            hostname: u.hostname,
+            port: u.port,
+            path: u.pathname + u.search,
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(body) },
+            timeout: opts.timeoutMs ?? 120_000,
+        }, (res) => {
+            if (res.statusCode && res.statusCode >= 400) {
+                let errBody = '';
+                res.on('data', (c) => { errBody += c.toString(); });
+                res.on('end', () => reject(new Error(`Ollama /api/chat ${res.statusCode}: ${errBody.slice(0, 300)}`)));
+                return;
+            }
+            let buffer = '';
+            let acc = initialOllamaAccumulator();
+            const decoder = new TextDecoder();
+            res.on('data', (chunk) => {
+                buffer += decoder.decode(chunk, { stream: true });
+                const { lines, rest } = splitOllamaLines(buffer);
+                buffer = rest;
+                for (const line of lines) {
+                    const delta = parseOllamaChatLine(line);
+                    if (delta?.content)
+                        opts.onChunk?.(delta.content);
+                    acc = foldOllamaDelta(acc, delta);
+                }
+            });
+            res.on('end', () => {
+                // Flush any trailing line (final object often arrives without a newline).
+                const delta = parseOllamaChatLine(buffer);
+                if (delta?.content)
+                    opts.onChunk?.(delta.content);
+                acc = foldOllamaDelta(acc, delta);
+                resolve({ text: acc.text, toolCalls: acc.toolCalls, promptTokens: acc.promptTokens, completionTokens: acc.completionTokens });
+            });
+            res.on('error', reject);
+        });
+        req.on('error', reject);
+        req.on('timeout', () => { req.destroy(new Error('Ollama request timed out')); });
+        req.write(body);
+        req.end();
+    });
+}

package/dist/config/index.d.ts

@@ -54,6 +54,19 @@ interface ConfigSchema {
     rateLimitCommands: number;
     agentMode: AgentMode;
     ollamaUrl: string;
+    /** Route Ollama through its NATIVE /api/chat endpoint instead of the
+     *  OpenAI-compatible /v1 shim. The native endpoint honors num_ctx + keep_alive
+     *  and exposes the model's real context window. OFF by default — opt-in until
+     *  verified against a live Ollama; when off, the existing /v1 path is used
+     *  unchanged so current behavior is preserved. */
+    ollamaNativeApi: boolean;
+    /** How long Ollama keeps the model loaded in memory between requests (e.g.
+     *  "30m", "1h", "-1" for forever). Avoids reload latency every turn. Sent on
+     *  native /api/chat requests (only when ollamaNativeApi is on). Default "30m". */
+    ollamaKeepAlive: string;
+    /** Override num_ctx (context window) for Ollama. 0 = auto-detect the model's
+     *  real max via /api/show. Set a specific number to cap VRAM use. Default 0. */
+    ollamaNumCtx: number;
     customBaseUrl: string;
     agentConfirmation: 'always' | 'dangerous' | 'never';
     agentConfirmDeleteFile: boolean;

package/dist/config/index.js

@@ -144,6 +144,9 @@ function createConfig() {
         model: 'glm-5.1',
         agentMode: 'on',
         ollamaUrl: 'http://localhost:11434',
+        ollamaNativeApi: false,
+        ollamaKeepAlive: '30m',
+        ollamaNumCtx: 0,
         customBaseUrl: '',
         agentConfirmation: 'dangerous',
         agentConfirmDeleteFile: true,

package/dist/config/providers.js

@@ -126,9 +126,9 @@ export const PROVIDERS = {
             },
         },
         models: [
-            { id: 'MiniMax-M2.7', name: 'MiniMax M2.7', description: 'Latest MiniMax model' },
+            { id: 'MiniMax-M3', name: 'MiniMax M3', description: 'Latest MiniMax model' },
         ],
-        defaultModel: 'MiniMax-M2.7',
+        defaultModel: 'MiniMax-M3',
         defaultProtocol: 'anthropic',
         envKey: 'MINIMAX_API_KEY',
         subscribeUrl: 'https://platform.minimax.io/subscribe/coding-plan?code=2lWvoWUhrp&source=link',
@@ -146,9 +146,9 @@ export const PROVIDERS = {
             },
         },
         models: [
-            { id: 'MiniMax-M2.7', name: 'MiniMax M2.7', description: 'Latest MiniMax model' },
+            { id: 'MiniMax-M3', name: 'MiniMax M3', description: 'Latest MiniMax model' },
         ],
-        defaultModel: 'MiniMax-M2.7',
+        defaultModel: 'MiniMax-M3',
         defaultProtocol: 'openai',
         envKey: 'MINIMAX_API_KEY',
         subscribeUrl: 'https://platform.minimax.io',
@@ -171,9 +171,9 @@ export const PROVIDERS = {
             },
         },
         models: [
-            { id: 'MiniMax-M2.7', name: 'MiniMax M2.7', description: 'Latest MiniMax model' },
+            { id: 'MiniMax-M3', name: 'MiniMax M3', description: 'Latest MiniMax model' },
         ],
-        defaultModel: 'MiniMax-M2.7',
+        defaultModel: 'MiniMax-M3',
         defaultProtocol: 'anthropic',
         envKey: 'MINIMAX_CN_API_KEY',
         subscribeUrl: 'https://platform.minimaxi.com',
@@ -243,12 +243,13 @@ export const PROVIDERS = {
             },
         },
         models: [
-            { id: 'claude-opus-4-7', name: 'Claude Opus 4.7', description: 'Most capable Claude model' },
-            { id: 'claude-opus-4-6', name: 'Claude Opus 4.6', description: 'Previous generation Opus' },
+            { id: 'claude-opus-4-8', name: 'Claude Opus 4.8', description: 'Most capable Claude model' },
+            { id: 'claude-opus-4-7', name: 'Claude Opus 4.7', description: 'Previous generation Opus' },
+            { id: 'claude-opus-4-6', name: 'Claude Opus 4.6', description: 'Older generation Opus' },
             { id: 'claude-sonnet-4-6', name: 'Claude Sonnet', description: 'Best balance of speed and intelligence' },
             { id: 'claude-haiku-4-5-20251001', name: 'Claude Haiku', description: 'Fastest and most affordable' },
         ],
-        defaultModel: 'claude-opus-4-7',
+        defaultModel: 'claude-opus-4-8',
         defaultProtocol: 'anthropic',
         envKey: 'ANTHROPIC_API_KEY',
         groupLabel: 'Anthropic',
@@ -266,7 +267,7 @@ export const PROVIDERS = {
         },
         models: [
             { id: 'gemini-3.1-pro-preview', name: 'Gemini 3.1 Pro', description: 'Most capable Gemini model' },
-            { id: 'gemini-3-flash-preview', name: 'Gemini 3 Flash', description: 'Pro-level intelligence at Flash speed' },
+            { id: 'gemini-3.5-flash', name: 'Gemini 3.5 Flash', description: 'Pro-level intelligence at Flash speed' },
         ],
         defaultModel: 'gemini-3.1-pro-preview',
         defaultProtocol: 'openai',

package/dist/renderer/commands.js

@@ -93,6 +93,56 @@ export async function handleCommand(command, args, ctx) {
                 });
                 break;
             }
+            // /model browse — curated catalog of recommended local coding models.
+            if (args[0] === 'browse') {
+                const ollamaUrl = (config.get('ollamaUrl') || 'http://localhost:11434').toLowerCase();
+                const isLocal = ollamaUrl.includes('localhost') || ollamaUrl.includes('127.0.0.1') || ollamaUrl.includes('[::1]');
+                const { OLLAMA_CODING_MODELS, catalogAgentHint } = await import('../utils/ollamaCatalog.js');
+                const items = OLLAMA_CODING_MODELS.map(m => ({
+                    key: m.pull,
+                    label: m.name,
+                    description: `${m.pull} · ${m.vram} · ${catalogAgentHint(m.params)} — ${m.description}`,
+                }));
+                ctx.app.showSelect('Recommended coding models (pull)', items, '', (item) => {
+                    if (!isLocal) {
+                        ctx.app.notify(`Ollama is on a remote server. SSH in and run: ollama pull ${item.key}`);
+                        return;
+                    }
+                    ctx.app.notify(`Pulling ${item.key}... (this may take a while)`);
+                    import('child_process').then(({ execFile }) => {
+                        execFile('ollama', ['pull', item.key], { timeout: 1_200_000 }, (err) => {
+                            if (err)
+                                ctx.app.notify(`Pull failed: ${err.message}`);
+                            else
+                                ctx.app.notify(`✓ ${item.key} ready — use /model to select it`);
+                        });
+                    });
+                });
+                break;
+            }
+            // /model rm <name> — delete a locally-installed Ollama model.
+            if (args[0] === 'rm' || args[0] === 'remove' || args[0] === 'delete') {
+                const modelName = args[1];
+                if (!modelName) {
+                    ctx.app.notify('Usage: /model rm <model-name>');
+                    break;
+                }
+                const ollamaUrl = (config.get('ollamaUrl') || 'http://localhost:11434').toLowerCase();
+                const isLocal = ollamaUrl.includes('localhost') || ollamaUrl.includes('127.0.0.1') || ollamaUrl.includes('[::1]');
+                if (!isLocal) {
+                    ctx.app.notify(`Ollama is on a remote server. SSH in and run: ollama rm ${modelName}`);
+                    break;
+                }
+                ctx.app.notify(`Removing ${modelName}…`);
+                const { execFile } = await import('child_process');
+                execFile('ollama', ['rm', modelName], { timeout: 60_000 }, (err) => {
+                    if (err)
+                        ctx.app.notify(`Remove failed: ${err.message}`);
+                    else
+                        ctx.app.notify(`✓ Removed ${modelName}`);
+                });
+                break;
+            }
             const providerId = config.get('provider');
             const { isDynamicModelsProvider, isNoApiKeyProvider: _noKey } = await import('../config/providers.js');
             if (isDynamicModelsProvider(providerId)) {

package/dist/renderer/components/Help.js

@@ -171,6 +171,8 @@ export const helpCategories = [
             { key: '/settings > Ollama URL', description: 'Set URL (default: http://localhost:11434)' },
             { key: '/model', description: 'Pick installed Ollama model dynamically' },
             { key: '/model pull <model>', description: 'Pull an Ollama model (local Ollama only)' },
+            { key: '/model browse', description: 'Browse recommended local coding models and pull one' },
+            { key: '/model rm <model>', description: 'Remove a locally-installed Ollama model (local only)' },
             { key: 'OLLAMA_HOST=0.0.0.0', description: 'Required env var for remote Ollama access' },
         ],
     },

package/dist/renderer/components/Settings.js

@@ -131,6 +131,28 @@ export const SETTINGS = [
         getValue: () => config.get('ollamaUrl') || 'http://localhost:11434',
         type: 'text',
     },
+    {
+        key: 'ollamaNativeApi',
+        label: 'Ollama Native API (beta)',
+        getValue: () => config.get('ollamaNativeApi'),
+        type: 'select',
+        options: [
+            { value: false, label: 'Off (OpenAI-compatible /v1)' },
+            { value: true, label: 'On — beta: native /api/chat (num_ctx + keep_alive)' },
+        ],
+    },
+    {
+        key: 'ollamaKeepAlive',
+        label: 'Ollama Keep-Alive',
+        getValue: () => String(config.get('ollamaKeepAlive') ?? '30m'),
+        type: 'text',
+    },
+    {
+        key: 'ollamaNumCtx',
+        label: 'Ollama Context (num_ctx, 0=auto)',
+        getValue: () => String(config.get('ollamaNumCtx') ?? 0),
+        type: 'text',
+    },
     {
         key: 'customBaseUrl',
         label: 'Custom Base URL',

package/dist/utils/agentChat.js

@@ -373,6 +373,38 @@ additionalTools) {
                 if (prefs)
                     openRouterExtras.provider = prefs;
             }
+            // Opt-in native Ollama transport for AGENT mode. When `ollamaNativeApi`
+            // is on, route through /api/chat (honors num_ctx + keep_alive + the real
+            // context window) and parse native tool_calls. OFF by default → the /v1
+            // path below runs unchanged. Returns the agent response directly.
+            if (providerId === 'ollama' && config.get('ollamaNativeApi') === true) {
+                const { streamOllamaNativeChat, getOllamaContextLength } = await import('../api/ollamaNative.js');
+                const ollamaUrl = config.get('ollamaUrl') || 'http://localhost:11434';
+                const cfgCtx = Number(config.get('ollamaNumCtx')) || 0;
+                const numCtx = cfgCtx > 0 ? cfgCtx : ((await getOllamaContextLength(model, ollamaUrl)) ?? undefined);
+                const res = await streamOllamaNativeChat({
+                    baseUrl: ollamaUrl,
+                    model,
+                    messages: [],
+                    rawMessages: [{ role: 'system', content: systemPrompt }, ...messages],
+                    tools: getOpenAITools(additionalTools),
+                    numCtx,
+                    keepAlive: config.get('ollamaKeepAlive') || undefined,
+                    temperature: requiresDefaultTemperature(providerId) ? undefined : Number(config.get('temperature')),
+                    timeoutMs,
+                    onChunk: useStreaming ? onChunk : undefined,
+                });
+                if (res.promptTokens != null && res.completionTokens != null) {
+                    recordTokenUsage({ promptTokens: res.promptTokens, completionTokens: res.completionTokens, totalTokens: res.promptTokens + res.completionTokens }, model, providerId);
+                }
+                const toolCalls = res.toolCalls.map((tc) => ({ tool: tc.name, parameters: tc.arguments }));
+                if (toolCalls.length === 0 && res.text) {
+                    const textCalls = parseToolCalls(res.text);
+                    if (textCalls.length > 0)
+                        return { content: res.text, toolCalls: textCalls, usedNativeTools: false };
+                }
+                return { content: res.text, toolCalls, usedNativeTools: true };
+            }
             body = {
                 model, messages: [{ role: 'system', content: systemPrompt }, ...messages],
                 tools: getOpenAITools(additionalTools), tool_choice: 'auto', stream: useStreaming,

package/dist/utils/ollamaCatalog.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Curated catalog of recommended local coding models for Ollama, surfaced via
+ * `/model browse`. Mirrors the MCP catalog pattern: a hand-picked shortlist so
+ * users don't have to hunt ollama.com for good coding models.
+ *
+ * Each entry's `pull` is the exact `ollama pull` tag. `params` is the parameter
+ * count (drives the agent-mode hint — <7B models struggle with tool-calling
+ * loops). `vram` is a rough "comfortable" requirement for the default quant.
+ *
+ * Curated, not exhaustive — users can still `/model pull <anything>`.
+ */
+export interface OllamaCatalogEntry {
+    /** Exact `ollama pull` tag, e.g. "qwen2.5-coder:7b". */
+    pull: string;
+    /** Display name. */
+    name: string;
+    /** Parameter count in billions (for the agent-mode hint). */
+    params: number;
+    /** Rough comfortable RAM/VRAM for the default quantization. */
+    vram: string;
+    /** One-line description. */
+    description: string;
+}
+/**
+ * Recommended coding models. Ordered roughly best-for-agent first within size
+ * tiers. All are real Ollama library tags as of this release.
+ */
+export declare const OLLAMA_CODING_MODELS: OllamaCatalogEntry[];
+/** Agent-mode suitability hint for a catalog entry (≥7B → agent-capable). */
+export declare function catalogAgentHint(params: number): string;

package/dist/utils/ollamaCatalog.js

@@ -0,0 +1,37 @@
+/**
+ * Curated catalog of recommended local coding models for Ollama, surfaced via
+ * `/model browse`. Mirrors the MCP catalog pattern: a hand-picked shortlist so
+ * users don't have to hunt ollama.com for good coding models.
+ *
+ * Each entry's `pull` is the exact `ollama pull` tag. `params` is the parameter
+ * count (drives the agent-mode hint — <7B models struggle with tool-calling
+ * loops). `vram` is a rough "comfortable" requirement for the default quant.
+ *
+ * Curated, not exhaustive — users can still `/model pull <anything>`.
+ */
+/**
+ * Recommended coding models. Ordered roughly best-for-agent first within size
+ * tiers. All are real Ollama library tags as of this release.
+ */
+export const OLLAMA_CODING_MODELS = [
+    // ── Coding-tuned, agent-capable ──────────────────────────────────────────
+    { pull: 'qwen2.5-coder:32b', name: 'Qwen2.5 Coder 32B', params: 32, vram: '~20 GB', description: 'Top open coding model — strong at tool use and multi-file edits' },
+    { pull: 'qwen2.5-coder:14b', name: 'Qwen2.5 Coder 14B', params: 14, vram: '~9 GB', description: 'Great balance of quality and speed for agent work' },
+    { pull: 'qwen2.5-coder:7b', name: 'Qwen2.5 Coder 7B', params: 7, vram: '~5 GB', description: 'Smallest Qwen Coder that still handles agent mode' },
+    { pull: 'deepseek-coder-v2:16b', name: 'DeepSeek Coder V2 16B', params: 16, vram: '~10 GB', description: 'MoE coding model — fast for its quality' },
+    // ── General-purpose, agent-capable ───────────────────────────────────────
+    { pull: 'llama3.1:8b', name: 'Llama 3.1 8B', params: 8, vram: '~5 GB', description: 'Solid all-rounder; reliable tool-calling for its size' },
+    { pull: 'llama3.1:70b', name: 'Llama 3.1 70B', params: 70, vram: '~40 GB', description: 'Large general model — strongest reasoning if you have the VRAM' },
+    { pull: 'mistral-nemo:12b', name: 'Mistral Nemo 12B', params: 12, vram: '~8 GB', description: '128K context general model, good instruction following' },
+    { pull: 'gemma2:9b', name: 'Gemma 2 9B', params: 9, vram: '~6 GB', description: 'Google open model — capable general assistant' },
+    // ── Reasoning ────────────────────────────────────────────────────────────
+    { pull: 'deepseek-r1:14b', name: 'DeepSeek R1 14B', params: 14, vram: '~9 GB', description: 'Reasoning model — thinks before answering; good for hard bugs' },
+    { pull: 'deepseek-r1:8b', name: 'DeepSeek R1 8B', params: 8, vram: '~5 GB', description: 'Smaller reasoning model for modest hardware' },
+    // ── Small / fast (chat-first; weaker at agent loops) ─────────────────────
+    { pull: 'qwen2.5-coder:3b', name: 'Qwen2.5 Coder 3B', params: 3, vram: '~3 GB', description: 'Fast inline completions / chat; light for full agent tasks' },
+    { pull: 'llama3.2:3b', name: 'Llama 3.2 3B', params: 3, vram: '~3 GB', description: 'Tiny + fast; great for quick chat on low-end machines' },
+];
+/** Agent-mode suitability hint for a catalog entry (≥7B → agent-capable). */
+export function catalogAgentHint(params) {
+    return params >= 7 ? '✓ agent mode' : '⚠ chat / completions (small)';
+}

package/dist/utils/tokenTracker.js

@@ -16,6 +16,7 @@ const MODEL_CONTEXT_WINDOWS = {
     'gpt-5.4-mini': 400_000,
     'gpt-5.4-nano': 400_000,
     // Anthropic
+    'claude-opus-4-8': 1_000_000,
     'claude-opus-4-7': 1_000_000,
     'claude-opus-4-6': 1_000_000,
     'claude-sonnet-4-6': 1_000_000,
@@ -25,9 +26,10 @@ const MODEL_CONTEXT_WINDOWS = {
     'deepseek-v4-flash': 1_000_000,
     // Google
     'gemini-3.1-pro-preview': 1_048_576,
+    'gemini-3.5-flash': 1_000_000,
     'gemini-3-flash-preview': 1_000_000,
     // MiniMax
-    'MiniMax-M2.7': 204_800,
+    'MiniMax-M3': 524_288,
 };
 const DEFAULT_CONTEXT_WINDOW = 128_000;
 /**
@@ -50,6 +52,7 @@ const MODEL_PRICING = {
     'gpt-5.4-mini': { inputPer1M: 0.75, outputPer1M: 4.50 },
     'gpt-5.4-nano': { inputPer1M: 0.20, outputPer1M: 1.25 },
     // Anthropic
+    'claude-opus-4-8': { inputPer1M: 5.00, outputPer1M: 25.00 },
     'claude-opus-4-7': { inputPer1M: 5.00, outputPer1M: 25.00 },
     'claude-opus-4-6': { inputPer1M: 5.00, outputPer1M: 25.00 },
     'claude-sonnet-4-6': { inputPer1M: 3.00, outputPer1M: 15.00 },
@@ -59,9 +62,10 @@ const MODEL_PRICING = {
     'deepseek-v4-flash': { inputPer1M: 0.14, outputPer1M: 0.28 },
     // Google
     'gemini-3.1-pro-preview': { inputPer1M: 2.00, outputPer1M: 12.00 },
+    'gemini-3.5-flash': { inputPer1M: 1.50, outputPer1M: 9.00 },
     'gemini-3-flash-preview': { inputPer1M: 0.50, outputPer1M: 3.00 },
     // MiniMax
-    'MiniMax-M2.7': { inputPer1M: 0.30, outputPer1M: 1.20 },
+    'MiniMax-M3': { inputPer1M: 0.60, outputPer1M: 2.40 },
 };
 export function getPricingTable() {
     return Object.entries(MODEL_PRICING).map(([model, p]) => ({ model, ...p }));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeep",
-  "version": "2.3.1",
+  "version": "2.4.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",