codeep 2.11.2 → 2.13.0

package/dist/api/index.js

@@ -2,7 +2,7 @@ import * as http from 'node:http';
 import * as https from 'node:https';
 import { config, getApiKey, resolveBaseUrl } from '../config/index.js';
 import { withRetry, isNetworkError } from '../utils/retry.js';
-import { getProvider, getProviderBaseUrl, getProviderAuthHeader, usesMaxCompletionTokens, requiresDefaultTemperature, modelRejectsSamplingParams } from '../config/providers.js';
+import { getProvider, getProviderBaseUrl, getProviderAuthHeader, usesMaxCompletionTokens, requiresDefaultTemperature, modelRejectsSamplingParams, reasoningParamsFor } from '../config/providers.js';
 import { logApiRequest, logApiResponse } from '../utils/logger.js';
 import { loadProjectIntelligence, generateContextFromIntelligence } from '../utils/projectIntelligence.js';
 import { loadProjectRules } from '../utils/agent.js';
@@ -390,6 +390,7 @@ async function chatOpenAI(message, history, model, apiKey, onChunk, abortSignal)
         ...(stream ? { stream_options: { include_usage: true } } : {}),
         ...(omitTemperature ? {} : { temperature }),
         ...(useCompletionTokens ? { max_completion_tokens: maxTokens } : { max_tokens: maxTokens }),
+        ...reasoningParamsFor(providerId, model, config.get('reasoningEffort')),
         ...(providerId === 'openrouter' ? { usage: { include: true } } : {}),
         ...(openRouterProvider ? { provider: openRouterProvider } : {}),
     });
@@ -658,6 +659,7 @@ async function chatAnthropic(message, history, model, apiKey, onChunk, abortSign
                 // Fable 5 / Opus 4.7+ reject temperature with a 400 — omit it there
                 // (omission means API default on every Claude model).
                 ...(modelRejectsSamplingParams(model) ? {} : { temperature }),
+                ...reasoningParamsFor(providerId, model, config.get('reasoningEffort')),
                 stream,
                 ...cachedSystem,
             }),

package/dist/config/index.d.ts

