@wrongstack/core 0.1.9 → 0.1.10

package/dist/mode-Pjt5vMS6.d.ts

@@ -1,815 +0,0 @@
-import { U as Usage, a0 as Context, z as ToolProgressEvent, v as Tool, P as Permission, T as TextBlock, c as ContentBlock, k as Response, i as ProviderError } from './provider-txgB0Oq9.js';
-
-/**
- * Container — dependency injection with explicit bind / override / decorate.
- *
- * Invariants:
- *   bind()     — throws if token already bound
- *   override() — throws if nothing to replace
- *   decorate() — stacks; cached value cleared on register
- */
-type Token<T> = symbol & {
-    readonly __type?: T;
-};
-type Factory<T> = (c: Container) => T;
-type Decorator<T> = (inner: T, c: Container) => T;
-interface BindOptions {
-    singleton?: boolean;
-    owner?: string;
-}
-declare class Container {
-    private readonly entries;
-    bind<T>(token: Token<T>, factory: Factory<T>, opts?: BindOptions): void;
-    override<T>(token: Token<T>, factory: Factory<T>, opts?: BindOptions): void;
-    decorate<T>(token: Token<T>, decorator: Decorator<T>, owner?: string): void;
-    resolve<T>(token: Token<T>): T;
-    has<T>(token: Token<T>): boolean;
-    ownerOf<T>(token: Token<T>): string | undefined;
-    /**
-     * Remove a token's binding (along with any decorators stacked on it).
-     * Returns true if the token existed. Use this to withdraw temporary
-     * bindings installed by a short-lived run or plugin — without it, the
-     * entry persists in the map forever.
-     */
-    unbind<T>(token: Token<T>): boolean;
-    /**
-     * Drop every binding. Intended for tests and short-lived CLI invocations
-     * that rebuild the container from scratch. Production code should prefer
-     * `unbind` on the specific tokens it owns.
-     */
-    clear(): void;
-    list(): Array<{
-        token: symbol;
-        owner: string;
-    }>;
-    /**
-     * Inspect a binding's full shape, including decorator count and whether
-     * a singleton value is cached. Returns null if the token is unbound.
-     * Decorator and factory function references are not exposed — only counts
-     * and metadata, to keep internal state hidden.
-     */
-    inspect<T>(token: Token<T>): {
-        owner: string;
-        singleton: boolean;
-        decoratorCount: number;
-        cached: boolean;
-    } | null;
-}
-
-/**
- * Pipeline — Koa-style middleware chain with named middleware
- * and position-aware insertion. Generic over input type T.
- */
-type NextFn<T> = (value: T) => Promise<T>;
-type MiddlewareHandler<T> = (value: T, next: NextFn<T>) => Promise<T>;
-/**
- * Called when a middleware crashes (throws or rejects). Used by the
- * Pipeline's error boundary to log the offender without aborting the run.
- *
- * Return `'rethrow'` to propagate the error (default for core middleware),
- * or `'swallow'` to skip past the crashing middleware and continue with the
- * value the previous one produced. Plugin middleware should usually be
- * swallowed so one bad plugin can't kill an agent run.
- */
-type PipelineErrorPolicy = 'rethrow' | 'swallow';
-interface PipelineErrorEvent {
-    middleware: string;
-    owner?: string;
-    err: unknown;
-}
-type PipelineErrorHandler = (ev: PipelineErrorEvent) => PipelineErrorPolicy | Promise<PipelineErrorPolicy>;
-interface Middleware<T> {
-    name: string;
-    handler: MiddlewareHandler<T>;
-    owner?: string;
-}
-interface PipelineOptions {
-    /** When true and the target middleware is not found, operations silently no-op instead of throwing. */
-    optional?: boolean;
-}
-/**
- * Read-only view of a pipeline. Returned to consumers (plugins, hooks)
- * so they can inspect but not mutate the chain.
- */
-interface ReadonlyPipeline<T> {
-    readonly size: number;
-    list(): readonly string[];
-    run(input: T): Promise<T>;
-}
-declare class Pipeline<T> {
-    private readonly chain;
-    private errorHandler?;
-    /**
-     * Install an error boundary. When a middleware throws or rejects, the
-     * handler is called and decides whether to swallow (continue with the
-     * pre-handler value) or rethrow. Without a handler, errors propagate.
-     *
-     * Wire one per pipeline at boot — the host CLI typically installs a
-     * single boundary that logs to the operational log and emits a
-     * `pipeline.error` event for /diag.
-     */
-    setErrorHandler(handler: PipelineErrorHandler | undefined): this;
-    use(mw: Middleware<T> | Middleware<unknown>): this;
-    prepend(mw: Middleware<T>): this;
-    /**
-     * Insert middleware at an explicit index. Out-of-range indices are clamped.
-     * Use this when insertBefore/insertAfter are insufficient (e.g. to place
-     * a middleware at a known position regardless of named targets).
-     */
-    insertAt(index: number, mw: Middleware<T>): this;
-    /**
-     * Insert mw immediately before the first occurrence of target.
-     * If called multiple times with the same target, each call inserts
-     * before the target's current position — so after insertBefore('B', X)
-     * then insertBefore('B', Y), the order is Y → X → B.
-     */
-    insertBefore(target: string, mw: Middleware<T>, opts?: PipelineOptions): this;
-    /**
-     * Insert mw immediately after the first occurrence of target.
-     * If called multiple times with the same target, each call inserts
-     * after the target's current position — so after insertAfter('B', X)
-     * then insertAfter('B', Y), the order is B → X → Y.
-     */
-    insertAfter(target: string, mw: Middleware<T>, opts?: PipelineOptions): this;
-    replace(target: string, mw: Middleware<T>, opts?: PipelineOptions): this;
-    remove(name: string, opts?: PipelineOptions): this;
-    list(): readonly string[];
-    size(): number;
-    /** Return a read-only view suitable for passing to plugins. */
-    asReadonly(): ReadonlyPipeline<T>;
-    run(input: T): Promise<T>;
-    private indexOf;
-    private ensureUnique;
-}
-
-/**
- * EventBus — observe-only typed event bus.
- * Subscribers cannot modify or cancel. Subscriber exceptions are caught.
- */
-
-interface EventMap {
-    'session.started': {
-        id: string;
-    };
-    'session.ended': {
-        id: string;
-        usage: Usage;
-    };
-    'session.damaged': {
-        sessionId: string;
-        detail: string;
-    };
-    'iteration.started': {
-        ctx: Context;
-        index: number;
-    };
-    'iteration.completed': {
-        ctx: Context;
-        index: number;
-    };
-    /**
-     * Fired when the agent hits its iteration limit. Listeners (CLI/TUI) can
-     * call `grant(extra)` to allow more iterations, or `deny()` to stop.
-     * If no listener responds within 30s the run ends with 'max_iterations'.
-     */
-    'iteration.limit_reached': {
-        currentIterations: number;
-        currentLimit: number;
-        grant: (extraIterations: number) => void;
-        deny: () => void;
-    };
-    'provider.response': {
-        ctx: Context;
-        usage: Usage;
-        stopReason: string;
-    };
-    'provider.text_delta': {
-        ctx: Context;
-        text: string;
-    };
-    'provider.tool_use_start': {
-        ctx: Context;
-        id: string;
-        name: string;
-    };
-    'provider.tool_use_stop': {
-        ctx: Context;
-        id: string;
-    };
-    /**
-     * Fired before each retry of a failed provider call. `attempt` is 1-based
-     * (the first retry is attempt 1, etc.). `description` is the human-readable
-     * one-liner from `ProviderError.describe()` — render this in the CLI/TUI
-     * instead of grepping logger output for the raw JSON body.
-     */
-    'provider.retry': {
-        providerId: string;
-        attempt: number;
-        delayMs: number;
-        status: number;
-        description: string;
-    };
-    /**
-     * Fired once when a provider call ultimately fails (retries exhausted, or
-     * non-retryable error). Same shape as `provider.retry` minus the delay.
-     */
-    'provider.error': {
-        providerId: string;
-        status: number;
-        description: string;
-        retryable: boolean;
-    };
-    'tool.started': {
-        name: string;
-        id: string;
-        input?: unknown;
-    };
-    /**
-     * Fired for each ToolProgressEvent yielded by `Tool.executeStream`. UIs
-     * subscribe to render incremental progress (streaming bash output, file
-     * tree counts, etc.) without the tool having to know about the UI.
-     */
-    'tool.progress': {
-        name: string;
-        id: string;
-        event: ToolProgressEvent;
-    };
-    /**
-     * Fired when a tool call needs user confirmation and no confirmHandler
-     * is registered on the executor. The TUI renders a confirmation dialog
-     * from this event. Resolution is driven by calling the resolve function
-     * passed in the payload with a decision string ('yes' | 'no' | 'always' | 'deny').
-     */
-    'tool.confirm_needed': {
-        tool: Tool;
-        input: unknown;
-        toolUseId: string;
-        suggestedPattern: string;
-        resolve: (decision: 'yes' | 'no' | 'always' | 'deny') => void;
-    };
-    /**
-     * `output` is a truncated preview of the tool's serialized result text
-     * (capped at ~400 chars by the emitter). UIs render this inline in the
-     * tool history line without re-fetching from the session log.
-     */
-    'tool.executed': {
-        /**
-         * The tool_use id (e.g. "toolu_…") issued by the provider for this call.
-         * Pairs with `tool.started.id` so subscribers can correlate start/finish
-         * even when the model fires multiple tools in parallel with identical
-         * inputs. Optional only for legacy emit sites — new code should always
-         * set it.
-         */
-        id?: string;
-        name: string;
-        durationMs: number;
-        ok: boolean;
-        input?: unknown;
-        output?: string;
-    };
-    'token.threshold': {
-        used: number;
-        limit: number;
-    };
-    'compaction.fired': {
-        before: number;
-        after: number;
-    };
-    /**
-     * Fired when the auto-compaction middleware's compactor.compact() call
-     * throws. Compaction is best-effort by design so we don't crash the agent
-     * loop, but a persistent failure (misconfigured summarizer model, network
-     * outage) means the next iteration may hit context overflow. Observability
-     * layers / dashboards subscribe to this to surface the silent regression.
-     */
-    'compaction.failed': {
-        err: Error;
-        aggressive: boolean;
-        level: 'warn' | 'soft' | 'hard';
-        tokens: number;
-        maxContext: number;
-        load: number;
-        fatal: boolean;
-    };
-    'mcp.server.connected': {
-        name: string;
-        toolCount: number;
-    };
-    'mcp.server.reconnected': {
-        name: string;
-        toolCount: number;
-    };
-    'mcp.server.disconnected': {
-        name: string;
-        reason: string;
-    };
-    'token.cost_estimate_unavailable': {
-        model: string;
-    };
-    error: {
-        err: Error;
-        phase: string;
-    };
-}
-type EventName = keyof EventMap;
-type Listener<E extends EventName> = (payload: EventMap[E]) => void;
-interface EventLogger {
-    error(msg: string, ctx?: unknown): void;
-}
-declare class EventBus {
-    private readonly listeners;
-    private logger?;
-    setLogger(logger: EventLogger): void;
-    on<E extends EventName>(event: E, fn: Listener<E>): () => void;
-    off<E extends EventName>(event: E, fn: Listener<E>): void;
-    once<E extends EventName>(event: E, fn: Listener<E>): () => void;
-    emit<E extends EventName>(event: E, payload: EventMap[E]): void;
-    clear(): void;
-    /**
-     * V2-D: introspection helper. Pass an `event` to count handlers for a
-     * single key, or omit to get the total across every event. Used by the
-     * leak-detection smoke test to flag handler accumulation across runs.
-     */
-    listenerCount(event?: EventName): number;
-}
-
-type LogLevel = 'error' | 'warn' | 'info' | 'debug' | 'trace';
-interface Logger {
-    level: LogLevel;
-    error(msg: string, ctx?: unknown): void;
-    warn(msg: string, ctx?: unknown): void;
-    info(msg: string, ctx?: unknown): void;
-    debug(msg: string, ctx?: unknown): void;
-    trace(msg: string, ctx?: unknown): void;
-    child(bindings: Record<string, unknown>): Logger;
-}
-
-type MemoryScope = 'project-agents' | 'project-memory' | 'user-memory';
-interface MemoryEntry {
-    scope: MemoryScope;
-    text: string;
-    ts: string;
-}
-interface MemoryStore {
-    readAll(): Promise<string>;
-    read(scope: MemoryScope): Promise<string>;
-    remember(text: string, scope?: MemoryScope): Promise<void>;
-    forget(query: string, scope?: MemoryScope): Promise<number>;
-    consolidate(scope: MemoryScope): Promise<void>;
-    clear(scope?: MemoryScope): Promise<void>;
-}
-
-interface TrustPolicy {
-    [toolNameOrPattern: string]: {
-        allow?: string[];
-        deny?: string[];
-        auto?: boolean;
-        trustWorkdir?: boolean;
-        denyPrivate?: boolean;
-    };
-}
-interface PermissionDecision {
-    permission: Permission;
-    reason?: string;
-    source: 'default' | 'trust' | 'yolo' | 'user' | 'deny';
-}
-interface PermissionPolicy {
-    evaluate(tool: Tool, input: unknown, ctx: Context): Promise<PermissionDecision>;
-    trust(rule: {
-        tool: string;
-        pattern: string;
-    }): Promise<void>;
-    reload(): Promise<void>;
-}
-
-interface CompactReport {
-    before: number;
-    after: number;
-    reductions: {
-        phase: 'elision' | 'summary' | 'selective';
-        saved: number;
-    }[];
-}
-interface Compactor {
-    compact(ctx: Context, opts?: {
-        aggressive?: boolean;
-    }): Promise<CompactReport>;
-}
-
-interface PathResolver {
-    readonly projectRoot: string;
-    readonly cwd: string;
-    resolve(input: string): string;
-    isInsideRoot(absPath: string): boolean;
-    ensureInsideRoot(absPath: string): string;
-    detectProjectRoot(start: string): string;
-}
-
-/**
- * Mirror of the models.dev/api.json schema. Top-level is keyed by provider id.
- * We keep `unknown` for fields we don't read so the cached payload stays faithful.
- */
-interface ModelsDevModel {
-    id: string;
-    name: string;
-    family?: string;
-    attachment?: boolean;
-    reasoning?: boolean;
-    tool_call?: boolean;
-    temperature?: boolean;
-    knowledge?: string;
-    release_date?: string;
-    last_updated?: string;
-    open_weights?: boolean;
-    modalities?: {
-        input?: string[];
-        output?: string[];
-    };
-    cost?: {
-        input?: number;
-        output?: number;
-        cache_read?: number;
-        cache_write?: number;
-        [k: string]: number | undefined;
-    };
-    limit?: {
-        context?: number;
-        output?: number;
-    };
-    [k: string]: unknown;
-}
-interface ModelsDevProvider {
-    id: string;
-    name: string;
-    /** Env vars that hold the API key, in priority order. */
-    env?: string[];
-    /** Identifies the wire format family (e.g. @ai-sdk/anthropic). */
-    npm?: string;
-    /** Default base URL when not provided by SDK defaults. */
-    api?: string;
-    /** Documentation URL. */
-    doc?: string;
-    models: Record<string, ModelsDevModel>;
-}
-type ModelsDevPayload = Record<string, ModelsDevProvider>;
-/**
- * Canonical wire-format families WrongStack knows how to speak natively.
- * Used by the provider registry to pick a transport.
- */
-type WireFamily = 'anthropic' | 'openai' | 'openai-compatible' | 'google' | 'unsupported';
-interface ResolvedProvider {
-    id: string;
-    name: string;
-    family: WireFamily;
-    apiBase?: string;
-    envVars: string[];
-    doc?: string;
-    models: ModelsDevModel[];
-    npm?: string;
-}
-interface ResolvedModel {
-    providerId: string;
-    modelId: string;
-    capabilities: {
-        tools: boolean;
-        vision: boolean;
-        reasoning: boolean;
-        maxContext: number;
-        maxOutput?: number;
-        knowledge?: string;
-    };
-    cost?: ModelsDevModel['cost'];
-}
-interface ModelsRegistry {
-    /** Load (from cache or network). Idempotent; second call returns cached value. */
-    load(opts?: {
-        force?: boolean;
-    }): Promise<ModelsDevPayload>;
-    /** Force-refresh from network and overwrite cache. */
-    refresh(): Promise<ModelsDevPayload>;
-    /** All providers, classified by wire family. */
-    listProviders(): Promise<ResolvedProvider[]>;
-    /** A single provider by id, or undefined. */
-    getProvider(id: string): Promise<ResolvedProvider | undefined>;
-    /** A model lookup with capabilities + cost. */
-    getModel(providerId: string, modelId: string): Promise<ResolvedModel | undefined>;
-    /** Suggest a default model for the given provider (latest by release_date). */
-    suggestModel(providerId: string): Promise<string | undefined>;
-    /** Cache freshness in seconds since last successful network fetch (Infinity if never). */
-    ageSeconds(): Promise<number>;
-}
-
-interface ContextConfig {
-    warnThreshold: number;
-    softThreshold: number;
-    hardThreshold: number;
-    /** Enable automatic compaction when thresholds are crossed (default: true). */
-    autoCompact?: boolean;
-    /**
-     * Model used for LLM-assisted summarization in IntelligentCompactor.
-     * Falls back to the main model when omitted.
-     */
-    summarizerModel?: string;
-    /**
-     * Override the effective context window size (in tokens). Use this when
-     * you want the compactor to trigger earlier than the provider's actual
-     * maxContext. Defaults to the provider's reported maxContext.
-     */
-    effectiveMaxContext?: number;
-    maxSessionTokens?: number;
-    maxDailyTokens?: number;
-    preserveK: number;
-    eliseThreshold: number;
-    /** Compactor strategy: 'hybrid' (default, fast rules), 'intelligent' (LLM summarization), 'selective' (LLM-driven selection). */
-    strategy?: 'hybrid' | 'intelligent' | 'selective';
-    /** Enable LLM-driven selective compaction (default: false for backward compat). */
-    llmSelector?: boolean;
-}
-interface ToolsConfig {
-    defaultExecutionStrategy: 'parallel' | 'sequential' | 'smart';
-    maxIterations: number;
-    iterationTimeoutMs: number;
-    sessionTimeoutMs: number;
-    perIterationOutputCapBytes: number;
-    /**
-     * When true (default), the agent automatically extends its iteration
-     * limit by 100 when hit. Set to false to require user confirmation.
-     */
-    autoExtendLimit?: boolean;
-}
-interface ProviderApiKey {
-    /** Short human-readable label (e.g. "personal", "work", "rate-limit-backup"). */
-    label: string;
-    /**
-     * The key itself. The field name contains `apiKey` so the secret-vault
-     * walker will encrypt it on write and decrypt it on read.
-     */
-    apiKey: string;
-    /** ISO-8601 timestamp the key was added. */
-    createdAt: string;
-}
-interface ProviderConfig {
-    type: string;
-    /**
-     * Legacy single-key field. Still honored as a fallback when `apiKeys`
-     * is empty. When `apiKeys`/`activeKey` are present, the config loader
-     * mirrors the active entry into this field so downstream consumers
-     * (provider construction, wire adapters) need no changes.
-     */
-    apiKey?: string;
-    /** Multiple keys for the same provider — pick one with `activeKey`. */
-    apiKeys?: ProviderApiKey[];
-    /** Label of the entry in `apiKeys` to use. Defaults to the first one. */
-    activeKey?: string;
-    baseUrl?: string;
-    headers?: Record<string, string>;
-    model?: string;
-    quirks?: Record<string, unknown>;
-    capabilities?: Record<string, unknown>;
-    /**
-     * Optional wire-family override. When present, the provider can be
-     * constructed without consulting the models.dev catalog — useful for
-     * self-hosted endpoints, internal proxies, or for working offline.
-     */
-    family?: WireFamily;
-    /** Custom env var names to probe when `apiKey` is missing. */
-    envVars?: string[];
-    /** Optional list of models the user wants visible for this provider. */
-    models?: string[];
-}
-interface MCPServerConfig {
-    /** Human-readable description shown in `wstack mcp list`. */
-    description?: string;
-    name: string;
-    transport: 'stdio' | 'sse' | 'streamable-http';
-    command?: string;
-    args?: string[];
-    env?: Record<string, string>;
-    url?: string;
-    headers?: Record<string, string>;
-    enabled?: boolean;
-    allowedTools?: string[];
-    permission?: Permission;
-    startupTimeoutMs?: number;
-}
-interface LogConfig {
-    level: 'error' | 'warn' | 'info' | 'debug' | 'trace';
-    file?: string;
-}
-interface PluginConfig {
-    name: string;
-    enabled?: boolean;
-    options?: Record<string, unknown>;
-}
-/**
- * Optional subsystems that the CLI can boot without. The core flow
- * (provider + agent loop + bundled tools + session) always works; these
- * just add capabilities. `--no-features` flips all of these off, which
- * is the minimum viable WrongStack: a single provider, a fixed config,
- * no network calls at startup.
- */
-interface FeaturesConfig {
-    /** Load MCP servers declared in `mcpServers`. */
-    mcp: boolean;
-    /** Load + initialise npm plugins declared in `plugins`. */
-    plugins: boolean;
-    /** Register `remember` / `forget` tools backed by memory store. */
-    memory: boolean;
-    /** Fetch the models.dev catalog at startup. When false, the provider
-     *  must declare its `family` explicitly in `providers[<id>]`. */
-    modelsRegistry: boolean;
-    /** Discover + load skills from disk. */
-    skills: boolean;
-}
-interface Config {
-    version: 1;
-    provider: string;
-    model: string;
-    apiKey?: string;
-    baseUrl?: string;
-    providers?: Record<string, ProviderConfig>;
-    context: ContextConfig;
-    tools: ToolsConfig;
-    mcpServers?: Record<string, MCPServerConfig>;
-    plugins?: (string | PluginConfig)[];
-    log: LogConfig;
-    features: FeaturesConfig;
-    yolo?: boolean;
-    cwd?: string;
-    /**
-     * Per-plugin namespaced config sections. Each plugin reads its own
-     * subtree via `ConfigStore.getExtension(pluginName)`. Plugins should
-     * declare a `configSchema` so the loader validates this section
-     * automatically before `setup()` runs.
-     *
-     * Example:
-     *   extensions: {
-     *     'wstack-auth': { tokenUrl: 'https://...', refreshBefore: 300 },
-     *     'wstack-metrics': { sink: 'prometheus', port: 9090 },
-     *   }
-     */
-    extensions?: Record<string, Record<string, unknown>>;
-}
-interface ConfigLoader {
-    load(opts?: {
-        cliFlags?: Partial<Config>;
-        cwd?: string;
-    }): Promise<Config>;
-}
-/**
- * Subscribable view over Config. Plugins and CLI subsystems use this instead
- * of holding a frozen Config reference, so they can react to runtime updates
- * (e.g. `/model` switching the active provider, secrets rotation, dynamic
- * extension reload).
- *
- * The store enforces immutability — `get()` always returns a frozen object.
- * Updates happen through `update(partial)`, which produces a new Config
- * (structurally cloned, then frozen) and notifies watchers.
- */
-interface ConfigStore {
-    get(): Readonly<Config>;
-    /**
-     * Get a typed top-level section. Convenience for consumers that only
-     * care about one slice (e.g. `tools` or `context`).
-     */
-    getSection<K extends keyof Config>(key: K): Readonly<Config[K]>;
-    /**
-     * Return the extension namespace for `pluginName`, or an empty record
-     * when none is configured. The returned object is frozen.
-     */
-    getExtension(pluginName: string): Readonly<Record<string, unknown>>;
-    /**
-     * Apply a partial update. Returns the new Config. Watchers are notified
-     * synchronously after the update completes. Throws if the result fails
-     * any registered invariants (currently: version must stay 1).
-     */
-    update(partial: Partial<Config>): Readonly<Config>;
-    /** Subscribe to changes. Returns an unsubscribe function. */
-    watch(cb: (next: Readonly<Config>, prev: Readonly<Config>) => void): () => void;
-}
-
-interface Renderer {
-    write(text: string | TextBlock): void;
-    writeLine(text?: string): void;
-    writeBlock(block: ContentBlock): void;
-    writeToolCall(name: string, input: unknown): void;
-    writeToolResult(name: string, content: unknown, isError: boolean): void;
-    writeDiff(unifiedDiff: string): void;
-    writeWarning(text: string): void;
-    writeError(text: string): void;
-    writeInfo(text: string): void;
-    clear(): void;
-}
-
-interface PromptOption {
-    key: string;
-    label: string;
-    value: string;
-}
-interface InputReader {
-    readLine(prompt?: string): Promise<string>;
-    readKey(prompt: string, options: PromptOption[]): Promise<string>;
-    close(): Promise<void>;
-}
-
-type RecoveryDecision = {
-    /**
-     * Recovery mutated state or waited for capacity and the agent should
-     * rebuild the provider request and try the turn again.
-     */
-    action: 'retry';
-    reason: string;
-    model?: string;
-} | {
-    /**
-     * Recovery produced a substitute provider response that should be
-     * processed exactly like a normal model response.
-     */
-    action: 'continue';
-    response: Response;
-    reason?: string;
-} | {
-    /** Recovery inspected the error and decided the agent must fail. */
-    action: 'fail';
-    reason: string;
-    error?: unknown;
-};
-interface ErrorHandler {
-    /**
-     * Attempt to recover from an unretried provider/tool boundary error.
-     *
-     * `null` means "no strategy matched". Non-null decisions are explicit:
-     * retry the current turn, continue with a substitute response, or fail
-     * deliberately. Callers should not infer control flow from truthiness.
-     */
-    recover(err: unknown, ctx: Context): Promise<RecoveryDecision | null>;
-    classify(err: unknown): {
-        kind: 'rate_limit' | 'overloaded' | 'server' | 'client' | 'network' | 'abort' | 'context_overflow' | 'unknown';
-        retryable: boolean;
-    };
-}
-
-interface RetryPolicy {
-    shouldRetry(err: ProviderError | Error, attempt: number): boolean;
-    delayMs(attempt: number): number;
-    maxAttempts(err: ProviderError | Error): number;
-}
-
-interface SkillManifest {
-    name: string;
-    description: string;
-    version?: string;
-    path: string;
-    source: 'project' | 'user' | 'bundled';
-}
-/** Parsed skill entry for structured rendering in system prompt. */
-interface SkillEntry {
-    name: string;
-    /** "Use when..." trigger condition — one-liner */
-    trigger: string;
-    /** Comma-separated scope items */
-    scope: string[];
-    source: SkillManifest['source'];
-    path: string;
-}
-interface SkillLoader {
-    list(): Promise<SkillManifest[]>;
-    /** Structured entries with trigger/scope for system prompt rendering. */
-    listEntries(): Promise<SkillEntry[]>;
-    find(name: string): Promise<SkillManifest | undefined>;
-    manifestText(): Promise<string>;
-    readBody(name: string): Promise<string>;
-}
-
-interface SecretScrubber {
-    scrub(text: string): string;
-    scrubObject<T>(obj: T): T;
-}
-
-interface Mode {
-    id: string;
-    name: string;
-    description: string;
-    /** Additional prompt text injected into system prompt when mode is active */
-    prompt: string;
-    /** Tags for tool_search filtering */
-    tags?: string[];
-    /** Tools that should be prioritized/highlighted when this mode is active */
-    toolPreferences?: string[];
-}
-interface ModeManifest {
-    modes: Mode[];
-    defaultMode?: string;
-}
-interface ModeStore {
-    getActiveMode(): Promise<Mode | null>;
-    setActiveMode(modeId: string | null): Promise<void>;
-    listModes(): Promise<Mode[]>;
-    getMode(modeId: string): Promise<Mode | null>;
-}
-interface ModeConfig {
-    directory: string;
-}
-declare const DEFAULT_MODES: Mode[];
-
-export { type Middleware as $, type ResolvedProvider as A, type RetryPolicy as B, type CompactReport as C, DEFAULT_MODES as D, type ErrorHandler as E, type FeaturesConfig as F, type SkillEntry as G, type SkillLoader as H, type InputReader as I, type SkillManifest as J, type TrustPolicy as K, type LogConfig as L, type MCPServerConfig as M, Container as N, EventBus as O, type PathResolver as P, type EventName as Q, type RecoveryDecision as R, type SecretScrubber as S, type ToolsConfig as T, type Listener as U, type BindOptions as V, type WireFamily as W, type Decorator as X, type EventLogger as Y, type EventMap as Z, type Factory as _, type Compactor as a, type MiddlewareHandler as a0, type NextFn as a1, Pipeline as a2, type PipelineOptions as a3, type Token as a4, type ReadonlyPipeline as a5, type Config as b, type ConfigLoader as c, type ConfigStore as d, type ContextConfig as e, type LogLevel as f, type Logger as g, type MemoryEntry as h, type MemoryScope as i, type MemoryStore as j, type Mode as k, type ModeConfig as l, type ModeManifest as m, type ModeStore as n, type ModelsDevModel as o, type ModelsDevPayload as p, type ModelsDevProvider as q, type ModelsRegistry as r, type PermissionDecision as s, type PermissionPolicy as t, type PluginConfig as u, type PromptOption as v, type ProviderApiKey as w, type ProviderConfig as x, type Renderer as y, type ResolvedModel as z };