@cjhyy/code-shell 0.3.0 → 0.5.0-rc.2

package/dist/engine/turn-loop.d.ts

@@ -1,122 +0,0 @@
-/**
- * Turn loop — state machine implementation.
- *
- * Following Claude Code's po_() pattern:
- * pre_check → model_call → post_check → tool_exec → context_mgmt → hook_notify → next turn
- */
-import type { Message, StreamCallback, TerminalReason } from "../types.js";
-import { ModelFacade } from "./model-facade.js";
-import { ToolExecutor } from "../tool-system/executor.js";
-import { ContextManager } from "../context/manager.js";
-import { HookRegistry } from "../hooks/registry.js";
-import { Transcript } from "../session/transcript.js";
-export interface TurnLoopConfig {
-    maxTurns: number;
-    maxToolCallsPerTurn: number;
-    tokenBudget?: number;
-    onStream?: StreamCallback;
-    signal?: AbortSignal;
-    /**
-     * Fired after each turn boundary is recorded. Lets the engine flush an
-     * up-to-date snapshot to state.json mid-run, so a long run doesn't leave
-     * the on-disk turnCount/status frozen at the last completion.
-     */
-    onTurnBoundary?: (turnCount: number) => void;
-}
-export interface CtxOverheadStore {
-    /** Tokens for system prompt + tool defs, derived from provider's promptTokens. */
-    get(sid: string): number;
-    set(sid: string, tokens: number): void;
-}
-export interface TurnLoopDeps {
-    model: ModelFacade;
-    toolExecutor: ToolExecutor;
-    contextManager: ContextManager;
-    hooks: HookRegistry;
-    transcript: Transcript;
-    systemPrompt: string;
-    tools: import("../types.js").ToolDefinition[];
-    /** Per-sid overhead cache so the ctx bar doesn't drop between turns. */
-    ctxOverheadStore: CtxOverheadStore;
-    /** Current session id, used to key the overhead store. */
-    sessionId: string;
-    /**
-     * Carried into every hook emit's `ctx.data.isSubAgent` so handlers can
-     * skip noisy injections for spawned children. Set by Engine from
-     * EngineConfig.isSubAgent (engine.ts:119).
-     */
-    isSubAgent?: boolean;
-    /**
-     * Reads/clears the most recent compaction event emitted by
-     * ContextManager since the last call. Returns `null` if no compaction
-     * fired since the previous check. The Engine wires this up so the
-     * turn loop can `post_compact` emit + inject hook messages without
-     * the ContextManager itself depending on HookRegistry.
-     */
-    consumePendingCompactInfo?: () => {
-        strategy: string;
-        before: number;
-        after: number;
-    } | null;
-}
-export interface TurnLoopResult {
-    text: string;
-    reason: TerminalReason;
-    messages: Message[];
-}
-export declare class TurnLoop {
-    private readonly deps;
-    private readonly config;
-    private turnCount;
-    /** Tool IDs already emitted as tool_use_start during streaming (to avoid duplicates). */
-    private streamedToolIds;
-    /**
-     * Turn-scoped child logger set at the top of each loop iteration. Class
-     * methods invoked inside the iteration (callModelWithFallback,
-     * executeToolCall, ...) read it instead of using the root `logger`, so
-     * every line they write is tagged with the current turn/turnId.
-     */
-    private currentTurnLog;
-    /** Last emitted ctx token estimate; used to skip no-op usage_update events. */
-    private lastCtxEmit;
-    constructor(deps: TurnLoopDeps, config: TurnLoopConfig);
-    /**
-     * Emit a lifecycle hook with isSubAgent + sessionId auto-merged into data.
-     * Returns the aggregated HookResult so callers can consume `messages` /
-     * `decision` / `stop`. Use this instead of `deps.hooks.emit` directly so
-     * every emit carries the same context envelope.
-     */
-    private emitHook;
-    /**
-     * Emit a usage_update so the UI ctx bar reflects current message-array
-     * size. Called at every point where messages mutate: after a tool_result
-     * is appended, after context management (which may shrink), and after an
-     * LLM response (which we also feed through with the provider's authoritative
-     * promptTokens to override our estimate).
-     */
-    private emitCtxFromMessages;
-    private emitCtxFromUsage;
-    /**
-     * Run the multi-turn agent loop until completion.
-     */
-    run(initialMessages: Message[]): Promise<TurnLoopResult>;
-    /**
-     * Call model with streaming fallback.
-     * If streaming fails, emit tombstone and retry non-streaming.
-     */
-    private callModelWithFallback;
-    /**
-     * Execute tools with overlap: start concurrent-safe (read-only) tools
-     * immediately in parallel while sequential (write) tools run one-by-one.
-     * Both groups run simultaneously — we don't wait for safe tools to finish
-     * before starting unsafe ones.
-     */
-    private executeToolsOverlapped;
-    get currentTurn(): number;
-    /**
-     * Generate synthetic error tool_results for any dangling tool_use blocks
-     * that never received results (e.g. because the API call failed).
-     * Prevents model confusion on the next turn.
-     */
-    private patchOrphanedToolUses;
-}

