@cjhyy/code-shell 0.2.0 → 0.5.0-rc.1

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

@@ -1,97 +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;
-}
-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 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,35 +0,0 @@
-/**
- * Hook event type definitions.
- */
-/**
- * Lifecycle hooks the engine emits.
- *
- * **Currently emitted** (handlers registered here will actually fire):
- *   - on_agent_start / on_agent_end        (engine.ts)
- *   - on_turn_start / on_turn_end          (turn-loop.ts)
- *   - pre_tool_use / post_tool_use         (executor.ts)
- *   - on_tool_start / on_tool_end          (executor.ts)
- *   - file_changed                         (executor.ts, Write/Edit only)
- *
- * **Reserved / not-yet-emitted** (defined so downstream can register handlers
- * in anticipation; wire the emitter before relying on them):
- *   - on_permission_check / on_session_start / on_session_end
- *   - user_prompt_submit / pre_compact / post_compact / notification
- */
-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";
-}

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/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>;

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

@@ -1,108 +0,0 @@
-/**
- * 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 {
-    /** 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/client-base.d.ts

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

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

@@ -1,10 +0,0 @@
-/**
- * LLM provider factory with registry pattern.
- */
-import type { LLMConfig } from "../types.js";
-import type { LLMClientBase } from "./client-base.js";
-type ProviderConstructor = new (config: LLMConfig) => LLMClientBase;
-declare const PROVIDER_REGISTRY: Map<string, ProviderConstructor>;
-export declare function registerProvider(name: string, cls: ProviderConstructor): void;
-export declare function createLLMClient(config: LLMConfig): Promise<LLMClientBase>;
-export { PROVIDER_REGISTRY };

package/dist/llm/model-cache.d.ts

@@ -1,21 +0,0 @@
-/**
- * Cache file IO for per-provider model lists.
- *
- * One file per provider key under <cacheDir>/<providerKey>.json. TTL is
- * 7 days. Callers decide whether to honor staleness — readCache just
- * reads, isStale just checks. Malformed/missing files yield undefined.
- */
-export interface CachedModel {
-    id: string;
-    contextLength: number;
-    maxOutputTokens: number;
-}
-export interface ModelCacheFile {
-    fetchedAt: string;
-    providerKey: string;
-    models: CachedModel[];
-}
-export declare function readCache(cacheDir: string, providerKey: string): ModelCacheFile | undefined;
-export declare function writeCache(cacheDir: string, providerKey: string, models: CachedModel[]): ModelCacheFile;
-export declare function isStale(file: ModelCacheFile, now?: number): boolean;
-export declare function defaultCacheDir(): string;

package/dist/llm/model-fetcher.d.ts

@@ -1,29 +0,0 @@
-/**
- * Fetch a provider's model list from its official /v1/models endpoint
- * (or the local OpenRouter snapshot). Normalizes wildly different
- * response shapes into a uniform `CachedModel[]`, applies the kind's
- * chat-only filter, and writes to disk cache.
- *
- * Network failures don't throw — they return `{ models: [], error }`
- * so the UI can prompt the user to refresh later or fall back to
- * manual entry.
- */
-import { type ProviderKindName } from "./provider-kinds.js";
-import { type ModelCacheFile } from "./model-cache.js";
-export interface FetcherProvider {
-    key: string;
-    kind: ProviderKindName;
-    baseUrl: string;
-    apiKey: string | undefined;
-    modelsPath?: string;
-}
-export interface FetchOptions {
-    cacheDir: string;
-    refresh?: boolean;
-    timeoutMs?: number;
-}
-export interface FetchResult extends ModelCacheFile {
-    error?: string;
-    fromCache?: boolean;
-}
-export declare function fetchModelList(provider: FetcherProvider, opts: FetchOptions): Promise<FetchResult>;

package/dist/llm/model-pool.d.ts

@@ -1,84 +0,0 @@
-/**
- * ModelPool — runtime model registry.
- *
- * Holds all available models loaded from settings. Provides:
- *   - `get(key?)` — retrieve a model config by key, or the active one
- *   - `switch(key)` — change the active model
- *   - `list()` — list all available models
- *   - `register(entry)` — add a model at runtime
- *
- * Consumers:
- *   - Engine/TurnLoop: `pool.get()` for the active model
- *   - Arena: `pool.get("sonnet")` to resolve participants by key
- *   - /model command: `pool.switch("haiku")` for hot-swap
- */
-import type { LLMConfig } from "../types.js";
-export interface ModelEntry {
-    /** Short alias: "claude", "sonnet", "haiku", "gpt", "deepseek" */
-    key: string;
-    /** Human-readable label. Auto-generated from model path if not provided. */
-    label?: string;
-    provider: string;
-    /** Full model path: "anthropic/claude-opus-4-6" */
-    model: string;
-    baseUrl?: string;
-    apiKey?: string;
-    maxOutputTokens?: number;
-    /** Per-model context window size. Falls back to config.maxContextTokens → 200_000. */
-    maxContextTokens?: number;
-    /** Optional reference into ProviderCatalog. When set, baseUrl/apiKey
-     *  come from the catalog unless the entry overrides them. */
-    providerKey?: string;
-    /**
-     * Per-model thinking override. Wins over the provider-level setting
-     * (ProviderCatalog entry's `thinking`). Useful when models in the same
-     * provider need different defaults — e.g. DeepSeek V4 Pro off but
-     * V4 Flash on.
-     */
-    thinking?: "enabled" | "disabled";
-}
-export declare class ModelPool {
-    private models;
-    private activeKey;
-    private providerCatalog;
-    private cacheDir;
-    setProviderCatalog(cat: import("./provider-catalog.js").ProviderCatalog): void;
-    setCacheDir(dir: string): void;
-    /**
-     * For each entry in the pool that lacks an explicit maxContextTokens
-     * but has a providerKey, look up the contextLength from the cached
-     * model list and patch it in.
-     */
-    reloadCachedContextWindows(): void;
-    /**
-     * Build a pool from an array of model entries.
-     * The first entry (or the one matching `defaultKey`) becomes active.
-     */
-    constructor(entries?: ModelEntry[], defaultKey?: string);
-    /** Register a model at runtime. */
-    register(entry: ModelEntry): void;
-    /** Fill in known defaults (e.g. context window for DeepSeek V4) when the entry doesn't specify them. */
-    private withBuiltinDefaults;
-    /** Switch the active model. Throws if key not found. */
-    switch(key: string): ModelEntry;
-    /** Get a model by key. No key = active model. Returns undefined if not found. */
-    get(key?: string): ModelEntry | undefined;
-    /** Get the active model key. */
-    getActiveKey(): string | undefined;
-    /** List all registered models. */
-    list(): ModelEntry[];
-    /** Number of registered models. */
-    get size(): number;
-    /** Check if a key exists. */
-    has(key: string): boolean;
-    /**
-     * Build an LLMConfig for a given model entry, merging with a base config
-     * (inherits apiKey, baseUrl, etc. from the base if not set on the entry).
-     */
-    toLLMConfig(entry: ModelEntry, base?: Partial<LLMConfig>): LLMConfig;
-    /**
-     * Build an LLMConfig for the active model (or a specific key),
-     * merging with a base config.
-     */
-    resolveLLMConfig(key?: string, base?: Partial<LLMConfig>): LLMConfig | undefined;
-}