indusagi-coding-agent 0.2.3 → 0.2.5

package/dist/types/launch/invocation/index.d.ts

@@ -1,23 +0,0 @@
-/**
- * Invocation subsystem — public barrel.
- *
- * Bundles the command-line behavior modules that all read the single
- * declarative {@link FLAG_SPECS} table:
- *
- *   - {@link readInvocation} — the generic, table-driven argv parser that folds
- *     a sliced argument vector into a typed {@link Invocation};
- *   - {@link renderUsage} — the `--help` banner generated from that same table,
- *     so help and parsing share one source of truth;
- *   - {@link gatherAttachments} — the `@file` expander that resolves references
- *     through the framework path resolver into inlined prose plus base64 media,
- *     raising a typed {@link AttachmentError} on failure.
- *
- * Consumers import the invocation surface from `src/launch/invocation` rather
- * than reaching into the individual modules.
- */
-export { FLAG_SPECS, FLAG_GROUPS } from "./flags";
-export type { FlagGroup, GroupedFlagSpec } from "./flags";
-export { readInvocation, readFileReferences } from "./read";
-export { renderUsage } from "./usage";
-export { gatherAttachments, AttachmentError } from "./attachments";
-export type { AttachmentErrorKind } from "./attachments";

package/dist/types/launch/invocation/read.d.ts

@@ -1,52 +0,0 @@
-/**
- * The invocation reader — a generic, table-driven argv parser over
- * {@link FLAG_SPECS}.
- *
- * This is the application's full command-line grammar (the boot layer carries
- * only a thin routing parser). It walks a sliced `argv` once and folds every
- * token into a fully-typed {@link Invocation}: recognised flags bind through the
- * declarative {@link FlagSpec} table, `@file` references collect for the
- * attachment gatherer, and remaining positionals become the prompt and the
- * positional tail.
- *
- * The grammar is deliberately textbook and entirely data-driven — there is no
- * per-flag branch. One index over {@link FLAG_SPECS} maps every canonical name
- * and alias to its row; the loop applies whichever row a token resolves to:
- *
- *   - **`--name=value`** and **`--name value`** both bind a `string` / `number`
- *     / `list` flag; an inline `=value` wins, otherwise the following token is
- *     consumed (unless it is itself a flag, in which case the value is empty).
- *   - **longest-alias match** resolves the canonical name, so a longer spelling
- *     is never shadowed by a shorter prefix.
- *   - **`--`** terminates option parsing; every subsequent token is positional.
- *   - **clustered short booleans** (`-pi`) expand to each single-letter switch.
- *   - **`list` flags accumulate** across repetition and split a single
- *     comma-separated token into elements.
- *   - **`@file`** tokens are recorded as attachment references rather than
- *     positionals.
- *
- * The parse is total: an unrecognised `--flag` is tolerated as a boolean switch
- * in the loose {@link Invocation.flags} bag (the extension-flag escape hatch)
- * rather than rejected, so nothing is silently dropped. Strong typing of the
- * named fields, and mode derivation, happen in one final fold.
- */
-import { type Invocation } from "../contract";
-/**
- * Read a sliced `argv` into the fully-parsed {@link Invocation}.
- *
- * Walks the tokens once via the {@link FLAG_SPECS} index, accumulates into a
- * {@link ParseState}, then folds that into the strongly-typed result: the loose
- * {@link Invocation.flags} bag is retained for round-tripping and extension
- * flags, and the named fields are derived from it with per-kind coercion and
- * validation. The `attachments` field is left unset here — the file references
- * are surfaced for the attachment gatherer to expand separately.
- *
- * @param argv the already-sliced argument vector (no node / executable path)
- */
-export declare function readInvocation(argv: readonly string[]): Invocation;
-/**
- * The `@file` references collected from an argv, exposed for the attachment
- * gatherer. A thin re-walk of the reader so the file references can be obtained
- * without re-deriving the whole parse where only attachments are needed.
- */
-export declare function readFileReferences(argv: readonly string[]): string[];

package/dist/types/launch/invocation/usage.d.ts

