codeep 1.3.42 → 2.0.1

package/dist/renderer/components/Help.js

@@ -29,6 +29,16 @@ export const helpCategories = [
             { key: '/rename <name>', description: 'Rename current session' },
             { key: '/search <term>', description: 'Search chat history' },
             { key: '/export [md|json|txt]', description: 'Export chat' },
+            { key: '/compact [keepN]', description: 'AI-summarize older messages to free up context (keeps last N)' },
+        ],
+    },
+    {
+        title: 'Checkpoints (2.0)',
+        items: [
+            { key: '/checkpoint [name]', description: 'Snapshot conversation + provider/model + git HEAD' },
+            { key: '/checkpoints', description: 'List saved checkpoints in this workspace' },
+            { key: '/rewind <id>', description: 'Restore conversation from a checkpoint' },
+            { key: '/checkpoint delete <id>', description: 'Delete a saved checkpoint' },
         ],
     },
     {
@@ -110,6 +120,24 @@ export const helpCategories = [
             { key: '/logout', description: 'Logout from provider' },
             { key: '/profile save <name>', description: 'Save current provider+model as profile' },
             { key: '/profile list', description: 'List saved profiles' },
+            { key: '/openrouter', description: 'OpenRouter routing prefs (prefer/ignore providers, fallbacks, privacy)' },
+        ],
+    },
+    {
+        title: 'Extensions & MCP (2.0)',
+        items: [
+            { key: '/mcp', description: 'List connected MCP servers + their tools' },
+            { key: '/mcp browse [id]', description: 'Browse marketplace (12 servers) or show one' },
+            { key: '/mcp install <id> [args]', description: 'Install a marketplace server into this project' },
+            { key: '/mcp add <name> <cmd>', description: 'Add a custom MCP server (npx, binary, etc.)' },
+            { key: '/mcp remove <name>', description: 'Remove a project-scoped MCP server' },
+            { key: '/mcp reload', description: 'Re-read .codeep/mcp_servers.json (after manual edit)' },
+            { key: '/mcp resources', description: 'List resources exposed by connected servers' },
+            { key: '/mcp read <uri>', description: 'Read one MCP resource' },
+            { key: '/mcp prompts', description: 'List prompt templates exposed by servers' },
+            { key: '/mcp prompt <server> <name>', description: 'Materialize a prompt with arguments (key=value)' },
+            { key: '/hooks', description: 'List installed lifecycle hooks (.codeep/hooks/<event>.sh)' },
+            { key: '/commands', description: 'List custom slash commands (.codeep/commands/*.md)' },
         ],
     },
     {

package/dist/renderer/components/Login.d.ts

@@ -44,4 +44,5 @@ export declare class LoginScreen {
 export declare function renderProviderSelect(screen: Screen, providers: Array<{
     id: string;
     name: string;
+    description?: string;
 }>, selectedIndex: number): void;

package/dist/renderer/components/Login.js

@@ -190,15 +190,17 @@ export function renderProviderSelect(screen, providers, selectedIndex) {
     const { width, height } = screen.getSize();
     screen.clear();
     // Title
-    const title = '═══ Codeep Setup ═══';
+    const title = '═══ Welcome to Codeep ═══';
     const titleX = Math.floor((width - title.length) / 2);
     screen.write(titleX, 1, title, PRIMARY_COLOR + style.bold);
     // Subtitle
-    const subtitle = 'Select your AI provider';
+    const subtitle = 'Pick an AI provider — you can switch later with /provider';
     const subtitleX = Math.floor((width - subtitle.length) / 2);
     screen.write(subtitleX, 3, subtitle, fg.white);
-    // Box
-    const boxWidth = Math.min(40, width - 4);
+    // Box — wider so we can show name + description on a single row.
+    const longestName = providers.reduce((m, p) => Math.max(m, p.name.length), 0);
+    const longestDesc = providers.reduce((m, p) => Math.max(m, (p.description ?? '').length), 0);
+    const boxWidth = Math.min(width - 4, Math.max(60, 6 + longestName + 3 + longestDesc));
     const boxHeight = providers.length + 4;
     const { x: boxX, y: boxY } = centerBox(width, height, boxWidth, boxHeight);
     const boxLines = createBox({
@@ -212,19 +214,32 @@ export function renderProviderSelect(screen, providers, selectedIndex) {
     for (const line of boxLines) {
         screen.writeLine(line.y, line.text, line.style);
     }
-    // Provider list
+    // Provider list — name in white/bold-on-selected, dim description beside it.
+    // Description is clipped to the room remaining inside the box so it never
+    // overwrites the right border on narrow terminals (80-col laptop splits).
     const contentX = boxX + 3;
-    let contentY = boxY + 2;
+    const contentY = boxY + 2;
+    const nameColWidth = longestName + 2;
+    const descStartX = contentX + 2 + nameColWidth;
+    const boxInnerRight = boxX + boxWidth - 2;
+    const descBudget = Math.max(0, boxInnerRight - descStartX);
     for (let i = 0; i < providers.length; i++) {
         const provider = providers[i];
         const isSelected = i === selectedIndex;
         const prefix = isSelected ? '► ' : '  ';
-        const itemStyle = isSelected ? PRIMARY_BRIGHT + style.bold : fg.white;
-        screen.write(contentX, contentY + i, prefix + provider.name, itemStyle);
+        const nameStyle = isSelected ? PRIMARY_BRIGHT + style.bold : fg.white;
+        const descStyle = isSelected ? fg.white : fg.gray;
+        screen.write(contentX, contentY + i, prefix + provider.name.padEnd(nameColWidth), nameStyle);
+        if (provider.description && descBudget > 0) {
+            const desc = provider.description.length > descBudget
+                ? provider.description.slice(0, Math.max(1, descBudget - 1)) + '…'
+                : provider.description;
+            screen.write(descStartX, contentY + i, desc, descStyle);
+        }
     }
     // Footer
     const footerY = height - 2;
-    screen.write(2, footerY, '↑↓ Navigate | Enter Select', fg.gray);
+    screen.write(2, footerY, '↑↓ Navigate · Enter Select · Esc skip (provider chosen later)', fg.gray);
     screen.showCursor(false);
     screen.fullRender();
 }

package/dist/renderer/handlers.d.ts

@@ -26,7 +26,17 @@ export interface MenuHandlerContext {
     close(callback: ((item: SelectItem) => void) | null, selected: SelectItem | null): void;
     render(): void;
 }
-export declare function handleMenuKey(event: KeyEvent, ctx: MenuHandlerContext): void;
+/**
+ * Optional context for type-to-filter support. Callers that supply these
+ * get inline filtering: letters/digits append to `filter`, Backspace
+ * deletes, first Esc clears a non-empty filter, second Esc closes.
+ * Callers that omit them behave exactly as before (back-compat).
+ */
+export interface MenuFilterContext {
+    filter: string;
+    setFilter(v: string): void;
+}
+export declare function handleMenuKey(event: KeyEvent, ctx: MenuHandlerContext & Partial<MenuFilterContext>): void;
 declare const PERMISSION_OPTIONS: readonly ["read", "write", "none"];
 type PermissionLevel = typeof PERMISSION_OPTIONS[number];
 export interface PermissionHandlerContext {

package/dist/renderer/handlers.js

@@ -42,7 +42,14 @@ export function handleInlineHelpKey(event, ctx) {
     }
 }
 export function handleMenuKey(event, ctx) {
+    const supportsFilter = typeof ctx.setFilter === 'function';
     if (event.key === 'escape') {
+        // Two-stage Esc when filter is on: first clears the filter, second closes.
+        if (supportsFilter && ctx.filter) {
+            ctx.setFilter('');
+            ctx.render();
+            return;
+        }
         ctx.close(null, null);
         ctx.render();
         return;
@@ -71,6 +78,29 @@ export function handleMenuKey(event, ctx) {
         const selected = ctx.items[ctx.index];
         ctx.close(null, selected);
         ctx.render();
+        return;
+    }
+    if (!supportsFilter)
+        return;
+    // Backspace removes the last filter char.
+    if (event.key === 'backspace') {
+        if (ctx.filter) {
+            ctx.setFilter(ctx.filter.slice(0, -1));
+            ctx.render();
+        }
+        return;
+    }
+    // Single printable char (letters, digits, punctuation). Modifier-free,
+    // non-paste. We deliberately exclude bare-space at empty filter so a
+    // stray space doesn't kick the user into an unintended filtered view.
+    if (!event.ctrl && !event.alt && !event.isPaste && event.key.length === 1) {
+        const ch = event.key;
+        if (ch === ' ' && !ctx.filter)
+            return;
+        if (/^[\S ]$/.test(ch)) {
+            ctx.setFilter((ctx.filter ?? '') + ch);
+            ctx.render();
+        }
     }
 }
 // ─── Permission ──────────────────────────────────────────────────────────────

package/dist/renderer/main.js

@@ -540,10 +540,83 @@ Commands (in chat):
     welcomeLines.push(githubId
         ? `  Account  codeep.dev linked`
         : `  Account  not linked  ·  run: codeep account`);
+    // Warn before first use if this workspace defines project-scoped custom
+    // slash commands. They run as user prompts — a hostile or unfamiliar repo
+    // could ship `.codeep/commands/refactor.md` whose body silently sends
+    // something the user didn't intend. The banner is informed-consent;
+    // `/commands` shows the full bodies.
+    if (projectPath) {
+        try {
+            const { loadCustomCommands } = await import('../utils/customCommands.js');
+            const projectCustom = loadCustomCommands(projectPath).filter(c => c.scope === 'project');
+            if (projectCustom.length > 0) {
+                const list = projectCustom.slice(0, 6).map(c => `/${c.name}`).join(', ');
+                const more = projectCustom.length > 6 ? ` (+${projectCustom.length - 6} more)` : '';
+                welcomeLines.push('');
+                welcomeLines.push(`  ⚠  This workspace defines ${projectCustom.length} custom slash command${projectCustom.length === 1 ? '' : 's'}: ${list}${more}`);
+                welcomeLines.push('     Type /commands to review before invoking');
+            }
+        }
+        catch {
+            // Loading must never block the welcome banner.
+        }
+        // Same flag for lifecycle hooks — they're arbitrary shell that fires on
+        // tool calls. A surprise post_edit / pre_tool_call from a freshly cloned
+        // repo is exactly the kind of thing a user should be told up front.
+        try {
+            const { summarizeHooks } = await import('../utils/hooks.js');
+            const summary = summarizeHooks(projectPath);
+            if (summary) {
+                welcomeLines.push('');
+                welcomeLines.push(`  ⚠  ${summary} — shell hooks run automatically. Type /hooks to inspect.`);
+            }
+        }
+        catch {
+            // Don't block on hook discovery failure.
+        }
+        // Skill bundles — less dangerous than hooks but worth surfacing
+        // because the agent will invoke them autonomously.
+        try {
+            const { summarizeBundles } = await import('../utils/skillBundles.js');
+            const summary = summarizeBundles(projectPath);
+            if (summary) {
+                welcomeLines.push('');
+                welcomeLines.push(`  ℹ  This workspace ships ${summary}. Type /skills bundles to inspect.`);
+            }
+        }
+        catch {
+            // Don't block on skill discovery failure.
+        }
+    }
     welcomeLines.push('');
     welcomeLines.push('  /help  ·  Ctrl+L clear  ·  Esc cancel');
     app.addMessage({ role: 'welcome', content: welcomeLines.join('\n') });
     app.start();
+    // Spawn MCP servers in the background. They register against the fixed
+    // session id `codeep-tui` that runAgentTask passes into runAgent's
+    // `mcpSessionId` — so the agent picks up `.codeep/mcp_servers.json`
+    // entries (project + global) the same way an ACP client would.
+    if (projectPath) {
+        (async () => {
+            try {
+                const { loadMcpServerConfig } = await import('../utils/mcpConfig.js');
+                const { registerSessionServers } = await import('../utils/mcpRegistry.js');
+                const servers = loadMcpServerConfig(projectPath);
+                if (servers.length === 0)
+                    return;
+                const { registered, errors } = await registerSessionServers('codeep-tui', servers, { workspaceRoot: projectPath });
+                if (registered.length > 0) {
+                    app.notify(`MCP: ${registered.length} tool(s) from ${servers.length} server(s) ready. Type /mcp.`);
+                }
+                for (const e of errors) {
+                    app.notifyWarn(`MCP server "${e.server}" failed: ${e.error}`);
+                }
+            }
+            catch {
+                // Loading MCP must never block the TUI.
+            }
+        })();
+    }
     // Check for updates in background — show notify if new version available
     checkForUpdates().then(info => {
         if (info.hasUpdate) {

package/dist/utils/agent.d.ts

@@ -30,6 +30,23 @@ export interface AgentOptions {
         stderr: string;
         exitCode: number;
     }>;
+    /**
+     * Optional filesystem callbacks. When the ACP client advertises `fs`
+     * capability, the server populates these so read_file/write_file/edit_file
+     * tools route through the client (preserving dirty buffers and undo
+     * history) instead of touching disk directly. Falls back to disk if not
+     * provided or if a delegated call throws.
+     */
+    fs?: import('./toolExecution').FsCallbacks;
+    /**
+     * Optional ACP session id used to route MCP-prefixed tool calls
+     * (`<server>__<tool>`) to the per-session `mcpRegistry`. Not set in TUI
+     * mode (no MCP support there yet); set by `runAgentSession` in ACP mode.
+     * When set, the agent loop also fetches the session's MCP tool list and
+     * passes it into the provider's tool catalog so the model can invoke
+     * those tools natively.
+     */
+    mcpSessionId?: string;
     abortSignal?: AbortSignal;
     dryRun?: boolean;
     autoVerify?: 'off' | 'build' | 'typecheck' | 'test' | 'all' | boolean;

package/dist/utils/agent.js

@@ -165,10 +165,66 @@ export async function runAgent(prompt, projectContext, options = {}) {
     const protocol = config.get('protocol');
     const providerId = config.get('provider');
     const useNativeTools = supportsNativeTools(providerId, protocol);
+    // Fetch the MCP tool catalog once per agent run. The session id keys into
+    // mcpRegistry; if no MCP servers are registered (or mcpSessionId is unset,
+    // e.g. TUI mode) we get back an empty array and the agent behaves as
+    // before. We do this before building the system prompt so the fallback
+    // text path can include MCP tools in its catalog too.
+    //
+    // We also append per-server "virtual" tools that wrap resource_list /
+    // resource_read / prompt_list / prompt_get so the agent can discover and
+    // pull MCP resources & prompts without the user having to type `/mcp
+    // read <uri>` manually. Servers that don't expose resources or prompts
+    // get no virtual tools — the wrappers are only emitted where useful.
+    let mcpToolDefs = [];
+    if (opts.mcpSessionId) {
+        try {
+            const { getSessionTools, getSessionVirtualTools } = await import('./mcpRegistry.js');
+            const [registered, virtuals] = await Promise.all([
+                getSessionTools(opts.mcpSessionId),
+                getSessionVirtualTools(opts.mcpSessionId),
+            ]);
+            mcpToolDefs = [...registered, ...virtuals].map(t => ({
+                name: t.agentName,
+                description: t.description,
+                inputSchema: t.inputSchema,
+            }));
+        }
+        catch {
+            // Don't let a registry blip kill the whole agent run.
+        }
+    }
+    // Skill bundles — structured `.codeep/skills/<name>/SKILL.md` directories
+    // the agent can discover and invoke via the `invoke_skill` tool. We just
+    // add the tool def here; the catalog block is appended to systemPrompt
+    // below alongside project rules / progress / etc. so we don't clobber
+    // those.
+    let skillCatalogBlock = '';
+    try {
+        const { loadSkillBundles, formatBundlesForSysprompt } = await import('./skillBundles.js');
+        const bundles = loadSkillBundles(projectContext.root);
+        if (bundles.length > 0) {
+            mcpToolDefs.push({
+                name: 'invoke_skill',
+                description: 'Invoke a Codeep skill bundle (curated workflow). Returns the SKILL.md body — follow its instructions step by step. Use when the user\'s request matches a skill\'s purpose.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        name: { type: 'string', description: 'Skill name from the catalog (e.g. "deploy").' },
+                    },
+                    required: ['name'],
+                },
+            });
+            skillCatalogBlock = formatBundlesForSysprompt(bundles);
+        }
+    }
+    catch {
+        // Skill loading failure shouldn't fail the whole agent run.
+    }
     // Build system prompt - use fallback format if native tools not supported
     let systemPrompt = useNativeTools
         ? getAgentSystemPrompt(projectContext)
-        : getFallbackSystemPrompt(projectContext);
+        : getFallbackSystemPrompt(projectContext, mcpToolDefs);
     // Inject project rules (from .codeep/rules.md or CODEEP.md)
     const projectRules = loadProjectRules(projectContext.root);
     if (projectRules) {
@@ -191,6 +247,12 @@ export async function runAgent(prompt, projectContext, options = {}) {
     if (chatHistoryStr) {
         systemPrompt += chatHistoryStr;
     }
+    // Skill bundles catalog goes last — closest to the user prompt so the
+    // model is most likely to remember the available skills when matching
+    // intent. Empty string when there are none.
+    if (skillCatalogBlock) {
+        systemPrompt += '\n\n' + skillCatalogBlock;
+    }
     // Initial user message with optional task plan
     let initialPrompt = prompt;
     if (taskPlan) {
@@ -282,13 +344,35 @@ export async function runAgent(prompt, projectContext, options = {}) {
             // Calculate dynamic timeout based on task complexity
             const dynamicTimeout = calculateDynamicTimeout(iteration, baseTimeout);
             debug(`Using timeout: ${dynamicTimeout}ms (base: ${baseTimeout}ms)`);
+            // Refresh MCP tool list if a server flagged its catalog as changed
+            // (e.g. via `tools/list_changed` notification, or after an
+            // auto-restart). This keeps the agent in sync mid-run instead of
+            // requiring a session restart to see new tools.
+            if (opts.mcpSessionId) {
+                try {
+                    const { consumeSessionCatalogChanges, getSessionTools } = await import('./mcpRegistry.js');
+                    const dirty = consumeSessionCatalogChanges(opts.mcpSessionId);
+                    if (dirty.has('tools')) {
+                        const refreshed = await getSessionTools(opts.mcpSessionId);
+                        mcpToolDefs = refreshed.map(t => ({
+                            name: t.agentName,
+                            description: t.description,
+                            inputSchema: t.inputSchema,
+                        }));
+                        debug(`MCP tool catalog refreshed mid-run: ${mcpToolDefs.length} tool(s)`);
+                    }
+                }
+                catch {
+                    // Don't let a refresh hiccup break the iteration.
+                }
+            }
             // Get AI response with retry logic for timeouts
             let chatResponse = null;
             let retryCount = 0;
             while (true) {
                 try {
-                    chatResponse = await agentChat(messages, systemPrompt, opts.onChunk, opts.abortSignal, dynamicTimeout * (1 + retryCount * 0.5) // Increase timeout on retry
-                    );
+                    chatResponse = await agentChat(messages, systemPrompt, opts.onChunk, opts.abortSignal, dynamicTimeout * (1 + retryCount * 0.5), // Increase timeout on retry
+                    mcpToolDefs);
                     consecutiveTimeouts = 0; // Reset consecutive count on success
                     consecutiveRateLimits = 0;
                     break;
@@ -559,12 +643,12 @@ export async function runAgent(prompt, projectContext, options = {}) {
                         catch (err) {
                             debug('onExecuteCommand callback threw, falling back to local execution:', err);
                             // Fallback to local execution if callback throws
-                            toolResult = await executeTool(toolCall, cwd);
+                            toolResult = await executeTool(toolCall, cwd, opts.fs, opts.mcpSessionId);
                         }
                     }
                 }
                 else {
-                    toolResult = await executeTool(toolCall, projectContext.root || process.cwd());
+                    toolResult = await executeTool(toolCall, projectContext.root || process.cwd(), opts.fs, opts.mcpSessionId);
                 }
                 opts.onToolResult?.(toolResult, toolCall);
                 // Log action
@@ -737,7 +821,7 @@ export async function runAgent(prompt, projectContext, options = {}) {
                     }
                     // Get AI response to fix errors
                     try {
-                        const fixResponse = await agentChat(messages, systemPrompt, opts.onChunk, opts.abortSignal);
+                        const fixResponse = await agentChat(messages, systemPrompt, opts.onChunk, opts.abortSignal, undefined, mcpToolDefs);
                         const { content: fixContent, toolCalls: fixToolCalls } = fixResponse;
                         if (fixToolCalls.length === 0) {
                             // Agent gave up or thinks it's fixed
@@ -749,7 +833,7 @@ export async function runAgent(prompt, projectContext, options = {}) {
                         const fixResults = [];
                         for (const toolCall of fixToolCalls) {
                             opts.onToolCall?.(toolCall);
-                            const toolResult = await executeTool(toolCall, projectContext.root || process.cwd());
+                            const toolResult = await executeTool(toolCall, projectContext.root || process.cwd(), opts.fs, opts.mcpSessionId);
                             opts.onToolResult?.(toolResult, toolCall);
                             const actionLog = createActionLog(toolCall, toolResult);
                             actions.push(actionLog);

package/dist/utils/agentChat.d.ts

@@ -13,6 +13,7 @@
  */
 import { ProjectContext } from './project';
 import { Message } from '../config/index';
+import { AdditionalToolDef } from './tools';
 import type { AgentChatResponse } from './agentStream';
 export type { AgentChatResponse };
 /**
@@ -52,12 +53,19 @@ export declare function formatChatHistoryForAgent(history?: Array<{
     content: string;
 }>, maxChars?: number): string;
 export declare function getAgentSystemPrompt(projectContext: ProjectContext): string;
-export declare function getFallbackSystemPrompt(projectContext: ProjectContext): string;
+export declare function getFallbackSystemPrompt(projectContext: ProjectContext, additionalTools?: AdditionalToolDef[]): string;
 /**
  * Make a chat API call for agent mode with native tool support.
  * Falls back to agentChatFallback() if provider doesn't support tools.
  */
-export declare function agentChat(messages: Message[], systemPrompt: string, onChunk?: (chunk: string) => void, abortSignal?: AbortSignal, dynamicTimeout?: number): Promise<AgentChatResponse>;
+export declare function agentChat(messages: Message[], systemPrompt: string, onChunk?: (chunk: string) => void, abortSignal?: AbortSignal, dynamicTimeout?: number, 
+/**
+ * Extra tool definitions appended to the catalog (currently used to
+ * surface MCP-registered tools as first-class entries the model can
+ * invoke). Optional — built-in tools work the same whether this is
+ * omitted or an empty array.
+ */
+additionalTools?: AdditionalToolDef[]): Promise<AgentChatResponse>;
 /**
  * Fallback chat without native tools (text-based tool format)
  */

package/dist/utils/agentChat.js

@@ -20,6 +20,7 @@ import { getProviderBaseUrl, getProviderAuthHeader, supportsNativeTools, getEffe
 import { recordTokenUsage, extractOpenAIUsage, extractAnthropicUsage } from './tokenTracker.js';
 import { parseOpenAIToolCalls, parseAnthropicToolCalls, parseToolCalls } from './toolParsing.js';
 import { formatToolDefinitions, getOpenAITools, getAnthropicTools } from './tools.js';
+import { readOpenRouterPreferences } from './openrouterPrefs.js';
 import { handleStream, handleOpenAIAgentStream, handleAnthropicAgentStream } from './agentStream.js';
 import { logger } from './logger.js';
 const debug = (...args) => {
@@ -212,14 +213,21 @@ ${projectContext.structure ? `\n## Project Structure\n${projectContext.structure
         return intelligence ? `\n\n${generateContextFromIntelligence(intelligence)}` : '';
     })()}`;
 }
-export function getFallbackSystemPrompt(projectContext) {
-    return getAgentSystemPrompt(projectContext) + '\n\n' + formatToolDefinitions();
+export function getFallbackSystemPrompt(projectContext, additionalTools) {
+    return getAgentSystemPrompt(projectContext) + '\n\n' + formatToolDefinitions(additionalTools);
 }
 /**
  * Make a chat API call for agent mode with native tool support.
  * Falls back to agentChatFallback() if provider doesn't support tools.
  */
-export async function agentChat(messages, systemPrompt, onChunk, abortSignal, dynamicTimeout) {
+export async function agentChat(messages, systemPrompt, onChunk, abortSignal, dynamicTimeout, 
+/**
+ * Extra tool definitions appended to the catalog (currently used to
+ * surface MCP-registered tools as first-class entries the model can
+ * invoke). Optional — built-in tools work the same whether this is
+ * omitted or an empty array.
+ */
+additionalTools) {
     const protocol = config.get('protocol');
     const model = config.get('model');
     const providerId = config.get('provider');
@@ -255,6 +263,14 @@ export async function agentChat(messages, systemPrompt, onChunk, abortSignal, dy
     }
     if (protocol === 'anthropic')
         headers['anthropic-version'] = '2023-06-01';
+    // OpenRouter branding — surfaces "Codeep" in the OpenRouter dashboard
+    // attribution so users (and OpenRouter itself, for any partnership
+    // tracking) see which app generated the traffic. Spec is informal; both
+    // headers are documented at openrouter.ai/docs#headers.
+    if (providerId === 'openrouter') {
+        headers['HTTP-Referer'] = 'https://codeep.dev';
+        headers['X-Title'] = 'Codeep';
+    }
     try {
         let endpoint;
         let body;
@@ -264,18 +280,30 @@ export async function agentChat(messages, systemPrompt, onChunk, abortSignal, dy
             const maxTok = getEffectiveMaxTokens(providerId, Math.max(config.get('maxTokens'), 16384));
             const tokParam = usesMaxCompletionTokens(providerId) ? { max_completion_tokens: maxTok } : { max_tokens: maxTok };
             endpoint = `${baseUrl}/chat/completions`;
+            // OpenRouter-specific extras: request `usage` block in the response
+            // body so we get per-call cost (skips our local pricing lookup), and
+            // optionally a provider-routing preferences object the user set via
+            // `/openrouter prefer …`.
+            const openRouterExtras = {};
+            if (providerId === 'openrouter') {
+                openRouterExtras.usage = { include: true };
+                const prefs = readOpenRouterPreferences();
+                if (prefs)
+                    openRouterExtras.provider = prefs;
+            }
             body = {
                 model, messages: [{ role: 'system', content: systemPrompt }, ...messages],
-                tools: getOpenAITools(), tool_choice: 'auto', stream: useStreaming,
+                tools: getOpenAITools(additionalTools), tool_choice: 'auto', stream: useStreaming,
                 ...tempParam, ...tokParam,
                 ...(useStreaming && providerId === 'openai' ? { stream_options: { include_usage: true } } : {}),
+                ...openRouterExtras,
             };
         }
         else {
             endpoint = `${baseUrl}/v1/messages`;
             body = {
                 model, system: systemPrompt, messages,
-                tools: getAnthropicTools(), stream: useStreaming,
+                tools: getAnthropicTools(additionalTools), stream: useStreaming,
                 ...tempParam, max_tokens: getEffectiveMaxTokens(providerId, Math.max(config.get('maxTokens'), 16384)),
             };
         }
@@ -298,8 +326,15 @@ export async function agentChat(messages, systemPrompt, onChunk, abortSignal, dy
         const data = await response.json();
         const usageExtractor = protocol === 'openai' ? extractOpenAIUsage : extractAnthropicUsage;
         const usage = usageExtractor(data);
-        if (usage)
-            recordTokenUsage(usage, model, providerId);
+        if (usage) {
+            // OpenRouter returns the authoritative per-call cost in
+            // `usage.cost` (USD). Use it instead of our local pricing table
+            // since the catalog has 100+ models we don't track ourselves.
+            const reportedCost = providerId === 'openrouter' && typeof data?.usage?.cost === 'number'
+                ? data.usage.cost
+                : undefined;
+            recordTokenUsage(usage, model, providerId, reportedCost);
+        }
         if (protocol === 'openai') {
             const message = data.choices?.[0]?.message;
             const content = message?.content || '';
@@ -426,8 +461,12 @@ export async function agentChatFallback(messages, systemPrompt, onChunk, abortSi
             const data = await response.json();
             const fallbackUsageExtractor = protocol === 'openai' ? extractOpenAIUsage : extractAnthropicUsage;
             const fallbackUsage = fallbackUsageExtractor(data);
-            if (fallbackUsage)
-                recordTokenUsage(fallbackUsage, model, providerId);
+            if (fallbackUsage) {
+                const reportedCost = providerId === 'openrouter' && typeof data?.usage?.cost === 'number'
+                    ? data.usage.cost
+                    : undefined;
+                recordTokenUsage(fallbackUsage, model, providerId, reportedCost);
+            }
             content = protocol === 'openai' ? (data.choices?.[0]?.message?.content || '') : (data.content?.[0]?.text || '');
         }
         const toolCalls = parseToolCalls(content);

package/dist/utils/agentStream.js

@@ -120,8 +120,12 @@ export async function handleOpenAIAgentStream(body, onChunk, model, providerId)
     }
     if (usageData) {
         const usage = extractOpenAIUsage(usageData);
-        if (usage)
-            recordTokenUsage(usage, model, providerId);
+        if (usage) {
+            const reportedCost = providerId === 'openrouter' && typeof usageData?.usage?.cost === 'number'
+                ? usageData.usage.cost
+                : undefined;
+            recordTokenUsage(usage, model, providerId, reportedCost);
+        }
     }
     const rawToolCalls = Array.from(toolCallMap.values()).map(tc => ({
         id: tc.id,