package/dist/engine/turn-state.d.ts

@@ -1,20 +0,0 @@
-/**
- * Turn loop state definitions.
- */
-import type { TurnPhase, ToolCall, LLMResponse, TerminalReason } from "../types.js";
-export interface TurnState {
-    phase: TurnPhase;
-    turnNumber: number;
-    modelResponse?: LLMResponse;
-    toolCalls?: ToolCall[];
-    finalText?: string;
-    error?: Error;
-    terminalReason?: TerminalReason;
-}
-export declare function initialTurnState(turnNumber: number): TurnState;
-/**
- * Short, human-readable turn correlation ID. Stamped on every log entry
- * written for the duration of one turn so `jq 'select(.turnId == "abc123")'`
- * pulls a single turn's whole timeline out of the daily log file.
- */
-export declare function newTurnId(): string;

package/dist/exceptions.d.ts

@@ -1,44 +0,0 @@
-/**
- * Custom exception hierarchy for the code-shell framework.
- */
-export declare class FrameworkError extends Error {
-    readonly details?: Record<string, unknown> | undefined;
-    constructor(message: string, details?: Record<string, unknown> | undefined);
-}
-export declare class LLMError extends FrameworkError {
-    readonly provider?: string | undefined;
-    constructor(message: string, provider?: string | undefined, details?: Record<string, unknown>);
-}
-export declare class LLMRateLimitError extends LLMError {
-    readonly retryAfter?: number | undefined;
-    constructor(provider: string, retryAfter?: number | undefined);
-}
-export declare class ContextLimitError extends LLMError {
-    constructor(provider?: string);
-}
-export declare class ToolError extends FrameworkError {
-    readonly toolName?: string | undefined;
-    constructor(message: string, toolName?: string | undefined, details?: Record<string, unknown>);
-}
-export declare class ToolNotFoundError extends ToolError {
-    constructor(toolName: string);
-}
-export declare class ToolExecutionError extends ToolError {
-    constructor(toolName: string, cause: string);
-}
-export declare class ToolTimeoutError extends ToolError {
-    readonly timeoutMs: number;
-    constructor(toolName: string, timeoutMs: number);
-}
-export declare class PermissionDeniedError extends FrameworkError {
-    constructor(toolName: string, reason?: string);
-}
-export declare class SessionError extends FrameworkError {
-    constructor(message: string, details?: Record<string, unknown>);
-}
-export declare class TranscriptError extends FrameworkError {
-    constructor(message: string, details?: Record<string, unknown>);
-}
-export declare class ConfigError extends FrameworkError {
-    constructor(message: string, details?: Record<string, unknown>);
-}

package/dist/export-md-U72T7NW7.js

