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

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

package/dist/llm/provider-catalog.d.ts

@@ -1,32 +0,0 @@
-/**
- * In-memory catalog of provider credentials. Mirrors settings.providers[]
- * but offers a small API for add/update/remove that validates uniqueness
- * and (for remove) refuses to delete a provider still referenced by a
- * model entry. The caller persists changes back to settings.
- */
-import type { ProviderKindName } from "./provider-kinds.js";
-export interface ProviderConfig {
-    key: string;
-    label?: string;
-    kind: ProviderKindName;
-    baseUrl: string;
-    apiKey?: string;
-    protocol?: "openai-compat" | "anthropic-style";
-    modelsPath?: string;
-    /** Default DeepSeek V4 thinking-mode for this provider. See LLMConfig. */
-    thinking?: "enabled" | "disabled";
-}
-export declare class ProviderCatalog {
-    private byKey;
-    constructor(entries?: ProviderConfig[]);
-    list(): ProviderConfig[];
-    get(key: string): ProviderConfig | undefined;
-    has(key: string): boolean;
-    add(entry: ProviderConfig): void;
-    update(key: string, patch: Partial<ProviderConfig>): void;
-    remove(key: string, opts: {
-        referencedBy: string[];
-    }): void;
-    /** Compute an unused key for a new provider, given a desired base. */
-    deriveKey(base: string): string;
-}

package/dist/llm/provider-kinds.d.ts

@@ -1,21 +0,0 @@
-/**
- * Built-in provider kind metadata.
- *
- * Each kind defines how to talk to that provider family: where its
- * model list lives, what auth header to send, which model IDs to keep
- * (chat-completion only — embeddings / TTS / image generation are
- * filtered out so they don't show up in the model picker).
- */
-export type ProviderKindName = "openai" | "anthropic" | "deepseek" | "zai" | "xai" | "mistral" | "groq" | "google" | "openrouter" | "ollama" | "custom";
-export type ProviderProtocol = "openai-compat" | "anthropic-style" | "gemini" | "ollama";
-export interface ProviderKindMeta {
-    label: string;
-    defaultBaseUrl: string;
-    modelsPath: string;
-    protocol: ProviderProtocol;
-    authHeader: (apiKey: string) => Record<string, string>;
-    chatFilter: (id: string) => boolean;
-    authQuery?: (apiKey: string) => Record<string, string>;
-}
-export declare const PROVIDER_KINDS: Record<ProviderKindName, ProviderKindMeta>;
-export declare function getKindMeta(kind: string): ProviderKindMeta;

package/dist/llm/providers/anthropic.d.ts

@@ -1,19 +0,0 @@
-/**
- * Anthropic Claude provider using @anthropic-ai/sdk.
- */
-import type { LLMConfig, LLMResponse } from "../../types.js";
-import type { CreateMessageOptions } from "../types.js";
-import { LLMClientBase } from "../client-base.js";
-export declare class AnthropicClient extends LLMClientBase {
-    private _client;
-    constructor(config: LLMConfig);
-    protected initClient(): void;
-    private get client();
-    createMessage(options: CreateMessageOptions): Promise<LLMResponse>;
-    private nonStreamMessage;
-    private streamMessage;
-    private processResponse;
-    private buildMessages;
-    private convertTools;
-    private handleApiError;
-}

package/dist/llm/providers/openai.d.ts

