@wrongstack/core 0.284.0 → 0.285.0

package/dist/pipeline-DGDyIohT.d.ts

@@ -1,331 +0,0 @@
-import { g as Tool, s as TextBlock, i as ContentBlock } from './tool-BNlnIJvo.js';
-import { a as MailboxAgentStatus } from './mailbox-types-BGZWrYTJ.js';
-import { H as HookEvent, f as HookMatcher, I as InProcessHook, g as HookRegistrationOptions, S as ShellHook, h as HttpHook, C as ConfiguredHook, i as HookEntry, T as ToolResultRenderMode } from './config-MRqn1V-u.js';
-
-/** Model capabilities relevant to prompt composition. */
-interface ModelCapabilities {
-    maxContextTokens: number;
-    supportsTools: boolean;
-    supportsVision: boolean;
-    supportsReasoning: boolean;
-}
-interface BuildContext {
-    cwd: string;
-    projectRoot: string;
-    tools: Tool[];
-    /** Provider id (e.g. "anthropic", "minimax-coding-plan"). */
-    provider?: string | undefined;
-    /** Model id (e.g. "configured-model", "MiniMax-M2.7"). */
-    model?: string | undefined;
-    /**
-     * True when the prompt is being built for a SUBAGENT, not the host
-     * agent. Subagents are scoped to a single task — they should NOT see
-     * the host's strategic plan board (which is anchoring the host across
-     * turns, not steering individual subtasks). The plan-injection
-     * layer short-circuits when this flag is set.
-     */
-    subagent?: boolean | undefined;
-    /**
-     * List of currently online agents in the shared mailbox system.
-     * Includes agents from all sessions (TUI, WebUI, CLI) in the same project.
-     */
-    onlineAgents?: MailboxAgentStatus[] | undefined;
-}
-/**
- * Stability regions for the system prompt.
- *
- * `core` and `session` form the provider-cache prefix and must remain byte-for-byte
- * stable after the first request in a session. `volatile` is appended at request
- * time and may change between turns without rewriting that prefix.
- */
-interface SystemPromptRegions {
-    readonly core: readonly TextBlock[];
-    readonly session: readonly TextBlock[];
-    readonly volatile: readonly TextBlock[];
-}
-declare function flattenSystemPromptRegions(regions: SystemPromptRegions): TextBlock[];
-interface SystemPromptBuilder {
-    build(ctx: BuildContext): Promise<TextBlock[]>;
-    /** Region-aware build used by hosts that enforce prompt-prefix stability. */
-    buildRegions?(ctx: BuildContext): Promise<SystemPromptRegions>;
-}
-
-interface LoadConfiguredHooksOptions {
-    /** Load only trusted hooks that remain active under `--no-hooks`. */
-    policyOnly?: boolean | undefined;
-}
-/**
- * Registry of lifecycle hooks (both in-process and shell). One instance is
- * shared per session: the boot path loads `config.hooks` as shell entries and
- * plugins add in-process entries via `PluginAPI.registerHook`. The
- * `HookRunner` reads from it at each lifecycle phase.
- */
-declare class HookRegistry {
-    private readonly entries;
-    /** Register an in-process hook. Returns an unsubscribe function. */
-    registerInProcess(event: HookEvent, matcher: HookMatcher | undefined, hook: InProcessHook, owner?: string | undefined, options?: HookRegistrationOptions): () => void;
-    /**
-     * Register a single shell hook. The hook is owned by the runtime (no plugin
-     * name) — it survives plugin uninstalls. Returns an unsubscribe function.
-     */
-    registerShell(event: HookEvent, hook: ShellHook): () => void;
-    /** Register a native HTTP hook. */
-    registerHttp(event: HookEvent, hook: HttpHook): () => void;
-    /** Bulk-load command/HTTP hooks from a `config.hooks` map. */
-    loadShellHooks(hooks: Partial<Record<HookEvent, ConfiguredHook[]>> | undefined, options?: LoadConfiguredHooksOptions): void;
-    /**
-     * Atomically replace the shell-hook set: drop every currently-registered
-     * shell entry, then load the supplied `config.hooks` map. In-process
-     * hooks (and their plugin owners) are untouched — only shell entries
-     * are touched, because they are the only entries sourced from
-     * `config.hooks`.
-     *
-     * Designed for hot-reload via `ConfigStore.watch`: when the operator
-     * edits `config.json` and the store fires its watcher, the CLI calls
-     * this with the new `config.hooks` value. Idempotent — calling twice
-     * with the same map yields the same registry state (callers should still
-     * guard at the change-detection layer to avoid wasted work).
-     */
-    replaceShellHooks(hooks: Partial<Record<HookEvent, ConfiguredHook[]>> | undefined, options?: LoadConfiguredHooksOptions): void;
-    /** All entries registered for an event, in registration order. */
-    list(event: HookEvent): readonly HookEntry[];
-    /** True when any entry is registered for the event. */
-    has(event: HookEvent): boolean;
-    /** Every entry currently registered (across all events). */
-    all(): readonly HookEntry[];
-    /**
-     * Drop every in-process hook whose `owner` matches. Used by the plugin
-     * loader during teardown as a belt-and-braces backstop for the per-call
-     * unsubscribe functions pushed onto `pluginCleanupFns` — if a plugin
-     * `setup()` throws partway through after registering some hooks, the
-     * remaining unsubscribes may never run, and the registry would otherwise
-     * hold dangling references to a torn-down plugin's closures.
-     *
-     * Returns the number of hooks actually removed (useful for tests).
-     * Shell hooks are owned by the runtime, not a plugin, so they're never
-     * drained by owner.
-     */
-    drainByOwner(owner: string): number;
-    /** Count of in-process hooks currently registered by `owner`. */
-    countByOwner(owner: string): number;
-    /** Drop every registered hook (used in teardown / tests). */
-    clear(): void;
-    private remove;
-}
-/**
- * Does a hook matcher apply to a tool name? `*` (or empty) matches everything;
- * otherwise the matcher is a case-insensitive pipe-delimited list of exact
- * tool names (`"edit|write"`). Non-tool events pass `undefined` and always match.
- */
-declare function hookMatcherMatches(matcher: HookMatcher, toolName: string | undefined): boolean;
-
-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;
-    /**
-     * Hint the renderer how to display the next {@link writeToolResult} for
-     * `name`. The renderer stores the mode and applies it on the next
-     * `writeToolResult` call. A no-op for renderers that do not implement
-     * per-tool on-screen rendering (the default).
-     */
-    setResultRenderMode?(name: string, mode: ToolResultRenderMode): void;
-}
-
-/**
- * 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 | undefined;
-    owner?: string | undefined;
-}
-declare class Container {
-    private readonly entries;
-    /**
-     * Tokens currently mid-resolve. Tracked so we can detect circular
-     * dependencies (A → B → A) and throw a structured error instead of
-     * overflowing the call stack with "Maximum call stack size exceeded".
-     *
-     * Not a memoization cache — the per-entry `cache` field is the source
-     * of truth for "have I built this before?". This set only lives for
-     * the duration of a single resolve call.
-     */
-    private readonly resolving;
-    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;
-    /**
-     * Build a human-readable description of the dependency cycle that
-     * caused the resolution to re-enter. Lists the tokens in the order
-     * they were entered, then appends the re-entered token to close the
-     * loop. Falls back to a generic message if the resolving set is
-     * somehow empty (shouldn't happen, but defensive).
-     */
-    private describeCycle;
-    has<T>(token: Token<T>): boolean;
-    /**
-     * Resolve a token if it is bound, otherwise return undefined.
-     * Unlike `resolve()`, this does not throw if the token is unbound.
-     *
-     * Single map lookup — `has()` + `resolve()` would walk the entries
-     * map twice. The bound check is folded into the resolve path so a
-     * non-existent token can never enter the `resolving` cycle-detection
-     * set.
-     */
-    safeResolve<T>(token: Token<T>): T | undefined;
-    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 abort descent into the crashing middleware: its caller's
- * `await next()` resolves with the value that was about to flow into the
- * crashed middleware. The crashed middleware AND every middleware after it in
- * the chain are skipped (they never run); UPSTREAM middleware, already paused
- * at their own `await next()`, resume their post-`next()` work normally. It
- * does NOT continue at the next sibling middleware. 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 | undefined;
-    err: unknown;
-}
-type PipelineErrorHandler = (ev: PipelineErrorEvent) => PipelineErrorPolicy | Promise<PipelineErrorPolicy>;
-interface Middleware<T> {
-    name: string;
-    handler: MiddlewareHandler<T>;
-    owner?: string | undefined;
-}
-interface PipelineOptions {
-    /** When true and the target middleware is not found, operations silently no-op instead of throwing. */
-    optional?: boolean | undefined;
-}
-/**
- * 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?;
-    /**
-     * Optional operational logger. When set, the `swallow` error-boundary path
-     * emits a structured warning so a swallowed middleware crash is never
-     * completely silent (P2 #7, before-release.md). Without a logger, the
-     * swallow path still works but the crash is invisible — host code should
-     * always wire one.
-     */
-    private logger?;
-    /**
-     * 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;
-    /**
-     * Set the operational logger used by the swallow error-boundary path.
-     * Without this, a swallowed middleware crash is completely silent.
-     */
-    setLogger(logger: {
-        warn: (msg: string, ctx?: unknown) => void | undefined;
-    } | 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;
-}
-
-export { type BuildContext as B, Container as C, type Decorator as D, type Factory as F, HookRegistry as H, type MiddlewareHandler as M, type NextFn as N, Pipeline as P, type ReadonlyPipeline as R, type SystemPromptBuilder as S, type Token as T, type Renderer as a, type Middleware as b, type ModelCapabilities as c, type SystemPromptRegions as d, type BindOptions as e, type PipelineOptions as f, flattenSystemPromptRegions as g, hookMatcherMatches as h };

