codeep 3.4.1 → 3.5.0

package/dist/acp/commands.js

@@ -4,7 +4,7 @@
 // responses (no TUI) suitable for streaming back via session/update.
 import { config, getCurrentProvider, getModelsForCurrentProvider, setProvider, setApiKey, isConfigured, listSessionsWithInfo, startNewSession, loadSession, saveSession, initializeAsProject, isManuallyInitializedProject, setProjectPermission, hasWritePermission, hasReadPermission, sessionNameProblem, sessionNameTaken, } from '../config/index.js';
 import { symlinkedCodeepNotice } from '../utils/projectPaths.js';
-import { getProviderList, getProvider } from '../config/providers.js';
+import { getProviderList, getProvider, replacementModelFor } from '../config/providers.js';
 import { telemetryCommand } from '../commands/core/telemetry.js';
 import { keysyncCommand } from '../commands/core/keysync.js';
 import { getProjectContext } from '../utils/project.js';
@@ -1387,20 +1387,25 @@ Anything else the agent should know — edge cases, gotchas, things to double-ch
             saveSession(session.codeepSessionId, session.history, session.workspaceRoot);
             // If the checkpoint captured a different provider/model, switch back.
             // configOptionsChanged signals the client to refresh its dropdowns.
+            // 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.
             let providerChanged = false;
             if (cp.provider && cp.provider !== getCurrentProvider().id) {
                 setProvider(cp.provider);
                 providerChanged = true;
             }
-            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);
                 providerChanged = true;
             }
+            const movedNote = cpModel !== cp.model ? ` (the checkpoint's \`${cp.model}\` is no longer offered)` : '';
             const lines = [
                 `## Rewound to ${cp.name ? `**${cp.name}**` : `\`${cp.id}\``}`,
                 '',
                 `Restored ${cp.messages.length} message${cp.messages.length === 1 ? '' : 's'} (was ${replacedCount}).`,
-                cp.provider && cp.model ? `Provider: \`${cp.provider}\` · Model: \`${cp.model}\`` : '',
+                cp.provider && cpModel ? `Provider: \`${cp.provider}\` · Model: \`${cpModel}\`${movedNote}` : '',
                 '',
                 buildRewindGitHint(cp),
             ].filter(Boolean);

package/dist/acp/server.d.ts

@@ -79,4 +79,17 @@ export declare function exitCodeFromWaitResult(result: unknown): number | null;
  * Exported for unit testing (see server.command.test.ts).
  */
 export declare function executeAcpCommand(command: string, args: string[], cwd: string, ctx: AcpCommandContext): Promise<AcpCommandOutcome>;
+/**
+ * What to tell the user when a prompt fails on authentication, or null when
+ * the failure is about something else.
+ *
+ * Every 401 used to read "No API key configured", key or no key. Kimi Code
+ * answers 401 for its plan limits — no K3 on the plan, K3 past 256K on
+ * Plus/Moderato, High-Speed below Pro/Allegretto, an unknown model id
+ * (kimi.com/code/docs/en/kimi-code/error-reference.html) — so a subscriber with
+ * a perfectly good key was sent to /login when the fix was another model. With
+ * a key configured, a 401 now says what else it can mean and quotes the
+ * provider.
+ */
+export declare function authFailureNotice(err: Error, providerId: string, keyConfigured: boolean): string | null;
 export declare function startAcpServer(transport?: StdioTransport): Promise<void>;

package/dist/acp/server.js

@@ -728,6 +728,43 @@ function persistSessionHistory(session) {
         return;
     saveSession(session.codeepSessionId, session.history, session.workspaceRoot);
 }
