codeep 3.4.1 → 3.5.0

package/dist/renderer/commands.js

@@ -9,7 +9,7 @@ import { config, getCurrentProvider, getModelsForCurrentProvider, PROTOCOLS, LAN
 import { setTelegramToken, clearTelegramToken, hasTelegramToken } from '../utils/telegramCredentials.js';
 import { getProjectContext } from '../utils/project.js';
 import { getCurrentVersion } from '../utils/update.js';
-import { getProviderList, getProvider, modelSupportsReasoningEffort, reasoningParamsFor, availableReasoningTiers, resolveReasoningTier, REASONING_TIERS } from '../config/providers.js';
+import { getProviderList, getProvider, modelSupportsReasoningEffort, reasoningParamsFor, availableReasoningTiers, resolveReasoningTier, agentTurnReasoningNote, replacementModelFor, REASONING_TIERS } from '../config/providers.js';
 import { setProjectContext } from '../api/index.js';
 import { runSkill, runCommandChain } from './agentExecution.js';
 import { loadProjectIntelligence, saveProjectIntelligence, INTELLIGENCE_NOT_SAVED } from '../utils/projectIntelligence.js';
@@ -301,14 +301,15 @@ export async function handleCommand(command, args, ctx) {
                     ctx.app.notify('Thinking effort: auto — each model uses its own default.');
                 }
                 else if (!supported) {
-                    ctx.app.notify(`Thinking effort set to "${sub}", but ${model} has no graded thinking control — it will be ignored until you switch to a model that does (e.g. Opus 5, GPT-5.x or GPT-6, Gemini 3, DeepSeek V4.1 Flash, GLM-5.x, Kimi K3).`);
+                    ctx.app.notify(`Thinking effort set to "${sub}", but ${model} has no graded thinking control — it will be ignored until you switch to a model that does (e.g. Opus 5.5, GPT-5.x or GPT-6, Gemini 3, DeepSeek V4, GLM-5.x, Kimi K3).`);
                 }
                 else {
                     // Tell the user what THIS model will actually run (the tier may
                     // collapse onto a level the model distinguishes, e.g. medium→high on Kimi K3).
                     const resolved = resolveReasoningTier(providerId, model, sub);
                     const note = resolved === sub ? '' : ` (${model} runs this as "${resolved}")`;
-                    ctx.app.notify(`Thinking effort: ${sub}${note} — sending ${JSON.stringify(reasoningParamsFor(providerId, model, sub))}.`);
+                    const agentNote = agentTurnReasoningNote(providerId, model);
+                    ctx.app.notify(`Thinking effort: ${sub}${note} — sending ${JSON.stringify(reasoningParamsFor(providerId, model, sub))}.${agentNote ? ` ${agentNote}` : ''}`);
                 }
                 break;
             }
@@ -333,8 +334,11 @@ export async function handleCommand(command, args, ctx) {
             }
             if (supported)
                 tLines.push(`**Available**  ${available.join(' · ')}`);
+            const agentNote = agentTurnReasoningNote(providerId, model);
+            if (agentNote)
+                tLines.push(`**Agent turns**  reasoning off — ${agentNote}`);
             tLines.push('');
-            tLines.push('Sets how hard the model reasons. Each model offers only the levels it distinguishes (DeepSeek → high · max; Kimi K3 → low · high · max; Gemini → low · high; Opus/Sonnet & GPT-5.x → the full set). The setting is global and clamps to the active model, so it never sends a value the API rejects. `/effort` is an alias.');
+            tLines.push('Sets how hard the model reasons. Each model offers only the levels it distinguishes (DeepSeek & Kimi K3 → low · high · max; Gemini → low · medium · high; Opus/Sonnet & GPT-5.x/6 → the full set). The setting is global and clamps to the active model, so it never sends a value the API rejects. `/effort` is an alias.');
             ctx.app.addMessage({ role: 'system', content: tLines.join('\n') });
             break;
         }
@@ -1737,14 +1741,19 @@ Format: use headers per category, only include categories where you found issues
             const replacedCount = ctx.app.getMessages().length;
             ctx.app.setMessages(cp.messages);
             saveSession(ctx.sessionId, cp.messages, ctx.projectPath);
