codeep 2.13.1 → 2.14.0

package/dist/acp/server.js

@@ -18,7 +18,7 @@ import { ApiError } from '../api/index.js';
 import { PROVIDERS } from '../config/providers.js';
 import { getCurrentVersion } from '../utils/update.js';
 import { reportStats, syncSession, generateProjectId } from '../utils/codeepCloud.js';
-import { getCostBreakdown, resetTokenTracking } from '../utils/tokenTracker.js';
+import { getCostBreakdown, getRecordCount, createTokenScope, runWithTokenScope } from '../utils/tokenTracker.js';
 import { isGitRepository } from '../utils/git.js';
 import { getProjectContext } from '../utils/project.js';
 // ─── Slash commands advertised to Zed ────────────────────────────────────────
@@ -141,10 +141,18 @@ export function formatToolInputForPermission(tool, params) {
                     ? lines.slice(0, MAX_CONTENT_LINES).join('\n') + `\n… (${lines.length - MAX_CONTENT_LINES} more lines)`
                     : params.content;
             }
-            if (typeof params.old_string === 'string' && typeof params.new_string === 'string') {
-                out.changes = `replace ${params.old_string.split('\n').length} line(s)`;
-                out.old_string = truncateDiff(params.old_string);
-                out.new_string = truncateDiff(params.new_string);
+            // The built-in edit_file tool schema emits old_text / new_text (see
+            // utils/tools.ts); accept the old_string/new_string spelling too for
+            // robustness. Without this the permission dialog dropped the diff and
+            // showed only { file, path } — the user approved edits blind.
+            const oldText = typeof params.old_text === 'string' ? params.old_text
+                : (typeof params.old_string === 'string' ? params.old_string : undefined);
+            const newText = typeof params.new_text === 'string' ? params.new_text
+                : (typeof params.new_string === 'string' ? params.new_string : undefined);
+            if (oldText !== undefined && newText !== undefined) {
+                out.changes = `replace ${oldText.split('\n').length} line(s)`;
+                out.old_string = truncateDiff(oldText);
+                out.new_string = truncateDiff(newText);
             }
             return out;
         }
@@ -860,7 +868,6 @@ export function startAcpServer() {
                 },
             });
         };
-        resetTokenTracking();
         // Manual mode gates write/edit for THIS run via a per-call option passed to
         // runAgentSession (extraDangerousTools, below) — NOT by mutating the global
         // `agentConfirmWriteFile` config, which leaked the session's mode into the
@@ -876,255 +883,283 @@ export function startAcpServer() {
                 },
             });
         };