@@ -1,25 +0,0 @@
-/**
- * The usage renderer — generated entirely from {@link FLAG_SPECS}.
- *
- * {@link renderUsage} produces the `--help` banner by walking the same
- * declarative flag table the reader parses against. There is no second,
- * hand-maintained help string; every option line is synthesised from its
- * {@link FlagSpec} (its canonical name, its aliases, its value placeholder, and
- * its one-line description), grouped by the editorial {@link FLAG_GROUPS}
- * sections. Adding a flag to the table therefore adds it to the help with no
- * further edit, and the two can never disagree about what exists.
- *
- * The renderer is pure and total: it reads only the table and returns a string.
- */
-/**
- * Render the full usage banner.
- *
- * Emits a synopsis line, then one section per {@link FLAG_GROUPS} entry that has
- * any rows, then a short note on the two positional conventions the reader
- * honours but that are not flags: the `@file` attachment syntax and the `--`
- * option terminator. Every option line is derived from {@link FLAG_SPECS}; this
- * function holds no per-flag knowledge of its own.
- *
- * @returns the complete multi-line usage string (no trailing newline)
- */
-export declare function renderUsage(): string;

package/dist/types/launch/launch.test.d.ts

@@ -1,20 +0,0 @@
-/**
- * Phase-10 launch subsystem — unit tests.
- *
- * No network and no real terminal: every effectful seam is injected. The tests
- * pin the public launch surface assembled from the contract:
- *
- *   1. {@link readInvocation} parses a representative argv into the right
- *      {@link Invocation} (mode, prompt, model, mcp list, thinking, no-tools).
- *   2. {@link renderUsage} is generated from {@link FLAG_SPECS} alone — every
- *      flag description appears, proving the one-source-of-truth invariant.
- *   3. {@link gatherAttachments} resolves an `@file` in a tmpdir and raises a
- *      typed {@link AttachmentError} for a missing and an oversized file.
- *   4. {@link runCredentialCommand} stores an api key through an injected fake
- *      vault for the api-key path, and drives the framework browser sign-in for
- *      an OAuth-capable provider (persisting the returned credentials).
- *   5. {@link printModelCatalog} lists models from an injected source.
- *   6. {@link registerBuiltInOAuthProviders} primes the framework registry and
- *      {@link listLoginProviders} surfaces both kinds.
- */
-export {};

package/dist/types/launch/oauth.d.ts