@@ -1,64 +0,0 @@
-/**
- * OpenAI GPT provider using openai SDK.
- *
- * Serves every OpenAI-compatible endpoint we support (OpenAI, DeepSeek,
- * OpenRouter, Z.AI, xAI, Mistral, Groq, Gemini-OpenAI-compat, Ollama,
- * custom). Per-(provider, model) request-shape divergence — token-limit
- * field name, rejected sampling params, thinking knob, reasoning echo —
- * is resolved through `capabilitiesFor()`, not hardcoded.
- */
-import type { LLMConfig, LLMResponse } from "../../types.js";
-import type { CreateMessageOptions } from "../types.js";
-import { LLMClientBase } from "../client-base.js";
-interface RunStreamOpts {
-    idleTimeoutMs?: number;
-    requestId?: string;
-    /**
-     * Per-chunk handler — invoked synchronously with the raw chunk for the
-     * provider to do its own parsing. Returns the text delta (or "") for
-     * the watchdog-side text accumulator used in tests.
-     */
-    onChunk?: (chunk: any) => string;
-}
-/**
- * Consume an async iterable of stream chunks with an idle watchdog.
- * Returns the accumulated text — either from onChunk return values, or
- * by extracting choices[0].delta.content from raw chunks (useful in tests
- * that call runStreamWithWatchdog directly without an onChunk handler).
- *
- * The watchdog is active whenever opts.idleTimeoutMs is explicitly provided,
- * or when STREAM_WATCHDOG_CONFIG.enabled is true. When active, each call to
- * iterator.next() races against an idle deadline; if the deadline fires first
- * the function rejects with StreamIdleTimeoutError.
- */
-export declare function runStreamWithWatchdog<T = any>(stream: AsyncIterable<T>, opts?: RunStreamOpts): Promise<string>;
-export declare class OpenAIClient extends LLMClientBase {
-    private _client;
-    private _forceMaxCompletionTokens;
-    constructor(config: LLMConfig);
-    protected initClient(): void;
-    private get client();
-    /**
-     * Resolve the capability descriptor for the current (provider kind, model)
-     * pair. Cached for the lifetime of the client — model never changes
-     * mid-client. `providerKind` defaults to "openai" because legacy LLMConfig
-     * paths (arena, env-derived) don't always populate it; for those, the
-     * built-in rules table treats them as plain OpenAI.
-     */
-    private _capability;
-    private get capability();
-    createMessage(options: CreateMessageOptions): Promise<LLMResponse>;
-    /**
-     * Build the request body honoring the model's capability descriptor.
-     * Centralized so both streaming and non-streaming paths agree on the
-     * exact shape.
-     */
-    private buildRequestBody;
-    private nonStreamMessage;
-    private streamMessage;
-    private processChoice;
-    private buildMessages;
-    private convertTools;
-    private handleApiError;
-}
-export {};

package/dist/llm/retry.d.ts

@@ -1,12 +0,0 @@
-/**
- * Retry classification — which errors trigger an automatic retry of the
- * streaming LLM call?
- *
- * Stream-idle timeouts are retried — the upstream may have just recovered.
- * User-initiated aborts (AbortError) are never retried — the user explicitly
- * asked for the work to stop.
- *
- * Other transient errors (5xx, 429, ECONNRESET) are out of scope for this
- * iteration; add them here as they become observed.
- */
-export declare function isRetryable(err: unknown): boolean;

package/dist/llm/stream-watchdog.d.ts

@@ -1,42 +0,0 @@
-/**
- * Stream Idle Watchdog — guarantees an upper bound on the time a streaming
- * LLM call can spend with no bytes arriving. Without this, a wedged HTTP/2
- * connection can hang the session indefinitely; the SDK's request timeout
- * only covers the initial fetch, not the streaming body.
- *
- * Disabled by default. Enabled via env CODESHELL_ENABLE_STREAM_WATCHDOG=1.
- */
-export interface StreamWatchdogOptions {
-    /** Abort the stream when no chunks arrive within this window. */
-    idleTimeoutMs: number;
-    /** Called when the watchdog decides to abort. */
-    onTimeout: () => void;
-    /**
-     * Called at idleTimeoutMs/2 (or warningMs if provided). Logging only —
-     * the watchdog does not abort on warning. The argument is the configured
-     * warning threshold (NOT real-time elapsed) so callers can format the log
-     * without re-deriving it.
-     */
-    onWarning?: (warnThresholdMs: number) => void;
-    /** Override the warning trigger; defaults to idleTimeoutMs / 2. */
-    warningMs?: number;
-}
-export interface StreamWatchdog {
-    /** Re-arm both timers — call after every chunk. */
-    reset(): void;
-    /** Clear all timers permanently — call in finally. */
-    dispose(): void;
-}
-export declare class StreamIdleTimeoutError extends Error {
-    idleMs: number;
-    requestId?: string | undefined;
-    readonly kind = "stream-idle-timeout";
-    constructor(idleMs: number, requestId?: string | undefined);
-}
-export declare function createStreamWatchdog(opts: StreamWatchdogOptions): StreamWatchdog;
-/** Environment-driven defaults. Read once at import time is fine — these never change inside a process. */
-export declare const STREAM_WATCHDOG_CONFIG: {
-    enabled: boolean;
-    idleTimeoutMs: number;
-    retries: number;
-};