@@ -52,6 +52,11 @@ interface ConfigSchema {
     migrationVersion: number;
     temperature: number;
     maxTokens: number;
+    /** Thinking / reasoning-effort tier sent with each request. 'auto' (default)
+     *  omits the param so each model uses its own default; low/medium/high/max are
+     *  clamped per provider+model by reasoningParamsFor() (config/providers.ts).
+     *  Only applied for models that expose a graded knob — set via `/thinking`. */
+    reasoningEffort: 'auto' | 'low' | 'medium' | 'high' | 'max';
     apiTimeout: number;
     rateLimitApi: number;
     rateLimitCommands: number;

package/dist/config/index.js

@@ -180,6 +180,7 @@ function createConfig() {
         currentSessionId: '',
         temperature: 0.7,
         maxTokens: 32768,
+        reasoningEffort: 'auto',
         apiTimeout: 60000,
         rateLimitApi: 10000,
         rateLimitCommands: 10000,

package/dist/config/providers.d.ts

@@ -26,6 +26,10 @@ export interface ProviderConfig {
     maxOutputTokens?: number;
     useMaxCompletionTokens?: boolean;
     requiresDefaultTemperature?: boolean;
+    /** Provider's OpenAI-compatible endpoint rejects `tools` together with
+     *  `stream: true` (Alibaba/Qwen DashScope). When true, agent turns that send
+     *  tools are issued non-streamed (we buffer the full response). */
+    noStreamWithTools?: boolean;
     envKey?: string;
     subscribeUrl?: string;
     noApiKey?: boolean;
@@ -68,9 +72,69 @@ export declare function usesMaxCompletionTokens(providerId: string): boolean;
  * (e.g. OpenAI GPT-5+ only accepts the default of 1).
  */
 export declare function requiresDefaultTemperature(providerId: string): boolean;
+/**
+ * Returns true if the provider's OpenAI-compatible endpoint rejects `tools`
+ * together with `stream: true` (Alibaba/Qwen) — callers must issue tool-bearing
+ * agent turns non-streamed.
+ */
+export declare function providerNoStreamWithTools(providerId: string): boolean;
 export declare function modelRejectsSamplingParams(model: string): boolean;
 /**
  * Returns the effective max output tokens for a provider, capped by the provider's limit.
  * Falls back to the requested value if no provider limit is set.
  */
 export declare function getEffectiveMaxTokens(providerId: string, requested: number): number;
+/**
+ * Unified, user-facing thinking-effort tiers (the `/thinking` setting).
+ *
+ *   'auto'  — omit the param entirely → each provider's own default.
+ *   low / medium / high / max — four explicit depth tiers.
+ *
+ * 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").
+ * 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.
+ */
+export type ReasoningTier = 'auto' | 'low' | 'medium' | 'high' | 'max';
+export declare const REASONING_TIERS: ReasoningTier[];
+/**
+ * Canonicalize a model id for capability matching: lowercase, drop any
+ * `vendor/` namespace (OpenRouter sends `anthropic/claude-opus-4.8`), and
+ * normalize `.` version separators to `-` (`glm-5.2` → `glm-5-2`,
+ * `claude-opus-4.8` → `claude-opus-4-8`). Mirrors macOS `ModelTuning.canonicalModelID`.
+ */
+export declare function canonicalModelId(model: string): string;
+/**
+ * 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.
+ * Keep in lockstep with macOS `ModelTuning.reasoningEffortSupported`.
+ */
+export declare function modelSupportsReasoningEffort(providerId: string, model: string): boolean;
+/**
+ * Build the request-body fields that carry the chosen effort tier for the
+ * active provider+model+protocol. Returns `{}` for 'auto', unsupported
+ * 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>;
+/**
+ * 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.
+ *
+ * Kept in lockstep with `reasoningParamsFor` (the providers-test asserts every
+ * listed tier yields a DISTINCT param, so this can't silently drift). Mirrors
+ * macOS `ModelTuning.availableReasoningTiers`.
+ */
+export declare function availableReasoningTiers(providerId: string, model: string): ReasoningTier[];
+/**
+ * Map a (possibly out-of-range) tier to the tier this model actually distinguishes,
+ * for display — the chip + the checked menu row. The effort setting is global, so
+ * a tier picked on Opus ('low') may not exist on GLM-5.2; we show the level GLM
+ * will really run (its 'low' clamps to 'high'). Picks the available tier whose
+ * effective param equals the requested one. 'auto' (or unsupported) → 'auto'.
+ */
+export declare function resolveReasoningTier(providerId: string, model: string, tier: ReasoningTier): ReasoningTier;

package/dist/config/providers.js

@@ -203,6 +203,196 @@ export const PROVIDERS = {
         groupLabel: 'DeepSeek',
         hint: 'Pay-per-use via DeepSeek API key (platform.deepseek.com).',
     },
+    // ── Kimi (Moonshot AI) ────────────────────────────────────────────
+    // Subscription (Kimi Code) mirrors the Z.AI GLM-Coding-Plan shape: a
+    // dedicated coding base URL + a separate key, model id ALWAYS
+    // `kimi-for-coding` (a backend alias). OpenAI-compatible is the
+    // battle-tested path so we don't expose the Anthropic surface here.
+    'kimi': {
+        name: 'Kimi (Moonshot) — Coding Plan',
+        description: 'Kimi Code subscription',
+        protocols: {
+            openai: { baseUrl: 'https://api.kimi.com/coding/v1', authHeader: 'Bearer', supportsNativeTools: true },
+        },
+        models: [
+            { id: 'kimi-for-coding', name: 'Kimi Code', description: 'Subscription alias — auto-maps to the latest Kimi coding model (K2.7 Code)' },
+        ],
+        defaultModel: 'kimi-for-coding',
+        defaultProtocol: 'openai',
+        maxOutputTokens: 32_768,
+        envKey: 'KIMI_CODE_API_KEY',
+        subscribeUrl: 'https://www.kimi.com/code',
+        groupLabel: 'Kimi — Subscription (Kimi Code)',
+        hint: 'Uses your Kimi Code subscription — no per-token charges. Key from kimi.com/code/console.',
+    },
+    'kimi-api': {
+        name: 'Kimi (Moonshot) API (pay-per-use)',
+        description: 'Moonshot AI Kimi models via API key',
+        protocols: {
+            openai: { baseUrl: 'https://api.moonshot.ai/v1', authHeader: 'Bearer', supportsNativeTools: true },
+        },
+        models: [
+            { id: 'kimi-k2.7-code', name: 'Kimi K2.7 Code', description: 'Flagship agentic coding model (256K context)' },
+            { id: 'kimi-k2.7-code-highspeed', name: 'Kimi K2.7 Code (High-Speed)', description: 'Throughput-tuned K2.7 Code for latency-sensitive loops' },
+            { id: 'kimi-k2.6', name: 'Kimi K2.6', description: 'Previous-gen multimodal reasoning model' },
+            { id: 'kimi-k2.5', name: 'Kimi K2.5', description: 'Older general-purpose model (cheaper)' },
+        ],
+        defaultModel: 'kimi-k2.7-code',
+        defaultProtocol: 'openai',
+        maxOutputTokens: 32_768,
+        envKey: 'MOONSHOT_API_KEY',
+        subscribeUrl: 'https://platform.kimi.ai/console/api-keys',
+        groupLabel: 'Kimi — API (pay-per-use)',
+        hint: 'Pay-per-use via Moonshot API key (platform.kimi.ai).',
+    },
+    'kimi-cn': {
+        name: 'Kimi China (Moonshot)',
+        description: 'Moonshot AI Kimi models (China)',
+        protocols: {
+            openai: { baseUrl: 'https://api.moonshot.cn/v1', authHeader: 'Bearer', supportsNativeTools: true },
+        },
+        models: [
+            { id: 'kimi-k2.7-code', name: 'Kimi K2.7 Code', description: 'Flagship agentic coding model (256K context)' },
+            { id: 'kimi-k2.7-code-highspeed', name: 'Kimi K2.7 Code (High-Speed)', description: 'Throughput-tuned K2.7 Code' },
+            { id: 'kimi-k2.6', name: 'Kimi K2.6', description: 'Previous-gen multimodal reasoning model' },
+            { id: 'kimi-k2.5', name: 'Kimi K2.5', description: 'Older general-purpose model' },
+        ],
+        defaultModel: 'kimi-k2.7-code',
+        defaultProtocol: 'openai',
+        maxOutputTokens: 32_768,
+        envKey: 'MOONSHOT_CN_API_KEY',
+        subscribeUrl: 'https://platform.moonshot.cn/console/api-keys',
+        groupLabel: 'Kimi China — API (pay-per-use)',
+        hint: 'Pay-per-use via Moonshot China API key (platform.moonshot.cn).',
+    },
+    // ── Grok (xAI) ────────────────────────────────────────────────────
+    // Pay-per-use today (console.x.ai key). The SuperGrok / X Premium+
+    // subscription is OAuth-based — added separately. Reasoning models
+    // require max_completion_tokens (like GPT-5), so useMaxCompletionTokens.
+    'grok': {
+        name: 'Grok (xAI)',
+        description: 'xAI Grok models',
+        protocols: {
+            openai: { baseUrl: 'https://api.x.ai/v1', authHeader: 'Bearer', supportsNativeTools: true },
+        },
+        models: [
+            { 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: 'Flagship — highest quality, 1M context' },
+            { id: 'grok-code-fast-1', name: 'Grok Code Fast 1', description: 'Low-cost speed-first coder (alias of Build 0.1)' },
+            { id: 'grok-4-fast-reasoning', name: 'Grok 4 Fast (reasoning)', description: 'Cheap reasoning model, very large context' },
+        ],
+        defaultModel: 'grok-build-0.1',
+        defaultProtocol: 'openai',
+        useMaxCompletionTokens: true, // reasoning models reject max_tokens
+        envKey: 'XAI_API_KEY',
+        subscribeUrl: 'https://console.x.ai',
+        groupLabel: 'xAI Grok',
+        hint: 'Pay-per-use via xAI API key (console.x.ai).',
+    },
+    // ── Qwen (Alibaba Model Studio / DashScope) ───────────────────────
+    // Coding Plan subscription = dedicated base URL + sk-sp- key (mirrors
+    // Z.AI). Qwen's OpenAI-compatible surface CANNOT combine tools with
+    // streaming, so all Qwen entries set noStreamWithTools.
+    'qwen': {
+        name: 'Qwen (Alibaba) — Coding Plan',
+        description: 'Qwen Coding Plan subscription',
+        protocols: {
+            openai: { baseUrl: 'https://coding-intl.dashscope.aliyuncs.com/v1', authHeader: 'Bearer', supportsNativeTools: true },
+        },
+        models: [
+            { id: 'qwen3-coder-plus', name: 'Qwen3-Coder Plus', description: 'Flagship coding model — best quality' },
+            { id: 'qwen3-coder-next', name: 'Qwen3-Coder Next', description: 'Balanced quality/speed/cost' },
+            { id: 'qwen3-max', name: 'Qwen3-Max', description: 'Flagship general model (code + reasoning)' },
+        ],
+        defaultModel: 'qwen3-coder-plus',
+        defaultProtocol: 'openai',
+        maxOutputTokens: 65_536,
+        noStreamWithTools: true,
+        envKey: 'BAILIAN_CODING_PLAN_API_KEY',
+        subscribeUrl: 'https://www.alibabacloud.com/help/en/model-studio/qwen-code-coding-plan',
+        groupLabel: 'Qwen — Subscription (Coding Plan)',
+        hint: 'Uses your Qwen Coding Plan — no per-token charges. sk-sp-… key from Model Studio. Interactive coding use only.',
+    },
+    'qwen-api': {
+        name: 'Qwen (Alibaba) API (pay-per-use)',
+        description: 'Alibaba Model Studio Qwen models via API key',
+        protocols: {
+            openai: { baseUrl: 'https://dashscope-intl.aliyuncs.com/compatible-mode/v1', authHeader: 'Bearer', supportsNativeTools: true },
+        },
+        models: [
+            { id: 'qwen3-coder-plus', name: 'Qwen3-Coder Plus', description: 'Flagship coding model (256K, up to 1M)' },
+            { id: 'qwen3-coder-next', name: 'Qwen3-Coder Next', description: 'Balanced quality/speed/cost' },
+            { id: 'qwen3-coder-flash', name: 'Qwen3-Coder Flash', description: 'Fast/cheap coder' },
+            { id: 'qwen3-max', name: 'Qwen3-Max', description: 'Flagship general model' },
+        ],
+        defaultModel: 'qwen3-coder-plus',
+        defaultProtocol: 'openai',
+        maxOutputTokens: 65_536,
+        noStreamWithTools: true,
+        envKey: 'DASHSCOPE_API_KEY',
+        subscribeUrl: 'https://modelstudio.console.alibabacloud.com/',
+        groupLabel: 'Qwen — API (pay-per-use)',
+        hint: 'Pay-per-use via Alibaba Model Studio key (DASHSCOPE_API_KEY).',
+    },
+    'qwen-cn': {
+        name: 'Qwen China — Coding Plan',
+        description: 'Qwen Coding Plan subscription (China)',
+        protocols: {
+            openai: { baseUrl: 'https://coding.dashscope.aliyuncs.com/v1', authHeader: 'Bearer', supportsNativeTools: true },
+        },
+        models: [
+            { id: 'qwen3-coder-plus', name: 'Qwen3-Coder Plus', description: 'Flagship coding model — best quality' },
+            { id: 'qwen3-coder-next', name: 'Qwen3-Coder Next', description: 'Balanced quality/speed/cost' },
+            { id: 'qwen3-max', name: 'Qwen3-Max', description: 'Flagship general model' },
+        ],
+        defaultModel: 'qwen3-coder-plus',
+        defaultProtocol: 'openai',
+        maxOutputTokens: 65_536,
+        noStreamWithTools: true,
+        envKey: 'BAILIAN_CODING_PLAN_CN_API_KEY',
+        subscribeUrl: 'https://bailian.console.aliyun.com/',
+        groupLabel: 'Qwen China — Subscription (Coding Plan)',
+        hint: 'Uses your Qwen Coding Plan (China). sk-sp-… key from Bailian.',
+    },
+    'qwen-cn-api': {
+        name: 'Qwen China API (pay-per-use)',
+        description: 'Alibaba Model Studio Qwen models via API key (China)',
+        protocols: {
+            openai: { baseUrl: 'https://dashscope.aliyuncs.com/compatible-mode/v1', authHeader: 'Bearer', supportsNativeTools: true },
+        },
+        models: [
+            { id: 'qwen3-coder-plus', name: 'Qwen3-Coder Plus', description: 'Flagship coding model' },
+            { id: 'qwen3-coder-next', name: 'Qwen3-Coder Next', description: 'Balanced quality/speed/cost' },
+            { id: 'qwen3-coder-flash', name: 'Qwen3-Coder Flash', description: 'Fast/cheap coder' },
+            { id: 'qwen3-max', name: 'Qwen3-Max', description: 'Flagship general model' },
+        ],
+        defaultModel: 'qwen3-coder-plus',
+        defaultProtocol: 'openai',
+        maxOutputTokens: 65_536,
+        noStreamWithTools: true,
+        envKey: 'DASHSCOPE_CN_API_KEY',
+        subscribeUrl: 'https://bailian.console.aliyun.com/',
+        groupLabel: 'Qwen China — API (pay-per-use)',
+        hint: 'Pay-per-use via Alibaba Model Studio China key.',
+    },
+    'modelscope': {
+        name: 'ModelScope (free Qwen)',
+        description: 'Free Qwen3-Coder inference via ModelScope',
+        protocols: {
+            openai: { baseUrl: 'https://api-inference.modelscope.cn/v1', authHeader: 'Bearer', supportsNativeTools: true },
+        },
+        models: [
+            { id: 'Qwen/Qwen3-Coder-480B-A35B-Instruct', name: 'Qwen3-Coder 480B', description: 'Open MoE coder — free tier (~2000 req/day)' },
+        ],
+        defaultModel: 'Qwen/Qwen3-Coder-480B-A35B-Instruct',
+        defaultProtocol: 'openai',
+        maxOutputTokens: 65_536,
+        noStreamWithTools: true,
+        envKey: 'MODELSCOPE_API_KEY',
+        subscribeUrl: 'https://modelscope.cn/my/myaccesstoken',
+        groupLabel: 'ModelScope — Free (Qwen)',
+        hint: 'Free tier (~2000 req/day) via ModelScope token (modelscope.cn). Needs a bound Aliyun account.',
+    },
     'openai': {
         name: 'OpenAI',
         description: 'GPT and o-series models',
@@ -361,14 +551,24 @@ const DISPLAY_ORDER = [
     'openrouter', // 100+ models, one key — surfaced high on purpose for 2.0.0.
     'z.ai',
     'z.ai-api',
+    'kimi',
+    'kimi-api',
+    'qwen',
+    'qwen-api',
+    'grok',
     'deepseek',
     'google',
     'minimax',
     'minimax-api',
+    'modelscope',
     'ollama',
     'custom',
+    // Regional + parameter-variant entries trail.
     'z.ai-cn',
     'z.ai-cn-api',
+    'kimi-cn',
+    'qwen-cn',
+    'qwen-cn-api',
     'minimax-cn',
 ];
 export function getProviderList() {
@@ -441,14 +641,26 @@ export function usesMaxCompletionTokens(providerId) {
 export function requiresDefaultTemperature(providerId) {
     return PROVIDERS[providerId]?.requiresDefaultTemperature ?? false;
 }
+/**
+ * Returns true if the provider's OpenAI-compatible endpoint rejects `tools`
+ * together with `stream: true` (Alibaba/Qwen) — callers must issue tool-bearing
+ * agent turns non-streamed.
+ */
+export function providerNoStreamWithTools(providerId) {
+    return PROVIDERS[providerId]?.noStreamWithTools ?? false;
+}
 /**
  * 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.
+ * 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'];
+const SAMPLING_PARAMS_REJECTED = [
+    'claude-fable-5', 'claude-opus-4-8', 'claude-opus-4-7',
+    'kimi-k2.7-code', 'kimi-for-coding',
+];
 export function modelRejectsSamplingParams(model) {
     return SAMPLING_PARAMS_REJECTED.some(id => model === id || model.startsWith(`${id}-`));
 }
@@ -462,3 +674,162 @@ export function getEffectiveMaxTokens(providerId, requested) {
         return requested;
     return Math.min(requested, provider.maxOutputTokens);
 }
+export const REASONING_TIERS = ['auto', 'low', 'medium', 'high', 'max'];
+/**
+ * Canonicalize a model id for capability matching: lowercase, drop any
+ * `vendor/` namespace (OpenRouter sends `anthropic/claude-opus-4.8`), and
+ * normalize `.` version separators to `-` (`glm-5.2` → `glm-5-2`,
+ * `claude-opus-4.8` → `claude-opus-4-8`). Mirrors macOS `ModelTuning.canonicalModelID`.
+ */
+export function canonicalModelId(model) {
+    let id = model.toLowerCase();
+    const slash = id.lastIndexOf('/');
+    if (slash !== -1)
+        id = id.slice(slash + 1);
+    return id.replace(/\./g, '-');
+}
+/** True when `id` equals `prefix` or starts with `prefix-` (catches dated variants). */
+function idMatches(id, prefix) {
+    return id === prefix || id.startsWith(`${prefix}-`);
+}
+/**
+ * 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.
+ * Keep in lockstep with macOS `ModelTuning.reasoningEffortSupported`.
+ */
+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.
+            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);
+        case 'openai':
+            // GPT-5.x are reasoning models — reasoning_effort across the family (incl. mini).
+            return id.startsWith('gpt-5');
+        case 'google':
+            // Gemini 3.x thinking_level via the OpenAI-compat reasoning_effort mapping.
+            return id.startsWith('gemini-3');
+        case 'deepseek':
+            return id.startsWith('deepseek-v4');
+        case 'z.ai':
+        case 'z.ai-api':
+        case 'z.ai-cn':
+        case 'z.ai-cn-api':
+            // GLM-5.2 added graded High/Max effort. glm-5-turbo is a plain thinking
+            // toggle (no graded levels) so it stays out.
+            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.
+            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.
+        case 'openrouter':
+            // OpenRouter normalizes a unified `reasoning` field and silently ignores
+            // it for non-reasoning models, so the control is always safe to expose.
+            return true;
+        default:
+            // minimax (toggle only), ollama, custom — no graded depth knob.
+            return false;
+    }
+}
+/**
+ * Build the request-body fields that carry the chosen effort tier for the
+ * active provider+model+protocol. Returns `{}` for 'auto', unsupported
+ * models, or providers without a graded knob — so callers can spread it
+ * unconditionally. Keep in lockstep with macOS `ModelTuning.reasoningParams`.
+ */
+export function reasoningParamsFor(providerId, model, tier) {
+    // 'auto', or any unexpected value from an older/garbled config, → no param.
+    // (Guards against ever emitting e.g. `effort: undefined`, which could 400.)
+    if (tier === 'auto' || !REASONING_TIERS.includes(tier))
+        return {};
+    if (!modelSupportsReasoningEffort(providerId, model))
+        return {};
+    switch (providerId) {
+        case 'anthropic':
+            // low / medium / high / max — all valid on the capable Claude models.
+            return { output_config: { effort: tier } };
+        case 'openai':
+            // 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' };
+        case 'deepseek':
+        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.
+            return { reasoning_effort: tier === 'max' ? 'max' : 'high' };
+        case 'grok':
+            // none/low/medium/high — no "max"; map our Max → high (the ceiling).
+            return { reasoning_effort: tier === 'max' ? 'high' : tier };
+        case 'openrouter':
+            // Unified reasoning object; no "max" effort → cap at high.
+            return { reasoning: { effort: tier === 'max' ? 'high' : tier } };
+        default:
+            return {};
+    }
+}
+/**
+ * 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.
+ *
+ * Kept in lockstep with `reasoningParamsFor` (the providers-test asserts every
+ * listed tier yields a DISTINCT param, so this can't silently drift). Mirrors
+ * macOS `ModelTuning.availableReasoningTiers`.
+ */
+export function availableReasoningTiers(providerId, model) {
+    if (!modelSupportsReasoningEffort(providerId, model))
+        return [];
+    switch (providerId) {
+        case 'anthropic':
+        case 'openai':
+            return ['auto', 'low', 'medium', 'high', 'max'];
+        case 'google':
+            // OpenAI-compat layer accepts only low/high — "medium" 400s.
+            return ['auto', 'low', 'high'];
+        case 'deepseek':
+        case 'z.ai':
+        case 'z.ai-api':
+        case 'z.ai-cn':
+        case 'z.ai-cn-api':
+            return ['auto', 'high', 'max'];
+        case 'grok':
+            return ['auto', 'low', 'medium', 'high'];
+        case 'openrouter':
+            return ['auto', 'low', 'medium', 'high'];
+        default:
+            return [];
+    }
+}
+/**
+ * Map a (possibly out-of-range) tier to the tier this model actually distinguishes,
+ * for display — the chip + the checked menu row. The effort setting is global, so
+ * a tier picked on Opus ('low') may not exist on GLM-5.2; we show the level GLM
+ * will really run (its 'low' clamps to 'high'). Picks the available tier whose
+ * effective param equals the requested one. 'auto' (or unsupported) → 'auto'.
+ */
+export function resolveReasoningTier(providerId, model, tier) {
+    if (tier === 'auto')
+        return 'auto';
+    const avail = availableReasoningTiers(providerId, model);
+    if (avail.length === 0)
+        return 'auto';
+    if (avail.includes(tier))
+        return tier;
+    const target = JSON.stringify(reasoningParamsFor(providerId, model, tier));
+    for (const t of avail) {
+        if (t === 'auto')
+            continue;
+        if (JSON.stringify(reasoningParamsFor(providerId, model, t)) === target)
+            return t;
+    }
+    return 'auto';
+}

package/dist/renderer/App.js

@@ -66,7 +66,7 @@ const COMMAND_DESCRIPTIONS = {
     'drop': 'Remove file from context',
     'multiline': 'Toggle multi-line input',
     'test': 'Generate/run tests',
-    'docs': 'Add documentation',
+    'docs': 'Open web docs for a command (e.g. /docs personality)',
     'refactor': 'Improve code quality',
     'fix': 'Debug and fix issues',
     'explain': 'Explain code',
@@ -123,6 +123,8 @@ const COMMAND_DESCRIPTIONS = {
     'sync': 'Sync learning preferences and profiles to codeep.dev',
     'telemetry': 'Show or toggle automatic cloud telemetry (on/off)',
     'keysync': 'Show or toggle syncing API keys to codeep.dev (on/off)',
+    'thinking': 'Set the thinking/reasoning-effort tier (auto/low/medium/high/max) for models that support it',
+    'effort': 'Alias for /thinking — set the reasoning-effort tier',
     // 2.0 — surfaced for `/` autocomplete; documented in /help too.
     'compact': 'Summarize older messages to free up context',
     'commands': 'List custom slash commands in .codeep/commands/*.md',
@@ -2312,6 +2314,14 @@ export class App {
             this.screen.write(leftX - 1, y, '·', fg.gray);
             leftX += 1;
         }
+        // Thinking-effort tier, right beside the model (the CLI twin of the Mac
+        // app's effort chip). Only present when set + supported — see getStatus.
+        if (status.reasoningEffort) {
+            this.screen.write(leftX, y, fg.yellow + status.reasoningEffort + style.reset);
+            leftX += status.reasoningEffort.length + 2;
+            this.screen.write(leftX - 1, y, '·', fg.gray);
+            leftX += 1;
+        }
         this.screen.write(leftX, y, msgCount, fg.gray);
         leftX += msgCount.length;
         if (tokenStr) {

package/dist/renderer/commands.js

@@ -8,7 +8,7 @@
 import { config, getCurrentProvider, getModelsForCurrentProvider, PROTOCOLS, LANGUAGES, setProvider, setApiKey, clearApiKey, getApiKey, isTelemetryEnabled, telemetryForcedOffByEnv, isKeySyncEnabled, keySyncForcedOffByEnv, saveSession, startNewSession, loadSession, listSessionsWithInfo, deleteSession, renameSession, setProjectPermission, saveProfile, loadProfile, applyProfile, listProfiles, deleteProfile, initializeAsProject, isManuallyInitializedProject, } from '../config/index.js';
 import { getProjectContext } from '../utils/project.js';
 import { getCurrentVersion } from '../utils/update.js';
-import { getProviderList, getProvider } from '../config/providers.js';
+import { getProviderList, getProvider, modelSupportsReasoningEffort, reasoningParamsFor, availableReasoningTiers, resolveReasoningTier, REASONING_TIERS } from '../config/providers.js';
 import { setProjectContext } from '../api/index.js';
 import { runSkill, runCommandChain } from './agentExecution.js';
 import { loadProjectIntelligence, saveProjectIntelligence } from '../utils/projectIntelligence.js';
@@ -303,6 +303,57 @@ export async function handleCommand(command, args, ctx) {
             ctx.app.addMessage({ role: 'system', content: kLines.join('\n') });
             break;
         }
+        case 'effort':
+        case 'thinking': {
+            const providerId = config.get('provider');
+            const model = config.get('model');
+            const supported = modelSupportsReasoningEffort(providerId, model);
+            // Tiers THIS model actually distinguishes (e.g. GLM-5.2 → auto/high/max).
+            const available = availableReasoningTiers(providerId, model);
+            const sub = args[0]?.toLowerCase();
+            if (sub && REASONING_TIERS.includes(sub)) {
+                config.set('reasoningEffort', sub);
+                if (sub === 'auto') {
+                    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 4.8, GPT-5.x, Gemini 3, DeepSeek V4, GLM-5.2).`);
+                }
+                else {
+                    // Tell the user what THIS model will actually run (the tier may
+                    // collapse onto a level the model distinguishes, e.g. low→high on GLM).
+                    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))}.`);
+                }
+                break;
+            }
+            if (sub && sub !== 'status') {
+                const offer = available.length > 0 ? available : REASONING_TIERS;
+                ctx.app.notify(`Usage: /thinking ${offer.join(' · /thinking ')}`);
+                break;
+            }
+            const tier = (config.get('reasoningEffort') ?? 'auto');
+            const resolved = resolveReasoningTier(providerId, model, tier);
+            const tLines = ['## Thinking effort', ''];
+            tLines.push(`**Tier**       ${tier}${resolved !== tier && tier !== 'auto' ? ` → ${resolved} on this model` : ''}`);
+            tLines.push(`**Model**      ${model} (${providerId})`);
+            if (!supported) {
+                tLines.push('**Effective**  not sent — this model has no graded thinking control');
+            }
+            else if (tier === 'auto') {
+                tLines.push('**Effective**  model default (no param sent)');
+            }
+            else {
+                tLines.push(`**Effective**  ${JSON.stringify(reasoningParamsFor(providerId, model, tier))}`);
+            }
+            if (supported)
+                tLines.push(`**Available**  ${available.join(' · ')}`);
+            tLines.push('');
+            tLines.push('Sets how hard the model reasons. Each model offers only the levels it distinguishes (GLM-5.2 / DeepSeek → 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.');
+            ctx.app.addMessage({ role: 'system', content: tLines.join('\n') });
+            break;
+        }
         case 'grant': {
             setProjectPermission(ctx.projectPath, true, true);
             ctx.setHasWriteAccess(true);
@@ -341,10 +392,12 @@ export async function handleCommand(command, args, ctx) {
             runAgentTask(args.join(' '), true, ctx, () => null, () => { });
             break;
         }
+        case 'd':
         case 'docs': {
             // Open per-command web docs in the system browser. Lets the inline
             // /help stay terse (single-line entries) while users who want the
-            // long story get one keystroke away from a real page.
+            // long story get one keystroke away from a real page. `/d` is the
+            // short alias.
             const cmd = (args[0] ?? '').toLowerCase().replace(/^\//, '');
             const KNOWN = {
                 personality: 'https://codeep.dev/docs/agent#personalities',
@@ -1504,8 +1557,6 @@ Format: use headers per category, only include categories where you found issues
         case 'commit':
         case 't':
         case 'test':
-        case 'd':
-        case 'docs':
         case 'r':
         case 'refactor':
         case 'f':

package/dist/renderer/components/Settings.js

@@ -26,6 +26,19 @@ export const SETTINGS = [
         max: 32768,
         step: 256,
     },
+    {
+        key: 'reasoningEffort',
+        label: 'Thinking Effort',
+        getValue: () => config.get('reasoningEffort') ?? 'auto',
+        type: 'select',
+        options: [
+            { value: 'auto', label: 'Auto (model default)' },
+            { value: 'low', label: 'Low' },
+            { value: 'medium', label: 'Medium' },
+            { value: 'high', label: 'High' },
+            { value: 'max', label: 'Max' },
+        ],
+    },
     {
         key: 'apiTimeout',
         label: 'API Timeout (ms)',

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

@@ -7,6 +7,9 @@ export interface StatusInfo {
     provider: string;
     model: string;
     agentMode: string;
+    /** Thinking-effort tier to show beside the model (e.g. "max") — only set
+     *  when non-auto AND the active model supports a graded knob; undefined hides it. */
+    reasoningEffort?: string;
     projectPath: string;
     hasWriteAccess: boolean;
     sessionId: string;

package/dist/renderer/main.js

@@ -15,7 +15,7 @@ import { getZaiVisionConfig, getMinimaxMcpConfig, callZaiVisionApi, callMinimaxA
 import { config, loadApiKey, loadAllApiKeys, getCurrentProvider, autoSaveSession, startNewSession, getCurrentSessionId, loadSession, listSessionsWithInfo, deleteSession, hasReadPermission, hasWritePermission, setProjectPermission, initializeAsProject, isManuallyInitializedProject, setApiKey, setProvider, getGithubId, } from '../config/index.js';
 import { isProjectDirectory, getProjectContext, } from '../utils/project.js';
 import { getCurrentVersion, checkForUpdates, getUpdateInstructions } from '../utils/update.js';
-import { getProviderList, isNoApiKeyProvider } from '../config/providers.js';
+import { getProviderList, isNoApiKeyProvider, resolveReasoningTier } from '../config/providers.js';
 import { getSessionStats, getCostBreakdown } from '../utils/tokenTracker.js';
 import { isGitRepository } from '../utils/git.js';
 import { reportStats, syncSession, generateProjectId } from '../utils/codeepCloud.js';
@@ -73,11 +73,17 @@ function getStatus() {
     const providers = getProviderList();
     const providerInfo = providers.find(p => p.id === provider.id);
     const stats = getSessionStats();
+    // Show the thinking-effort tier beside the model. Resolve the (global) tier
+    // to what THIS model actually runs — e.g. a global 'low' shows as 'high' on
+    // GLM-5.2, which only grades high|max. 'auto'/unsupported → hidden.
+    const resolved = resolveReasoningTier(provider.id, config.get('model'), config.get('reasoningEffort'));
+    const reasoningEffort = resolved !== 'auto' ? resolved : undefined;
     return {
         version: getCurrentVersion(),
         provider: providerInfo?.name || 'Unknown',
         model: config.get('model'),
         agentMode: config.get('agentMode') || 'off',
+        reasoningEffort,
         projectPath,
         hasWriteAccess,
         sessionId,

package/dist/utils/agentChat.js

@@ -16,8 +16,9 @@ import { join } from 'path';
 import { createHash } from 'crypto';
 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 } from '../config/providers.js';
+import { getProviderAuthHeader, supportsNativeTools, getEffectiveMaxTokens, usesMaxCompletionTokens, requiresDefaultTemperature, modelRejectsSamplingParams, isNoApiKeyProvider, reasoningParamsFor, providerNoStreamWithTools } 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';
@@ -281,6 +282,16 @@ export function getAgentSystemPrompt(projectContext) {
 - Keep working until the task is actually finished. If you still have work to do, CALL A TOOL — don't just narrate. If you're done, reply with a short summary and no tool calls.
 - Don't ask permission for routine work; the user already launched the agent.
 
+## About Codeep
+Codeep is an open-source, terminal-native AI coding agent — also a native macOS app and a VS Code / Zed extension (over ACP). Beyond the file/command tools above, the user can extend you through Codeep features:
+- Skills — reusable workflow bundles (browse/add/run with \`/skills\`)
+- MCP — connect external tools & data, e.g. Postgres, GitHub, a browser, the iOS simulator (\`/mcp\`)
+- Sub-agents — delegate focused subtasks (\`/agents\`)
+- Personalities — change your working style (\`/personality\`)
+- A dashboard at codeep.dev for synced sessions, usage & cost
+When the user asks what you can do, or a task maps to one of these, point them at the right slash-command:
+${formatCommandIndex()}
+
 ## Codeep App Storage (your own metadata)
 This project uses Codeep. The following paths are Codeep's internal state — **read** them if you need context about prior sessions, but do not edit them manually during a task:
 - \`${root}/.codeep/intelligence.json\` — cached project analysis (structure, frameworks, CI/CD, conventions). Refresh via \`/scan\`.
@@ -356,10 +367,15 @@ additionalTools) {
     try {
         let endpoint;
         let body;
-        const useStreaming = Boolean(onChunk);
+        // Qwen/DashScope reject `tools` + `stream:true` together; this path always
+        // sends tools, so force a non-streamed request there (the non-streaming
+        // branch below still emits the content via onChunk). Other providers stream.
+        const useStreaming = Boolean(onChunk) && !providerNoStreamWithTools(providerId);
         // 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'));
         if (protocol === 'openai') {
             const maxTok = getEffectiveMaxTokens(providerId, Math.max(config.get('maxTokens'), 16384));
             const tokParam = usesMaxCompletionTokens(providerId) ? { max_completion_tokens: maxTok } : { max_tokens: maxTok };
@@ -410,7 +426,7 @@ additionalTools) {
             body = {
                 model, messages: [{ role: 'system', content: systemPrompt }, ...messages],
                 tools: getOpenAITools(additionalTools), tool_choice: 'auto', stream: useStreaming,
-                ...tempParam, ...tokParam,
+                ...tempParam, ...tokParam, ...reasoningParam,
                 ...(useStreaming && providerId === 'openai' ? { stream_options: { include_usage: true } } : {}),
                 ...openRouterExtras,
             };
@@ -436,7 +452,7 @@ additionalTools) {
                 system: [{ type: 'text', text: systemPrompt, cache_control: { type: 'ephemeral' } }],
                 messages,
                 tools: cachedTools, stream: useStreaming,
-                ...tempParam, max_tokens: getEffectiveMaxTokens(providerId, Math.max(config.get('maxTokens'), 16384)),
+                ...tempParam, ...reasoningParam, max_tokens: getEffectiveMaxTokens(providerId, Math.max(config.get('maxTokens'), 16384)),
             };
         }
         const response = await fetch(endpoint, {
@@ -554,13 +570,15 @@ 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') };
+        // Thinking-effort tier → provider-shaped param ({} for 'auto'/unsupported).
+        const reasoningParam = reasoningParamsFor(providerId, model, config.get('reasoningEffort'));
         if (protocol === 'openai') {
             const maxTok = getEffectiveMaxTokens(providerId, Math.max(config.get('maxTokens'), 16384));
             const tokParam = usesMaxCompletionTokens(providerId) ? { max_completion_tokens: maxTok } : { max_tokens: maxTok };
             endpoint = `${baseUrl}/chat/completions`;
             body = {
                 model, messages: [{ role: 'system', content: fallbackPrompt }, ...messages],
-                stream: Boolean(onChunk), ...tempParam, ...tokParam,
+                stream: Boolean(onChunk), ...tempParam, ...tokParam, ...reasoningParam,
             };
         }
         else {
@@ -577,7 +595,7 @@ export async function agentChatFallback(messages, systemPrompt, onChunk, abortSi
                     { role: 'assistant', content: 'Understood. I will use the tools as specified.' },
                     ...messages,
                 ],
-                stream: Boolean(onChunk), ...tempParam,
+                stream: Boolean(onChunk), ...tempParam, ...reasoningParam,
                 max_tokens: getEffectiveMaxTokens(providerId, Math.max(config.get('maxTokens'), 16384)),
             };
         }

package/dist/utils/commandIndex.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Curated, agent-facing index of the most useful Codeep slash-commands.
+ *
+ * Injected into the agent's system prompt (see `getAgentSystemPrompt`) so the
+ * model knows these exist and can point the user at the right one. Deliberately
+ * a CURATED subset — not the full ~60-command registry in
+ * `renderer/commands.ts` — to keep the prompt small; every entry here must be
+ * a real command. Single source for this list so it doesn't drift across the
+ * places that describe Codeep to the model.
+ */
+export declare const COMMAND_INDEX: {
+    cmd: string;
+    desc: string;
+}[];
+/** Render the index as Markdown bullets for the system prompt. */
+export declare function formatCommandIndex(): string;

package/dist/utils/commandIndex.js

@@ -0,0 +1,29 @@
+/**
+ * Curated, agent-facing index of the most useful Codeep slash-commands.
+ *
+ * Injected into the agent's system prompt (see `getAgentSystemPrompt`) so the
+ * model knows these exist and can point the user at the right one. Deliberately
+ * a CURATED subset — not the full ~60-command registry in
+ * `renderer/commands.ts` — to keep the prompt small; every entry here must be
+ * a real command. Single source for this list so it doesn't drift across the
+ * places that describe Codeep to the model.
+ */
+export const COMMAND_INDEX = [
+    { cmd: '/scan', desc: 'analyze the project (structure, frameworks, conventions) into .codeep/intelligence.json' },
+    { cmd: '/plan', desc: 'plan a task before executing it (plan mode)' },
+    { cmd: '/skills', desc: 'browse, add, or run reusable skill bundles' },
+    { cmd: '/mcp', desc: 'connect external tools & data via MCP servers (Postgres, GitHub, a browser, the iOS simulator…)' },
+    { cmd: '/agents', desc: 'manage sub-agents you can delegate focused subtasks to' },
+    { cmd: '/personality', desc: 'switch the agent persona / working style' },
+    { cmd: '/review', desc: 'code-review the current changes' },
+    { cmd: '/commit', desc: 'write a commit message from the current diff' },
+    { cmd: '/pr', desc: 'open a pull request' },
+    { cmd: '/checkpoint', desc: 'save a restore point (/rewind rolls back to it)' },
+    { cmd: '/memory', desc: 'add or list project memory notes the agent remembers' },
+    { cmd: '/cost', desc: 'show token usage and estimated cost for the session' },
+    { cmd: '/settings', desc: 'change models, providers, confirmation policy, and limits' },
+];
+/** Render the index as Markdown bullets for the system prompt. */
+export function formatCommandIndex() {
+    return COMMAND_INDEX.map(c => `- \`${c.cmd}\` — ${c.desc}`).join('\n');
+}

package/dist/utils/mcpMarketplace.d.ts

@@ -9,7 +9,9 @@
  *   - Each entry's `args` should be the **invocation-without-runtime-args**
  *     so `/mcp install` can prompt for the things that vary per user
  *     (paths, tokens, etc.) via `argHints`.
- *   - Prefer official `@modelcontextprotocol/*` packages over third-party.
+ *   - Prefer official `@modelcontextprotocol/*` packages; well-maintained
+ *     third-party servers are fine when they're the de-facto standard for
+ *     their niche (e.g. Playwright for browsers, the iOS-simulator servers).
  */
 import type { McpServer } from '../acp/protocol.js';
 export interface MarketplaceEntry {

package/dist/utils/mcpMarketplace.js

@@ -9,7 +9,9 @@
  *   - Each entry's `args` should be the **invocation-without-runtime-args**
  *     so `/mcp install` can prompt for the things that vary per user
  *     (paths, tokens, etc.) via `argHints`.
- *   - Prefer official `@modelcontextprotocol/*` packages over third-party.
+ *   - Prefer official `@modelcontextprotocol/*` packages; well-maintained
+ *     third-party servers are fine when they're the de-facto standard for
+ *     their niche (e.g. Playwright for browsers, the iOS-simulator servers).
  */
 export const MCP_MARKETPLACE = [
     {
@@ -116,11 +118,25 @@ export const MCP_MARKETPLACE = [
         url: 'https://github.com/modelcontextprotocol/servers/tree/main/src/time',
     },
     {
-        id: 'puppeteer',
-        name: 'Puppeteer (browser)',
-        description: 'Headless Chromium for navigating, screenshotting, and scraping pages.',
-        server: { command: 'npx', args: ['-y', '@modelcontextprotocol/server-puppeteer'] },
-        url: 'https://github.com/modelcontextprotocol/servers/tree/main/src/puppeteer',
+        id: 'playwright',
+        name: 'Playwright (browser)',
+        description: 'Drive a real browser — navigate, click, fill, screenshot, and scrape — via Microsoft Playwright. The de-facto browser-automation MCP (supersedes Puppeteer).',
+        server: { command: 'npx', args: ['-y', '@playwright/mcp@latest'] },
+        url: 'https://github.com/microsoft/playwright-mcp',
+    },
+    {
+        id: 'ios-simulator',
+        name: 'iOS Simulator',
+        description: 'Drive the iOS Simulator — tap, type, swipe, screenshot, record, install & launch apps. macOS only; needs Xcode + idb (`brew install facebook/fb/idb-companion`).',
+        server: { command: 'npx', args: ['-y', 'ios-simulator-mcp'] },
+        url: 'https://github.com/joshuayoes/ios-simulator-mcp',
+    },
+    {
+        id: 'mobile',
+        name: 'Mobile (iOS + Android)',
+        description: 'UI automation for end-to-end mobile testing across iOS simulators/devices and Android. macOS needs Xcode command-line tools.',
+        server: { command: 'npx', args: ['-y', '@mobilenext/mobile-mcp@latest'] },
+        url: 'https://github.com/mobile-next/mobile-mcp',
     },
 ];
 export function findMarketplaceEntry(id) {

package/dist/utils/tokenTracker.js

@@ -26,6 +26,23 @@ const MODEL_CONTEXT_WINDOWS = {
     'gemini-3-flash-preview': 1_000_000,
     // MiniMax
     'MiniMax-M3': 524_288,
+    // Kimi (Moonshot) — 256K across the K2.x line
+    'kimi-k2.7-code': 262_144,
+    'kimi-k2.7-code-highspeed': 262_144,
+    'kimi-k2.6': 262_144,
+    'kimi-k2.5': 262_144,
+    'kimi-for-coding': 262_144,
+    // Grok (xAI)
+    'grok-build-0.1': 256_000,
+    'grok-4.3': 1_000_000,
+    'grok-code-fast-1': 256_000,
+    'grok-4-fast-reasoning': 2_000_000,
+    // Qwen (Alibaba) — 256K native (1M with extrapolation)
+    'qwen3-coder-plus': 262_144,
+    'qwen3-coder-next': 262_144,
+    'qwen3-coder-flash': 262_144,
+    'qwen3-max': 262_144,
+    'Qwen/Qwen3-Coder-480B-A35B-Instruct': 262_144,
 };
 const DEFAULT_CONTEXT_WINDOW = 128_000;
 /**
@@ -62,6 +79,26 @@ const MODEL_PRICING = {
     'gemini-3-flash-preview': { inputPer1M: 0.50, outputPer1M: 3.00 },
     // MiniMax
     'MiniMax-M3': { inputPer1M: 0.60, outputPer1M: 2.40 },
+    // Kimi (Moonshot) — pay-per-use cache-miss rates; `kimi-for-coding` is the
+    // subscription alias (flat-fee in reality, priced notionally like K2.7 Code).
+    'kimi-k2.7-code': { inputPer1M: 0.60, outputPer1M: 2.50 },
+    'kimi-k2.7-code-highspeed': { inputPer1M: 0.60, outputPer1M: 2.50 },
+    'kimi-k2.6': { inputPer1M: 0.55, outputPer1M: 2.20 },
+    'kimi-k2.5': { inputPer1M: 0.40, outputPer1M: 1.90 },
+    'kimi-for-coding': { inputPer1M: 0.60, outputPer1M: 2.50 },
+    // Grok (xAI)
+    'grok-build-0.1': { inputPer1M: 1.00, outputPer1M: 2.00 },
+    'grok-4.3': { inputPer1M: 1.25, outputPer1M: 2.50 },
+    'grok-code-fast-1': { inputPer1M: 0.20, outputPer1M: 1.50 },
+    'grok-4-fast-reasoning': { inputPer1M: 0.20, outputPer1M: 0.50 },
+    // Qwen (Alibaba) — qwen3-coder-* 0–256K tier; the Coding Plan is flat-fee so
+    // this only affects the pay-per-use estimate.
+    'qwen3-coder-plus': { inputPer1M: 0.28, outputPer1M: 1.65 },
+    'qwen3-coder-next': { inputPer1M: 0.28, outputPer1M: 1.65 },
+    'qwen3-coder-flash': { inputPer1M: 0.10, outputPer1M: 0.50 },
+    'qwen3-max': { inputPer1M: 1.20, outputPer1M: 6.00 },
+    // ModelScope free tier — no per-token charge.
+    'Qwen/Qwen3-Coder-480B-A35B-Instruct': { inputPer1M: 0, outputPer1M: 0 },
 };
 export function getPricingTable() {
     return Object.entries(MODEL_PRICING).map(([model, p]) => ({ model, ...p }));

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "2.11.2";
+export declare const VERSION = "2.13.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.11.2';
+export const VERSION = '2.13.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeep",
-  "version": "2.11.2",
+  "version": "2.13.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",