@@ -1,101 +0,0 @@
-/**
- * OAuth integration — the browser-sign-in counterpart to the api-key flow.
- *
- * The framework ships working sign-in machinery for a handful of providers but
- * leaves its registry empty by default (api-key-only mode). This module turns
- * that on: {@link registerBuiltInOAuthProviders} populates the registry with the
- * three framework providers, and runs once as a side effect of importing the
- * module so that the moment the launch layer loads, the OAuth-capable providers
- * are live.
- *
- * On top of registration it offers three things the credential command needs:
- *   - {@link listLoginProviders} — the merged sign-in directory, every entry
- *     tagged with whether it authenticates by browser sign-in or by api key.
- *   - {@link startOAuthLogin} — drives a framework provider's login flow and
- *     persists the resulting credentials through the {@link AuthVault}.
- *   - {@link openLoginUrl} — a default-browser launcher (per platform) the login
- *     callback uses to send the user to the provider's consent page.
- *
- * No state is held here beyond the framework registry itself; the module is a
- * thin, testable seam over the framework API plus the app's vault.
- */
-import { type OAuthLoginCallbacks } from "indusagi/ai";
-import type { AuthVault } from "./contract";
-/**
- * Register the framework's built-in sign-in providers, idempotently.
- *
- * Each provider is registered only when its id is not already present, so
- * repeated calls (or a re-import) leave the registry unchanged. Returns the ids
- * that are registered after the call, for callers that want to confirm the set.
- */
-export declare function registerBuiltInOAuthProviders(): string[];
-/**
- * Whether a registered sign-in provider has a *real* OAuth client id wired in
- * (its env var is set to something other than the framework's sentinel), so its
- * browser sign-in can actually complete.
- *
- * Reads the env var live (not at import time) so a deployer that exports the id
- * before launching `/login` is honored. A provider with no known client-id
- * wiring (i.e. not one of the three sentinel-shipped framework providers) is
- * treated as registered — we only gate the providers we know ship a sentinel.
- *
- * @param providerId the registered sign-in provider id
- */
-export declare function hasRegisteredOAuthClientId(providerId: string): boolean;
-/** How a provider authenticates in the merged sign-in directory. */
-export type AuthKind = "oauth" | "apiKey";
-/** One row of the merged sign-in directory. */
-export interface LoginProvider {
-    /** Stable provider id (framework registry id or api-key directory id). */
-    readonly id: string;
-    /** Human-facing label for menus and prompts. */
-    readonly label: string;
-    /** Whether this entry signs in via the browser or stores an api key. */
-    readonly authKind: AuthKind;
-}
-/**
- * The merged sign-in directory: every registered browser-sign-in provider plus
- * every api-key provider the app knows, each tagged with its {@link AuthKind}.
- *
- * Browser-sign-in providers lead the list (they are the preferred path for the
- * providers that support them); an api-key provider that shares an id with a
- * registered sign-in provider is still listed, so a user can choose either path
- * for the same underlying account.
- */
-export declare function listLoginProviders(): LoginProvider[];
-/**
- * Open a sign-in url in the user's default browser.
- *
- * Refuses anything that is not an `http`/`https` url and resolves `false`, so a
- * provider that hands back a non-web redirect never spawns a process. Each
- * strategy is tried in turn; the first one that spawns without an immediate
- * error wins. Resolves `true` if a browser was launched, `false` otherwise.
- */
-export declare function openLoginUrl(url: string): Promise<boolean>;
-/**
- * The outcome of {@link startOAuthLogin}: the provider and account the
- * credentials were stored under, and whether this account became the default.
- */
-export interface OAuthLoginResult {
-    /** The provider id the sign-in completed for. */
-    readonly provider: string;
-    /** The account name the credentials were stored under. */
-    readonly account: string;
-    /** Whether the new account was stored as the provider default. */
-    readonly madeDefault: boolean;
-}
-/**
- * Drive a framework provider's browser sign-in and persist the result.
- *
- * Looks the provider up in the (now populated) framework registry, runs its
- * login flow with the supplied {@link OAuthLoginCallbacks}, and writes the
- * returned credentials into the {@link AuthVault} under `account`. The first
- * account stored for a provider becomes its default. Throws when the provider id
- * is not registered or the framework login flow rejects.
- *
- * @param providerId the registered sign-in provider id (e.g. the framework id)
- * @param callbacks  the framework login callbacks (url open, prompt, progress)
- * @param vault      the credential store the result is persisted through
- * @param account    the account name to store under (defaults to `"default"`)
- */
-export declare function startOAuthLogin(providerId: string, callbacks: OAuthLoginCallbacks, vault: AuthVault, account?: string): Promise<OAuthLoginResult>;

package/dist/types/launch/packages.d.ts