@@ -1,22 +0,0 @@
-import {h as h$1,a}from'./chunk-3QP5BQ3L.js';import {join,basename}from'path';h$1();var h=2e3,_=800,w=/^[A-Za-z0-9_-]+$/;function R(n,r,e){if(!w.test(n))throw new Error(`renderSessionMarkdown: invalid sessionId ${JSON.stringify(n)} \u2014 expected [A-Za-z0-9_-]+`);let t=[],s=[],u=`session-${n}-attachments`;t.push(`# Session ${n}`),t.push("");let i=0;for(let d of r){let o=d;if(o.type!=="message")continue;i+=1;let $=o.data?.role??"unknown",a=o.data?.content;if(t.push(`## turn ${i} \xB7 ${$}`),t.push(""),typeof a=="string"){t.push(a),t.push("");continue}if(!Array.isArray(a)){t.push("```json"),t.push(JSON.stringify(a,null,2)),t.push("```"),t.push("");continue}let l=0;for(let m of a){l+=1;let g=I(m,{turnNumber:i,itemIdx:l,sidecarDir:u,cwd:e,sidecars:s});g&&(t.push(g),t.push(""));}}return {md:t.join(`
-`),sidecars:s}}a(R,"renderSessionMarkdown");function I(n,r){let e=n.type;if(e==="reasoning"){let t=n.reasoningContent??"";return y("reasoning",t)}if(e==="text")return n.text??"";if(e==="tool_use"){let t=n.name??"?",s=JSON.stringify(n.input??{},null,2)??"{}",u=`**\u{1F6E0} tool_use** \xB7 \`${t}\``;return s.length<=_?`${u}
-
-\`\`\`json
-${s}
-\`\`\``:y(`${t} args (${s.length} bytes)`,s,"json")}if(e==="tool_result"){let t=n.tool_use_id??n.id??"?",s=N(n.content);if(s.length<=h)return `**\u25C0 tool_result** \xB7 ${t}
-
-\`\`\`
-${s}
-\`\`\``;let u=`t${r.turnNumber}-i${r.itemIdx}-${t.slice(0,12)}.txt`,i=join(r.cwd,r.sidecarDir,u);r.sidecars.push({path:i,content:s});let d=s.slice(0,h),o=join(r.sidecarDir,basename(i));return `**\u25C0 tool_result** \xB7 ${t} \xB7 ${s.length.toLocaleString()} bytes \xB7 [full \u2192 ${o}](./${o})
-
-\`\`\`
-${d}
-\u2026(truncated, see sidecar)
-\`\`\``}return "```json\n"+JSON.stringify(n,null,2)+"\n```"}a(I,"renderBlock");function y(n,r,e=""){let t=e?"```"+e:"```";return `<details><summary>${n}</summary>
-
-${t}
-${r}
-\`\`\`
-
-</details>`}a(y,"collapsible");function N(n){if(n==null)return "";if(typeof n=="string")return n;if(Array.isArray(n)){let r=[];for(let e of n)e&&typeof e=="object"&&"text"in e&&typeof e.text=="string"?r.push(e.text):r.push(JSON.stringify(e));return r.join(`
-`)}return JSON.stringify(n,null,2)}a(N,"stringifyResult");export{R as renderSessionMarkdown};

package/dist/file-history-7FQFEQOL.js

@@ -1 +0,0 @@
-export{a as FileHistory}from'./chunk-WI6FSWGU.js';import'./chunk-3QP5BQ3L.js';

package/dist/git/utils.d.ts

