codeep 2.17.0 → 2.18.1

package/dist/api/index.js

@@ -343,7 +343,13 @@ async function chatOpenAI(message, history, model, apiKey, onChunk, abortSignal)
     let baseUrl = resolveBaseUrl(providerId, 'openai');
     const authHeader = getProviderAuthHeader(providerId, 'openai');
     const useCompletionTokens = usesMaxCompletionTokens(providerId);
-    const omitTemperature = requiresDefaultTemperature(providerId);
+    // Two independent reasons to leave temperature out, and both must be checked
+    // here: the provider-level flag (endpoints that only accept the default) and
+    // the per-model one (generations that removed the sampling params outright,
+    // e.g. gemini-3.7-flash). Testing only the provider flag let a rejecting
+    // model through, because every model this rule covers is served over the
+    // OpenAI-compatible path, not the Anthropic one.
+    const omitTemperature = requiresDefaultTemperature(providerId) || modelRejectsSamplingParams(model);
     if (!baseUrl) {
         throw new Error(`Provider ${providerId} does not support OpenAI protocol`);
     }

package/dist/config/providers.d.ts

@@ -34,6 +34,10 @@ export interface ProviderConfig {
     subscribeUrl?: string;
     noApiKey?: boolean;
     dynamicModels?: boolean;
+    /** Billed as a flat subscription (or free) — token counts are real, per-token
+     *  cost is not. Cost surfaces must say "included in plan" instead of pricing
+     *  these tokens at the provider's pay-per-use rates. */
+    flatFee?: boolean;
     groupLabel?: string;
     hint?: string;
     mcpEndpoints?: {
@@ -60,6 +64,11 @@ export declare function getProviderModels(providerId: string): {
 }[];
 export declare function isNoApiKeyProvider(providerId: string): boolean;
 export declare function isDynamicModelsProvider(providerId: string): boolean;
+/**
+ * Returns true if the provider bills a flat subscription (or is free), so any
+ * per-token dollar figure we compute for it is invented — see `flatFee`.
+ */
+export declare function isFlatFeeProvider(providerId: string): boolean;
 export declare function getProviderBaseUrl(providerId: string, protocol: 'openai' | 'anthropic'): string | null;
 export declare function getProviderAuthHeader(providerId: string, protocol: 'openai' | 'anthropic'): 'Bearer' | 'x-api-key';
 export declare function getProviderMcpEndpoints(providerId: string): ProviderConfig['mcpEndpoints'] | null;

package/dist/config/providers.js

@@ -18,15 +18,19 @@ export const PROVIDERS = {
             },
         },
         models: [
-            { id: 'glm-5.2', name: 'GLM-5.2', description: 'Latest flagship for project-scale engineering (1M context)' },
+            // GLM-5.3 is Coding-Plan only — the standalone pay-per-use API does not
+            // accept it yet, so it must NOT be copied into `z.ai-api`.
+            { id: 'glm-5.3', name: 'GLM-5.3', description: 'Latest flagship for project-scale engineering (1M context)' },
+            { id: 'glm-5.2', name: 'GLM-5.2', description: 'Previous flagship for project-scale engineering (1M context)' },
             { id: 'glm-5-turbo', name: 'GLM-5 Turbo', description: 'Fast GLM-5 variant, available to all users' },
         ],
-        defaultModel: 'glm-5.2',
+        defaultModel: 'glm-5.3',
         defaultProtocol: 'openai',
         maxOutputTokens: 131_072,
         envKey: 'ZAI_API_KEY',
         subscribeUrl: 'https://z.ai/subscribe?ic=NXYNXZOV14',
         groupLabel: 'Z.AI — Subscription (GLM Coding Plan)',
+        flatFee: true,
         hint: 'Uses your Z.AI subscription — no per-token charges.',
         mcpEndpoints: {
             webSearch: 'https://api.z.ai/api/mcp/web_search_prime/mcp',
@@ -81,6 +85,7 @@ export const PROVIDERS = {
         envKey: 'ZAI_CN_API_KEY',
         subscribeUrl: 'https://open.bigmodel.cn/glm-coding',
         groupLabel: 'Z.AI China — Subscription (GLM Coding Plan)',
+        flatFee: true,
         hint: 'Uses your ZhipuAI China subscription.',
         mcpEndpoints: {
             webSearch: 'https://open.bigmodel.cn/api/mcp/web_search_prime/mcp',
@@ -133,6 +138,7 @@ export const PROVIDERS = {
         envKey: 'MINIMAX_API_KEY',
         subscribeUrl: 'https://platform.minimax.io/subscribe/coding-plan?code=2lWvoWUhrp&source=link',
         groupLabel: 'MiniMax — Subscription',
+        flatFee: true,
         hint: 'Uses your MiniMax subscription — no per-token charges.',
     },
     'minimax-api': {
@@ -178,6 +184,7 @@ export const PROVIDERS = {
         envKey: 'MINIMAX_CN_API_KEY',
         subscribeUrl: 'https://platform.minimaxi.com',
         groupLabel: 'MiniMax China — Subscription',
+        flatFee: true,
         hint: 'Uses your MiniMax China subscription.',
     },
     'deepseek': {
@@ -230,6 +237,7 @@ export const PROVIDERS = {
         envKey: 'KIMI_CODE_API_KEY',
         subscribeUrl: 'https://www.kimi.com/code',
         groupLabel: 'Kimi — Subscription (Kimi Code)',
+        flatFee: true,
         hint: 'Uses your Kimi Code subscription — no per-token charges. Key from kimi.com/code/console.',
     },
     'kimi-api': {
@@ -283,10 +291,15 @@ export const PROVIDERS = {
             openai: { baseUrl: 'https://api.x.ai/v1', authHeader: 'Bearer', supportsNativeTools: true },
         },
         models: [
-            { id: 'grok-4.5', name: 'Grok 4.5', description: 'Flagship reasoning model — highest quality, 500K context' },
+            { id: 'grok-4.6', name: 'Grok 4.6', description: 'Flagship reasoning model — xAI recommends it for code, 500K context' },
+            { id: 'grok-4.5', name: 'Grok 4.5', description: 'Previous flagship reasoning model, 500K context' },
             { id: 'grok-build-0.1', name: 'Grok Build 0.1', description: 'Agentic coding model — fast, 256K context' },
-            { id: 'grok-4.3', name: 'Grok 4.3', description: 'Previous flagship, 1M context' },
+            { id: 'grok-4.3', name: 'Grok 4.3', description: 'Older flagship, 1M context' },
         ],
+        // Stays on the agentic coder, not the new flagship. grok-4.6 is the better
+        // model and xAI recommends it for code, but it bills 2x input and 3x output
+        // against grok-build-0.1 — moving every unpinned user onto it silently is
+        // not ours to decide. It is one `/model` away for anyone who wants it.
         defaultModel: 'grok-build-0.1',
         defaultProtocol: 'openai',
         useMaxCompletionTokens: true, // reasoning models reject max_tokens
@@ -317,6 +330,7 @@ export const PROVIDERS = {
         envKey: 'BAILIAN_CODING_PLAN_API_KEY',
         subscribeUrl: 'https://www.alibabacloud.com/help/en/model-studio/qwen-code-coding-plan',
         groupLabel: 'Qwen — Subscription (Coding Plan)',
+        flatFee: true,
         hint: 'Uses your Qwen Coding Plan — no per-token charges. sk-sp-… key from Model Studio. Interactive coding use only.',
     },
     'qwen-api': {
@@ -359,6 +373,7 @@ export const PROVIDERS = {
         envKey: 'BAILIAN_TOKEN_PLAN_API_KEY',
         subscribeUrl: 'https://modelstudio.console.alibabacloud.com/',
         groupLabel: 'Qwen — Subscription (Token Plan)',
+        flatFee: true,
         hint: 'Uses monthly Token Plan credits. Requires a separate sk-sp-… Token Plan key.',
     },
     'qwen-cn': {
@@ -379,6 +394,7 @@ export const PROVIDERS = {
         envKey: 'BAILIAN_CODING_PLAN_CN_API_KEY',
         subscribeUrl: 'https://bailian.console.aliyun.com/',
         groupLabel: 'Qwen China — Subscription (Coding Plan)',
+        flatFee: true,
         hint: 'Uses your Qwen Coding Plan (China). sk-sp-… key from Bailian.',
     },
     'qwen-cn-api': {
@@ -418,6 +434,7 @@ export const PROVIDERS = {
         envKey: 'MODELSCOPE_API_KEY',
         subscribeUrl: 'https://modelscope.cn/my/myaccesstoken',
         groupLabel: 'ModelScope — Free (Qwen)',
+        flatFee: true,
         hint: 'Fetches the live free catalog for your ModelScope token; availability and limits vary by account.',
     },
     'openai': {
@@ -478,7 +495,8 @@ export const PROVIDERS = {
         },
         models: [
             { id: 'gemini-3.1-pro-preview', name: 'Gemini 3.1 Pro', description: 'Most capable Gemini model' },
-            { id: 'gemini-3.6-flash', name: 'Gemini 3.6 Flash', description: 'Latest production Flash model' },
+            { id: 'gemini-3.7-flash', name: 'Gemini 3.7 Flash', description: 'Latest production Flash model — adjustable thinking, 64K output' },
+            { id: 'gemini-3.6-flash', name: 'Gemini 3.6 Flash', description: 'Previous production Flash model' },
             { id: 'gemini-3.5-flash', name: 'Gemini 3.5 Flash', description: 'Stable frontier Flash model for coding and long agentic tasks' },
             { id: 'gemini-3.5-flash-lite', name: 'Gemini 3.5 Flash-Lite', description: 'Latest low-latency, low-cost workhorse' },
         ],
@@ -510,11 +528,11 @@ export const PROVIDERS = {
             { id: 'anthropic/claude-sonnet-5', name: 'Claude Sonnet 5', description: 'Anthropic — balanced' },
             { id: 'openai/gpt-5.6-sol', name: 'GPT-5.6 Sol', description: 'OpenAI — flagship' },
             { id: 'openai/gpt-5.6-luna', name: 'GPT-5.6 Luna', description: 'OpenAI — fast/efficient' },
-            { id: 'google/gemini-3.6-flash', name: 'Gemini 3.6 Flash', description: 'Google — latest production Flash' },
+            { id: 'google/gemini-3.7-flash', name: 'Gemini 3.7 Flash', description: 'Google — latest production Flash' },
             { id: 'deepseek/deepseek-v4-pro', name: 'DeepSeek V4 Pro', description: 'DeepSeek — flagship agentic model' },
             { id: 'moonshotai/kimi-k3', name: 'Kimi K3', description: 'Moonshot — long-horizon coding' },
             { id: 'qwen/qwen3.8-max', name: 'Qwen 3.8 Max', description: 'Alibaba — latest flagship' },
-            { id: 'x-ai/grok-4.5', name: 'Grok 4.5', description: 'xAI — flagship reasoning' },
+            { id: 'x-ai/grok-4.6', name: 'Grok 4.6', description: 'xAI — flagship reasoning' },
         ],
         defaultModel: 'openrouter/auto',
         defaultProtocol: 'openai',
@@ -695,6 +713,13 @@ export function isNoApiKeyProvider(providerId) {
 export function isDynamicModelsProvider(providerId) {
     return PROVIDERS[providerId]?.dynamicModels === true;
 }
+/**
+ * Returns true if the provider bills a flat subscription (or is free), so any
+ * per-token dollar figure we compute for it is invented — see `flatFee`.
+ */
+export function isFlatFeeProvider(providerId) {
+    return PROVIDERS[providerId]?.flatFee === true;
+}
 export function getProviderBaseUrl(providerId, protocol) {
     const provider = PROVIDERS[providerId];
     if (!provider)
@@ -745,14 +770,23 @@ export function providerNoStreamWithTools(providerId) {
  * 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.
+ * internally and 400 on any custom value, so they're here too. Google removed
+ * the deprecated sampling parameters outright in the Gemini 3.7 generation.
  */
 const SAMPLING_PARAMS_REJECTED = [
     'claude-fable-5', 'claude-opus-5', 'claude-opus-4-8', 'claude-opus-4-7', 'claude-sonnet-5',
     'kimi-k3', 'kimi-k2.7-code', 'kimi-for-coding', 'k3',
+    'gemini-3.7-flash',
 ];
 export function modelRejectsSamplingParams(model) {
-    return SAMPLING_PARAMS_REJECTED.some(id => model === id || model.startsWith(`${id}-`));
+    // Canonicalize both sides. OpenRouter routes these as `google/gemini-3.7-flash`
+    // and `anthropic/claude-opus-4.8`, which a raw comparison misses — so the model
+    // gets a temperature it rejects, on the one path where the id is namespaced.
+    const id = canonicalModelId(model);
+    return SAMPLING_PARAMS_REJECTED.some(entry => {
+        const canonical = canonicalModelId(entry);
+        return id === canonical || id.startsWith(`${canonical}-`);
+    });
 }
 /**
  * Returns the effective max output tokens for a provider, capped by the provider's limit.
@@ -807,8 +841,9 @@ export function modelSupportsReasoningEffort(providerId, model) {
         case 'z.ai-api':
         case 'z.ai-cn':
         case 'z.ai-cn-api':
-            // GLM-5.2 exposes graded High/Max effort; Turbo is a plain toggle.
-            return idMatches(id, 'glm-5-2');
+            // GLM-5.2 exposes graded High/Max effort; GLM-5.3 adds a distinct Low.
+            // Turbo is a plain toggle.
+            return idMatches(id, 'glm-5-2') || idMatches(id, 'glm-5-3');
         case 'kimi':
             return idMatches(id, 'k3');
         case 'kimi-api':
@@ -854,14 +889,25 @@ export function reasoningParamsFor(providerId, model, tier) {
             // none/low/medium/high/xhigh — no "max"; map our Max → xhigh (the ceiling).
             return { reasoning_effort: tier === 'max' ? 'xhigh' : tier };
         case 'google':
-            // Gemini 3 (OpenAI-compat) accepts ONLY low/high — "medium" 400s.
-            return { reasoning_effort: tier === 'low' ? 'low' : 'high' };
+            // Gemini's OpenAI-compat layer maps reasoning_effort onto thinking_level
+            // and documents low | medium | high. (Medium 400'd on Gemini 3 Preview,
+            // which is why this used to collapse it — that was a preview-era bug and
+            // is fixed.) 'max' has no Gemini equivalent, so it tops out at high.
+            // 'minimal' is deliberately not emitted: 3.7 Flash rejects it outright.
+            return { reasoning_effort: tier === 'max' ? 'high' : tier };
         case 'deepseek':
+            // Graded thinking depth: high (default) or max. Lower tiers collapse to high.
+            return { reasoning_effort: tier === 'max' ? 'max' : 'high' };
         case 'z.ai':
         case 'z.ai-api':
         case 'z.ai-cn':
         case 'z.ai-cn-api':
-            // Graded thinking depth: high (default) or max. Lower tiers collapse to high.
+            // GLM-5.3 accepts low/high/max; GLM-5.2 grades only high|max, so lower
+            // tiers collapse to high there. Either way we always send an effort and
+            // never a disabled thinking block — GLM-5.3 rejects "disabled" outright.
+            if (idMatches(canonicalModelId(model), 'glm-5-3')) {
+                return { reasoning_effort: tier === 'low' ? 'low' : tier === 'max' ? 'max' : 'high' };
+            }
             return { reasoning_effort: tier === 'max' ? 'max' : 'high' };
         case 'kimi':
         case 'kimi-api':
@@ -896,14 +942,20 @@ export function availableReasoningTiers(providerId, model) {
         case 'openai':
             return ['auto', 'low', 'medium', 'high', 'max'];
         case 'google':
-            // OpenAI-compat layer accepts only low/high — "medium" 400s.
-            return ['auto', 'low', 'high'];
+            // low | medium | high, per Gemini's OpenAI-compat mapping table. Medium
+            // is 3.7 Flash's own default and the tier Google recommends for agentic
+            // coding, so collapsing it hid the setting most users want.
+            return ['auto', 'low', 'medium', 'high'];
         case 'deepseek':
+            return ['auto', 'high', 'max'];
         case 'z.ai':
         case 'z.ai-api':
         case 'z.ai-cn':
         case 'z.ai-cn-api':
-            return ['auto', 'high', 'max'];
+            // GLM-5.3 distinguishes a Low tier; GLM-5.2 grades only high|max.
+            return idMatches(canonicalModelId(model), 'glm-5-3')
+                ? ['auto', 'low', 'high', 'max']
+                : ['auto', 'high', 'max'];
         case 'kimi':
         case 'kimi-api':
         case 'kimi-cn':

package/dist/renderer/App.js

@@ -2636,8 +2636,14 @@ export class App {
                 `runtime ${elapsed}`,
                 `tokens ${formatTokenCount(totalTokens)}`,
             ];
-            if (typeof stats.estimatedCost === 'number' && stats.estimatedCost > 0) {
-                leftParts.push(`cost $${stats.estimatedCost < 0.01 ? stats.estimatedCost.toFixed(4) : stats.estimatedCost.toFixed(2)}`);
+            // Only pay-per-use tokens carry a real price; flat-fee providers get the
+            // short "in plan" wording so the segment can't crowd the right-edge hint.
+            const billable = typeof stats.billableCost === 'number' ? stats.billableCost : (stats.estimatedCost ?? 0);
+            if (billable > 0) {
+                leftParts.push(`cost $${billable < 0.01 ? billable.toFixed(4) : billable.toFixed(2)}${stats.hasFlatFeeUsage ? ' + in plan' : ''}`);
+            }
+            else if (stats.hasFlatFeeUsage) {
+                leftParts.push('cost in plan');
             }
             // Thinking-effort tier, same chip the compact fallback shows beside the
             // model. Only present when set + supported — see getStatus.

package/dist/renderer/commands/helpers.d.ts

@@ -77,6 +77,8 @@ export interface StatsTotals {
     totalTokens: number;
     totalPromptTokens: number;
     totalCompletionTokens: number;
+    /** Raw sum across every entry. The report's total is derived from the
+     *  breakdown instead, so flat-fee rows don't contribute dollars. */
     estimatedCost: number;
 }
 export interface StatsCache {

package/dist/renderer/commands/helpers.js

@@ -7,6 +7,7 @@
  * alongside `ctx.app.*` calls. Pulling them here gives them direct unit
  * coverage.
  */
+import { isFlatFeeProvider } from '../../config/providers.js';
 /** Snippet window: chars of context before / after the match. */
 export const SEARCH_SNIPPET_BEFORE = 30;
 export const SEARCH_SNIPPET_AFTER = 50;
@@ -121,6 +122,10 @@ export function formatMemoryList(notes) {
 export function formatModelCost(provider, estimatedCost) {
     if (provider === 'ollama')
         return 'free';
+    // Flat-fee providers meter real tokens but charge nothing per token — the
+    // dollar figure our pricing table computes for them is invented.
+    if (isFlatFeeProvider(provider))
+        return 'included in plan';
     return estimatedCost > 0 ? `~$${estimatedCost.toFixed(4)}` : '(no pricing data)';
 }
 /**
@@ -143,11 +148,20 @@ export function formatStatsReport(args) {
                 lines.push(`- **${b.model}** (${b.provider}): ${fmt(b.promptTokens)} in / ${fmt(b.completionTokens)} out — ${costStr}`);
             }
             lines.push('');
+            // The total prices only pay-per-use rows; flat-fee rows are called out
+            // rather than folded in (or quietly dropped) — see formatModelCost.
+            const planRows = breakdown.filter(b => isFlatFeeProvider(b.provider));
+            const billable = breakdown
+                .filter(b => !isFlatFeeProvider(b.provider))
+                .reduce((s, b) => s + b.estimatedCost, 0);
             if (currentProvider === 'ollama') {
                 lines.push(`**Total: free · ${fmt(totals.totalTokens)} tokens**`);
             }
-            else if (totals.estimatedCost > 0) {
-                lines.push(`**Total: ~$${totals.estimatedCost.toFixed(4)}**`);
+            else if (planRows.length === breakdown.length) {
+                lines.push(`**Total: included in plan · ${fmt(totals.totalTokens)} tokens**`);
+            }
+            else if (billable > 0) {
+                lines.push(`**Total: ~$${billable.toFixed(4)}${planRows.length > 0 ? ' + usage included in plan' : ''}**`);
             }
         }
         if (cache.cacheReadTokens > 0 || cache.cacheCreationTokens > 0) {

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

@@ -21,6 +21,12 @@ export interface StatusInfo {
         completionTokens: number;
         requestCount: number;
         estimatedCost?: number;
+        /** `estimatedCost` minus flat-fee entries — the only spend we may show in
+         *  dollars (see providers.flatFee). */
+        billableCost?: number;
+        /** At least one entry came from a flat-fee provider, so the footer says
+         *  "in plan" instead of pricing those tokens. */
+        hasFlatFeeUsage?: boolean;
     };
 }
 /**

package/dist/renderer/main.js

@@ -111,6 +111,8 @@ function getStatus() {
             completionTokens: stats.totalCompletionTokens,
             requestCount: stats.requestCount,
             estimatedCost: stats.estimatedCost,
+            billableCost: stats.billableCost,
+            hasFlatFeeUsage: stats.hasFlatFeeUsage,
         },
     };
 }

package/dist/utils/tokenTracker.d.ts

@@ -19,6 +19,12 @@ export interface SessionTokenStats {
     totalTokens: number;
     requestCount: number;
     estimatedCost: number;
+    /** `estimatedCost` minus every flat-fee entry — the only figure we may show
+     *  as a dollar total, since flat-fee tokens carry no per-token charge. */
+    billableCost: number;
+    /** True when at least one entry came from a flat-fee provider, so callers can
+     *  say "included in plan" instead of silently dropping that usage. */
+    hasFlatFeeUsage: boolean;
     /** Anthropic prompt caching: total tokens written to cache this session. */
     totalCacheCreationTokens: number;
     /** Anthropic prompt caching: total tokens read from cache this session. */
@@ -105,8 +111,15 @@ export declare function getCostBreakdown(startIndex?: number): ProviderCostBreak
 export interface CacheStats {
     cacheCreationTokens: number;
     cacheReadTokens: number;
-    /** Sum of estimatedSavings across all Anthropic-priced records. */
+    /** Sum of estimatedSavings across pay-per-use records only. */
     estimatedSavingsUsd: number;
+    /** True when some cached tokens came from a flat-fee plan, whose "savings"
+     *  are not a dollar amount at all. Lets the report say so instead of quoting
+     *  a figure that silently covers only part of the session. */
+    hasFlatFeeCacheUsage: boolean;
+    /** True when EVERY cached token came from a flat-fee plan — there is no
+     *  metered spend to have saved against. */
+    isEntirelyFlatFeeCache: boolean;
 }
 export declare function getCacheStats(): CacheStats;
 /**

package/dist/utils/tokenTracker.js

@@ -2,12 +2,14 @@
  * Token and cost tracking for API usage
  */
 import { AsyncLocalStorage } from 'node:async_hooks';
+import { isFlatFeeProvider } from '../config/providers.js';
 import { formatResourceImpactReport } from './resourceImpact.js';
 // Context window sizes per model (in tokens). Primarily mirrors providers.ts;
 // retired aliases remain only where restored historical sessions still need a
 // meaningful context/cost display.
 const MODEL_CONTEXT_WINDOWS = {
     // Z.AI / ZhipuAI
+    'glm-5.3': 1_000_000,
     'glm-5.2': 1_000_000,
     'glm-5.1': 200_000,
     'glm-5-turbo': 202_752,
@@ -29,6 +31,7 @@ const MODEL_CONTEXT_WINDOWS = {
     'deepseek-v4-flash': 1_000_000,
     // Google
     'gemini-3.1-pro-preview': 1_048_576,
+    'gemini-3.7-flash': 1_048_576,
     'gemini-3.6-flash': 1_048_576,
     'gemini-3.5-flash': 1_048_576,
     'gemini-3.5-flash-lite': 1_048_576,
@@ -45,6 +48,7 @@ const MODEL_CONTEXT_WINDOWS = {
     'k3': 1_000_000,
     'k3-256k': 262_144,
     // Grok (xAI)
+    'grok-4.6': 500_000,
     'grok-4.5': 500_000,
     'grok-build-0.1': 256_000,
     'grok-4.3': 1_000_000,
@@ -72,6 +76,9 @@ export function getModelContextWindow(model) {
 const MODEL_PRICING = {
     // Z.AI / ZhipuAI
     // Coding Plan is flat-fee; these official rates apply to pay-per-use.
+    // `glm-5.3` is GLM Coding Plan only — Z.AI publishes no per-token rate for it
+    // (the standalone model API is still "coming soon"), so it stays unpriced
+    // rather than borrowing GLM-5.2's.
     'glm-5.2': { inputPer1M: 1.40, outputPer1M: 4.40 },
     'glm-5.1': { inputPer1M: 1.40, outputPer1M: 4.40 },
     'glm-5-turbo': { inputPer1M: 1.20, outputPer1M: 4.00 },
@@ -89,11 +96,20 @@ const MODEL_PRICING = {
     '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 moved to peak / off-peak billing on 2026-08-16, with off-peak at
+    // half these rates. This table holds one rate per model and has no notion of
+    // wall-clock time, so it keeps the PEAK figures: an over-estimate is the
+    // honest direction for a cost estimate, and rule 5 of the catalogue policy
+    // allows a clearly-labelled conservative approximation but never an invented
+    // number. Cache-miss input; cache hits are ~1/50th and not modelled here.
     'deepseek-v4-pro': { inputPer1M: 0.435, outputPer1M: 0.87 },
     'deepseek-v4-flash': { inputPer1M: 0.14, outputPer1M: 0.28 },
     // Google
+    // Gemini 3.6/3.7 Flash carry PROMOTIONAL rates that run through 2026-12-31 and
+    // step up to 1.50/7.50 on 2027-01-01 — revisit both rows on that date.
     'gemini-3.1-pro-preview': { inputPer1M: 2.00, outputPer1M: 12.00 },
-    'gemini-3.6-flash': { inputPer1M: 1.50, outputPer1M: 7.50 },
+    'gemini-3.7-flash': { inputPer1M: 0.75, outputPer1M: 3.75 },
+    'gemini-3.6-flash': { inputPer1M: 0.75, outputPer1M: 3.75 },
     'gemini-3.5-flash': { inputPer1M: 1.50, outputPer1M: 9.00 },
     'gemini-3.5-flash-lite': { inputPer1M: 0.30, outputPer1M: 2.50 },
     'gemini-3-flash-preview': { inputPer1M: 0.50, outputPer1M: 3.00 },
@@ -110,7 +126,9 @@ const MODEL_PRICING = {
     'kimi-for-coding-highspeed': { inputPer1M: 0.95, outputPer1M: 4.00 },
     'k3': { inputPer1M: 3.00, outputPer1M: 15.00 },
     'k3-256k': { inputPer1M: 3.00, outputPer1M: 15.00 },
-    // Grok (xAI)
+    // Grok (xAI) — base-tier rates. xAI doubles Grok 4.5/4.6 at prompts ≥200K;
+    // this table stores one flat rate per model, so the base tier is what we show.
+    'grok-4.6': { inputPer1M: 2.00, outputPer1M: 6.00 },
     'grok-4.5': { inputPer1M: 2.00, outputPer1M: 6.00 },
     'grok-build-0.1': { inputPer1M: 1.00, outputPer1M: 2.00 },
     'grok-4.3': { inputPer1M: 1.25, outputPer1M: 2.50 },
@@ -262,9 +280,20 @@ export function getCacheStats() {
     let cacheCreate = 0;
     let cacheRead = 0;
     let savings = 0;
+    let flatFeeCached = 0;
+    let meteredCached = 0;
     for (const record of currentRecords()) {
+        const cached = (record.cacheCreationTokens ?? 0) + (record.cacheReadTokens ?? 0);
         cacheCreate += record.cacheCreationTokens ?? 0;
         cacheRead += record.cacheReadTokens ?? 0;
+        // A plan bills a flat fee, so caching saves latency but not money — pricing
+        // its cached tokens would invent a dollar figure the same way the per-model
+        // cost lines used to. Count the tokens (measured), skip the arithmetic.
+        if (isFlatFeeProvider(record.provider)) {
+            flatFeeCached += cached;
+            continue;
+        }
+        meteredCached += cached;
         // Savings = what cache-read tokens would have cost at full input rate,
         // minus what they actually cost at 0.1×. (Cache creation is a slight
         // *penalty* of 0.25× — netted in for honest reporting.)
@@ -275,7 +304,13 @@ export function getCacheStats() {
             savings += cReadSaved - cCreateCost;
         }
     }
-    return { cacheCreationTokens: cacheCreate, cacheReadTokens: cacheRead, estimatedSavingsUsd: Math.max(0, savings) };
+    return {
+        cacheCreationTokens: cacheCreate,
+        cacheReadTokens: cacheRead,
+        estimatedSavingsUsd: Math.max(0, savings),
+        hasFlatFeeCacheUsage: flatFeeCached > 0,
+        isEntirelyFlatFeeCache: flatFeeCached > 0 && meteredCached === 0,
+    };
 }
 /**
  * Get session stats
@@ -293,13 +328,20 @@ export function getSessionStats() {
         totalCacheCreationTokens += record.cacheCreationTokens ?? 0;
         totalCacheReadTokens += record.cacheReadTokens ?? 0;
     }
-    const estimatedCost = getCostBreakdown().reduce((s, b) => s + b.estimatedCost, 0);
+    const breakdown = getCostBreakdown();
+    const estimatedCost = breakdown.reduce((s, b) => s + b.estimatedCost, 0);
+    const billableCost = breakdown
+        .filter(b => !isFlatFeeProvider(b.provider))
+        .reduce((s, b) => s + b.estimatedCost, 0);
+    const hasFlatFeeUsage = breakdown.some(b => isFlatFeeProvider(b.provider));
     return {
         totalPromptTokens,
         totalCompletionTokens,
         totalTokens,
         requestCount: currentRecords().length,
         estimatedCost,
+        billableCost,
+        hasFlatFeeUsage,
         totalCacheCreationTokens,
         totalCacheReadTokens,
     };
@@ -350,36 +392,54 @@ export function formatCostReport() {
         return '_No API requests in this session yet._';
     }
     const breakdown = getCostBreakdown();
+    // Flat-fee providers (subscriptions / free tiers) bill nothing per token, so
+    // their notional cost is never shown and never folded into the total. A
+    // session can mix them with pay-per-use models, so decide per entry.
+    const planEntries = breakdown.filter(b => isFlatFeeProvider(b.provider));
+    const costLine = planEntries.length === breakdown.length
+        ? '**Estimated cost:** included in plan'
+        : `**Estimated cost:** $${stats.billableCost.toFixed(4)}${planEntries.length > 0 ? ' + usage included in plan' : ''}`;
     const lines = [
         '## Session Cost',
         '',
         `**Requests:** ${stats.requestCount}  ·  **Input:** ${formatTokenCount(stats.totalPromptTokens)}  ·  **Output:** ${formatTokenCount(stats.totalCompletionTokens)}  ·  **Total:** ${formatTokenCount(stats.totalTokens)}`,
-        `**Estimated cost:** $${stats.estimatedCost.toFixed(4)}`,
+        costLine,
         '',
     ];
-    if (breakdown.length > 1 || (breakdown.length === 1 && breakdown[0].estimatedCost > 0)) {
+    if (breakdown.length > 1 || (breakdown.length === 1 && (breakdown[0].estimatedCost > 0 || planEntries.length > 0))) {
         lines.push('| Provider / Model | Input | Output | Cost |');
         lines.push('|---|---:|---:|---:|');
         for (const b of breakdown) {
-            lines.push(`| \`${b.provider}\` / \`${b.model}\` | ${formatTokenCount(b.promptTokens)} | ${formatTokenCount(b.completionTokens)} | $${b.estimatedCost.toFixed(4)} |`);
+            const cost = isFlatFeeProvider(b.provider) ? 'included in plan' : `$${b.estimatedCost.toFixed(4)}`;
+            lines.push(`| \`${b.provider}\` / \`${b.model}\` | ${formatTokenCount(b.promptTokens)} | ${formatTokenCount(b.completionTokens)} | ${cost} |`);
         }
     }
     // Prompt caching summary — only shown if at least one cached call landed.
     const cache = getCacheStats();
     if (cache.cacheReadTokens > 0 || cache.cacheCreationTokens > 0) {
         lines.push('', '### Prompt caching');
-        lines.push(`**Cache reads:** ${formatTokenCount(cache.cacheReadTokens)} tokens (billed at 0.1× input rate)`);
+        // The billing multipliers only describe a metered account. On a plan
+        // nothing is billed per token, so quoting a rate there would be as invented
+        // as the per-model prices this report already refuses to show.
+        const readNote = cache.isEntirelyFlatFeeCache ? '' : ' (billed at 0.1× input rate)';
+        const writeNote = cache.isEntirelyFlatFeeCache ? '' : ' (billed at 1.25× input rate)';
+        lines.push(`**Cache reads:** ${formatTokenCount(cache.cacheReadTokens)} tokens${readNote}`);
         if (cache.cacheCreationTokens > 0) {
-            lines.push(`**Cache writes:** ${formatTokenCount(cache.cacheCreationTokens)} tokens (billed at 1.25× input rate)`);
+            lines.push(`**Cache writes:** ${formatTokenCount(cache.cacheCreationTokens)} tokens${writeNote}`);
+        }
+        if (cache.isEntirelyFlatFeeCache) {
+            lines.push('**Savings:** caching saves latency, not money — this session is on a plan');
         }
-        if (cache.estimatedSavingsUsd > 0) {
-            lines.push(`**Estimated savings vs no caching:** $${cache.estimatedSavingsUsd.toFixed(4)}`);
+        else if (cache.estimatedSavingsUsd > 0) {
+            // Name the partial coverage rather than letting one figure look total.
+            const scope = cache.hasFlatFeeCacheUsage ? ' (pay-per-use models only)' : '';
+            lines.push(`**Estimated savings vs no caching:** $${cache.estimatedSavingsUsd.toFixed(4)}${scope}`);
         }
     }
     lines.push('', ...formatResourceImpactReport(stats.totalTokens));
     // Models with no pricing entry don't contribute to cost — flag so users
     // aren't surprised the total looks low.
-    const untracked = breakdown.filter(b => b.estimatedCost === 0 && (b.promptTokens + b.completionTokens) > 0);
+    const untracked = breakdown.filter(b => b.estimatedCost === 0 && (b.promptTokens + b.completionTokens) > 0 && !isFlatFeeProvider(b.provider));
     if (untracked.length > 0) {
         lines.push('', `_Note: ${untracked.length} model${untracked.length === 1 ? '' : 's'} (${untracked.map(u => `\`${u.model}\``).join(', ')}) have no pricing entry — token counts are tracked but not priced._`);
     }

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "2.17.0";
+export declare const VERSION = "2.18.1";

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.17.0';
+export const VERSION = '2.18.1';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeep",
-  "version": "2.17.0",
+  "version": "2.18.1",
   "description": "AI-powered coding assistant built for the terminal. Multiple LLM providers, project-aware context, and a seamless development workflow.",
   "type": "module",
   "main": "dist/index.js",
@@ -16,6 +16,7 @@
     "test:watch": "vitest",
     "test:coverage": "vitest run --coverage",
     "version": "node scripts/gen-version.js && git add src/version.ts",
+    "export:catalogue": "node --import tsx scripts/export-catalogue.ts",
     "release": "node scripts/release.js"
   },
   "repository": {