@@ -1,75 +0,0 @@
-/**
- * Package command — `runPackageCommand`.
- *
- * The top-level `install` / `remove` / `update` / `list` / `config` surface that
- * manages the extension-package sources the launcher loads. A source is a plain
- * string the loader understands — an `npm:` spec, a `git:` / `https:` repo, or a
- * bare local path — and the configured set lives in the user settings under the
- * `extensionPackages` key, persisted through the {@link PreferenceStore}.
- *
- * The command owns the first positional token only: it returns
- * `{ handled: false }` when that token is not one of the recognised subcommands,
- * so the orchestrator can call this first and fall through to a normal launch on
- * a miss. It never throws for an expected failure — a bad argument is reported as
- * a printed line and a non-zero {@link PackageResult.code}.
- *
- * I/O is injected. The default {@link PackageIo} wraps `process.stdout` /
- * `process.stderr`, but tests drive the whole flow over an in-memory stand-in and
- * a store pinned to a temp directory, so the real home is never touched.
- */
-import { PreferenceStore } from "../settings";
-/** The five subcommands the package command recognises as the first token. */
-export type PackageCommand = "install" | "remove" | "update" | "list" | "config";
-/** Every {@link PackageCommand}, as a frozen tuple for membership tests. */
-export declare const PACKAGE_COMMANDS: readonly PackageCommand[];
-/**
- * The console seam the package command writes through. Pinned to a normal line
- * and an error line so a test can capture both streams without a real terminal.
- */
-export interface PackageIo {
-    /** Emit one line of human-facing text to the standard stream. */
-    print(line: string): void;
-    /** Emit one line to the error stream. */
-    printError(line: string): void;
-}
-/** The default {@link PackageIo} backed by `process.stdout` / `process.stderr`. */
-export declare function defaultPackageIo(): PackageIo;
-/**
- * Options for {@link runPackageCommand}: the injected settings store the sources
- * persist through and the optional io seam. The store is injected so tests pin it
- * to a temp directory; boot resolves it from the workspace.
- */
-export interface PackageCommandOptions {
-    /** The settings store the package sources read from and write to. */
-    readonly store: PreferenceStore;
-    /** The console seam; defaults to {@link defaultPackageIo}. */
-    readonly io?: PackageIo;
-}
-/**
- * The outcome of {@link runPackageCommand}.
- *
- * {@link handled} reports whether the first token was a recognised subcommand;
- * when `false`, the caller proceeds to a normal launch unchanged. {@link code}
- * is the process exit code for a handled command — zero on success, non-zero when
- * a required argument was missing or invalid.
- */
-export interface PackageResult {
-    /** Whether this invocation was a package subcommand. */
-    readonly handled: boolean;
-    /** The subcommand that ran, when {@link handled} is true. */
-    readonly command?: PackageCommand;
-    /** Process exit code for a handled command (zero on success). */
-    readonly code?: number;
-}
-/**
- * Run the package command.
- *
- * Returns `{ handled: false }` immediately when `argv[0]` is not a recognised
- * subcommand, so the orchestrator can call this first and fall through on a miss.
- * Otherwise it performs the subcommand against the injected store and resolves a
- * {@link PackageResult} — never throwing for an expected failure.
- *
- * @param argv the raw token list following the program name
- * @param opts the injected settings store and (optionally) the io seam
- */
-export declare function runPackageCommand(argv: readonly string[], opts: PackageCommandOptions): Promise<PackageResult>;

package/dist/types/launch/packages.test.d.ts

@@ -1,15 +0,0 @@
-/**
- * Package command — unit tests.
- *
- * Everything runs against a {@link PreferenceStore} pinned to a temp directory
- * through {@link PreferenceStore.atPaths}; the real home is never read or
- * written. The io seam is an in-memory capture, so there is no real terminal. The
- * tests pin the public behaviour of {@link runPackageCommand}:
- *
- *   1. A non-package leading token falls through (`handled: false`).
- *   2. `install` persists a source, is idempotent under equivalent spellings, and
- *      `list` reads it back; `remove` clears it again.
- *   3. A missing source argument is a non-zero, non-throwing failure.
- *   4. `config` prints the resolved settings paths and contents.
- */
-export {};

package/dist/types/launch/pickers.d.ts