@@ -1,35 +0,0 @@
-/**
- * Git utility functions for the git workflow commands.
- */
-export interface GitStatusEntry {
-    status: string;
-    path: string;
-}
-export interface GitLogEntry {
-    hash: string;
-    message: string;
-    author: string;
-    date: string;
-}
-export declare function isGitRepo(cwd: string): boolean;
-export declare function getCurrentBranch(cwd: string): string;
-export declare function getGitStatus(cwd: string): GitStatusEntry[];
-export declare function getGitDiff(cwd: string, opts?: {
-    staged?: boolean;
-    file?: string;
-}): string;
-export declare function getGitDiffStat(cwd: string, opts?: {
-    staged?: boolean;
-    file?: string;
-}): string;
-export declare function getGitLog(cwd: string, n?: number): GitLogEntry[];
-export declare function getRemoteUrl(cwd: string): string | undefined;
-export declare function gitAdd(cwd: string, files?: string[]): void;
-export declare function gitCommit(cwd: string, message: string): string;
-export declare function gitListBranches(cwd: string): {
-    name: string;
-    current: boolean;
-}[];
-export declare function gitCheckout(cwd: string, branch: string, create?: boolean): void;
-export declare function ghAvailable(): boolean;
-export declare function ghPrComments(cwd: string, prUrl: string): string;

package/dist/git/worktree.d.ts

@@ -1,36 +0,0 @@
-/**
- * Git worktree management — create/remove isolated worktrees for agents.
- */
-export interface WorktreeSession {
-    originalCwd: string;
-    worktreePath: string;
-    worktreeName: string;
-    worktreeBranch: string;
-    originalBranch?: string;
-    sessionId: string;
-    createdAt: number;
-}
-/**
- * Validate worktree slug to prevent path traversal attacks.
- */
-export declare function validateWorktreeSlug(slug: string): void;
-/**
- * Find the canonical git root (resolves worktree → main repo).
- */
-export declare function findGitRoot(cwd: string): string;
-/**
- * Create an isolated git worktree for an agent session.
- */
-export declare function createWorktree(cwd: string, slug: string, sessionId: string): WorktreeSession;
-/**
- * Remove a worktree and optionally its branch.
- */
-export declare function removeWorktree(worktreePath: string, removeBranch?: boolean): void;
-/**
- * List active worktrees.
- */
-export declare function listWorktrees(cwd: string): Array<{
-    path: string;
-    branch: string;
-    head: string;
-}>;

package/dist/hooks/events.d.ts