-        // Try slash commands first
-        handleCommand(prompt, session, sendChunk, abortController.signal)
-            .then((cmd) => {
-            if (cmd.handled) {
-                if (cmd.response)
-                    sendChunk(cmd.response);
-                // If provider or model changed, push updated config options to Zed
-                if (cmd.configOptionsChanged) {
-                    transport.notify('session/update', {
-                        sessionId: params.sessionId,
-                        update: {
-                            sessionUpdate: 'config_option_update',
-                            configOptions: buildConfigOptions(),
-                        },
-                    });
-                }
-                // Update title with first real prompt if session had no history
-                if (!session.titleSent && !session.hadHistory) {
-                    session.titleSent = true;
-                    sendSessionTitle(params.sessionId, [{ role: 'user', content: prompt }]);
-                }
-                transport.respond(msg.id, { stopReason: 'end_turn' });
-                return;
-            }
-            // Not a command — run agent loop
-            let enrichedPrompt = prompt;
-            if (session.addedFiles.size > 0) {
-                const parts = ['[Attached files]'];
-                for (const [, f] of session.addedFiles) {
-                    parts.push(`\nFile: ${f.relativePath}\n\`\`\`\n${f.content}\n\`\`\``);
-                }
-                enrichedPrompt = parts.join('\n') + '\n\n' + prompt;
-            }
-            runAgentSession({
-                prompt: enrichedPrompt,
-                workspaceRoot: session.workspaceRoot,
-                conversationId: params.sessionId,
-                abortSignal: abortController.signal,
-                onChunk: sendChunk,
-                onThought: (text) => {
-                    transport.notify('session/update', {
-                        sessionId: params.sessionId,
-                        update: {
-                            sessionUpdate: 'agent_thought_chunk',
-                            content: { type: 'text', text },
-                        },
-                    });
-                },
-                onToolCall: (toolCallId, toolName, kind, title, status, locations, rawOutput) => {
-                    if (status === 'running') {
-                        // Initial tool_call notification: spec ToolCall shape
+        // Try slash commands first.
+        // Run the whole prompt lifecycle inside THIS ACP session's token scope so
+        // (a) concurrent sessions on one process can't mix usage totals, and
+        // (b) usage accumulates into the session's own buffer across prompts, so
+        // `/cost` stays session-cumulative. `tokenReportStart` marks the pre-prompt
+        // count so we report only this prompt's delta to cloud telemetry.
+        session.tokenRecords ??= createTokenScope();
+        runWithTokenScope(session.tokenRecords, () => {
+            const tokenReportStart = getRecordCount();
+            return handleCommand(prompt, session, sendChunk, abortController.signal)
+                .then((cmd) => {
+                if (cmd.handled) {
+                    if (cmd.response)
+                        sendChunk(cmd.response);
+                    // If provider or model changed, push updated config options to Zed
+                    if (cmd.configOptionsChanged) {
                         transport.notify('session/update', {
                             sessionId: params.sessionId,
                             update: {
-                                sessionUpdate: 'tool_call',
-                                toolCallId,
-                                title: title || toolName,
-                                kind: kind || 'other',
-                                status: 'in_progress',
-                                ...(locations && locations.length > 0
-                                    ? { locations: locations.map(path => ({ path })) }
-                                    : {}),
+                                sessionUpdate: 'config_option_update',
+                                configOptions: buildConfigOptions(),
                             },
                         });
-                        // Add to plan as in_progress — only meaningful actions (not reads)
-                        if (kind === 'edit' || kind === 'execute' || kind === 'delete') {
-                            planEntries.set(toolCallId, {
-                                id: toolCallId,
-                                content: title || toolName,
-                                priority: kind === 'execute' ? 'high' : 'medium',
-                                status: 'in_progress',
-                            });
-                            sendPlan();
-                        }
                     }
-                    else {
-                        // tool_call_update: update status to completed/failed, with optional content
+                    // Update title with first real prompt if session had no history
+                    if (!session.titleSent && !session.hadHistory) {
+                        session.titleSent = true;
+                        sendSessionTitle(params.sessionId, [{ role: 'user', content: prompt }]);
+                    }
+                    transport.respond(msg.id, { stopReason: 'end_turn' });
+                    return;
+                }
+                // Not a command — run agent loop
+                let enrichedPrompt = prompt;
+                if (session.addedFiles.size > 0) {
+                    const parts = ['[Attached files]'];
+                    for (const [, f] of session.addedFiles) {
+                        parts.push(`\nFile: ${f.relativePath}\n\`\`\`\n${f.content}\n\`\`\``);
+                    }
+                    enrichedPrompt = parts.join('\n') + '\n\n' + prompt;
+                }
+                runAgentSession({
+                    prompt: enrichedPrompt,
+                    workspaceRoot: session.workspaceRoot,
+                    conversationId: params.sessionId,
+                    abortSignal: abortController.signal,
+                    onChunk: sendChunk,
+                    onThought: (text) => {
                         transport.notify('session/update', {
                             sessionId: params.sessionId,
                             update: {
-                                sessionUpdate: 'tool_call_update',
-                                toolCallId,
-                                status: status === 'finished' ? 'completed' : 'failed',
-                                ...(rawOutput !== undefined ? { rawOutput } : {}),
+                                sessionUpdate: 'agent_thought_chunk',
+                                content: { type: 'text', text },
                             },
                         });
-                        // Mark plan entry as completed
-                        const entry = planEntries.get(toolCallId);
-                        if (entry) {
-                            entry.status = 'completed';
-                            sendPlan();
+                    },
+                    onToolCall: (toolCallId, toolName, kind, title, status, locations, rawOutput) => {
+                        if (status === 'running') {
+                            // Initial tool_call notification: spec ToolCall shape
+                            transport.notify('session/update', {
+                                sessionId: params.sessionId,
+                                update: {
+                                    sessionUpdate: 'tool_call',
+                                    toolCallId,
+                                    title: title || toolName,
+                                    kind: kind || 'other',
+                                    status: 'in_progress',
+                                    ...(locations && locations.length > 0
+                                        ? { locations: locations.map(path => ({ path })) }
+                                        : {}),
+                                },
+                            });
+                            // Add to plan as in_progress — only meaningful actions (not reads)
+                            if (kind === 'edit' || kind === 'execute' || kind === 'delete') {
+                                planEntries.set(toolCallId, {
+                                    id: toolCallId,
+                                    content: title || toolName,
+                                    priority: kind === 'execute' ? 'high' : 'medium',
+                                    status: 'in_progress',
+                                });
+                                sendPlan();
+                            }
                         }
-                    }
-                },
-                // Manual mode gates write_file/edit_file for this run only (per-call,
-                // no global config mutation).
-                extraDangerousTools: session.currentModeId === 'manual' ? ['write_file', 'edit_file'] : undefined,
-                // Only request permission in Manual mode
-                onRequestPermission: session.currentModeId === 'manual'
-                    ? async (toolCall) => {
-                        const permToolCallId = `perm_${randomUUID()}`;
-                        const result = await transport.request('session/request_permission', {
-                            sessionId: params.sessionId,
-                            toolCall: {
-                                toolCallId: permToolCallId,
-                                toolName: toolCall.tool,
-                                toolInput: formatToolInputForPermission(toolCall.tool, toolCall.parameters),
-                                status: 'pending',
-                                content: [],
-                            },
-                            options: [
-                                { optionId: 'allow_once', name: 'Allow once', kind: 'allow_once' },
-                                { optionId: 'allow_always', name: 'Allow always', kind: 'allow_always' },
-                                { optionId: 'reject_once', name: 'Reject once', kind: 'reject_once' },
-                                { optionId: 'reject_always', name: 'Reject always', kind: 'reject_always' },
-                            ],
-                        });
-                        // Map ACP outcome back to PermissionOutcome
-                        if (!result || result.outcome.type === 'cancelled')
-                            return 'reject_once';
-                        return result.outcome.optionId;
-                    }
-                    : undefined,
-                // Per ACP spec, `fs/read_text_file` and `fs/write_text_file` are
-                // CLIENT methods — only safe to call when the client advertised
-                // the capability in `initialize`. Routing through the client
-                // means the editor's dirty buffers + undo history stay correct
-                // (otherwise an in-editor unsaved change would be invisible to
-                // the agent, or worse, silently overwritten).
-                fs: {
-                    readTextFile: clientSupportsFsRead
-                        ? async (absolutePath) => {
-                            const result = await transport.request('fs/read_text_file', {
+                        else {
+                            // tool_call_update: update status to completed/failed, with optional content
+                            transport.notify('session/update', {
                                 sessionId: params.sessionId,
-                                path: absolutePath,
+                                update: {
+                                    sessionUpdate: 'tool_call_update',
+                                    toolCallId,
+                                    status: status === 'finished' ? 'completed' : 'failed',
+                                    ...(rawOutput !== undefined ? { rawOutput } : {}),
+                                },
                             });
-                            if (!result || typeof result.content !== 'string') {
-                                throw new Error('fs/read_text_file returned no content');
+                            // Mark plan entry as completed
+                            const entry = planEntries.get(toolCallId);
+                            if (entry) {
+                                entry.status = 'completed';
+                                sendPlan();
                             }
-                            return result.content;
                         }
-                        : undefined,
-                    writeTextFile: clientSupportsFsWrite
-                        ? async (absolutePath, content) => {
-                            await transport.request('fs/write_text_file', {
+                    },
+                    // Manual mode gates write_file/edit_file for this run only (per-call,
+                    // no global config mutation).
+                    extraDangerousTools: session.currentModeId === 'manual' ? ['write_file', 'edit_file'] : undefined,
+                    // Only request permission in Manual mode
+                    onRequestPermission: session.currentModeId === 'manual'
+                        ? async (toolCall) => {
+                            const permToolCallId = `perm_${randomUUID()}`;
+                            const result = await transport.request('session/request_permission', {
                                 sessionId: params.sessionId,
-                                path: absolutePath,
-                                content,
+                                toolCall: {
+                                    toolCallId: permToolCallId,
+                                    toolName: toolCall.tool,
+                                    toolInput: formatToolInputForPermission(toolCall.tool, toolCall.parameters),
+                                    status: 'pending',
+                                    content: [],
+                                },
+                                options: [
+                                    { optionId: 'allow_once', name: 'Allow once', kind: 'allow_once' },
+                                    { optionId: 'allow_always', name: 'Allow always', kind: 'allow_always' },
+                                    { optionId: 'reject_once', name: 'Reject once', kind: 'reject_once' },
+                                    { optionId: 'reject_always', name: 'Reject always', kind: 'reject_always' },
+                                ],
                             });
+                            // Map ACP outcome back to PermissionOutcome
+                            if (!result || result.outcome.type === 'cancelled')
+                                return 'reject_once';
+                            return result.outcome.optionId;
                         }
                         : undefined,
-                },
-                onExecuteCommand: async (command, args, cwd) => {
-                    // Per ACP spec, only call terminal/* if the client advertised the
-                    // capability in initialize. Otherwise execute locally.
-                    if (!clientSupportsTerminal) {
-                        const r = await executeCommandAsync(command, args, { cwd, projectRoot: cwd, timeout: 120000 });
-                        return { stdout: r.stdout ?? '', stderr: r.stderr ?? '', exitCode: r.exitCode ?? 0 };
+                    // Per ACP spec, `fs/read_text_file` and `fs/write_text_file` are
+                    // CLIENT methods — only safe to call when the client advertised
+                    // the capability in `initialize`. Routing through the client
+                    // means the editor's dirty buffers + undo history stay correct
+                    // (otherwise an in-editor unsaved change would be invisible to
+                    // the agent, or worse, silently overwritten).
+                    fs: {
+                        readTextFile: clientSupportsFsRead
+                            ? async (absolutePath) => {
+                                const result = await transport.request('fs/read_text_file', {
+                                    sessionId: params.sessionId,
+                                    path: absolutePath,
+                                });
+                                if (!result || typeof result.content !== 'string') {
+                                    throw new Error('fs/read_text_file returned no content');
+                                }
+                                return result.content;
+                            }
+                            : undefined,
+                        writeTextFile: clientSupportsFsWrite
+                            ? async (absolutePath, content) => {
+                                await transport.request('fs/write_text_file', {
+                                    sessionId: params.sessionId,
+                                    path: absolutePath,
+                                    content,
+                                });
+                            }
+                            : undefined,
+                    },
+                    onExecuteCommand: async (command, args, cwd) => {
+                        // Per ACP spec, only call terminal/* if the client advertised the
+                        // capability in initialize. Otherwise execute locally.
+                        if (!clientSupportsTerminal) {
+                            const r = await executeCommandAsync(command, args, { cwd, projectRoot: cwd, timeout: 120000 });
+                            return { stdout: r.stdout ?? '', stderr: r.stderr ?? '', exitCode: r.exitCode ?? 0 };
+                        }
+                        try {
+                            const createResult = await transport.request('terminal/create', {
+                                sessionId: params.sessionId,
+                                command,
+                                args,
+                                cwd,
+                                outputByteLimit: 1_000_000,
+                            });
+                            const { terminalId } = createResult;
+                            // Spec method is snake_case `terminal/wait_for_exit` and takes
+                            // only { sessionId, terminalId } — no timeoutMs.
+                            const waitResult = await transport.request('terminal/wait_for_exit', {
+                                sessionId: params.sessionId,
+                                terminalId,
+                            });
+                            const outputResult = await transport.request('terminal/output', {
+                                sessionId: params.sessionId,
+                                terminalId,
+                            });
+                            await transport.request('terminal/release', {
+                                sessionId: params.sessionId,
+                                terminalId,
+                            });
+                            const exitCode = waitResult.exitStatus.type === 'exited' ? waitResult.exitStatus.code : 1;
+                            return { stdout: outputResult.output ?? '', stderr: '', exitCode };
+                        }
+                        catch (err) {
+                            // Client terminal failed — fall back to local execution
+                            const r = await executeCommandAsync(command, args, { cwd, projectRoot: cwd, timeout: 120000 });
+                            return { stdout: r.stdout ?? '', stderr: r.stderr ?? '', exitCode: r.exitCode ?? 0 };
+                        }
+                    },
+                }).then(() => {
+                    session.history.push({ role: 'user', content: prompt });
+                    const agentResponse = agentResponseChunks.join('');
+                    if (agentResponse) {
+                        session.history.push({ role: 'assistant', content: agentResponse });
                     }
-                    try {
-                        const createResult = await transport.request('terminal/create', {
-                            sessionId: params.sessionId,
-                            command,
-                            args,
-                            cwd,
-                            outputByteLimit: 1_000_000,
-                        });
-                        const { terminalId } = createResult;
-                        // Spec method is snake_case `terminal/wait_for_exit` and takes
-                        // only { sessionId, terminalId } — no timeoutMs.
-                        const waitResult = await transport.request('terminal/wait_for_exit', {
-                            sessionId: params.sessionId,
-                            terminalId,
-                        });
-                        const outputResult = await transport.request('terminal/output', {
-                            sessionId: params.sessionId,
-                            terminalId,
-                        });
-                        await transport.request('terminal/release', {
-                            sessionId: params.sessionId,
-                            terminalId,
-                        });
-                        const exitCode = waitResult.exitStatus.type === 'exited' ? waitResult.exitStatus.code : 1;
-                        return { stdout: outputResult.output ?? '', stderr: '', exitCode };
+                    autoSaveSession(session.history, session.workspaceRoot);
+                    // Report token usage to dashboard
+                    const projectCtx = getProjectContext(session.workspaceRoot);
+                    const sharedFields = {
+                        sessionId: session.codeepSessionId,
+                        sessionName: session.codeepSessionId,
+                        messageCount: session.history.length,
+                        cliVersion: getCurrentVersion(),
+                        projectName: projectCtx?.name,
+                        projectId: generateProjectId(session.workspaceRoot),
+                        language: projectCtx?.type,
+                        isGit: isGitRepository(session.workspaceRoot),
+                    };
+                    const costBreakdown = getCostBreakdown(tokenReportStart);
+                    if (costBreakdown.length > 0) {
+                        for (const entry of costBreakdown) {
+                            reportStats({
+                                ...sharedFields,
+                                model: entry.model,
+                                provider: entry.provider,
+                                inputTokens: entry.promptTokens || undefined,
+                                outputTokens: entry.completionTokens || undefined,
+                                cacheCreationTokens: entry.cacheCreationTokens || undefined,
+                                cacheReadTokens: entry.cacheReadTokens || undefined,
+                                estimatedCost: entry.estimatedCost || undefined,
+                            });
+                        }
                     }
-                    catch (err) {
-                        // Client terminal failed — fall back to local execution
-                        const r = await executeCommandAsync(command, args, { cwd, projectRoot: cwd, timeout: 120000 });
-                        return { stdout: r.stdout ?? '', stderr: r.stderr ?? '', exitCode: r.exitCode ?? 0 };
+                    else {
+                        reportStats({ ...sharedFields, model: config.get('model'), provider: config.get('provider') });
                     }
-                },
-            }).then(() => {
-                session.history.push({ role: 'user', content: prompt });
-                const agentResponse = agentResponseChunks.join('');
-                if (agentResponse) {
-                    session.history.push({ role: 'assistant', content: agentResponse });
-                }
-                autoSaveSession(session.history, session.workspaceRoot);
-                // Report token usage to dashboard
-                const projectCtx = getProjectContext(session.workspaceRoot);
-                const sharedFields = {
-                    sessionId: session.codeepSessionId,
-                    sessionName: session.codeepSessionId,
-                    messageCount: session.history.length,
-                    cliVersion: getCurrentVersion(),
-                    projectName: projectCtx?.name,
-                    projectId: generateProjectId(session.workspaceRoot),
-                    language: projectCtx?.type,
-                    isGit: isGitRepository(session.workspaceRoot),
-                };
-                const costBreakdown = getCostBreakdown();
-                if (costBreakdown.length > 0) {
-                    for (const entry of costBreakdown) {
-                        reportStats({
-                            ...sharedFields,
-                            model: entry.model,
-                            provider: entry.provider,
-                            inputTokens: entry.promptTokens || undefined,
-                            outputTokens: entry.completionTokens || undefined,
-                            estimatedCost: entry.estimatedCost || undefined,
-                        });
+                    // Sync session history to dashboard
+                    syncSession({
+                        sessionId: session.codeepSessionId,
+                        projectName: projectCtx?.name,
+                        projectId: generateProjectId(session.workspaceRoot),
+                        messages: session.history,
+                    });
+                    // Update title with first real prompt if session had no history
+                    if (!session.titleSent && !session.hadHistory) {
+                        session.titleSent = true;
+                        sendSessionTitle(params.sessionId, [{ role: 'user', content: prompt }]);
                     }
-                }
-                else {
-                    reportStats({ ...sharedFields, model: config.get('model'), provider: config.get('provider') });
-                }
-                // Sync session history to dashboard
-                syncSession({
-                    sessionId: session.codeepSessionId,
-                    projectName: projectCtx?.name,
-                    projectId: generateProjectId(session.workspaceRoot),
-                    messages: session.history,
-                });
-                // Update title with first real prompt if session had no history
-                if (!session.titleSent && !session.hadHistory) {
-                    session.titleSent = true;
-                    sendSessionTitle(params.sessionId, [{ role: 'user', content: prompt }]);
-                }
-                transport.respond(msg.id, { stopReason: 'end_turn' });
-            }).catch((err) => {
-                if (err.name === 'AbortError') {
-                    // Clear plan UI on the client side when session is cancelled
-                    if (planEntries.size > 0) {
-                        planEntries.clear();
-                        sendPlan();
+                    transport.respond(msg.id, { stopReason: 'end_turn' });
+                }).catch((err) => {
+                    if (err.name === 'AbortError') {
+                        // Clear plan UI on the client side when session is cancelled
+                        if (planEntries.size > 0) {
+                            planEntries.clear();
+                            sendPlan();
+                        }
+                        transport.respond(msg.id, { stopReason: 'cancelled' });
                     }
-                    transport.respond(msg.id, { stopReason: 'cancelled' });
-                }
-                else if (err.message?.includes('API key not configured') || err.message?.includes('API key') || (err instanceof ApiError && err.status === 401)) {
+                    else if (err.message?.includes('API key not configured') || err.message?.includes('API key') || (err instanceof ApiError && err.status === 401)) {
+                        sendChunk(`❌ No API key configured. Use /login <provider> <key> or set the environment variable (e.g. ZAI_API_KEY, ANTHROPIC_API_KEY).`);
+                        transport.respond(msg.id, { stopReason: 'end_turn' });
+                    }
+                    else if (err instanceof ApiError && err.status >= 500) {
+                        sendChunk(`⚠️ API server error (${err.status}). Please try again.`);
+                        transport.respond(msg.id, { stopReason: 'end_turn' });
+                    }
+                    else {
+                        transport.error(msg.id, -32000, err.message);
+                    }
+                }).finally(() => {
+                    if (session)
+                        session.abortController = null;
+                    planEntries.clear();
+                });
+            })
+                .catch((err) => {
+                if (err.message?.includes('API key not configured') || err.message?.includes('API key') || (err instanceof ApiError && err.status === 401)) {
                     sendChunk(`❌ No API key configured. Use /login <provider> <key> or set the environment variable (e.g. ZAI_API_KEY, ANTHROPIC_API_KEY).`);
                     transport.respond(msg.id, { stopReason: 'end_turn' });
                 }
@@ -1135,26 +1170,9 @@ export function startAcpServer() {
                 else {
                     transport.error(msg.id, -32000, err.message);
                 }
-            }).finally(() => {
                 if (session)
                     session.abortController = null;
-                planEntries.clear();
             });
-        })
-            .catch((err) => {
-            if (err.message?.includes('API key not configured') || err.message?.includes('API key') || (err instanceof ApiError && err.status === 401)) {
-                sendChunk(`❌ No API key configured. Use /login <provider> <key> or set the environment variable (e.g. ZAI_API_KEY, ANTHROPIC_API_KEY).`);
-                transport.respond(msg.id, { stopReason: 'end_turn' });
-            }
-            else if (err instanceof ApiError && err.status >= 500) {
-                sendChunk(`⚠️ API server error (${err.status}). Please try again.`);
-                transport.respond(msg.id, { stopReason: 'end_turn' });
-            }
-            else {
-                transport.error(msg.id, -32000, err.message);
-            }
-            if (session)
-                session.abortController = null;
         });
     }
     // Keep process alive until stdin closes (Zed terminates us)

package/dist/config/providers.js

@@ -428,8 +428,9 @@ export const PROVIDERS = {
             },
         },
         models: [
+            { id: 'claude-fable-5', name: 'Claude Fable 5', description: 'Most capable — hardest reasoning & long-horizon agentic work' },
             { id: 'claude-opus-4-8', name: 'Claude Opus 4.8', description: 'Most capable Opus model' },
-            { id: 'claude-sonnet-4-6', name: 'Claude Sonnet', description: 'Best balance of speed and intelligence' },
+            { id: 'claude-sonnet-5', name: 'Claude Sonnet 5', 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-8',
@@ -475,8 +476,9 @@ export const PROVIDERS = {
         // get a working dropdown.
         models: [
             { id: 'openrouter/auto', name: 'Auto-route', description: 'OpenRouter picks the best model for the task' },
-            { id: 'anthropic/claude-opus-4', name: 'Claude Opus 4', description: 'Anthropic — most capable' },
-            { id: 'anthropic/claude-sonnet-4', name: 'Claude Sonnet 4', description: 'Anthropic — balanced' },
+            { id: 'anthropic/claude-fable-5', name: 'Claude Fable 5', description: 'Anthropic — most capable' },
+            { id: 'anthropic/claude-opus-4', name: 'Claude Opus 4', description: 'Anthropic — Opus tier' },
+            { id: 'anthropic/claude-sonnet-5', name: 'Claude Sonnet 5', description: 'Anthropic — balanced' },
             { id: 'openai/gpt-5.5', name: 'GPT-5.5', description: 'OpenAI — flagship' },
             { id: 'openai/gpt-5.4-mini', name: 'GPT-5.4 Mini', description: 'OpenAI — fast/cheap' },
             { id: 'google/gemini-3.1-pro', name: 'Gemini 3.1 Pro', description: 'Google — multimodal' },
@@ -651,14 +653,15 @@ export function providerNoStreamWithTools(providerId) {
 }
 /**
  * Models that reject sampling parameters (temperature/top_p/top_k) with a 400.
- * Anthropic removed them on Fable 5 and Opus 4.7+; older Claude models still
- * accept them, so this must be a MODEL-level check, not a provider-level one
- * (requiresDefaultTemperature can't express it). Omitting the field is always
- * safe — the API treats omission as default. Kimi K2.x code/thinking models
- * fix temperature internally and 400 on any custom value, so they're here too.
+ * Anthropic removed them on Fable 5 and Opus 4.7+, and Sonnet 5 rejects any
+ * non-default value; older Claude models still accept them, so this must be a
+ * MODEL-level check, not a provider-level one (requiresDefaultTemperature
+ * can't express it). Omitting the field is always safe — the API treats
+ * omission as default. Kimi K2.x code/thinking models fix temperature
+ * internally and 400 on any custom value, so they're here too.
  */
 const SAMPLING_PARAMS_REJECTED = [
-    'claude-fable-5', 'claude-opus-4-8', 'claude-opus-4-7',
+    'claude-fable-5', 'claude-opus-4-8', 'claude-opus-4-7', 'claude-sonnet-5',
     'kimi-k2.7-code', 'kimi-for-coding',
 ];
 export function modelRejectsSamplingParams(model) {
@@ -701,10 +704,10 @@ export function modelSupportsReasoningEffort(providerId, model) {
     const id = canonicalModelId(model);
     switch (providerId) {
         case 'anthropic':
-            // Effort is GA on Opus 4.5+, Sonnet 4.6, Fable 5 — NOT Haiku or Sonnet 4.5.
+            // Effort is GA on Opus 4.5+, Sonnet 4.6/5, Fable 5 — NOT Haiku or Sonnet 4.5.
             if (idMatches(id, 'claude-haiku-4-5') || idMatches(id, 'claude-sonnet-4-5'))
                 return false;
-            return /^claude-(opus-4-([5-9]|\d\d)|sonnet-4-6|fable-5)/.test(id);
+            return /^claude-(opus-4-([5-9]|\d\d)|sonnet-(4-6|5)|fable-5)/.test(id);
         case 'openai':
             // GPT-5.x are reasoning models — reasoning_effort across the family (incl. mini).
             return id.startsWith('gpt-5');
@@ -722,7 +725,12 @@ export function modelSupportsReasoningEffort(providerId, model) {
             return idMatches(id, 'glm-5-2');
         case 'grok':
             // Grok reasoning models accept reasoning_effort (none/low/medium/high).
-            // Explicit *-non-reasoning variants don't think → excluded.
+            // The coders (grok-code-fast, grok-build — the default) are NON-reasoning
+            // and 400 on reasoning_effort; a 400 here silently drops the whole turn
+            // into the weaker text-tool fallback (agentChat.ts), so exclude them
+            // alongside the explicit *-non-reasoning variants.
+            if (id.startsWith('grok-build') || id.startsWith('grok-code'))
+                return false;
             return id.startsWith('grok') && !id.includes('non-reasoning');
         // Kimi (thinking on/off, not graded) and Qwen coders (non-thinking) have
         // no graded knob → fall through to default false.

package/dist/renderer/agentExecution.d.ts

@@ -23,7 +23,7 @@ export interface AppExecutionContext {
     formatAddedFilesContext: () => string;
     handleCommand: (command: string, args: string[]) => Promise<void>;
     sessionDisplayName?: string;
-    setSessionDisplayName?: (name: string) => void;
+    setSessionDisplayName?: (name: string | null) => void;
 }
 export declare function isDangerousTool(toolName: string, parameters: Record<string, unknown>): boolean;
 export declare function requestToolConfirmation(app: App, tool: string, parameters: Record<string, unknown>, onConfirm: () => void, onCancel: () => void): void;

package/dist/renderer/agentExecution.js

@@ -10,7 +10,7 @@ import { runAgent } from '../utils/agent.js';
 import { config, autoSaveSession, getCurrentSessionId } from '../config/index.js';
 import { reportStats, syncSession, generateProjectId } from '../utils/codeepCloud.js';
 import { getGitStatus, isGitRepository } from '../utils/git.js';
-import { getCostBreakdown, resetTokenTracking } from '../utils/tokenTracker.js';
+import { getCostBreakdown, getRecordCount } from '../utils/tokenTracker.js';
 function getActionType(toolName) {
     return toolName.includes('write') ? 'write' :
         toolName.includes('edit') ? 'edit' :
@@ -140,7 +140,9 @@ export async function executeAgentTask(task, dryRun, ctx) {
     ctx.setAgentRunning(true);
     const abortController = new AbortController();
     ctx.setAbortController(abortController);
-    resetTokenTracking(); // Reset per-run so reportStats sends only this run's tokens
+    // Marker for cloud reporting: report only this run's tokens to the dashboard
+    // without wiping the session-cumulative store the status bar and `/cost` read.
+    const tokenReportStart = getRecordCount();
     const prefix = dryRun ? '[DRY RUN] ' : '[AGENT] ';
     app.addMessage({ role: 'user', content: prefix + task });
     app.setAgentRunning(true);
@@ -378,8 +380,9 @@ export async function executeAgentTask(task, dryRun, ctx) {
             messages: app.getMessages(),
         });
         // Report per-model so tokens are attributed to the correct model/provider
-        // even if the user switched model mid-session.
-        const costBreakdown = getCostBreakdown();
+        // even if the user switched model mid-session. Only this run's delta
+        // (since tokenReportStart) is reported; the cumulative store is preserved.
+        const costBreakdown = getCostBreakdown(tokenReportStart);
         const sharedFields = {
             sessionId,
             sessionName: displayName,
@@ -398,6 +401,8 @@ export async function executeAgentTask(task, dryRun, ctx) {
                     provider: entry.provider,
                     inputTokens: entry.promptTokens || undefined,
                     outputTokens: entry.completionTokens || undefined,
+                    cacheCreationTokens: entry.cacheCreationTokens || undefined,
+                    cacheReadTokens: entry.cacheReadTokens || undefined,
                     estimatedCost: entry.estimatedCost || undefined,
                 });
             }

package/dist/renderer/commands.js

@@ -679,6 +679,9 @@ export async function handleCommand(command, args, ctx) {
         case 'new': {
             ctx.app.clearMessages();
             ctx.setSessionId(startNewSession());
+            // Clear the derived display name so the next chat re-derives it — else
+            // the new session syncs/reports under the PREVIOUS session's name.
+            ctx.setSessionDisplayName?.(null);
             ctx.app.notify('New session started');
             break;
         }
@@ -1071,7 +1074,7 @@ Format: use headers per category, only include categories where you found issues
                 return;
             }
             const index = blockNum === -1 ? codeBlocks.length - 1 : blockNum - 1;
-            if (index < 0 || index >= codeBlocks.length) {
+            if (Number.isNaN(index) || index < 0 || index >= codeBlocks.length) {
                 ctx.app.notify(`Invalid block number. Available: 1-${codeBlocks.length}`);
                 return;
             }

package/dist/renderer/main.js

@@ -203,6 +203,8 @@ async function handleSubmit(message) {
                     provider: entry.provider,
                     inputTokens: entry.promptTokens || undefined,
                     outputTokens: entry.completionTokens || undefined,
+                    cacheCreationTokens: entry.cacheCreationTokens || undefined,
+                    cacheReadTokens: entry.cacheReadTokens || undefined,
                     estimatedCost: entry.estimatedCost || undefined,
                 });
             }
@@ -888,6 +890,8 @@ async function gracefulShutdown() {
             projectId,
             inputTokens: tokenStats.totalPromptTokens || undefined,
             outputTokens: tokenStats.totalCompletionTokens || undefined,
+            cacheCreationTokens: tokenStats.totalCacheCreationTokens || undefined,
+            cacheReadTokens: tokenStats.totalCacheReadTokens || undefined,
             estimatedCost: tokenStats.estimatedCost || undefined,
         }),
     ]);

package/dist/utils/agentChat.js

@@ -427,7 +427,11 @@ additionalTools) {
                 model, messages: [{ role: 'system', content: systemPrompt }, ...messages],
                 tools: getOpenAITools(additionalTools), tool_choice: 'auto', stream: useStreaming,
                 ...tempParam, ...tokParam, ...reasoningParam,
-                ...(useStreaming && providerId === 'openai' ? { stream_options: { include_usage: true } } : {}),
+                // Ask ALL OpenAI-compatible providers to emit a usage block in the
+                // stream — without this most (DeepSeek/Kimi/Grok/Qwen/GLM/…) send no
+                // usage on streamed responses and the whole turn records zero tokens.
+                // (OpenRouter also gets usage via openRouterExtras below; both is fine.)
+                ...(useStreaming ? { stream_options: { include_usage: true } } : {}),
                 ...openRouterExtras,
             };
         }

package/dist/utils/codeepCloud.d.ts

@@ -25,6 +25,12 @@ export interface StatsPayload {
     isGit?: boolean;
     inputTokens?: number;
     outputTokens?: number;
+    /** Anthropic prompt caching: tokens written to cache (billed ~1.25× input).
+     *  Undefined for providers that don't report caching. */
+    cacheCreationTokens?: number;
+    /** Anthropic prompt caching: tokens read from cache (billed ~0.1× input).
+     *  Undefined for providers that don't report caching. */
+    cacheReadTokens?: number;
     estimatedCost?: number;
 }
 /**

package/dist/utils/tokenTracker.d.ts

@@ -19,6 +19,10 @@ export interface SessionTokenStats {
     totalTokens: number;
     requestCount: number;
     estimatedCost: number;
+    /** Anthropic prompt caching: total tokens written to cache this session. */
+    totalCacheCreationTokens: number;
+    /** Anthropic prompt caching: total tokens read from cache this session. */
+    totalCacheReadTokens: number;
 }
 interface TokenRecord {
     timestamp: number;
@@ -42,6 +46,18 @@ export declare function getPricingTable(): {
     inputPer1M: number;
     outputPer1M: number;
 }[];
+/** An isolated token-record buffer for one scope (e.g. one ACP session). */
+export type TokenScope = TokenRecord[];
+/** Create a fresh, empty scope buffer (one per ACP session). */
+export declare function createTokenScope(): TokenScope;
+/**
+ * Run `fn` with `scope` as the active token-record buffer. Every
+ * recordTokenUsage() call made within `fn`'s async flow (including across
+ * awaits) accumulates into `scope`, and reads (getCostBreakdown/…) made in the
+ * same flow see only `scope`. Used by the ACP server to isolate per-session
+ * usage without threading a session id through the deep API layer.
+ */
+export declare function runWithTokenScope<T>(scope: TokenScope, fn: () => T): T;
 /**
  * Record token usage from an API response. The optional `actualCostUsd`
  * argument lets aggregator providers (OpenRouter) pass through the
@@ -63,12 +79,23 @@ export interface ProviderCostBreakdown {
     model: string;
     promptTokens: number;
     completionTokens: number;
+    /** Anthropic prompt caching: tokens written to cache (billed ~1.25× input).
+     *  0 for providers that don't report caching. */
+    cacheCreationTokens: number;
+    /** Anthropic prompt caching: tokens read from cache (billed ~0.1× input).
+     *  0 for providers that don't report caching. */
+    cacheReadTokens: number;
     estimatedCost: number;
 }
 /**
- * Get cost breakdown grouped by provider/model
+ * Get cost breakdown grouped by provider/model.
+ *
+ * `startIndex` lets callers price only the records appended since a marker (see
+ * getRecordCount) — used to report a single run/prompt's delta to cloud
+ * telemetry WITHOUT wiping the session-cumulative store the status bar and
+ * `/cost` read. Defaults to 0 (the whole current scope).
  */
-export declare function getCostBreakdown(): ProviderCostBreakdown[];
+export declare function getCostBreakdown(startIndex?: number): ProviderCostBreakdown[];
 /**
  * Aggregate Anthropic prompt-caching stats for the current session.
  * Returns the breakdown plus an estimate of what the input billing would
@@ -95,7 +122,17 @@ export declare function getLastUsage(): TokenRecord | null;
  */
 export declare function formatTokenCount(tokens: number): string;
 /**
- * Reset session tracking
+ * Number of records in the current scope. Capture before a run/prompt and pass
+ * it to getCostBreakdown(startIndex) to price just that run's delta (for cloud
+ * telemetry) without wiping the cumulative store the status bar and `/cost`
+ * read.
+ */
+export declare function getRecordCount(): number;
+/**
+ * Reset the current scope's tracking. Production run/prompt paths no longer
+ * call this (they use getRecordCount + getCostBreakdown(startIndex) so the
+ * session-cumulative totals survive); retained for the test suite, which uses
+ * it to isolate the process-wide default buffer between cases.
  */
 export declare function resetTokenTracking(): void;
 /**

package/dist/utils/tokenTracker.js

@@ -1,6 +1,7 @@
 /**
  * Token and cost tracking for API usage
  */
+import { AsyncLocalStorage } from 'node:async_hooks';
 // Context window sizes per model (in tokens).
 // Keep this table in lockstep with `providers.ts` — entries for models that
 // aren't in the provider catalogue only show up if a user types an id by hand
@@ -14,8 +15,10 @@ const MODEL_CONTEXT_WINDOWS = {
     'gpt-5.4': 1_050_000,
     'gpt-5.4-mini': 400_000,
     // Anthropic
+    'claude-fable-5': 1_000_000,
     'claude-opus-4-8': 1_000_000,
     'claude-sonnet-4-6': 1_000_000,
+    'claude-sonnet-5': 1_000_000,
     'claude-haiku-4-5-20251001': 200_000,
     // DeepSeek
     'deepseek-v4-pro': 1_000_000,
@@ -67,8 +70,10 @@ const MODEL_PRICING = {
     'gpt-5.4': { inputPer1M: 2.50, outputPer1M: 15.00 },
     'gpt-5.4-mini': { inputPer1M: 0.75, outputPer1M: 4.50 },
     // Anthropic
+    'claude-fable-5': { inputPer1M: 10.00, outputPer1M: 50.00 },
     'claude-opus-4-8': { inputPer1M: 5.00, outputPer1M: 25.00 },
     'claude-sonnet-4-6': { inputPer1M: 3.00, outputPer1M: 15.00 },
+    'claude-sonnet-5': { inputPer1M: 3.00, outputPer1M: 15.00 },
     'claude-haiku-4-5-20251001': { inputPer1M: 1.00, outputPer1M: 5.00 },
     // DeepSeek (cache-miss input pricing)
     'deepseek-v4-pro': { inputPer1M: 1.74, outputPer1M: 3.48 },
@@ -103,8 +108,27 @@ const MODEL_PRICING = {
 export function getPricingTable() {
     return Object.entries(MODEL_PRICING).map(([model, p]) => ({ model, ...p }));
 }
-// Session-level accumulator
-const records = [];
+const defaultRecords = [];
+const recordsStore = new AsyncLocalStorage();
+/** The record buffer for the current async flow (a scope's buffer inside
+ *  runWithTokenScope, otherwise the process-wide default). */
+function currentRecords() {
+    return recordsStore.getStore() ?? defaultRecords;
+}
+/** Create a fresh, empty scope buffer (one per ACP session). */
+export function createTokenScope() {
+    return [];
+}
+/**
+ * Run `fn` with `scope` as the active token-record buffer. Every
+ * recordTokenUsage() call made within `fn`'s async flow (including across
+ * awaits) accumulates into `scope`, and reads (getCostBreakdown/…) made in the
+ * same flow see only `scope`. Used by the ACP server to isolate per-session
+ * usage without threading a session id through the deep API layer.
+ */
+export function runWithTokenScope(scope, fn) {
+    return recordsStore.run(scope, fn);
+}
 /**
  * Record token usage from an API response. The optional `actualCostUsd`
  * argument lets aggregator providers (OpenRouter) pass through the
@@ -113,7 +137,7 @@ const records = [];
  * for every OpenRouter-listed model — there are 100+).
  */
 export function recordTokenUsage(usage, model, provider, actualCostUsd) {
-    records.push({
+    currentRecords().push({
         timestamp: Date.now(),
         promptTokens: usage.promptTokens,
         completionTokens: usage.completionTokens,
@@ -130,10 +154,16 @@ export function recordTokenUsage(usage, model, provider, actualCostUsd) {
  */
 export function extractOpenAIUsage(data) {
     if (data?.usage) {
+        // OpenAI-protocol `prompt_tokens` is INCLUSIVE of cached prompt tokens
+        // (DeepSeek/OpenAI report cache hits in prompt_tokens_details.cached_tokens).
+        // Surface them so getCostBreakdown bills cache reads at the discounted
+        // rate instead of the full cache-miss input rate.
+        const cached = data.usage.prompt_tokens_details?.cached_tokens || 0;
         return {
             promptTokens: data.usage.prompt_tokens || 0,
             completionTokens: data.usage.completion_tokens || 0,
             totalTokens: data.usage.total_tokens || 0,
+            cacheReadTokens: cached || undefined,
         };
     }
     return null;
@@ -161,15 +191,22 @@ export function extractAnthropicUsage(data) {
     return null;
 }
 /**
- * Get cost breakdown grouped by provider/model
+ * Get cost breakdown grouped by provider/model.
+ *
+ * `startIndex` lets callers price only the records appended since a marker (see
+ * getRecordCount) — used to report a single run/prompt's delta to cloud
+ * telemetry WITHOUT wiping the session-cumulative store the status bar and
+ * `/cost` read. Defaults to 0 (the whole current scope).
  */
-export function getCostBreakdown() {
+export function getCostBreakdown(startIndex = 0) {
     const grouped = new Map();
-    for (const record of records) {
+    for (const record of currentRecords().slice(startIndex)) {
         const key = `${record.provider}/${record.model}`;
-        const existing = grouped.get(key) ?? { provider: record.provider, model: record.model, promptTokens: 0, completionTokens: 0, estimatedCost: 0 };
+        const existing = grouped.get(key) ?? { provider: record.provider, model: record.model, promptTokens: 0, completionTokens: 0, cacheCreationTokens: 0, cacheReadTokens: 0, estimatedCost: 0 };
         existing.promptTokens += record.promptTokens;
         existing.completionTokens += record.completionTokens;
+        existing.cacheCreationTokens += record.cacheCreationTokens ?? 0;
+        existing.cacheReadTokens += record.cacheReadTokens ?? 0;
         // Cost source priority:
         //   1. Provider-reported USD (OpenRouter, MaxiCloud, etc.) — most accurate.
         //   2. Our MODEL_PRICING table — for built-in providers we maintain rates for.
@@ -201,7 +238,7 @@ export function getCacheStats() {
     let cacheCreate = 0;
     let cacheRead = 0;
     let savings = 0;
-    for (const record of records) {
+    for (const record of currentRecords()) {
         cacheCreate += record.cacheCreationTokens ?? 0;
         cacheRead += record.cacheReadTokens ?? 0;
         // Savings = what cache-read tokens would have cost at full input rate,
@@ -223,24 +260,31 @@ export function getSessionStats() {
     let totalPromptTokens = 0;
     let totalCompletionTokens = 0;
     let totalTokens = 0;
-    for (const record of records) {
+    let totalCacheCreationTokens = 0;
+    let totalCacheReadTokens = 0;
+    for (const record of currentRecords()) {
         totalPromptTokens += record.promptTokens;
         totalCompletionTokens += record.completionTokens;
         totalTokens += record.totalTokens;
+        totalCacheCreationTokens += record.cacheCreationTokens ?? 0;
+        totalCacheReadTokens += record.cacheReadTokens ?? 0;
     }
     const estimatedCost = getCostBreakdown().reduce((s, b) => s + b.estimatedCost, 0);
     return {
         totalPromptTokens,
         totalCompletionTokens,
         totalTokens,
-        requestCount: records.length,
+        requestCount: currentRecords().length,
         estimatedCost,
+        totalCacheCreationTokens,
+        totalCacheReadTokens,
     };
 }
 /**
  * Get last request usage
  */
 export function getLastUsage() {
+    const records = currentRecords();
     return records.length > 0 ? records[records.length - 1] : null;
 }
 /**
@@ -254,10 +298,22 @@ export function formatTokenCount(tokens) {
     return (tokens / 1000000).toFixed(2) + 'M';
 }
 /**
- * Reset session tracking
+ * Number of records in the current scope. Capture before a run/prompt and pass
+ * it to getCostBreakdown(startIndex) to price just that run's delta (for cloud
+ * telemetry) without wiping the cumulative store the status bar and `/cost`
+ * read.
+ */
+export function getRecordCount() {
+    return currentRecords().length;
+}
+/**
+ * Reset the current scope's tracking. Production run/prompt paths no longer
+ * call this (they use getRecordCount + getCostBreakdown(startIndex) so the
+ * session-cumulative totals survive); retained for the test suite, which uses
+ * it to isolate the process-wide default buffer between cases.
  */
 export function resetTokenTracking() {
-    records.length = 0;
+    currentRecords().length = 0;
 }
 /**
  * Format a session cost report as a Markdown block. Used by `/cost` in both

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "2.13.1";
+export declare const VERSION = "2.14.0";

package/dist/version.js

@@ -1,4 +1,4 @@
 // AUTO-GENERATED by scripts/gen-version.js — do not edit by hand.
 // Baked from package.json at build time so the bun-compiled binary reports
 // the right version (it has no package.json on disk to read at runtime).
-export const VERSION = '2.13.1';
+export const VERSION = '2.14.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeep",
-  "version": "2.13.1",
+  "version": "2.14.0",
   "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",