@@ -1,97 +0,0 @@
-/**
- * Launch pickers — `pickResumeTarget` and `browseSettings`.
- *
- * Two thin, injectable selection surfaces:
- *
- *   - {@link pickResumeTarget} loads the resumable sessions (current cwd plus
- *     every directory), de-duplicates by path, sorts newest-first, and lets the
- *     user choose one through the framework React-Ink `StartupSessionPicker`. On a
- *     non-interactive stdin it skips the picker and resolves the newest session,
- *     so a piped invocation still resumes deterministically.
- *
- *   - {@link browseSettings} prints a plain readline listing of the resolved
- *     settings and the discovered user resources, then waits for a keypress. No
- *     TUI — a flat console dump the user reads and dismisses.
- *
- * Both keep their effectful pieces (the Ink mount, the readline pause, the TTY
- * probe) behind injectable seams so the selection logic is unit-testable without
- * a terminal.
- */
-import type { ResumeFault, ResumeRef, SessionLoader, SettingsBrowseOptions } from "./contract";
-/**
- * The effectful seams {@link pickResumeTarget} depends on. Injected so a test can
- * report a non-interactive terminal and stub the picker mount.
- */
-export interface ResumeDeps {
-    /** Whether stdin is an interactive terminal (drives the non-TTY fast-path). */
-    isInteractive(): boolean;
-    /**
-     * Mount the picker over the session list and resolve with the chosen session,
-     * or `null` when the user dismisses it.
-     */
-    mountPicker(sessions: readonly ResumeRef[], totalCount: number): Promise<ResumeRef | null>;
-}
-/** The live {@link ResumeDeps}: a real TTY probe and the Ink picker mount. */
-export declare function defaultResumeDeps(): ResumeDeps;
-/**
- * Merge two session lists into one newest-first list de-duplicated by path.
- *
- * Earlier entries win the path key, then the merged set is sorted by
- * `lastModified` descending. Pure; the picker and the fast-path both consume it.
- */
-export declare function mergeSessions(current: readonly ResumeRef[], all: readonly ResumeRef[]): ResumeRef[];
-/**
- * The outcome of {@link pickResumeTarget}: the chosen session path, or `null`
- * when there was nothing to resume or the user dismissed the picker. A typed
- * {@link ResumeFault} is returned (never thrown) when the load or mount failed.
- */
-export interface ResumeOutcome {
-    /** The selected session file path, or `null` for none. */
-    readonly path: string | null;
-    /** A typed failure, present only when the resume flow could not run. */
-    readonly fault?: ResumeFault;
-}
-/**
- * Choose a session to resume.
- *
- * Loads the current-directory and all-directory session lists, merges them
- * (de-dupe by path, newest first), and either mounts the React-Ink picker or —
- * on a non-interactive stdin — resolves the newest session directly. An empty
- * merged list resolves to `{ path: null }`.
- *
- * @param loadCurrent loader for sessions started in the active cwd
- * @param loadAll     loader for sessions across every directory
- * @param deps        injectable TTY probe and picker mount (defaults to live)
- */
-export declare function pickResumeTarget(loadCurrent: SessionLoader, loadAll: SessionLoader, deps?: ResumeDeps): Promise<ResumeOutcome>;
-/**
- * The effectful seams {@link browseSettings} depends on: a line sink and a pause
- * that waits for the user to press a key. Injected so a test captures the listing
- * and resolves the pause immediately.
- */
-export interface SettingsBrowseIo {
-    /** Emit one line of the listing. */
-    print(line: string): void;
-    /** Wait for the user to dismiss the listing (e.g. press Enter). */
-    pause(prompt: string): Promise<void>;
-}
-/** The live {@link SettingsBrowseIo}: stdout plus a readline pause. */
-export declare function defaultSettingsBrowseIo(): SettingsBrowseIo;
-/**
- * Build the entire settings listing as an array of lines. Pure — it consumes the
- * resolved settings, the active cwd, the profile directory, and the grouped
- * resource paths, and produces the flat dump {@link browseSettings} prints. Kept
- * separate so a test can assert the content without an io seam.
- */
-export declare function renderSettingsListing(opts: SettingsBrowseOptions): string[];
-/**
- * Print the settings / resource listing and wait for the user to dismiss it.
- *
- * A plain console dump — no TUI. It renders the resolved settings summary and the
- * discovered resources grouped by category, then pauses for a keypress so the
- * listing stays on screen.
- *
- * @param opts the resolved settings, resource paths, cwd, and profile directory
- * @param io   the injectable line sink and pause (defaults to stdout + readline)
- */
-export declare function browseSettings(opts: SettingsBrowseOptions, io?: SettingsBrowseIo): Promise<void>;

package/dist/types/runtime-bridge/bridges/_drive.d.ts

