@wrongstack/core 0.1.0

package/dist/secret-scrubber-Dax_Ou_o.d.ts

@@ -0,0 +1,1055 @@
+/**
+ * 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>;
+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;
+    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;
+}
+
+interface TextBlock {
+    type: 'text';
+    text: string;
+    cache_control?: {
+        type: 'ephemeral';
+    };
+}
+interface ToolUseBlock {
+    type: 'tool_use';
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+}
+interface ToolResultBlock {
+    type: 'tool_result';
+    tool_use_id: string;
+    /**
+     * The original tool name. Useful for providers like Google Gemini that
+     * need the tool name in `functionResponse.name` — the tool_use_id is
+     * only a session-local identifier and is not stable across replays.
+     * Always set by ToolExecutor; may be absent on manually-constructed blocks.
+     */
+    name?: string;
+    content: string;
+    is_error?: boolean;
+}
+interface ImageBlock {
+    type: 'image';
+    source: {
+        type: 'base64' | 'url';
+        media_type?: string;
+        data?: string;
+        url?: string;
+    };
+}
+type ContentBlock = TextBlock | ToolUseBlock | ToolResultBlock | ImageBlock;
+declare function isTextBlock(b: ContentBlock): b is TextBlock;
+declare function isToolUseBlock(b: ContentBlock): b is ToolUseBlock;
+declare function isToolResultBlock(b: ContentBlock): b is ToolResultBlock;
+declare function isImageBlock(b: ContentBlock): b is ImageBlock;
+
+type MessageRole = 'user' | 'assistant' | 'system';
+interface Message {
+    role: MessageRole;
+    content: string | ContentBlock[];
+}
+declare function asBlocks(content: string | ContentBlock[]): ContentBlock[];
+declare function asText(content: string | ContentBlock[]): string;
+
+interface SessionMetadata {
+    id: string;
+    title?: string;
+    model?: string;
+    provider?: string;
+    startedAt: string;
+    endedAt?: string;
+}
+type SessionEvent = {
+    type: 'session_start';
+    ts: string;
+    id: string;
+    model: string;
+    provider: string;
+} | {
+    type: 'session_resumed';
+    ts: string;
+    id: string;
+    model: string;
+    provider: string;
+} | {
+    type: 'user_input';
+    ts: string;
+    content: string | ContentBlock[];
+} | {
+    type: 'llm_request';
+    ts: string;
+    model: string;
+    messageCount: number;
+} | {
+    type: 'llm_response';
+    ts: string;
+    content: ContentBlock[];
+    stopReason: string;
+    usage: Usage;
+} | {
+    type: 'tool_use';
+    ts: string;
+    name: string;
+    id: string;
+    input: unknown;
+} | {
+    type: 'tool_result';
+    ts: string;
+    id: string;
+    content: unknown;
+    isError: boolean;
+} | {
+    type: 'compaction';
+    ts: string;
+    before: number;
+    after: number;
+} | {
+    type: 'error';
+    ts: string;
+    message: string;
+    phase: string;
+} | {
+    type: 'session_end';
+    ts: string;
+    usage: Usage;
+} | {
+    type: 'mode_changed';
+    ts: string;
+    from: string;
+    to: string;
+} | {
+    type: 'task_created';
+    ts: string;
+    taskId: string;
+    title: string;
+} | {
+    type: 'task_updated';
+    ts: string;
+    taskId: string;
+    status: string;
+} | {
+    type: 'task_completed';
+    ts: string;
+    taskId: string;
+    title: string;
+} | {
+    type: 'task_failed';
+    ts: string;
+    taskId: string;
+    title: string;
+    error: string;
+} | {
+    type: 'agent_spawned';
+    ts: string;
+    agentId: string;
+    role: string;
+} | {
+    type: 'agent_stopped';
+    ts: string;
+    agentId: string;
+} | {
+    type: 'agent_error';
+    ts: string;
+    agentId: string;
+    error: string;
+} | {
+    type: 'spec_parsed';
+    ts: string;
+    specId: string;
+    title: string;
+    completeness: number;
+} | {
+    type: 'spec_analyzed';
+    ts: string;
+    specId: string;
+    gaps: string[];
+} | {
+    type: 'skill_activated';
+    ts: string;
+    skillName: string;
+} | {
+    type: 'skill_deactivated';
+    ts: string;
+    skillName: string;
+} | {
+    type: 'tool_call_start';
+    ts: string;
+    name: string;
+    id: string;
+    input: unknown;
+} | {
+    type: 'tool_call_end';
+    ts: string;
+    name: string;
+    id: string;
+    durationMs: number;
+    outputSize: number;
+} | {
+    type: 'message_truncated';
+    ts: string;
+    before: number;
+    after: number;
+};
+interface SessionSummary {
+    id: string;
+    title: string;
+    startedAt: string;
+    model: string;
+    provider: string;
+    tokenTotal: number;
+}
+interface SessionData {
+    metadata: SessionMetadata;
+    events: SessionEvent[];
+    messages: Message[];
+    usage: Usage;
+}
+interface ResumedSession {
+    writer: SessionWriter;
+    data: SessionData;
+}
+interface SessionStore {
+    create(meta: Omit<SessionMetadata, 'startedAt'>): Promise<SessionWriter>;
+    load(id: string): Promise<SessionData>;
+    /**
+     * Open an existing session for append, returning both a writer that
+     * continues writing to the same JSONL file and the replayed state
+     * (messages + usage) so the caller can hydrate a Context. A
+     * `session_resumed` marker is appended for audit.
+     */
+    resume(id: string): Promise<ResumedSession>;
+    list(limit?: number): Promise<SessionSummary[]>;
+    delete(id: string): Promise<void>;
+}
+interface SessionWriter {
+    readonly id: string;
+    append(event: SessionEvent): Promise<void>;
+    close(): Promise<void>;
+}
+
+interface CacheStats {
+    /** Tokens served from cache (cheaper). */
+    readTokens: number;
+    /** Tokens written into the cache (more expensive than input on first hit). */
+    writeTokens: number;
+    /** Hit ratio: cacheRead / (cacheRead + input). 0 when nothing cached. */
+    hitRatio: number;
+}
+interface TokenCounter {
+    account(usage: Usage, model?: string): void;
+    total(): Usage;
+    estimateCost(): {
+        input: number;
+        output: number;
+        total: number;
+        currency: 'USD';
+    };
+    cacheStats(): CacheStats;
+    reset(): void;
+}
+
+interface TodoItem {
+    id: string;
+    content: string;
+    status: 'pending' | 'in_progress' | 'completed';
+    activeForm?: string;
+}
+interface RunOptions {
+    signal?: AbortSignal;
+    model?: string;
+    executionStrategy?: 'parallel' | 'sequential' | 'smart';
+    maxIterations?: number;
+}
+interface ContextInit {
+    systemPrompt: TextBlock[];
+    provider: Provider;
+    session: SessionWriter;
+    signal: AbortSignal;
+    tokenCounter: TokenCounter;
+    cwd: string;
+    projectRoot: string;
+    model: string;
+    tools?: Tool[];
+}
+declare class Context {
+    messages: Message[];
+    todos: TodoItem[];
+    readFiles: Set<string>;
+    fileMtimes: Map<string, number>;
+    systemPrompt: TextBlock[];
+    provider: Provider;
+    session: SessionWriter;
+    signal: AbortSignal;
+    tokenCounter: TokenCounter;
+    cwd: string;
+    projectRoot: string;
+    model: string;
+    tools: Tool[];
+    meta: Record<string, unknown>;
+    constructor(init: ContextInit);
+    /**
+     * Register a teardown hook tied to the current run's abort signal. The
+     * hook fires when the run aborts OR ends normally — Agent.run wires
+     * this through a RunController. When no run is active the hook fires
+     * immediately so callers don't leak resources.
+     */
+    private abortHooks;
+    registerAbortHook(fn: () => void | Promise<void>): () => void;
+    drainAbortHooks(): Promise<void>;
+    recordRead(absPath: string, mtimeMs: number): void;
+    hasRead(absPath: string): boolean;
+    lastReadMtime(absPath: string): number | undefined;
+    usage(): Usage;
+}
+
+type Permission = 'auto' | 'confirm' | 'deny';
+interface JSONSchema {
+    type?: string;
+    properties?: Record<string, JSONSchema>;
+    required?: string[];
+    items?: JSONSchema;
+    enum?: unknown[];
+    description?: string;
+    [k: string]: unknown;
+}
+interface Tool<I = unknown, O = unknown> {
+    name: string;
+    description: string;
+    usageHint?: string;
+    inputSchema: JSONSchema;
+    permission: Permission;
+    mutating: boolean;
+    maxOutputBytes?: number;
+    timeoutMs?: number;
+    execute(input: I, ctx: Context, opts: {
+        signal: AbortSignal;
+    }): Promise<O>;
+}
+interface ToolCallContext {
+    tool: Tool;
+    input: unknown;
+    callId: string;
+    ctx: Context;
+    signal: AbortSignal;
+}
+
+interface Usage {
+    input: number;
+    output: number;
+    cacheRead?: number;
+    cacheWrite?: number;
+}
+interface Capabilities {
+    tools: boolean;
+    parallelTools: boolean;
+    vision: boolean;
+    streaming: boolean;
+    promptCache: boolean;
+    systemPrompt: boolean;
+    jsonMode: boolean;
+    maxContext: number;
+    cacheControl: 'native' | 'auto' | 'none';
+}
+interface Request {
+    model: string;
+    system?: TextBlock[];
+    messages: Message[];
+    tools?: Tool[];
+    maxTokens: number;
+    temperature?: number;
+    topP?: number;
+    stopSequences?: string[];
+    toolChoice?: 'auto' | 'required' | 'none' | {
+        type: 'tool';
+        name: string;
+    };
+}
+type StopReason = 'end_turn' | 'tool_use' | 'max_tokens' | 'stop_sequence' | 'refusal';
+interface Response {
+    content: ContentBlock[];
+    stopReason: StopReason;
+    usage: Usage;
+    model: string;
+}
+type StreamEvent = {
+    type: 'message_start';
+    model: string;
+} | {
+    type: 'content_block_start';
+    kind: 'text' | 'tool_use';
+    id?: string;
+    name?: string;
+} | {
+    type: 'content_block_stop';
+    index: number;
+} | {
+    type: 'text_delta';
+    text: string;
+} | {
+    type: 'tool_use_start';
+    id: string;
+    name: string;
+} | {
+    type: 'tool_use_input_delta';
+    id: string;
+    partial: string;
+} | {
+    type: 'tool_use_stop';
+    id: string;
+    input: unknown;
+} | {
+    type: 'message_stop';
+    stopReason: StopReason;
+    usage: Usage;
+};
+interface Provider {
+    readonly id: string;
+    readonly capabilities: Capabilities;
+    /** Canonical streaming entry point. `complete()` defaults to a wrapper that
+     * aggregates this stream — providers may override for non-streaming wires. */
+    stream(req: Request, opts: {
+        signal: AbortSignal;
+    }): AsyncIterable<StreamEvent>;
+    complete(req: Request, opts: {
+        signal: AbortSignal;
+    }): Promise<Response>;
+}
+/**
+ * Structured body parsed from a provider's HTTP error response. Populated
+ * best-effort: providers return JSON shaped differently (Anthropic uses
+ * `{error: {type, message}}`, OpenAI uses `{error: {message, code}}`,
+ * Google uses `{error: {status, message}}`), so the fields here are the
+ * intersection that's usable for rendering and routing.
+ */
+interface ProviderErrorBody {
+    /** Provider-specific kind, e.g. "overloaded_error", "rate_limit_error", "invalid_request_error". */
+    type?: string;
+    /** Human-readable explanation from the provider. */
+    message?: string;
+    /** Provider request id, when present in the body or headers. */
+    requestId?: string;
+    /** Parsed Retry-After header (or equivalent body hint) in milliseconds. */
+    retryAfterMs?: number;
+    /** The raw response body (truncated), kept for debugging. */
+    raw?: string;
+}
+declare class ProviderError extends Error {
+    readonly status: number;
+    readonly retryable: boolean;
+    readonly providerId: string;
+    readonly body?: ProviderErrorBody;
+    readonly cause?: unknown;
+    constructor(message: string, status: number, retryable: boolean, providerId: string, opts?: {
+        body?: ProviderErrorBody;
+        cause?: unknown;
+    });
+    /**
+     * Render a one-line, user-facing description. Designed for the CLI/TUI
+     * status line and the agent's retry warning. Avoids dumping raw JSON
+     * (which is what users see today when a 529 lands and the log message
+     * includes the full `{"type":"error",...}` body).
+     *
+     * Examples:
+     *   "minimax-coding-plan overloaded (529): High traffic detected. Upgrade for highspeed model. [req 06534785201de9c0…]"
+     *   "openai rate limited (429): Retry after 12s"
+     *   "anthropic invalid request (400): messages.0.role must be one of 'user'|'assistant'"
+     *   "groq HTTP 500 (server error)"
+     */
+    describe(): string;
+}
+
+/**
+ * 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;
+    };
+    /**
+     * `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': {
+        name: string;
+        durationMs: number;
+        ok: boolean;
+        input?: unknown;
+        output?: string;
+    };
+    'token.threshold': {
+        used: number;
+        limit: number;
+    };
+    'compaction.fired': {
+        before: number;
+        after: number;
+    };
+    '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;
+}
+
+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 ProviderConfig {
+    type: string;
+    apiKey?: 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 {
+    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;
+}
+interface ConfigLoader {
+    load(opts?: {
+        cliFlags?: Partial<Config>;
+        cwd?: string;
+    }): Promise<Config>;
+}
+
+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>;
+}
+
+interface ErrorHandler {
+    recover(err: unknown, ctx: Context): Promise<Response | 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';
+}
+interface SkillLoader {
+    list(): Promise<SkillManifest[]>;
+    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;
+}
+
+export { type StreamEvent as $, ProviderError as A, type ProviderErrorBody as B, type CacheStats as C, type Request as D, type ErrorHandler as E, type FeaturesConfig as F, type ResolvedModel as G, type ResolvedProvider as H, type ImageBlock as I, type JSONSchema as J, type Response as K, type LogConfig as L, type MCPServerConfig as M, type ResumedSession as N, type RetryPolicy as O, type PathResolver as P, type SessionData as Q, type Renderer as R, type SecretScrubber as S, type SessionEvent as T, type SessionMetadata as U, type SessionStore as V, type SessionSummary as W, type SessionWriter as X, type SkillLoader as Y, type SkillManifest as Z, type StopReason as _, type Capabilities as a, type TextBlock as a0, type TokenCounter as a1, type Tool as a2, type ToolCallContext as a3, type ToolResultBlock as a4, type ToolUseBlock as a5, type ToolsConfig as a6, type TrustPolicy as a7, type Usage as a8, type WireFamily as a9, asBlocks as aa, asText as ab, isImageBlock as ac, isTextBlock as ad, isToolResultBlock as ae, isToolUseBlock as af, Context as ag, Container as ah, EventBus as ai, type EventName as aj, type Listener as ak, type BindOptions as al, type ContextInit as am, type Decorator as an, type EventLogger as ao, type EventMap as ap, type Factory as aq, type Middleware as ar, type MiddlewareHandler as as, type NextFn as at, Pipeline as au, type PipelineOptions as av, type RunOptions as aw, type TodoItem as ax, type Token as ay, type ReadonlyPipeline as az, type CompactReport as b, type Compactor as c, type Config as d, type ConfigLoader as e, type ContentBlock as f, type ContextConfig as g, type InputReader as h, type LogLevel as i, type Logger as j, type MemoryEntry as k, type MemoryScope as l, type MemoryStore as m, type Message as n, type MessageRole as o, type ModelsDevModel as p, type ModelsDevPayload as q, type ModelsDevProvider as r, type ModelsRegistry as s, type Permission as t, type PermissionDecision as u, type PermissionPolicy as v, type PluginConfig as w, type PromptOption as x, type Provider as y, type ProviderConfig as z };