package/dist/provider-model-resolve-o2hHLs79.d.ts

@@ -1,263 +0,0 @@
-import { P as Provider, M as Message } from './tool-BNlnIJvo.js';
-import { M as MessageSelector, S as SelectorResult } from './selector-D8O6B_Rm.js';
-import { M as ModeStore, a as ModeConfig, b as Mode } from './mode-CZlO9iU1.js';
-import { M as ModelsRegistry, c as ModelsDevPayload, d as ResolvedProvider, R as ResolvedModel, W as WireFamily, e as ModelsDevModel } from './config-MRqn1V-u.js';
-
-/**
- * Offline **floor** for the ChatGPT "Sign in with ChatGPT" (`openai-codex`)
- * models, mirroring what the official Codex CLI / ChatGPT model picker shows.
- *
- * Source-of-truth precedence (live path wins):
- *  1. The curated overlay `packages/cli/data/providers.json` — provider
- *     `openai-codex` — which is **synced from raw GitHub** + cached + bundled
- *     offline by `DefaultModelsRegistry` (overlayUrl/overlayFile). Editing that
- *     JSON and pushing updates every client without a code release; this is the
- *     authoritative list whenever the registry overlay is wired (the CLI path).
- *  2. This hardcoded table — the last-resort floor used where no overlay is
- *     available (a standalone registry without the bundled file) and by the CLI
- *     auth-menu login flow, which needs a synchronous id list.
- *
- * Keep this in lockstep with the `openai-codex` block in `providers.json`; the
- * drift-guard test `packages/cli/tests/codex-catalog-overlay-sync.test.ts`
- * asserts they agree.
- *
- * Layer note: this lives in `core` (not the CLI auth-menu) so the model-list
- * resolver can read it without `core` depending on `cli`. The CLI's
- * `FALLBACK_CODEX_MODELS` is derived from this list.
- */
-interface CodexModelMeta {
-    /** The wire id sent to the backend and stored in config (e.g. `gpt-5.5`). */
-    id: string;
-    /** Human-readable display name shown in pickers. */
-    name: string;
-    /** One-line capability blurb, matching the official Codex picker copy. */
-    description: string;
-    /** The recommended / latest model — tagged "(current)" in the official UI. */
-    current?: boolean;
-}
-/**
- * Current ChatGPT sign-in models, newest first. The first entry is the
- * recommended default (`current`). Order is significant: callers that need a
- * default model id use `CODEX_MODELS[0]`.
- */
-declare const CODEX_MODELS: ReadonlyArray<CodexModelMeta>;
-/** Look up the canonical metadata for a Codex model id, or `undefined`. */
-declare function codexModelMeta(id: string): CodexModelMeta | undefined;
-
-interface LLMSelectorOptions {
-    /** Provider used for the selector LLM call. Required. */
-    provider: Provider;
-    /** Model for the selector. Defaults to the provider's default model. */
-    model?: string | undefined;
-    /**
-     * Maximum tokens to keep in context (target budget).
-     * Selector will aim to keep total content below this.
-     */
-    maxContextTokens?: number | undefined;
-    /**
-     * Prompt instructing the selector how to behave.
-     * Should guide the LLM on importance tiers and output format.
-     */
-    systemPrompt?: string | undefined;
-    /**
-     * Maximum output tokens for the selector LLM call.
-     * Controls both the JSON response budget and the token reservation for the
-     * history text budget calculation (default: 1024).
-     */
-    maxOutputTokens?: number | undefined;
-}
-/**
- * LLM-powered message selector. Calls a sub-LLM to analyze the
- * message history and produce a keep/collapse plan — more surgical
- * than fixed-window rules.
- */
-declare class LLMSelector implements MessageSelector {
-    private readonly provider;
-    private readonly model;
-    private readonly maxContextTokens;
-    private readonly systemPrompt;
-    private readonly maxOutputTokens;
-    constructor(opts: LLMSelectorOptions);
-    select(messages: Message[], maxToKeep: number): Promise<SelectorResult>;
-    private fallbackSelect;
-    /**
-     * Parse and validate the raw LLM output into a SelectorResult.
-     * Falls back to recency-based selection if the LLM output is malformed,
-     * out-of-bounds, or internally inconsistent.
-     */
-    private parseSelectorOutput;
-}
-
-declare class DefaultModeStore implements ModeStore {
-    private activeModeId;
-    private modes;
-    private configDir;
-    constructor(config: ModeConfig);
-    getActiveMode(): Promise<Mode | null>;
-    setActiveMode(modeId: string | null): Promise<void>;
-    listModes(): Promise<Mode[]>;
-    getMode(modeId: string): Promise<Mode | null>;
-    addMode(mode: Mode): Promise<void>;
-    removeMode(modeId: string): Promise<void>;
-    private loadActiveMode;
-    private saveActiveMode;
-}
-interface ModeLoaderOptions {
-    projectModesDir?: string | undefined;
-    userModesDir?: string | undefined;
-}
-declare function loadProjectModes(modesDir: string): Promise<Mode[]>;
-declare function loadUserModes(modesDir: string): Promise<Mode[]>;
-
-interface DefaultModelsRegistryOptions {
-    cacheFile: string;
-    url?: string | undefined;
-    ttlSeconds?: number | undefined;
-    fetchImpl?: typeof fetch | undefined;
-    /** Pre-seeded payload — useful for offline scenarios and tests. */
-    seed?: ModelsDevPayload | undefined;
-    /**
-     * Maximum age in seconds for stale cache fallback when network fails.
-     * Defaults to 7 days. Set to `Infinity` for full offline resilience
-     * (risk: deprecated models, wrong pricing). Set to `0` to disable
-     * stale fallback entirely.
-     */
-    maxStaleAgeSeconds?: number | undefined;
-    /**
-     * Timeout in milliseconds for the models.dev network fetch. When exceeded,
-     * the fetch is aborted and cache/stale fallback is used instead.
-     * Defaults to 15 seconds. Set to `0` to disable (infinite wait).
-     */
-    refreshTimeoutMs?: number | undefined;
-    /**
-     * Curated override payload deep-merged ON TOP of the models.dev base via
-     * `mergeModelsPayload` — adds providers/models the base lacks and overrides
-     * fields it gets wrong. Resolution order (first non-empty wins): this
-     * in-memory `overlay` → `overlayUrl` (fetched, cached) → `overlayFile`
-     * (bundled, read from disk). A missing/broken overlay degrades to `{}` and
-     * never throws, so the base alone still works.
-     */
-    overlay?: ModelsDevPayload | undefined;
-    /** GitHub-raw (or any) URL serving the curated overlay `providers.json`. */
-    overlayUrl?: string | undefined;
-    /** Path to the bundled overlay `providers.json` (offline floor). */
-    overlayFile?: string | undefined;
-    /** Cache file for the fetched `overlayUrl`. Defaults next to `cacheFile`. */
-    overlayCacheFile?: string | undefined;
-}
-declare function classifyFamily(npm: string | undefined): WireFamily;
-declare class DefaultModelsRegistry implements ModelsRegistry {
-    /** Merged (base + overlay) payload — what every reader sees. */
-    private payload?;
-    /** Memoised overlay payload (in-memory / fetched / file). */
-    private overlayPayload?;
-    /**
-     * Extra providers injected at runtime via `mergeOverlay()` — e.g. an
-     * openai-compatible server (omniroute, LiteLLM, …) auto-discovered from its
-     * `/v1/models` endpoint at boot. Applied LAST (on top of base + curated
-     * overlay) and re-applied across `refresh()` so the discovered catalog
-     * survives a models.dev refetch.
-     */
-    private extraOverlay?;
-    private fetchedAt?;
-    private readonly cacheFile;
-    private readonly url;
-    private readonly ttlMs;
-    private readonly fetchImpl;
-    private readonly seed?;
-    private readonly maxStaleAgeMs;
-    private readonly refreshTimeoutMs;
-    private readonly overlay?;
-    private readonly overlayUrl?;
-    private readonly overlayFile?;
-    private readonly overlayCacheFile?;
-    constructor(opts: DefaultModelsRegistryOptions);
-    load(opts?: {
-        force?: boolean | undefined;
-    }): Promise<ModelsDevPayload>;
-    /**
-     * Merge an additional provider payload on top of the resolved catalog. Used
-     * for runtime-discovered openai-compatible providers. Remembered so it is
-     * re-applied across `refresh()`. A no-op for an empty payload.
-     */
-    mergeOverlay(payload: ModelsDevPayload): void;
-    private withExtraOverlay;
-    /**
-     * Load the models.dev base payload: fresh cache → network → stale cache.
-     * On total failure, degrade to `{}` (so a non-empty overlay still drives
-     * the catalog) rather than throwing — unless there's no curated overlay to
-     * fall back on, in which case the original error propagates so pure-
-     * models.dev setups still surface the problem.
-     */
-    private loadBase;
-    /** Fetch + cache the models.dev base. Throws on failure (used by `refresh`). */
-    private refreshBase;
-    /**
-     * Resolve the curated overlay, memoised. Order: in-memory `overlay` →
-     * fetched `overlayUrl` (cached, same TTL/stale rules) → `overlayFile` on
-     * disk. Never throws — a missing/broken overlay yields `{}`.
-     */
-    private loadOverlay;
-    private loadOverlayFromUrl;
-    private readOverlayFile;
-    refresh(): Promise<ModelsDevPayload>;
-    listProviders(): Promise<ResolvedProvider[]>;
-    getProvider(id: string): Promise<ResolvedProvider | undefined>;
-    getModel(providerId: string, modelId: string): Promise<ResolvedModel | undefined>;
-    suggestModel(providerId: string): Promise<string | undefined>;
-    ageSeconds(): Promise<number>;
-    private resolveProvider;
-    private isFresh;
-    private isWithinMaxStaleAge;
-    private readCacheAt;
-    /** Used by `wstack models refresh` to expose where the cache lives. */
-    cacheLocation(): string;
-}
-
-/**
- * A model descriptor shaped for the WebUI `provider.models` message. All
- * metadata fields are optional because OAuth / subscription providers that
- * models.dev doesn't list contribute only a bare id.
- */
-interface ProviderModelDescriptor {
-    id: string;
-    name: string;
-    /** One-line capability blurb, when known (e.g. the Codex subscription models). */
-    description?: string | undefined;
-    releaseDate?: string | undefined;
-    contextWindow?: number | undefined;
-    inputCost?: number | undefined;
-    outputCost?: number | undefined;
-    capabilities: string[];
-}
-/** Map a models.dev catalog model to the WebUI descriptor shape. */
-declare function describeCatalogModel(m: ModelsDevModel): ProviderModelDescriptor;
-/**
- * Resolve the model list to offer for a provider, merging a saved-config
- * allowlist with optional models.dev catalog metadata.
- *
- * Priority:
- *  1. The saved `models` allowlist is authoritative. This is the only source
- *     for OAuth / subscription / custom providers that models.dev does not
- *     list — `github-copilot`, `anthropic-oauth`, `openai-codex`,
- *     `zai-coding-plan`, etc. Each id is enriched with catalog metadata when a
- *     same-id catalog model exists, otherwise returned as a bare `{id, name}`.
- *  2. Otherwise the full catalog model list (standard API-key providers with no
- *     saved allowlist).
- *  3. Otherwise an empty list — *never* an error. A provider the user saved
- *     that is neither in the catalog nor carries an allowlist simply has no
- *     suggestions yet; callers must not raise a toast for that case (doing so
- *     produced the "not found in catalog" notification flood when the WebUI
- *     model switcher lazy-loaded every saved provider).
- */
-declare function resolveProviderModelList(savedModels: string[] | undefined, catalog: ResolvedProvider | undefined, 
-/**
- * Provider id / wire family the list is being resolved for. Lets the
- * resolver fall back to a known offline catalog (currently the ChatGPT
- * `openai-codex` models) when the saved allowlist is empty AND the
- * models.dev catalog is unavailable — so deleting the models from config
- * never leaves the provider showing zero models.
- */
-providerHint?: string | undefined): ProviderModelDescriptor[];
-
-export { CODEX_MODELS as C, DefaultModeStore as D, LLMSelector as L, type ModeLoaderOptions as M, type ProviderModelDescriptor as P, type CodexModelMeta as a, DefaultModelsRegistry as b, type DefaultModelsRegistryOptions as c, type LLMSelectorOptions as d, classifyFamily as e, codexModelMeta as f, describeCatalogModel as g, loadUserModes as h, loadProjectModes as l, resolveProviderModelList as r };

package/dist/secret-scrubber-3MHDDAtm.d.ts

@@ -1,6 +0,0 @@
-interface SecretScrubber {
-    scrub(text: string): string;
-    scrubObject<T>(obj: T): T;
-}
-
-export type { SecretScrubber as S };