@@ -1,74 +0,0 @@
-/**
- * Shared exchange driver — the transport-wiring half every bridge reuses.
- *
- * A bridge is meant to be *only* a per-dialect parser. Two concerns are common
- * to all three shipped bridges and are factored here so a bridge never repeats
- * them:
- *
- *   1. The lifecycle wiring: subscribe to the {@link ChildTransport}, forward
- *      each inbound {@link ChildMessage} to the bridge's parser, settle the sink
- *      on a terminal parser result, honour the caller's {@link AbortSignal}, and
- *      always dispose the subscription + transport on the way out.
- *   2. The seed: deriving the {@link BridgeMessageSeed} the sink stamps onto the
- *      accumulated message from the bound {@link Model}.
- *
- * A bridge supplies a {@link ChildParser} (pure: child payload -> parser result)
- * and an opening {@link ChildRequest}; {@link driveExchange} does the rest and
- * returns the populated {@link AssistantMessageEventStream}.
- *
- * Crucially this module touches the transport only through the injected
- * interface — no `child_process`, no `spawn`. A test hands a fake transport and
- * drives the parser end-to-end with zero real binaries.
- */
-import type { AssistantMessageEventStream, BridgeEventSink, ChildMessage, ChildRequest, ChildTransport, ExchangeOptions, Model, Api } from "../contract";
-import { type BridgeMessageSeed } from "../sink";
-/**
- * The outcome a parser reports for one inbound child payload. A parser maps a
- * single {@link ChildMessage} payload to the normalized events it produced and
- * whether that payload terminated the exchange.
- *
- *   - `continue`  — zero or more events were emitted; the stream stays open.
- *   - `done`      — the exchange settled (the parser already emitted the
- *                   `finish` / `failed` event, or the driver should finish with
- *                   the default reason). No further payloads are processed.
- */
-export type ParseStep = {
-    readonly status: "continue";
-} | {
-    readonly status: "done";
-};
-/**
- * A per-dialect parser: interpret one inbound child payload, drive the sink with
- * whatever normalized events it yields, and report whether the exchange is over.
- *
- * The parser owns *interpretation* only; it never touches the framework stream
- * directly — it calls sink methods (`text` / `thinking` / `toolCall` / `emit` /
- * `finishSuccess` / `finishError`). Returning `{ status: "done" }` tells the
- * driver to stop and (if the sink is not already settled) finish successfully.
- */
-export type ChildParser = (message: ChildMessage, sink: BridgeEventSink) => ParseStep;
-/** Derive the message seed the sink stamps onto its accumulated message. */
-export declare function seedFromModel(model: Model<Api>): BridgeMessageSeed;
-/**
- * Drive a full exchange over an injected transport.
- *
- * Returns the sink's {@link AssistantMessageEventStream} synchronously; the
- * stream is populated asynchronously as the child emits. The driver:
- *   - subscribes the parser to inbound messages;
- *   - sends the opening request;
- *   - settles + tears down on a terminal parse step, transport closure, abort,
- *     or thrown parser error.
- *
- * @param model     the bound model (seeds the sink identity)
- * @param opts      per-exchange options (only `signal` is consulted here)
- * @param transport the injected child boundary
- * @param request   the opening request to send once subscribed
- * @param parse     the per-dialect parser
- */
-export declare function driveExchange(model: Model<Api>, opts: ExchangeOptions, transport: ChildTransport, request: ChildRequest, parse: ChildParser): AssistantMessageEventStream;
-/** Best-effort single-line message for an unknown thrown value. */
-export declare function errorText(cause: unknown): string;
-/** Narrow an opaque payload to a string-keyed record (or `undefined`). */
-export declare function asRecord(value: unknown): Record<string, unknown> | undefined;
-/** Read a string field off a record, or `undefined` when absent/non-string. */
-export declare function strField(record: Record<string, unknown>, key: string): string | undefined;

package/dist/types/runtime-bridge/bridges/builtins.d.ts