-            // Switch provider/model back to checkpoint state if different.
+            // Switch provider/model back to checkpoint state if different. A
+            // checkpoint predates any later retirement, so its model goes through the
+            // same map as a stored config (`gpt-6-astra` comes back as `gpt-6-sol`),
+            // looked up on the provider actually active after the switch.
             if (cp.provider && cp.provider !== getCurrentProvider().id)
                 setProvider(cp.provider);
-            if (cp.model && cp.model !== config.get('model'))
-                config.set('model', cp.model);
+            const cpModel = cp.model && (replacementModelFor(config.get('provider'), cp.model) ?? cp.model);
+            if (cpModel && cpModel !== config.get('model'))
+                config.set('model', cpModel);
+            const movedNote = cpModel !== cp.model ? ` (the checkpoint's \`${cp.model}\` is no longer offered)` : '';
             ctx.app.addMessage({
                 role: 'system',
-                content: `# Rewound to ${cp.name ? `**${cp.name}**` : `\`${cp.id}\``}\n\nRestored ${cp.messages.length} message${cp.messages.length === 1 ? '' : 's'} (was ${replacedCount}). Provider: \`${cp.provider}\` · Model: \`${cp.model}\`\n\n${buildRewindGitHint(cp)}`,
+                content: `# Rewound to ${cp.name ? `**${cp.name}**` : `\`${cp.id}\``}\n\nRestored ${cp.messages.length} message${cp.messages.length === 1 ? '' : 's'} (was ${replacedCount}). Provider: \`${cp.provider}\` · Model: \`${cpModel}\`${movedNote}\n\n${buildRewindGitHint(cp)}`,
             });
             break;
         }

package/dist/utils/agent.d.ts

@@ -14,6 +14,22 @@ import { type TrustBearingWrite } from './toolExecution';
 import { undoLastAction, undoAllActions, getCurrentSession, getRecentSessions, formatSession, ActionSession } from './history';
 import { VerifyResult } from './verify';
 import { TaskPlan, SubTask } from './taskPlanner';
+/**
+ * The text an assistant turn is kept as in the history sent back next time.
+ *
+ * The loop stores each turn as plain text, and a turn that only called tools
+ * has none: Claude often skips the narration, and Opus 5.5 and Fable 5.1 move
+ * it into thinking blocks, which the stream parser does not keep. Stored as
+ * '', that turn is an empty non-final message on the next request, which
+ * Anthropic's Messages API refuses with a 400 ("all messages must have
+ * non-empty content except for the optional final assistant message").
+ * agentChat turns that 400 into the text-tool fallback, which sends the same
+ * history and fails the same way, so the run died on its second iteration.
+ * Naming the tools keeps the turn truthful and non-empty.
+ */
+export declare function assistantHistoryText(content: string, toolCalls: ReadonlyArray<{
+    tool: string;
+}>): string;
 export type PermissionOutcome = 'allow_once' | 'allow_always' | 'reject_once' | 'reject_always';
 export type PermissionDecision = 'allow-once' | 'allow-always' | 'deny-once' | 'deny-always';
 /**

package/dist/utils/agent.js

@@ -56,6 +56,27 @@ function truncateToolResult(output, toolName) {
     const truncated = output.length - TOOL_RESULT_MAX_CHARS;
     return `${kept}\n[... ${truncated} chars truncated — use search_code or read specific sections if you need more]`;
 }
+// ─── Assistant turns in the flattened history ─────────────────────────────────
+/**
+ * The text an assistant turn is kept as in the history sent back next time.
+ *
+ * The loop stores each turn as plain text, and a turn that only called tools
+ * has none: Claude often skips the narration, and Opus 5.5 and Fable 5.1 move
+ * it into thinking blocks, which the stream parser does not keep. Stored as
+ * '', that turn is an empty non-final message on the next request, which
+ * Anthropic's Messages API refuses with a 400 ("all messages must have
+ * non-empty content except for the optional final assistant message").
+ * agentChat turns that 400 into the text-tool fallback, which sends the same
+ * history and fails the same way, so the run died on its second iteration.
+ * Naming the tools keeps the turn truthful and non-empty.
+ */
+export function assistantHistoryText(content, toolCalls) {
+    if (content.trim())
+        return content;
+    if (toolCalls.length > 0)
+        return `Using ${[...new Set(toolCalls.map(t => t.tool))].join(', ')}.`;
+    return '(no reply)';
+}
 // ─── Context window compression ───────────────────────────────────────────────
 const CONTEXT_COMPRESS_THRESHOLD = 200_000; // ~50K tokens, safe for all providers
 const RECENT_MESSAGES_TO_KEEP = 6; // Always preserve the last N messages verbatim