package/dist/llm/token-counter.d.ts

@@ -1,17 +0,0 @@
-/**
- * Token counter — best-effort live token count for streaming output.
- *
- * Uses gpt-tokenizer's cl100k_base encoding. It's exact for GPT-4 family and
- * close enough (within ~10%) for Claude/DeepSeek/Qwen for the purpose of a
- * live counter in the UI. The authoritative number is still the provider's
- * `usage` field, captured at end-of-stream.
- *
- * The encoder is lazy-initialized on first use so we don't pay the cost on
- * startup for sessions that never stream.
- */
-/**
- * Count tokens in `text`. Synchronous. If the encoder isn't loaded yet,
- * falls back to chars/4 — only happens for the very first stream chunk in a
- * cold process.
- */
-export declare function countTokens(text: string): number;

package/dist/llm/types.d.ts

@@ -1,37 +0,0 @@
-/**
- * LLM-specific internal types.
- */
-import type { Message, ToolDefinition, LLMStreamChunk, TokenUsage } from "../types.js";
-export interface CreateMessageOptions {
-    systemPrompt: string;
-    messages: Message[];
-    tools?: ToolDefinition[];
-    temperature?: number;
-    maxTokens?: number;
-    stream?: boolean;
-    onChunk?: (chunk: LLMStreamChunk) => void;
-    signal?: AbortSignal;
-    /**
-     * If false, this call's usage is excluded from the client's usage tracker
-     * and from the process-wide onUsage hook. Used for auxiliary sub-calls
-     * (tool-summary, future helper prompts) that should not appear in
-     * session_end.cost or skew turn/requestCount semantics.
-     * @default true
-     */
-    recordUsage?: boolean;
-    /**
-     * DeepSeek V4 thinking-mode switch. "enabled" is the endpoint default;
-     * "disabled" turns reasoning off (faster, cheaper, no `reasoning_content`
-     * on the reply). Ignored by every provider except DeepSeek V4 — the OpenAI
-     * SDK forwards unknown top-level fields verbatim, so it's harmless on
-     * other compatible endpoints.
-     */
-    thinking?: "enabled" | "disabled";
-}
-export interface LLMUsageTracker {
-    records: TokenUsage[];
-    totalPromptTokens: number;
-    totalCompletionTokens: number;
-    totalTokens: number;
-    requestCount: number;
-}

package/dist/logging/logger.d.ts