@@ -1,77 +0,0 @@
-/**
- * Built-in external-runtime catalog — the shipped {@link ExternalRuntimeSpec}
- * entries and the helper that *annotates* a model with one.
- *
- * The model catalog (Phase 2, `src/conductor/catalog`) owns the {@link Model}
- * list; this layer never re-catalogues. Instead it carries a small table of the
- * three runtimes this build ships and a single sanctioned way to stamp a runtime
- * onto a model: rewrite the model's `baseUrl` to the synthetic
- * `bridge:<adapter>` endpoint (so a card has a stable, non-HTTP address) and
- * return the runtime annotation alongside it.
- *
- * Why a `baseUrl` rewrite rather than a new field on the card: the catalog card
- * shape is frozen by Phase 2 and the framework {@link Model} has a fixed shape;
- * the `bridge:<adapter>` convention lets a routing consumer recognize a
- * runtime-backed model purely from its address (`baseUrl.startsWith(scheme)`),
- * with the full spec resolved from this table — no schema change to the catalog.
- */
-import type { CatalogCard } from "../../conductor/catalog";
-import { type Api, type ExternalRuntimeSpec, type Model, type RuntimeAdapterId } from "../contract";
-/**
- * The three runtimes this build ships, keyed by adapter id.
- *
- * Each is `external-cli` (the spawned child owns its own login), so a model
- * bound to one is offered as available with an empty credential vault. The
- * `binaryPath` names the default executable the broker launches when a model's
- * spec does not override it; `args` are extra flags prepended ahead of the
- * bridge's own protocol flags.
- */
-export declare const BUILTIN_RUNTIME_SPECS: Readonly<Record<RuntimeAdapterId, ExternalRuntimeSpec>>;
-/** The shipped adapter ids, in catalog order. */
-export declare const BUILTIN_ADAPTERS: readonly RuntimeAdapterId[];
-/** Look up a shipped {@link ExternalRuntimeSpec} by adapter id (`undefined` if none). */
-export declare function builtinRuntimeSpec(adapter: RuntimeAdapterId): ExternalRuntimeSpec | undefined;
-/**
- * A model annotated with its external runtime: the rewritten framework model
- * (its `baseUrl` now the `bridge:<adapter>` synthetic endpoint) paired with the
- * resolved {@link ExternalRuntimeSpec}. This is the value a routing consumer
- * stores in its side table keyed by canonical id.
- */
-export interface RuntimeAnnotatedModel {
-    /** The framework model with its `baseUrl` rewritten to the synthetic endpoint. */
-    readonly model: Model<Api>;
-    /** The runtime spec the {@link RuntimeBroker} drives this model through. */
-    readonly spec: ExternalRuntimeSpec;
-}
-/**
- * Rewrite a framework {@link Model}'s `baseUrl` to the synthetic
- * `bridge:<adapter>` endpoint for `spec.adapter`. Returns a fresh model; the
- * input is never mutated.
- */
-export declare function withRuntimeEndpoint(model: Model<Api>, spec: ExternalRuntimeSpec): Model<Api>;
-/**
- * Annotate one {@link CatalogCard} with a runtime spec.
- *
- * Resolves the spec from `spec` when given explicitly, else from the shipped
- * table by `adapter`. Returns the card's framework model rewritten to the
- * synthetic endpoint plus the resolved spec, or `undefined` when no spec is
- * known for `adapter` (so a caller can skip non-runtime adapters).
- *
- * @param card    the catalog card whose model to annotate
- * @param adapter the runtime adapter to bind the model to
- * @param spec    an explicit spec override; defaults to the shipped one
- */
-export declare function annotateCard(card: CatalogCard, adapter: RuntimeAdapterId, spec?: ExternalRuntimeSpec): RuntimeAnnotatedModel | undefined;
-/**
- * Decode the runtime annotation off a framework {@link Model}, the inverse of
- * {@link withRuntimeEndpoint}. Returns the shipped {@link ExternalRuntimeSpec}
- * for the adapter named in a `bridge:<adapter>` `baseUrl`, or `undefined` when
- * the model is a plain HTTP-provider model (its `baseUrl` is a real URL) or the
- * named adapter is not a shipped runtime.
- *
- * This is the lookup a {@link RuntimeBroker} uses to recognize a runtime-backed
- * model purely from its address.
- *
- * @param model the model whose `baseUrl` to inspect
- */
-export declare function specFromModel(model: Model<Api>): ExternalRuntimeSpec | undefined;

package/dist/types/runtime-bridge/bridges/claude-cli.d.ts