+/** The provider's own words from an `API error: 401 - …` message, if any. */
+function providerErrorDetail(message) {
+    const body = message.replace(/^[\s\S]*?\b401\s*-\s*/, '').trim();
+    let detail = body;
+    try {
+        const json = JSON.parse(body);
+        detail = json?.error?.message ?? json?.message ?? body;
+    }
+    catch {
+        // Not JSON — the text is the detail.
+    }
+    const text = String(detail).trim();
+    return text.length > 300 ? `${text.slice(0, 300)}…` : text;
+}
+/**
+ * What to tell the user when a prompt fails on authentication, or null when
+ * the failure is about something else.
+ *
+ * Every 401 used to read "No API key configured", key or no key. Kimi Code
+ * answers 401 for its plan limits — no K3 on the plan, K3 past 256K on
+ * Plus/Moderato, High-Speed below Pro/Allegretto, an unknown model id
+ * (kimi.com/code/docs/en/kimi-code/error-reference.html) — so a subscriber with
+ * a perfectly good key was sent to /login when the fix was another model. With
+ * a key configured, a 401 now says what else it can mean and quotes the
+ * provider.
+ */
+export function authFailureNotice(err, providerId, keyConfigured) {
+    const is401 = err instanceof ApiError && err.status === 401;
+    if (!is401 && !err.message?.includes('API key'))
+        return null;
+    if (is401 && keyConfigured) {
+        const name = PROVIDERS[providerId]?.name ?? providerId;
+        const detail = providerErrorDetail(err.message ?? '');
+        return `❌ ${name} refused the request (401)${detail ? `: ${detail}` : ''}. A key is configured, so this is not a missing key: the key may be invalid or revoked, or your plan may not include this model or limit (Kimi Code, for one, answers 401 when a plan lacks K3, K3's 1M context or High-Speed). Pick another model with /model, or re-enter the key with /login.`;
+    }
+    return `❌ No API key configured. Use /login <provider> <key> or set the environment variable (e.g. ZAI_API_KEY, ANTHROPIC_API_KEY).`;
+}
 export function startAcpServer(transport = new StdioTransport()) {
     // ACP sessionId → full AcpSession (includes history + codeep session tracking)
     const sessions = new Map();
@@ -1367,6 +1404,11 @@ export function startAcpServer(transport = new StdioTransport()) {
                 },
             });
         };
+        // Read when the prompt fails, not now: /login during the turn counts.
+        const authNotice = (err) => {
+            const providerId = config.get('provider');
+            return authFailureNotice(err, providerId, Boolean(getApiKey(providerId)));
+        };
         // Ask the user through the client. A person answers this: wait as long
         // as the dialog is open. Only cancelling the prompt stops the wait. No
         // answer (error, cancelled prompt, a reply without an outcome) is null,