@@ -1,102 +0,0 @@
-/**
- * Unified file logger for code-shell.
- *
- * Sinks (JSON Lines), routed by `cat`:
- *   ~/.code-shell/logs/ui-ink-YYYY-MM-DD.log
- *     — UI/ink chatter: stream events, ctx render, ink screen diffs.
- *   ~/.code-shell/logs/engine-YYYY-MM-DD.log
- *     — everything else: engine, llm, tool, context, mcp, sandbox, ...
- *
- * Routing is by entry `cat`: cat ∈ {ui, ink, render, stream} → ui-ink bucket;
- * anything else → engine bucket. Run scripts/logs.sh to query both at once
- * (merge sorted by timestamp, filter by sid, etc).
- *
- * Level defaults:
- *   - Local dev (CODE_SHELL_DEV=1, or running from src/, or --debug)   → "debug"
- *   - Otherwise                                                         → "info"
- *   - CODE_SHELL_LOG_LEVEL overrides everything.
- *
- * Category filter (--debug=mcp,api or CODE_SHELL_DEBUG=mcp,api):
- *   When set, only debug logs whose `cat` matches are written.
- *
- * Disable entirely: CODE_SHELL_LOG=0
- */
-export type LogLevel = "debug" | "info" | "warn" | "error";
-export declare function setCurrentSid(sid: string): void;
-export declare function getCurrentSid(): string;
-/**
- * Run `fn` inside an ALS scope tagged with `sid`. All log lines emitted
- * synchronously or via `await` inside `fn` resolve `getCurrentSid()` to
- * this `sid` — concurrent Engine.run invocations no longer race on a
- * module global.
- */
-export declare function runWithSid<T>(sid: string, fn: () => T | Promise<T>): T | Promise<T>;
-/**
- * Bind `sid` to the *current* async context without needing a callback.
- * The binding lasts until the current async stack unwinds; concurrent
- * sibling async chains keep their own bindings. Engine.run uses this so
- * we don't have to indent the entire (long) method body into a callback.
- */
-export declare function enterSid(sid: string): void;
-export declare function getInMemoryErrors(): ReadonlyArray<{
-    msg: string;
-    t: string;
-    data?: unknown;
-}>;
-export type ErrorLogSink = {
-    logError: (error: Error) => void;
-    logMCPError: (serverName: string, error: unknown) => void;
-    logMCPDebug: (serverName: string, message: string) => void;
-    getErrorsPath: () => string;
-    getMCPLogsPath: (serverName: string) => string;
-};
-export declare function attachErrorLogSink(sink: ErrorLogSink): void;
-export interface LogContext {
-    cat?: string;
-    sid?: string;
-    [key: string]: unknown;
-}
-declare class Logger {
-    private readonly context;
-    private readonly enabled;
-    private readonly minLevel;
-    private readonly categoryFilter;
-    private readonly stderrEcho;
-    private dirReady;
-    constructor(context?: LogContext);
-    child(extra: LogContext): Logger;
-    /**
-     * Set the session id stamped on every subsequent log entry written by
-     * any logger in the process. Called by Engine once a run's
-     * authoritative session id is known.
-     */
-    setSid(sid: string): void;
-    getSid(): string;
-    debug(msg: string, data?: Record<string, unknown>): void;
-    info(msg: string, data?: Record<string, unknown>): void;
-    warn(msg: string, data?: Record<string, unknown>): void;
-    error(msgOrErr: string | Error | unknown, data?: Record<string, unknown> | Error): void;
-    private recordError;
-    private write;
-    getMinLevel(): LogLevel;
-    isCategoryActive(cat: string): boolean;
-    /**
-     * Open a span: writes a `<name>.begin` debug entry now and returns a handle
-     * whose `end()` writes `<name>.end` with `duration_ms` populated. Use for
-     * any "I want begin → end + how long" pattern (tool exec, LLM request,
-     * permission ask, etc.) so the begin/end pair is grouped under one cat
-     * and the duration is computed once instead of by hand from timestamps.
-     */
-    span(name: string, data?: Record<string, unknown>): LogSpan;
-}
-export interface LogSpan {
-    end(extra?: Record<string, unknown>): void;
-    fail(err: unknown, extra?: Record<string, unknown>): void;
-}
-export declare const logger: Logger;
-export declare function getLogsDir(): string;
-export declare function getRecentLogs(n?: number): string[];
-export declare function rotateLogs(): void;
-/** @internal — for tests */
-export declare function _resetLoggerStateForTesting(): void;
-export {};