@@ -1120,7 +1141,7 @@ export async function runAgent(prompt, projectContext, options = {}) {
                 if (hasIncompleteWork) {
                     debug('Model wants to continue, prompting for next action');
                     incompleteWorkRetries++;
-                    messages.push({ role: 'assistant', content });
+                    messages.push({ role: 'assistant', content: assistantHistoryText(content, toolCalls) });
                     messages.push({
                         role: 'user',
                         content: 'Continue. Execute the tool calls now.'
@@ -1136,8 +1157,8 @@ export async function runAgent(prompt, projectContext, options = {}) {
                 debug(`Agent finished at iteration ${iteration}`);
                 break;
             }
-            // Add assistant response to history
-            messages.push({ role: 'assistant', content });
+            // Add assistant response to history — never empty (see assistantHistoryText).
+            messages.push({ role: 'assistant', content: assistantHistoryText(content, toolCalls) });
             // Execute tool calls
             const toolResults = [];
             for (const toolCall of toolCalls) {

package/dist/utils/agentChat.js

@@ -20,7 +20,7 @@ import { config, getApiKey, resolveBaseUrl } from '../config/index.js';
 import { loadProjectIntelligence, generateContextFromIntelligence } from './projectIntelligence.js';
 import { formatCommandIndex } from './commandIndex.js';
 import { syncProgress, generateProjectId } from './codeepCloud.js';
-import { getProviderAuthHeader, supportsNativeTools, getEffectiveMaxTokens, usesMaxCompletionTokens, requiresDefaultTemperature, modelRejectsSamplingParams, isNoApiKeyProvider, reasoningParamsFor, providerNoStreamWithTools } from '../config/providers.js';
+import { getProviderAuthHeader, supportsNativeTools, getEffectiveMaxTokens, usesMaxCompletionTokens, requiresDefaultTemperature, modelRejectsSamplingParams, isNoApiKeyProvider, reasoningParamsFor, providerNoStreamWithTools, minResponseTokensFor } from '../config/providers.js';
 import { recordTokenUsage, extractOpenAIUsage, extractAnthropicUsage } from './tokenTracker.js';
 import { parseOpenAIToolCalls, parseAnthropicToolCalls, parseToolCalls } from './toolParsing.js';
 import { formatToolDefinitions, getOpenAITools, getAnthropicTools } from './tools.js';
@@ -484,10 +484,17 @@ additionalTools, runtime) {
         // Provider-level guard (OpenAI GPT-5+) OR model-level guard — Anthropic's
         // Fable 5 / Opus 4.7+ reject temperature with a 400; omission is safe.
         const tempParam = (requiresDefaultTemperature(providerId) || modelRejectsSamplingParams(model)) ? {} : { temperature: config.get('temperature') };
-        // Thinking-effort tier → provider-shaped param ({} for 'auto'/unsupported).
-        const reasoningParam = reasoningParamsFor(providerId, model, config.get('reasoningEffort'));
+        const tier = config.get('reasoningEffort');
+        // Room for the answer after the thinking (Opus 5.5 thinks on every turn).
+        const responseBudget = Math.max(config.get('maxTokens'), 16384, minResponseTokensFor(model, tier));
         if (protocol === 'openai') {
-            const maxTok = getEffectiveMaxTokens(providerId, Math.max(config.get('maxTokens'), 16384));
+            const openAITools = getOpenAITools(additionalTools, allowedTools);
+            // Thinking-effort tier → provider-shaped param ({} for 'auto'/unsupported).
+            // This request carries tools, which GPT-6 Sol/Luna on Chat Completions
+            // accept only at reasoning_effort "none"; told so, reasoningParamsFor
+            // sends that for them whatever the tier.
+            const openAIReasoning = reasoningParamsFor(providerId, model, tier, { tools: openAITools.length > 0 });
+            const maxTok = getEffectiveMaxTokens(providerId, responseBudget);
             const tokParam = usesMaxCompletionTokens(providerId) ? { max_completion_tokens: maxTok } : { max_tokens: maxTok };
             endpoint = `${baseUrl}/chat/completions`;
             // OpenRouter-specific extras: request `usage` block in the response
@@ -537,8 +544,8 @@ additionalTools, runtime) {
             }
             body = {
                 model, messages: [{ role: 'system', content: systemPrompt }, ...messages],
-                tools: getOpenAITools(additionalTools, allowedTools), tool_choice: 'auto', stream: useStreaming,
-                ...tempParam, ...tokParam, ...reasoningParam,
+                tools: openAITools, tool_choice: 'auto', stream: useStreaming,
+                ...tempParam, ...tokParam, ...openAIReasoning,
                 // 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.
@@ -568,7 +575,8 @@ additionalTools, runtime) {
                 system: [{ type: 'text', text: systemPrompt, cache_control: { type: 'ephemeral' } }],
                 messages,
                 tools: cachedTools, stream: useStreaming,
-                ...tempParam, ...reasoningParam, max_tokens: getEffectiveMaxTokens(providerId, Math.max(config.get('maxTokens'), 16384)),
+                ...tempParam, ...reasoningParamsFor(providerId, model, tier),
+                max_tokens: getEffectiveMaxTokens(providerId, responseBudget),
             };
         }
         const response = await fetch(endpoint, {
@@ -701,10 +709,14 @@ export async function agentChatFallback(messages, systemPrompt, onChunk, abortSi
         // Provider-level guard (OpenAI GPT-5+) OR model-level guard — Anthropic's
         // Fable 5 / Opus 4.7+ reject temperature with a 400; omission is safe.
         const tempParam = (requiresDefaultTemperature(providerId) || modelRejectsSamplingParams(model)) ? {} : { temperature: config.get('temperature') };
+        const tier = config.get('reasoningEffort');
         // Thinking-effort tier → provider-shaped param ({} for 'auto'/unsupported).
-        const reasoningParam = reasoningParamsFor(providerId, model, config.get('reasoningEffort'));
+        // No `tools` array goes out on this path — the tools are text in the
+        // prompt — so GPT-6 Sol/Luna keep the user's tier here.
+        const reasoningParam = reasoningParamsFor(providerId, model, tier);
+        const responseBudget = Math.max(config.get('maxTokens'), 16384, minResponseTokensFor(model, tier));
         if (protocol === 'openai') {
-            const maxTok = getEffectiveMaxTokens(providerId, Math.max(config.get('maxTokens'), 16384));
+            const maxTok = getEffectiveMaxTokens(providerId, responseBudget);
             const tokParam = usesMaxCompletionTokens(providerId) ? { max_completion_tokens: maxTok } : { max_tokens: maxTok };
             endpoint = `${baseUrl}/chat/completions`;
             body = {
@@ -727,7 +739,7 @@ export async function agentChatFallback(messages, systemPrompt, onChunk, abortSi
                     ...messages,
                 ],
                 stream: Boolean(onChunk), ...tempParam, ...reasoningParam,
-                max_tokens: getEffectiveMaxTokens(providerId, Math.max(config.get('maxTokens'), 16384)),
+                max_tokens: getEffectiveMaxTokens(providerId, responseBudget),
             };
         }
         const response = await fetch(endpoint, {

package/dist/utils/personalities.js

@@ -39,7 +39,7 @@ import { basename, join } from 'path';
 import { homedir } from 'os';
 import { leadsOutsideProject } from './projectPaths.js';
 import { config } from '../config/index.js';
-import { getProvider } from '../config/providers.js';
+import { getProvider, replacementModelFor } from '../config/providers.js';
 const CAPABILITIES = new Set([
     'files', 'terminal', 'tests', 'git', 'web', 'mcp',
 ]);
@@ -126,7 +126,13 @@ function exactModelPreference(preference) {
         return null;
     const providerId = value.slice(0, slash).trim();
     const model = value.slice(slash + 1).trim();
-    return providerId && model ? { providerId, model } : null;
+    if (!providerId || !model)
+        return null;
+    // A bot written before a vendor retired its model (or before Codeep stopped
+    // offering one, like `openai/gpt-6-astra`) names an id the picker no longer
+    // has, and the exact check below would make the whole bot unavailable. Map it
+    // the way the startup migration and applyProfile map a stored id.
+    return { providerId, model: replacementModelFor(providerId, model) ?? model };
 }
 /** Whether a structured bot's model field satisfies the portable v1 contract. */
 export function isPersonalityModelPreferenceValid(personality) {

package/dist/utils/taskPlanner.js

@@ -2,7 +2,7 @@
  * Task Planning - breaks down complex tasks into subtasks
  */
 import { config, getApiKey, resolveBaseUrl } from '../config/index.js';
-import { getProviderAuthHeader, isNoApiKeyProvider, requiresDefaultTemperature } from '../config/providers.js';
+import { getProviderAuthHeader, isNoApiKeyProvider, requiresDefaultTemperature, modelRejectsSamplingParams, minResponseTokensFor } from '../config/providers.js';
 /**
  * Ask AI to break down a complex task into subtasks
  */
@@ -51,10 +51,14 @@ Break this down into subtasks. Each task = one file or one logical unit. Respond
         const messages = [
             { role: 'user', content: systemPrompt }
         ];
+        // 2048 is plenty for a JSON plan, but not for a model that thinks on every
+        // request inside the same limit (Opus 5.5 — see minResponseTokensFor). The
+        // planner sends no effort, so the model runs at its own default: 'auto'.
+        const maxTokens = Math.max(2048, minResponseTokensFor(model, 'auto'));
         const requestBody = protocol === 'anthropic'
             ? {
                 model,
-                max_tokens: 2048,
+                max_tokens: maxTokens,
                 messages,
                 system: 'You are a task planning assistant. Respond with JSON only.',
             }
@@ -64,8 +68,12 @@ Break this down into subtasks. Each task = one file or one logical unit. Respond
                     { role: 'system', content: 'You are a task planning assistant. Respond with JSON only.' },
                     ...messages
                 ],
-                ...(requiresDefaultTemperature(provider) ? {} : { temperature: 0.3 }),
-                max_tokens: 2048,
+                // Both guards, as in agentChat: the provider flag covers direct
+                // OpenAI, and the model list covers ids that reach this branch through
+                // OpenRouter (anthropic/claude-opus-5.5, openai/gpt-6-*), which 400 on
+                // a temperature they do not accept.
+                ...(requiresDefaultTemperature(provider) || modelRejectsSamplingParams(model) ? {} : { temperature: 0.3 }),
+                max_tokens: maxTokens,
             };
         const headers = {
             'Content-Type': 'application/json',

package/dist/utils/tokenTracker.d.ts

@@ -5,9 +5,10 @@ export interface TokenUsage {
     promptTokens: number;
     completionTokens: number;
     totalTokens: number;
-    /** Anthropic prompt caching: tokens written to the cache on this call
-     *  (billed at ~1.25× input rate). Undefined for providers that don't
-     *  support caching or for calls below the cache size threshold. */
+    /** Prompt caching: tokens written to the cache on this call — Anthropic's
+     *  cache_creation_input_tokens, or OpenAI-protocol
+     *  prompt_tokens_details.cache_write_tokens (GPT-5.6+, Kimi K3). Billed at
+     *  cacheWriteRateFor(). Undefined when the provider reports none. */
     cacheCreationTokens?: number;
     /** Anthropic prompt caching: tokens read from cache on this call
      *  (billed at ~0.1× input rate — the big savings live here). */
@@ -85,8 +86,8 @@ 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. */
+    /** Prompt caching: tokens written to cache (billed at cacheWriteRateFor()).
+     *  0 for providers that don't report writes. */
     cacheCreationTokens: number;
     /** Anthropic prompt caching: tokens read from cache (billed ~0.1× input).
      *  0 for providers that don't report caching. */
@@ -102,6 +103,11 @@ export interface ProviderCostBreakdown {
  * cost and a "saved" figure that disagreed with each other.
  */
 export declare function cacheReadRateFor(model: string, provider: string | undefined): number;
+/**
+ * What writing a prompt token into the cache costs, as a multiple of the
+ * model's input rate. Same order as reads: model, then provider, then default.
+ */
+export declare function cacheWriteRateFor(model: string, provider: string | undefined): number;
 /**
  * The rate note for a report. One rate reads as "0.02×"; a session mixing
  * providers reads as a range, because any single number there would be wrong
@@ -138,6 +144,8 @@ export interface CacheStats {
     /** The read rate of each metered record that read from cache, so a report
      *  can state the rate that actually applied instead of assuming 0.1×. */
     cacheReadRates: number[];
+    /** Likewise for writes, which are not 1.25× everywhere (Kimi: 1.0×). */
+    cacheWriteRates: number[];
 }
 export declare function getCacheStats(): CacheStats;
 /**