@cjhyy/code-shell-core 0.5.0-rc.0

package/dist/llm/api-key-sanitize.js

@@ -0,0 +1,81 @@
+/**
+ * sanitizeApiKey — defensive cleanup for API keys pasted via the wizard.
+ *
+ * Windows terminals (ConPTY, legacy cmd.exe, IME-active states) are the main
+ * source of breakage: bracketed-paste residue, CR endings, zero-width chars
+ * pulled in from rich-text sources (Notion / OneNote / web pages), full-width
+ * spaces from CJK IME, smart quotes from word processors. None of these are
+ * valid in any real provider's API key, so we strip them and warn.
+ */
+const BRACKETED_PASTE_START = /^\x1b\[200~/;
+const BRACKETED_PASTE_END = /\x1b\[201~$/;
+// Zero-width + BOM + word joiner. These render as nothing but break auth.
+// U+200B ZWSP, U+200C ZWNJ, U+200D ZWJ, U+2060 WORD JOINER, U+FEFF BOM.
+// eslint-disable-next-line no-irregular-whitespace
+const INVISIBLE_CHARS = /[​-‍⁠]/g;
+// CJK full-width space (U+3000) — IME residue. Normal space is U+0020.
+// eslint-disable-next-line no-irregular-whitespace
+const FULLWIDTH_SPACE = /　/g;
+// Smart quotes — Word / web pages auto-convert ASCII quotes. Real keys
+// never contain quotes, so strip them rather than replace.
+// U+2018 ‘, U+2019 ’, U+201C “, U+201D ”.
+const SMART_QUOTES = /[‘’“”]/g;
+// All C0 (0x00-0x1F) and C1 (0x7F-0x9F) control chars, plus DEL.
+// eslint-disable-next-line no-control-regex
+const CONTROL_CHARS = /[\x00-\x1F\x7F-\x9F]/g;
+export function sanitizeApiKey(raw) {
+    const warnings = [];
+    let v = raw;
+    // 1. Strip bracketed-paste wrapper if it leaked through parse-keypress.
+    if (BRACKETED_PASTE_START.test(v) || BRACKETED_PASTE_END.test(v)) {
+        v = v.replace(BRACKETED_PASTE_START, "").replace(BRACKETED_PASTE_END, "");
+        warnings.push("已剥离终端粘贴包裹符");
+    }
+    // 2. Drop every line break — keys are single-line.
+    if (/[\r\n]/.test(v)) {
+        v = v.replace(/[\r\n]+/g, "");
+        warnings.push("已移除换行符");
+    }
+    // 3. Invisible / zero-width characters.
+    if (INVISIBLE_CHARS.test(v)) {
+        v = v.replace(INVISIBLE_CHARS, "");
+        warnings.push("已移除零宽字符");
+    }
+    // 4. Full-width space (IME).
+    if (FULLWIDTH_SPACE.test(v)) {
+        v = v.replace(FULLWIDTH_SPACE, "");
+        warnings.push("已移除全角空格");
+    }
+    // 5. Smart quotes (Word/web).
+    if (SMART_QUOTES.test(v)) {
+        v = v.replace(SMART_QUOTES, "");
+        warnings.push("已移除中文/智能引号");
+    }
+    // 6. Any other control character (NUL, ESC, …).
+    if (CONTROL_CHARS.test(v)) {
+        v = v.replace(CONTROL_CHARS, "");
+        warnings.push("已移除控制字符");
+    }
+    // 7. Trim ASCII whitespace last.
+    const trimmed = v.trim();
+    if (trimmed !== v) {
+        v = trimmed;
+        // Don't warn on plain leading/trailing space — too noisy and obvious.
+    }
+    const changed = v !== raw;
+    return { value: v, changed, warnings };
+}
+/**
+ * Returns true when the sanitized key contains any non-ASCII-printable
+ * character. Real provider keys are uniformly ASCII (`[A-Za-z0-9_\-.]`-ish),
+ * so a stray non-ASCII char almost certainly means the user pasted the wrong
+ * thing (e.g. the surrounding sentence in Chinese).
+ */
+export function hasNonAsciiPrintable(s) {
+    for (let i = 0; i < s.length; i++) {
+        const c = s.charCodeAt(i);
+        if (c < 0x20 || c > 0x7e)
+            return true;
+    }
+    return false;
+}

package/dist/llm/capabilities/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Capability layer — single entry point.
+ *
+ * `capabilitiesFor(kind, model)` walks the rules in `rules.ts`, returns
+ * a `Capability` describing what params the (provider, model) pair will
+ * accept. Clients spread the result into their request-build code.
+ *
+ * Pure function. No I/O, no caching beyond the rules array.
+ */
+import type { ProviderKindName } from "../provider-kinds.js";
+import { type Capability } from "./types.js";
+export { DEFAULT_CAPABILITY } from "./types.js";
+export type { Capability, ReasoningShape, ReasoningEffort, ThinkingSwitch, EchoReasoning, ParallelToolCallsShape, StreamUsageShape, } from "./types.js";
+/**
+ * Resolve the capability for a given (provider kind, model id).
+ *
+ * First matching rule for the kind wins — rules.ts is ordered so that
+ * more specific patterns come before catch-alls.
+ */
+export declare function capabilitiesFor(kind: ProviderKindName, model: string): Capability;

package/dist/llm/capabilities/index.js

@@ -0,0 +1,39 @@
+/**
+ * Capability layer — single entry point.
+ *
+ * `capabilitiesFor(kind, model)` walks the rules in `rules.ts`, returns
+ * a `Capability` describing what params the (provider, model) pair will
+ * accept. Clients spread the result into their request-build code.
+ *
+ * Pure function. No I/O, no caching beyond the rules array.
+ */
+import { RULES } from "./rules.js";
+import { DEFAULT_CAPABILITY, } from "./types.js";
+export { DEFAULT_CAPABILITY } from "./types.js";
+/**
+ * Resolve the capability for a given (provider kind, model id).
+ *
+ * First matching rule for the kind wins — rules.ts is ordered so that
+ * more specific patterns come before catch-alls.
+ */
+export function capabilitiesFor(kind, model) {
+    for (const rule of RULES) {
+        if (rule.kind !== kind)
+            continue;
+        if (!rule.match.test(model))
+            continue;
+        return {
+            ...DEFAULT_CAPABILITY,
+            ...rule.capability,
+            // Set fields need explicit merge — Object spread copies the
+            // reference but the caller might mutate it. Keep DEFAULT immutable.
+            rejectedParams: rule.capability.rejectedParams
+                ? new Set(rule.capability.rejectedParams)
+                : new Set(DEFAULT_CAPABILITY.rejectedParams),
+        };
+    }
+    return {
+        ...DEFAULT_CAPABILITY,
+        rejectedParams: new Set(DEFAULT_CAPABILITY.rejectedParams),
+    };
+}

package/dist/llm/capabilities/rules.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Per-(provider kind, model family) capability overrides.
+ *
+ * Each rule patches the conservative DEFAULT_CAPABILITY. First match per
+ * kind wins — order matters for overlapping families.
+ *
+ * Authority for every entry is the vendor's own docs; the `why` field
+ * cites the specific page. When a model 400s on something not captured
+ * here, add a rule, don't patch the client.
+ *
+ * Sources audited 2026-05-15:
+ *   OpenAI:    https://platform.openai.com/docs/guides/reasoning
+ *              https://learn.microsoft.com/en-us/azure/foundry/openai/how-to/reasoning
+ *   Anthropic: https://platform.claude.com/docs/en/build-with-claude/extended-thinking
+ *   DeepSeek:  https://api-docs.deepseek.com/guides/reasoning_model
+ *              https://api-docs.deepseek.com/guides/thinking_mode
+ *   Z.AI:      https://docs.z.ai/guides/llm/glm-4.6
+ *   Gemini:    https://ai.google.dev/gemini-api/docs/openai
+ *              https://ai.google.dev/gemini-api/docs/thinking
+ *   OpenRouter: https://openrouter.ai/docs/guides/best-practices/reasoning-tokens
+ *   xAI:       https://docs.x.ai/docs/guides/reasoning
+ *   Mistral:   https://docs.mistral.ai/api/
+ *   Groq:      https://console.groq.com/docs/reasoning
+ */
+import type { CapabilityRule } from "./types.js";
+export declare const RULES: ReadonlyArray<CapabilityRule>;

package/dist/llm/capabilities/rules.js

@@ -0,0 +1,215 @@
+/**
+ * Per-(provider kind, model family) capability overrides.
+ *
+ * Each rule patches the conservative DEFAULT_CAPABILITY. First match per
+ * kind wins — order matters for overlapping families.
+ *
+ * Authority for every entry is the vendor's own docs; the `why` field
+ * cites the specific page. When a model 400s on something not captured
+ * here, add a rule, don't patch the client.
+ *
+ * Sources audited 2026-05-15:
+ *   OpenAI:    https://platform.openai.com/docs/guides/reasoning
+ *              https://learn.microsoft.com/en-us/azure/foundry/openai/how-to/reasoning
+ *   Anthropic: https://platform.claude.com/docs/en/build-with-claude/extended-thinking
+ *   DeepSeek:  https://api-docs.deepseek.com/guides/reasoning_model
+ *              https://api-docs.deepseek.com/guides/thinking_mode
+ *   Z.AI:      https://docs.z.ai/guides/llm/glm-4.6
+ *   Gemini:    https://ai.google.dev/gemini-api/docs/openai
+ *              https://ai.google.dev/gemini-api/docs/thinking
+ *   OpenRouter: https://openrouter.ai/docs/guides/best-practices/reasoning-tokens
+ *   xAI:       https://docs.x.ai/docs/guides/reasoning
+ *   Mistral:   https://docs.mistral.ai/api/
+ *   Groq:      https://console.groq.com/docs/reasoning
+ */
+export const RULES = [
+    // ─── OpenAI native — gpt-5.5+ (and presumably 5.6+) ────────────
+    // gpt-5.5 dropped 'minimal' from reasoning_effort and added 'xhigh'.
+    // Supported values are now {none, low, medium, high, xhigh}.
+    // Trying to send 'minimal' returns a 400 that the SDK surfaces as
+    // "Request was aborted". List this rule BEFORE the broader gpt-5
+    // rule so 5.5+ doesn't fall into the old shape.
+    {
+        kind: "openai",
+        match: /^gpt-5\.(?:[5-9]|\d{2,})(?:[-.]|$)/i,
+        capability: {
+            supportsVision: true,
+            tokenLimitField: "max_completion_tokens",
+            rejectedParams: new Set([
+                "temperature", "top_p", "presence_penalty",
+                "frequency_penalty", "logit_bias", "logprobs", "top_logprobs",
+            ]),
+            reasoning: { kind: "openai-effort", disabledEffort: "none" },
+            echoReasoning: "optional",
+        },
+        why: "OpenAI gpt-5.5+ accepts reasoning_effort none|low|medium|high|xhigh (no `minimal`).",
+    },
+    // ─── OpenAI native — o-series + gpt-5 through gpt-5.4 ──────────
+    {
+        kind: "openai",
+        // o1/o3/o4-mini + gpt-5/5.1/5.2/5.3/5.4 + future digits.
+        // Anchored to start so OpenRouter-prefixed ids like `openai/gpt-5`
+        // never match this rule (OpenRouter rule below handles those).
+        match: /^(?:o[1-9]\d*|gpt-[5-9])(?:[-.]|$)/i,
+        capability: {
+            supportsVision: true,
+            tokenLimitField: "max_completion_tokens",
+            rejectedParams: new Set([
+                "temperature", "top_p", "presence_penalty",
+                "frequency_penalty", "logit_bias", "logprobs", "top_logprobs",
+            ]),
+            reasoning: { kind: "openai-effort" },
+            echoReasoning: "optional",
+        },
+        why: "OpenAI o-series + gpt-5..5.4 reject classic sampling params; use max_completion_tokens + reasoning_effort.",
+    },
+    // ─── DeepSeek ──────────────────────────────────────────────────
+    {
+        kind: "deepseek",
+        match: /^deepseek-v4(?:[-.]|$)/i,
+        capability: {
+            reasoning: { kind: "deepseek-thinking" },
+            // V4 + tools requires reasoning_content echoed; non-tool turns optional.
+            // Empty-string echo triggers an endpoint regression where the model
+            // returns an empty content. We backfill only when thinking is ON.
+            echoReasoning: "when-tools",
+        },
+        why: "DeepSeek V4 thinking mode — top-level thinking:{type}; echo reasoning_content when tools are present.",
+    },
+    {
+        kind: "deepseek",
+        match: /^deepseek-reasoner(?:[-.]|$)/i,
+        capability: {
+            reasoning: { kind: "none" },
+            // Sending reasoning_content back makes deepseek-reasoner 400.
+            echoReasoning: "never",
+        },
+        why: "deepseek-reasoner refuses prior reasoning_content in input; always-on reasoning, no toggle.",
+    },
+    // ─── Z.AI (GLM) ────────────────────────────────────────────────
+    {
+        kind: "zai",
+        // GLM-4.5, 4.6, 5.1 — same `thinking:{type}` shape as DeepSeek V4.
+        match: /^glm-[4-9](?:[-.]|$)/i,
+        capability: {
+            reasoning: { kind: "deepseek-thinking" },
+            echoReasoning: "optional",
+        },
+        why: "Z.AI GLM-4.5+ thinking shape is identical to DeepSeek V4; default is enabled.",
+    },
+    // ─── Anthropic direct ─────────────────────────────────────────
+    // Older Claude 4.x (≤4.5) accept explicit thinking:{type, budget_tokens}.
+    // The newer 4.6+ family (Opus 4.7 included) is adaptive — sending the
+    // opt-in field 400s. We check 4.6 boundary numerically below.
+    {
+        kind: "anthropic",
+        match: /^claude-(?:opus|sonnet|haiku)-4-[6-9](?:[-.]|$)/i,
+        capability: {
+            supportsVision: true,
+            reasoning: { kind: "anthropic-adaptive" },
+            echoReasoning: "when-tools",
+            parallelToolCalls: "anthropic-disable-flag",
+            streamUsage: "auto",
+        },
+        why: "Claude 4.6+ thinking is adaptive — no opt-in field. Echo thinking blocks on tool turns.",
+    },
+    {
+        kind: "anthropic",
+        match: /^claude-(?:opus|sonnet|haiku)-4(?:[-.]|$)/i,
+        capability: {
+            supportsVision: true,
+            reasoning: { kind: "anthropic-budget", minBudgetTokens: 1024 },
+            echoReasoning: "when-tools",
+            parallelToolCalls: "anthropic-disable-flag",
+            streamUsage: "auto",
+        },
+        why: "Claude 4.x ≤4.5 supports explicit thinking:{type:enabled, budget_tokens≥1024}.",
+    },
+    // Catch-all for Claude 3.x and earlier — no thinking field, but still
+    // needs Anthropic-shape tool_choice. Claude 3+ all support vision.
+    {
+        kind: "anthropic",
+        match: /^claude-/i,
+        capability: {
+            supportsVision: true,
+            parallelToolCalls: "anthropic-disable-flag",
+            streamUsage: "auto",
+        },
+        why: "Pre-Claude-4 — no extended thinking; keep Anthropic tool_choice/stream shape; vision supported since Claude 3.",
+    },
+    // ─── Gemini (OpenAI-compat endpoint) ───────────────────────────
+    {
+        kind: "google",
+        // 2.5+ all support thinking; OpenAI-compat surface maps reasoning_effort
+        // to thinkingConfig. Lite/flash families also accept it.
+        match: /^gemini-(?:[2-9]\.\d|[2-9])/i,
+        capability: {
+            supportsVision: true,
+            reasoning: { kind: "openai-effort" },
+            echoReasoning: "optional",
+        },
+        why: "Gemini 2.5+ via OpenAI-compat — reasoning_effort is auto-mapped to thinking_level; multimodal native.",
+    },
+    // ─── OpenRouter ────────────────────────────────────────────────
+    // OpenRouter normalizes everything under {reasoning: {...}}. It also
+    // accepts max_tokens for every model it routes (internal mapping).
+    // OpenRouter rules — check vision-specific backends first so the
+    // catch-all doesn't mask them.
+    {
+        kind: "openrouter",
+        // Most modern frontier models on OpenRouter are multimodal; flag the
+        // big families explicitly. The catch-all below stays vision=false so
+        // older/text-only routes don't get a green checkmark they don't earn.
+        match: /^(?:openai\/(?:gpt-4o|gpt-5|o[1-9])|anthropic\/claude-(?:3|4|opus|sonnet|haiku)|google\/gemini-[2-9]|x-ai\/grok-[4-9]|qwen\/qwen-?vl|meta\/llama-(?:3\.2|4))/i,
+        capability: {
+            supportsVision: true,
+            reasoning: { kind: "openrouter-reasoning" },
+            echoReasoning: "optional",
+        },
+        why: "OpenRouter routes to vision-capable backends for these slugs (GPT-4o, Claude 3+, Gemini 2.5+, Grok 4+, Qwen-VL, Llama 3.2/4).",
+    },
+    {
+        kind: "openrouter",
+        match: /./, // Any other model via OpenRouter
+        capability: {
+            reasoning: { kind: "openrouter-reasoning" },
+            // OpenRouter doesn't enforce per-provider echo contracts at its edge.
+            echoReasoning: "optional",
+        },
+        why: "OpenRouter exposes a unified reasoning:{effort,max_tokens,exclude,enabled} field for every backend.",
+    },
+    // ─── xAI Grok ──────────────────────────────────────────────────
+    {
+        kind: "xai",
+        // grok-4.3 has reasoning_effort: none|low|medium|high (no "minimal").
+        // Send "low" when the caller asks to disable — xAI rejects "minimal" 400.
+        match: /^grok-4\.3(?:[-.]|$)/i,
+        capability: {
+            supportsVision: true,
+            reasoning: { kind: "openai-effort", disabledEffort: "low" },
+        },
+        why: "xAI grok-4.3 supports reasoning_effort none|low|medium|high — no `minimal`; vision supported in grok-4+.",
+    },
+    // ─── Mistral ───────────────────────────────────────────────────
+    {
+        kind: "mistral",
+        // Magistral series exposes reasoning_effort: high|none — no minimal/low/medium.
+        match: /^magistral/i,
+        capability: {
+            reasoning: { kind: "openai-effort", disabledEffort: "none" },
+        },
+        why: "Mistral magistral models accept only reasoning_effort `high` or `none`.",
+    },
+    // ─── Groq ──────────────────────────────────────────────────────
+    {
+        kind: "groq",
+        match: /^(?:gpt-oss-(?:20b|120b)|qwen3-)/i,
+        capability: {
+            reasoning: { kind: "openai-effort" },
+            // Groq uses max_completion_tokens canonically (max_tokens is a
+            // deprecated alias). Safe to pin to the new field.
+            tokenLimitField: "max_completion_tokens",
+        },
+        why: "Groq reasoning-capable models use max_completion_tokens + reasoning_effort.",
+    },
+];

package/dist/llm/capabilities/types.d.ts

@@ -0,0 +1,114 @@
+/**
+ * Per-(provider, model) capability descriptor.
+ *
+ * Captures the subset of request-shape divergence we've actually observed
+ * cause HTTP 400s or behavior changes. Each rule in `rules.ts` produces
+ * one of these; clients spread it into the outgoing request.
+ *
+ * Sources for every field are documented next to the matching rule in
+ * `rules.ts` — vendor docs, not folklore.
+ */
+import type { ProviderKindName } from "../provider-kinds.js";
+/** OpenAI-style reasoning effort levels — shared by several vendors. */
+export type ReasoningEffort = "minimal" | "low" | "medium" | "high";
+/** A binary thinking switch, like DeepSeek V4 and Z.AI GLM use. */
+export type ThinkingSwitch = "enabled" | "disabled";
+/**
+ * How the vendor exposes a "think harder / think less" knob (or none).
+ * Each kind has different field names and value shapes — we keep them
+ * separate so the engine can't accidentally cross-pollinate.
+ */
+export type ReasoningShape = {
+    kind: "none";
+}
+/** DeepSeek V4, Z.AI GLM-4.5+ — `{thinking: {type: "enabled"|"disabled"}}` at top level. */
+ | {
+    kind: "deepseek-thinking";
+}
+/**
+ * OpenAI o-series & gpt-5+ — `reasoning_effort: "minimal"|"low"|"medium"|"high"`.
+ * `disabledEffort` is the value we send when the caller asks for thinking
+ * "disabled" — defaults to `"minimal"` (OpenAI), but vendors with a
+ * narrower vocabulary override it (e.g. xAI Grok 4.3 has no `"minimal"`;
+ * Mistral Magistral only accepts `"high"` and `"none"`).
+ */
+ | {
+    kind: "openai-effort";
+    disabledEffort?: ReasoningEffort | "none";
+}
+/** Anthropic Claude 4.x ≤ 4.5 — `{thinking: {type: "enabled", budget_tokens: N}}`. */
+ | {
+    kind: "anthropic-budget";
+    minBudgetTokens: number;
+}
+/** Anthropic Claude 4.6+ — no opt-in, thinking is adaptive. Sending `type: "enabled"` 400s. */
+ | {
+    kind: "anthropic-adaptive";
+}
+/** OpenRouter normalized — `{reasoning: {effort, max_tokens, exclude, enabled}}`. */
+ | {
+    kind: "openrouter-reasoning";
+};
+/**
+ * How prior `reasoning_content` (or `thinking` blocks) must be threaded
+ * back into the next request.
+ */
+export type EchoReasoning = 
+/** DeepSeek `deepseek-reasoner`: 400 if you echo it back at all. */
+"never"
+/** DeepSeek V4 + tools, Claude 4.x + tools: must echo or 400. */
+ | "when-tools"
+/** Optional — echo if you have it, but absence is fine. */
+ | "optional";
+/**
+ * Parallel-tool-call shape. OpenAI exposes `parallel_tool_calls: bool`.
+ * Anthropic exposes it inside `tool_choice.disable_parallel_tool_use`.
+ * Some endpoints don't support it at all.
+ */
+export type ParallelToolCallsShape = "openai-flag" | "anthropic-disable-flag" | "unsupported";
+/**
+ * Streaming usage signal. OpenAI-compat needs `stream_options:
+ * {include_usage: true}`; Anthropic always emits usage in
+ * `message_delta`; some endpoints reject the field.
+ */
+export type StreamUsageShape = "include-usage-flag" | "auto" | "none";
+export interface Capability {
+    /**
+     * Whether the model accepts image content blocks. UI gates image attachments
+     * on this — non-vision models surface a "this model does not accept images"
+     * message instead of silently dropping the upload.
+     */
+    supportsVision: boolean;
+    /** Token-limit request field. */
+    tokenLimitField: "max_tokens" | "max_completion_tokens";
+    /**
+     * Request fields the model 400s on (or silently drops). We just don't
+     * send them. Names are in OpenAI-compat spelling; clients translate
+     * for native protocols.
+     */
+    rejectedParams: ReadonlySet<"temperature" | "top_p" | "presence_penalty" | "frequency_penalty" | "logit_bias" | "logprobs" | "top_logprobs">;
+    /** How thinking is exposed (or not). */
+    reasoning: ReasoningShape;
+    /** Echo-back contract for prior reasoning. */
+    echoReasoning: EchoReasoning;
+    /** Parallel-tool-calls flag shape. */
+    parallelToolCalls: ParallelToolCallsShape;
+    /** Streaming usage reporting shape. */
+    streamUsage: StreamUsageShape;
+}
+/**
+ * Conservative default — used when no rule matches. Picks "send everything
+ * the vanilla OpenAI Chat Completions spec accepts," because that's what
+ * every OpenAI-compat endpoint at minimum understands.
+ */
+export declare const DEFAULT_CAPABILITY: Capability;
+export interface CapabilityRule {
+    /** Which provider kind this rule applies to. */
+    kind: ProviderKindName;
+    /** Model-id matcher. First matching rule wins (per kind). */
+    match: RegExp;
+    /** Patch applied on top of DEFAULT_CAPABILITY. */
+    capability: Partial<Capability>;
+    /** Free-text reason — shown in logs, helps future-you. */
+    why: string;
+}

package/dist/llm/capabilities/types.js

@@ -0,0 +1,24 @@
+/**
+ * Per-(provider, model) capability descriptor.
+ *
+ * Captures the subset of request-shape divergence we've actually observed
+ * cause HTTP 400s or behavior changes. Each rule in `rules.ts` produces
+ * one of these; clients spread it into the outgoing request.
+ *
+ * Sources for every field are documented next to the matching rule in
+ * `rules.ts` — vendor docs, not folklore.
+ */
+/**
+ * Conservative default — used when no rule matches. Picks "send everything
+ * the vanilla OpenAI Chat Completions spec accepts," because that's what
+ * every OpenAI-compat endpoint at minimum understands.
+ */
+export const DEFAULT_CAPABILITY = {
+    supportsVision: false,
+    tokenLimitField: "max_tokens",
+    rejectedParams: new Set(),
+    reasoning: { kind: "none" },
+    echoReasoning: "optional",
+    parallelToolCalls: "openai-flag",
+    streamUsage: "include-usage-flag",
+};

package/dist/llm/client-base.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Abstract base class for all LLM provider clients.
+ */
+import type { LLMConfig, LLMResponse, TokenUsage } from "../types.js";
+import type { CreateMessageOptions, LLMUsageTracker } from "./types.js";
+export declare abstract class LLMClientBase {
+    protected readonly config: LLMConfig;
+    readonly provider: string;
+    readonly model: string;
+    readonly temperature: number;
+    readonly maxTokens: number;
+    readonly timeout: number;
+    readonly retryMaxAttempts: number;
+    readonly enableStreaming: boolean;
+    /**
+     * Process-wide hook fired on every LLM response. The CLI installs this in
+     * main.ts to feed the cost tracker; lives on the base class so every code
+     * path (REPL, run, arena, sub-agents) reports through one funnel without
+     * each call site needing to remember.
+     */
+    static onUsage?: (model: string, usage: TokenUsage) => void;
+    protected usage: LLMUsageTracker;
+    constructor(config: LLMConfig);
+    protected abstract initClient(): void;
+    abstract createMessage(options: CreateMessageOptions): Promise<LLMResponse>;
+    protected recordUsage(usage: TokenUsage, options?: CreateMessageOptions): void;
+    getUsage(): LLMUsageTracker;
+    protected withRetry<T>(fn: () => Promise<T>, maxAttempts?: number): Promise<T>;
+}