@@ -1,37 +0,0 @@
-/**
- * `claude-cli` bridge — drives an Anthropic-flavoured CLI that emits
- * line-delimited stream-json content blocks.
- *
- * Wire dialect (each inbound {@link ChildMessage.payload} is one parsed JSON
- * line of the CLI's NDJSON stdout):
- *   - `{ type: "system", subtype: "init", session_id }` — the CLI announces the
- *     session id it allocated; surfaced as a `resume` event so the broker can
- *     persist it and reattach the same CLI session later.
- *   - `{ type: "content_block_start", content_block: { type } }` — a block opens;
- *     a `tool_use` block carries `{ id, name, input }` which becomes a fully
- *     formed tool call immediately (the CLI batches the input).
- *   - `{ type: "content_block_delta", delta: { type, text | thinking } }` — a
- *     `text_delta` / `thinking_delta` chunk; mapped to a `text` / `thinking`
- *     normalized event. `input_json_delta` chunks (streamed tool arguments) are
- *     ignored here because the bridge emits the tool call from the terminal
- *     `content_block_stop` snapshot.
- *   - `{ type: "message_delta", delta: { stop_reason } }` — carries the final
- *     stop reason, recorded for the eventual `finish`.
- *   - `{ type: "message_stop" }` / `{ type: "result" }` — the turn is over;
- *     finish with the recorded reason.
- *   - `{ type: "error", error: { message } }` — a runtime fault.
- *
- * The opening request is the user turn forwarded as the CLI's prompt body; the
- * spec's binary/args/env are the {@link RuntimeBroker}'s concern when it builds
- * the transport, so this bridge only formats the protocol body.
- *
- * The child process is reached exclusively through the injected
- * {@link ChildTransport}; no `claude` binary is spawned here.
- */
-import type { RuntimeBridge } from "../contract";
-/**
- * The `claude-cli` {@link RuntimeBridge}. Stateless on the contract surface: it
- * parses the injected transport's stream-json into the sink and returns the
- * framework push stream.
- */
-export declare const claudeCliBridge: RuntimeBridge;

package/dist/types/runtime-bridge/bridges/codex-cli.d.ts

@@ -1,27 +0,0 @@
-/**
- * `codex-cli` bridge — drives an OpenAI-flavoured CLI emitting `--json`
- * turn/item events.
- *
- * Wire dialect (each inbound {@link ChildMessage.payload} is one parsed `--json`
- * event object):
- *   - `{ type: "thread.started", thread_id }` — the CLI opened a thread;
- *     surfaced as a `resume` event so the broker can persist the thread id and
- *     continue it on a later exchange.
- *   - `{ type: "response.output_text.delta", delta }` — a chunk of answer text.
- *   - `{ type: "response.reasoning_text.delta" | "response.reasoning.delta",
- *        delta }` — a chunk of reasoning text.
- *   - `{ type: "response.output_item.done", item }` /
- *     `{ type: "item.completed", item }` — a completed item; a
- *     `function_call` / `tool_call` item becomes a fully-formed tool call (its
- *     `arguments` string is parsed into an object).
- *   - `{ type: "turn.completed" | "response.completed" }` — the turn settled;
- *     finish (tool-bearing turns settle as `toolUse`, else `stop`).
- *   - `{ type: "error" | "turn.failed", error | message }` — a runtime fault.
- *
- * Item-level `*.delta` text is preferred; if a CLI variant only emits whole
- * items, the completed-item handler still surfaces the text. The injected
- * {@link ChildTransport} carries the events — no `codex` binary is spawned here.
- */
-import type { RuntimeBridge } from "../contract";
-/** The `codex-cli` {@link RuntimeBridge}. */
-export declare const codexCliBridge: RuntimeBridge;

package/dist/types/runtime-bridge/bridges/index.d.ts

@@ -1,15 +0,0 @@
-/**
- * Bridges subsystem — public barrel.
- *
- * Bundles the three shipped external-runtime {@link RuntimeBridge}s — the
- * Anthropic-flavoured `claude-cli`, the OpenAI-flavoured `codex-cli`, and the
- * peer JSON-RPC `indusagi-cli` — plus the built-in runtime spec catalog and the
- * model-annotation helpers. Consumers register the bridges with a
- * {@link RuntimeBroker} and annotate catalog cards via this barrel rather than
- * reaching into the individual modules.
- */
-export { claudeCliBridge } from "./claude-cli";
-export { codexCliBridge } from "./codex-cli";
-export { indusagiCliBridge, makeIndusagiCliBridge } from "./indusagi-cli";
-export { BUILTIN_RUNTIME_SPECS, BUILTIN_ADAPTERS, builtinRuntimeSpec, annotateCard, withRuntimeEndpoint, specFromModel, type RuntimeAnnotatedModel, } from "./builtins";
-export { driveExchange, seedFromModel, asRecord, strField, errorText, type ChildParser, type ParseStep, } from "./_drive";