@@ -1674,8 +1716,8 @@ export function startAcpServer(transport = new StdioTransport()) {
                         }
                         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)) {
-                        sendChunk(`❌ No API key configured. Use /login <provider> <key> or set the environment variable (e.g. ZAI_API_KEY, ANTHROPIC_API_KEY).`);
+                    else if (authNotice(err)) {
+                        sendChunk(authNotice(err));
                         transport.respond(msg.id, { stopReason: 'end_turn' });
                     }
                     else if (err instanceof ApiError && err.status >= 500) {
@@ -1696,8 +1738,8 @@ export function startAcpServer(transport = new StdioTransport()) {
                 if (err.name === 'AbortError' || abortController.signal.aborted) {
                     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)) {
-                    sendChunk(`❌ No API key configured. Use /login <provider> <key> or set the environment variable (e.g. ZAI_API_KEY, ANTHROPIC_API_KEY).`);
+                else if (authNotice(err)) {
+                    sendChunk(authNotice(err));
                     transport.respond(msg.id, { stopReason: 'end_turn' });
                 }
                 else if (err instanceof ApiError && err.status >= 500) {

package/dist/acp/serverHandlers.js

@@ -17,6 +17,7 @@
 // is "look up the session, mutate config or session state, acknowledge".
 import { AGENT_MODES, buildConfigOptions } from './server.js';
 import { config, setProvider, setApiKey, listSessionsWithInfo, deleteSession as deleteSessionFile, } from '../config/index.js';
+import { replacementModelFor } from '../config/providers.js';
 import { disposeSession as disposeMcpSession } from '../utils/mcpRegistry.js';
 import { clearPendingPlan } from '../utils/planMode.js';
 // ─── session/set_mode ─────────────────────────────────────────────────────────
@@ -99,17 +100,16 @@ export function handleSetConfigOption(msg, deps) {
  */
 export function applyConfigOption(configId, value) {
     if (configId === 'model' && typeof value === 'string') {
-        // value is "providerId/modelId" — split and switch both
+        // value is "providerId/modelId" — split and switch both. An editor setting
+        // pinned before a retirement (`openai/gpt-6-astra`) names an id the picker
+        // no longer has, so the model goes through the same map as a stored config,
+        // looked up on the provider actually active: setProvider refuses an unknown
+        // id and leaves the old one in place.
         const slashIdx = value.indexOf('/');
-        if (slashIdx !== -1) {
-            const providerId = value.slice(0, slashIdx);
-            const modelId = value.slice(slashIdx + 1);
-            setProvider(providerId); // sets provider + defaultModel + protocol
-            config.set('model', modelId);
-        }
-        else {
-            config.set('model', value);
-        }
+        const modelId = slashIdx !== -1 ? value.slice(slashIdx + 1) : value;
+        if (slashIdx !== -1)
+            setProvider(value.slice(0, slashIdx)); // sets provider + defaultModel + protocol
+        config.set('model', replacementModelFor(config.get('provider'), modelId) ?? modelId);
     }
     else if (configId === 'provider' && typeof value === 'string') {
         // Switch provider without specifying a model — picks the provider's

package/dist/api/index.js

@@ -3,7 +3,7 @@ import * as https from 'node:https';
 import { config, getApiKey, resolveBaseUrl, describeUnsendableKey } from '../config/index.js';
 import { withRetry, isNetworkError } from '../utils/retry.js';
 import { checkApiRateLimit } from '../utils/ratelimit.js';
-import { getProvider, getProviderBaseUrl, getProviderAuthHeader, usesMaxCompletionTokens, requiresDefaultTemperature, modelRejectsSamplingParams, reasoningParamsFor } from '../config/providers.js';
+import { getProvider, getProviderBaseUrl, getProviderAuthHeader, usesMaxCompletionTokens, requiresDefaultTemperature, modelRejectsSamplingParams, reasoningParamsFor, minResponseTokensFor } from '../config/providers.js';
 import { logApiRequest, logApiResponse } from '../utils/logger.js';
 import { loadProjectIntelligence, generateContextFromIntelligence } from '../utils/projectIntelligence.js';
 import { loadProjectRules } from '../utils/agent.js';
@@ -366,7 +366,8 @@ async function chatOpenAI(message, history, model, apiKey, onChunk, abortSignal)
     const stream = Boolean(onChunk);
     const timeout = config.get('apiTimeout');
     const temperature = config.get('temperature');
-    const maxTokens = config.get('maxTokens');
+    // Never below the model's floor (Opus 5.5 on OpenRouter — see minResponseTokensFor).
+    const maxTokens = Math.max(config.get('maxTokens'), minResponseTokensFor(model, config.get('reasoningEffort')));
     // Get provider-specific URL and auth. resolveBaseUrl applies user
     // overrides: Ollama (ollamaUrl), Custom (customBaseUrl), and OpenAI
     // (OPENAI_BASE_URL env) — so self-hosted / OpenAI-compatible endpoints work.
@@ -647,7 +648,9 @@ async function chatAnthropic(message, history, model, apiKey, onChunk, abortSign
     const stream = Boolean(onChunk);
     const timeout = config.get('apiTimeout');
     const temperature = config.get('temperature');
-    const maxTokens = config.get('maxTokens');
+    // Never below the model's floor: Opus 5.5's always-on thinking spends the
+    // same limit as the answer (see minResponseTokensFor).
+    const maxTokens = Math.max(config.get('maxTokens'), minResponseTokensFor(model, config.get('reasoningEffort')));
     const baseUrl = getProviderBaseUrl(providerId, 'anthropic');
     const authHeader = getProviderAuthHeader(providerId, 'anthropic');
     if (!baseUrl) {

package/dist/config/index.js

@@ -280,10 +280,18 @@ if (currentMigrationVersion < 1) {
         config.set('rateLimitCommands', 10000);
     }
 }
-if (currentMigrationVersion < 4) {
-    // Vendor aliases below were removed from Codeep's curated catalogue after
-    // their replacements became available. Migrate only exact known aliases:
-    // OpenRouter/Ollama/custom model ids remain user-controlled.
+// Retired model ids: on EVERY load, not once. This sat inside
+// `currentMigrationVersion < 4` until 2026-09-23, and MIGRATION_VERSION had
+// been 4 since 2026-08-15 — so every RETIRED_MODEL_REPLACEMENTS entry added
+// after that (the GPT-5.5/5.4, Grok, DeepSeek and Gemini ones) reached only
+// fresh configs and profile loads, never an existing user's active model. The
+// lookup is exact and idempotent, it touches only ids a vendor retired or
+// rerouted (never OpenRouter/Ollama/custom ids, which the map does not key),
+// and it is what applyProfile and the macOS app already do on every load. The
+// one-shot rule above protects settings a user chooses; the ids in that map are
+// ones the vendor retired or reroutes, or that cannot work from Codeep (GPT-6
+// Astra's tool calls), so rewriting them again cannot undo a working choice.
+{
     const provider = config.get('provider');
     const model = config.get('model');
     const replacement = replacementModelFor(provider, model);

package/dist/config/providers.d.ts

@@ -49,7 +49,14 @@ export interface ProviderConfig {
 export declare const PROVIDERS: Record<string, ProviderConfig>;
 export type ProviderId = keyof typeof PROVIDERS;
 export declare function getProvider(id: string): ProviderConfig | null;
+/**
+ * One exact lookup, never followed further: every target must already be a
+ * model its own provider offers (providers.test.ts holds the map to that), so a
+ * chain can never be needed and the macOS mirror stays a flat table too.
+ */
 export declare function replacementModelFor(providerId: string, modelId: string): string | undefined;
+/** The whole map, read-only — for the invariant test and nothing else. */
+export declare function retiredModelReplacements(): Readonly<Record<string, Readonly<Record<string, string>>>>;
 export declare function getProviderList(): {
     id: string;
     name: string;
@@ -94,6 +101,21 @@ export declare function modelRejectsSamplingParams(model: string): boolean;
  * Falls back to the requested value if no provider limit is set.
  */
 export declare function getEffectiveMaxTokens(providerId: string, requested: number): number;
+/**
+ * The smallest response budget (`max_tokens`) worth sending this model, or 0
+ * for no floor. Callers take the larger of this and whatever they would have
+ * sent, then apply getEffectiveMaxTokens as usual.
+ *
+ * Claude Opus 5.5 thinks on every request — adaptive thinking cannot be turned
+ * off — and "tends to think more per turn than Claude Opus 5" at the same
+ * effort; Anthropic's notes say to "leave room in max_tokens for the thinking",
+ * which spends the same limit as the answer. The task planner's 2048, or a
+ * maxTokens lowered in /settings, could go on thinking alone and cut the reply
+ * off. 32K is Codeep's own default; the Max tier gets 64K, where Anthropic's
+ * advice for max effort on Opus 5 is "starting at 64k tokens". Matched on the
+ * canonical id, so `anthropic/claude-opus-5.5` on OpenRouter is covered too.
+ */
+export declare function minResponseTokensFor(model: string, tier: ReasoningTier | undefined): number;
 /**
  * Unified, user-facing thinking-effort tiers (the `/thinking` setting).
  *
@@ -102,7 +124,7 @@ export declare function getEffectiveMaxTokens(providerId: string, requested: num
  *
  * The four tiers are CONCEPTUAL. `reasoningParamsFor()` clamps each one to the
  * nearest level the active provider+model actually accepts, so we never send a
- * value that would 400 (e.g. Gemini rejects "medium"; OpenAI has no "max").
+ * value that would 400 (e.g. Gemini has no "max"; GPT-5.5 tops out at "xhigh").
  * The control is a pure DEPTH knob on models that already think — it never
  * toggles thinking on/off, which keeps us clear of the reasoning_content-replay
  * contract that DeepSeek/GLM impose when thinking mode is flipped.
@@ -116,6 +138,21 @@ export declare const REASONING_TIERS: ReasoningTier[];
  * `claude-opus-4.8` → `claude-opus-4-8`). Mirrors macOS `ModelTuning.canonicalModelID`.
  */
 export declare function canonicalModelId(model: string): string;
+/**
+ * GPT-6 Sol and Luna on Chat Completions support function calling "only with
+ * `reasoning_effort` set to `none`" (developers.openai.com models/gpt-6-sol,
+ * guides/latest-model). So a request that carries tools to them must send
+ * "none", whatever /thinking says. Direct `openai` only: OpenRouter may reach
+ * OpenAI through the Responses API, where the rule does not apply, and Astra
+ * rejects "none" with a 400 (it is not offered on `openai` at all).
+ */
+export declare function toolsForceReasoningOff(providerId: string, model: string): boolean;
+/**
+ * What /thinking must tell the user when the tier does not reach every request
+ * for this model, or null. Without it the setting would look applied while
+ * agent turns quietly ran at "none".
+ */
+export declare function agentTurnReasoningNote(providerId: string, model: string): string | null;
 /**
  * Does this provider+model expose a GRADED thinking-effort control we can drive?
  * Used to gate the `/thinking` UI — hidden entirely for models without one.
@@ -128,12 +165,19 @@ export declare function modelSupportsReasoningEffort(providerId: string, model:
  * models, or providers without a graded knob — so callers can spread it
  * unconditionally. Keep in lockstep with macOS `ModelTuning.reasoningParams`.
  */
-export declare function reasoningParamsFor(providerId: string, model: string, tier: ReasoningTier): Record<string, unknown>;
+export declare function reasoningParamsFor(providerId: string, model: string, tier: ReasoningTier, 
+/** The request carries a non-empty `tools` array (native tool calling). */
+opts?: {
+    tools?: boolean;
+}): Record<string, unknown>;
 /**
  * The DISTINCT tiers a given provider+model actually exposes — used to build a
  * per-model picker that only offers levels the model can tell apart (e.g.
- * GLM-5.2/DeepSeek grade only high|max; Gemini via the OpenAI-compat layer only
- * low|high). Always leads with 'auto'. `[]` for models with no graded knob.
+ * GLM-5.2 grades only high|max; Gemini via the OpenAI-compat layer has no max).
+ * Always leads with 'auto'. `[]` for models with no graded knob.
+ *
+ * GPT-6 Sol/Luna list their full set: it is what they run on plain chat. Agent
+ * turns send "none" regardless (toolsForceReasoningOff), and /thinking says so.
  *
  * Kept in lockstep with `reasoningParamsFor` (the providers-test asserts every
  * listed tier yields a DISTINCT param, so this can't silently drift). Mirrors