@@ -1,114 +0,0 @@
-/**
- * Hook event type definitions.
- */
-/**
- * Lifecycle hooks the engine emits.
- *
- * **Currently emitted** (handlers registered here will actually fire):
- *   - on_session_start / on_session_end    (engine.ts) — fires once per Engine.run().
- *                                          on_session_start handlers may return
- *                                          `messages` to inject a <system-reminder>
- *                                          at the head of the conversation, before
- *                                          the current user prompt.
- *   - on_agent_start / on_agent_end        (engine.ts) — notify-only; returned
- *                                          messages are NOT consumed (the loop
- *                                          is already armed by the time these
- *                                          fire). Use on_session_start instead.
- *   - user_prompt_submit                   (engine.ts) — fires once per run() for
- *                                          every new user prompt (cold-start and
- *                                          resume both qualify). Returned messages
- *                                          are merged into the same lifecycle
- *                                          <system-reminder> as on_session_start.
- *   - on_turn_start / on_turn_end          (turn-loop.ts) — on_turn_start handlers
- *                                          may return `messages` to inject a
- *                                          per-turn reminder appended to the
- *                                          conversation right before the model call.
- *   - pre_tool_use / post_tool_use         (executor.ts) — pre_tool_use honors
- *                                          `decision: "deny"` to short-circuit
- *                                          the call (executor.ts:131).
- *   - on_tool_start / on_tool_end          (executor.ts)
- *   - file_changed                         (executor.ts, Write/Edit only)
- *   - on_permission_check                  (executor.ts) — fires after the
- *                                          classifier runs and before its
- *                                          decision is acted on. Handler can
- *                                          override via `decision`; the
- *                                          override is logged as
- *                                          `permission.hook_override`. ctx.data
- *                                          carries `classifierDecision` so
- *                                          handlers can branch on the rule
- *                                          set's verdict.
- *   - post_compact                         (turn-loop.ts) — fires after
- *                                          ContextManager.manageAsync() runs
- *                                          a non-micro compaction. Handlers
- *                                          may return `messages` to inject a
- *                                          <system-reminder> into the same
- *                                          turn before the model call. ctx.data
- *                                          carries `strategy` (summary/snip/
- *                                          window/emergency), `beforeTokens`,
- *                                          `afterTokens`. Microcompact is
- *                                          intentionally suppressed.
- *   - notification                         (agent.ts) — fired when a background
- *                                          sub-agent transitions to a terminal
- *                                          state. ctx.data carries `kind`
- *                                          ("agent_completed" / "agent_failed" /
- *                                          "agent_cancelled"), `agentId`,
- *                                          `name`, `description`, plus
- *                                          `finalText` (completed) or `error`
- *                                          (failed). Fired void — handler
- *                                          latency does not block the main
- *                                          loop. Not consumed by the engine
- *                                          (bg-agent feed renders the same
- *                                          info via notificationQueue);
- *                                          intended for shell hooks (osascript
- *                                          / desktop notifications).
- *
- * All Engine-side emits run through Engine.emitHook / TurnLoop.emitHook, which
- * auto-merge `isSubAgent` (and sessionId, for turn-loop) into ctx.data so
- * handlers can skip noisy injections for spawned children.
- *
- * **Reserved / not-yet-emitted** (defined so downstream can register handlers
- * in anticipation; wire the emitter before relying on them):
- *   - pre_compact   — would require pre-flight prediction inside
- *                     ContextManager; current implementation only knows
- *                     after-the-fact (use post_compact instead).
- */
-export type HookEventName = "on_agent_start" | "on_agent_end" | "on_turn_start" | "on_turn_end" | "on_tool_start" | "on_tool_end" | "on_permission_check" | "on_session_start" | "on_session_end" | "pre_tool_use" | "post_tool_use" | "user_prompt_submit" | "pre_compact" | "post_compact" | "file_changed" | "notification";
-export interface HookContext {
-    eventName: HookEventName;
-    data: Record<string, unknown>;
-    sessionId?: string;
-    turnNumber?: number;
-}
-export interface HookResult {
-    /** If true, stop the hook chain */
-    stop?: boolean;
-    /** Modified data to pass along */
-    data?: Record<string, unknown>;
-    /** Additional messages to inject */
-    messages?: string[];
-    /** Allow/deny/ask override for permission hooks */
-    decision?: "allow" | "deny" | "ask";
-    /**
-     * For pre_tool_use: replace the tool's args before execution. Used by
-     * "sanitizer" handlers (e.g. redact secrets in Bash commands, normalize
-     * file paths, inject a default flag). Last handler in the chain wins.
-     * Args are re-validated against the tool's input schema before the
-     * tool runs, so a malformed updatedInput still surfaces as an
-     * "Invalid input" error rather than silently passing through.
-     */
-    updatedInput?: Record<string, unknown>;
-    /**
-     * For post_tool_use: text appended to the tool's content (visible to
-     * the model on the next LLM call). Used by linter/typecheck handlers
-     * to surface results without re-running the tool. Multiple handlers'
-     * additionalContext entries are joined with two newlines.
-     */
-    additionalContext?: string;
-    /**
-     * For user_prompt_submit: replace the most recent user message text
-     * with this string. Last handler wins. Used to auto-prepend project
-     * context, mask secrets, or rewrite shorthand prompts. The original
-     * prompt is logged at info level for audit purposes.
-     */
-    updatedPrompt?: string;
-}

package/dist/hooks/inject.d.ts

@@ -1,19 +0,0 @@
-/**
- * Hook message injection helper.
- *
- * Handlers return raw markdown strings via HookResult.messages. The emit
- * site uses wrapHookMessages() to package them into a single user-role
- * <system-reminder> Message so the model sees them as one block instead
- * of a noisy sequence of separate user turns.
- *
- * Contract:
- *   - Handlers do NOT wrap their own <system-reminder>; emit-site owns the
- *     wrapper. Keeps formatting consistent and lets us evolve it (e.g. add
- *     a trailing close-tag, tag attributes) without touching every handler.
- *   - Empty / whitespace-only messages are dropped before wrapping; if
- *     nothing remains, returns null (caller skips the injection).
- *   - Multiple handlers' messages are joined with a blank line between
- *     blocks so each is visually distinct inside the reminder.
- */
-import type { Message } from "../types.js";
-export declare function wrapHookMessages(messages: string[] | undefined): Message | null;

package/dist/hooks/registry.d.ts

@@ -1,15 +0,0 @@
-/**
- * Hook registry with priority-based chain-of-responsibility execution.
- */
-import type { HookEventName, HookContext, HookResult } from "./events.js";
-export type HookHandler = (ctx: HookContext) => HookResult | Promise<HookResult>;
-export declare class HookRegistry {
-    private hooks;
-    register(eventName: HookEventName, handler: HookHandler, priority?: number, name?: string): void;
-    emit(eventName: HookEventName, data?: Record<string, unknown>): Promise<HookResult>;
-    hasHooks(eventName: HookEventName): boolean;
-    clear(eventName?: HookEventName): void;
-    listHooks(): Map<HookEventName, string[]>;
-    listEvents(): HookEventName[];
-    countHandlers(eventName: HookEventName): number;
-}

package/dist/hooks/shell-runner.d.ts

@@ -1,45 +0,0 @@
-/**
- * shell-runner — execute a user-configured shell command as a hook handler.
- *
- * Protocol (matches Claude Code's shell-hook contract):
- *
- *   stdin       JSON.stringify({ eventName, data }) — the full HookContext
- *               envelope, including ctx.data fields like toolName / args /
- *               sessionId / isSubAgent.
- *
- *   stdout      Either ignored (when exit 0 with no/blank output) or parsed
- *               as a HookResult JSON document. Unparseable stdout on exit 0
- *               is logged at warn level and dropped — we do NOT crash the
- *               turn loop on malformed handler output.
- *
- *   exit  0     Normal return. Stdout (if any) becomes the HookResult.
- *   exit  2     Deny / block. Stderr becomes the human-readable reason and
- *               is surfaced to the model via HookResult.messages so the LLM
- *               sees why the action was rejected.
- *   exit  *     Any other non-zero code = handler error. Logged at error
- *               level; we return {} (no effect) so a buggy hook never wedges
- *               the engine.
- *
- *   ENV (passed to child):
- *               CODESHELL_HOOK_EVENT   — event name, also in stdin
- *               CODESHELL_HOOK_CWD     — repo root for context-aware hooks
- *               (callers may add more by reading process.env directly)
- *
- *   timeout     Defaults to 60_000 ms; settings.timeout_ms overrides.
- *               On timeout we SIGTERM then SIGKILL, log, and return {}.
- */
-import type { HookContext, HookResult } from "./events.js";
-import type { SettingsHookConfig } from "../types.js";
-/**
- * Run one shell-hook command and return the parsed HookResult. Catches
- * every failure mode (spawn error, timeout, malformed JSON) and
- * returns an empty result so the registry's chain keeps going.
- */
-export declare function runShellHook(config: SettingsHookConfig, ctx: HookContext): Promise<HookResult>;
-/**
- * Check whether the hook should fire for the current ctx, respecting
- * the optional `matcher` regex. Returns false for non-tool events
- * when matcher is set (matcher only makes sense when ctx.data has a
- * toolName field).
- */
-export declare function shellHookMatches(config: SettingsHookConfig, ctx: HookContext): boolean;

package/dist/llm/api-key-sanitize.d.ts

@@ -1,22 +0,0 @@
-/**
- * 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.
- */
-export type SanitizeResult = {
-    value: string;
-    changed: boolean;
-    warnings: string[];
-};
-export declare function sanitizeApiKey(raw: string): SanitizeResult;
-/**
- * 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 declare function hasNonAsciiPrintable(s: string): boolean;

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

@@ -1,20 +0,0 @@
-/**
- * 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/rules.d.ts

@@ -1,26 +0,0 @@
-/**
- * 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>;