indusagi-coding-agent 0.2.3 → 0.2.5

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

@@ -1,36 +0,0 @@
-/**
- * `indusagi-cli` bridge — drives a peer agent over JSON-RPC.
- *
- * Unlike the CLI bridges, the peer already speaks (a transport-framed form of)
- * the framework event vocabulary, so its messages map onto
- * {@link NormalizedEvent} near-directly. Each inbound {@link ChildMessage.payload}
- * is a JSON-RPC frame:
- *   - a **notification** `{ method, params }` streams one turn event:
- *       · `stream/text`        params `{ delta }`       → `text`
- *       · `stream/thinking`    params `{ delta }`       → `thinking`
- *       · `stream/toolCall`    params `{ id, name, arguments }` → `tool_call`
- *       · `session/resume`     params `{ resumeToken }` → `resume`
- *       · `stream/done`        params `{ reason }`      → `finish`
- *       · `stream/error`       params `{ message, aborted }` → `failed`
- *   - a **response** `{ id, result | error }` to the opening `runExchange`
- *     request: an `error` member fails the exchange; a `result` is treated as a
- *     terminal acknowledgement (`finish`) if the stream has not already settled.
- *
- * The opening request is a JSON-RPC `runExchange` call carrying the context,
- * delegate provider, and resume token. The peer is reached only through the
- * injected {@link ChildTransport}; no peer process is spawned here.
- */
-import type { ExternalRuntimeSpec, RuntimeBridge } from "../contract";
-/**
- * Build the `indusagi-cli` {@link RuntimeBridge}. The bound {@link ExternalRuntimeSpec}
- * is captured so the opening request can forward its `delegate` to the peer; the
- * broker constructs one bridge per spec it routes to.
- *
- * @param spec the runtime annotation whose `delegate` the peer should target
- */
-export declare function makeIndusagiCliBridge(spec: ExternalRuntimeSpec): RuntimeBridge;
-/**
- * A default `indusagi-cli` bridge bound to a spec with no delegate. Use
- * {@link makeIndusagiCliBridge} when a delegate provider must be forwarded.
- */
-export declare const indusagiCliBridge: RuntimeBridge;

package/dist/types/runtime-bridge/broker.d.ts

@@ -1,182 +0,0 @@
-/**
- * RuntimeBroker — the single decision point that routes every turn to either an
- * external runtime (a spawned child coding-agent driven by a {@link RuntimeBridge})
- * or the framework network stream (`streamSimple` over an HTTP provider).
- *
- * The broker is the only component the product asks "how is this turn produced?".
- * It owns three concerns:
- *
- *   1. **Routing.** {@link RuntimeBroker.route} resolves the model's optional
- *      {@link ExternalRuntimeSpec} (a `bridge:<adapter>` baseUrl decode) and a
- *      matching registered {@link RuntimeBridge}. A model with a spec whose
- *      adapter is registered routes `"external"`; everything else routes
- *      `"framework"`.
- *   2. **Dispatch.** {@link RuntimeBrokerRuntime.exchange} acts on that decision:
- *      for an external route it builds (or is injected) a {@link ChildTransport}
- *      and calls {@link RuntimeBridge.runExchange} over it; for a framework route
- *      it calls the framework `streamSimple`. Either way it returns the framework
- *      {@link AssistantMessageEventStream} the turn streams into — the two paths
- *      are indistinguishable to the caller.
- *   3. **Resume persistence.** When a bridge surfaces a `resume` token (a CLI
- *      session id / thread id), the broker persists it through an injected
- *      {@link RuntimeLinkStore} as a *renamed* custom transcript entry —
- *      {@link RUNTIME_LINK_ENTRY} = `"external-runtime-link"`, shape
- *      `{ source, bridge, resumeToken, at }` — so a later exchange can reattach
- *      the same underlying session. Handle reuse keys on the composite
- *      {@link runtimeSourceKey} (`source|model|bridge`), not three separate field
- *      comparisons.
- *
- * The {@link ChildTransport} is injectable end to end: a production factory wraps
- * a spawned process, a test factory returns a hand-written fake. The broker never
- * imports `child_process`; nothing here spawns a real `claude`/`codex` binary.
- */
-import type { Api, AssistantMessageEventStream, ChildTransport, Context, ExchangeOptions, ExternalRuntimeSpec, Model, NormalizedEvent, RuntimeBridge, RuntimeBroker } from "./contract";
-/**
- * The custom transcript-entry tag under which a runtime resume token is logged.
- *
- * The record this build writes is its own `"external-runtime-link"` shape so the
- * persisted log carries no inherited vocabulary. A consumer scanning the active
- * branch backwards for a reattachable session matches on this tag.
- */
-export declare const RUNTIME_LINK_ENTRY: "external-runtime-link";
-/** The literal type of {@link RUNTIME_LINK_ENTRY}. */
-export type RuntimeLinkEntryTag = typeof RUNTIME_LINK_ENTRY;
-/**
- * The serializable payload persisted under {@link RUNTIME_LINK_ENTRY}.
- *
- * The renamed shape: `{ source, bridge, resumeToken, at }`. `source` is the
- * model's provider slug, `bridge` is the owning {@link RuntimeBridge.adapter},
- * `resumeToken` is the reattachable CLI session id / thread id the child
- * reported, and `at` is the ISO instant it was captured. Reuse keys on
- * {@link runtimeSourceKey}, derived from `source` + model id + `bridge`.
- */
-export interface RuntimeLink {
-    /** The model's provider slug (its `source`). */
-    readonly source: string;
-    /** The owning bridge adapter id. */
-    readonly bridge: string;
-    /** The reattachable session id / thread id reported by the child runtime. */
-    readonly resumeToken: string;
-    /** ISO-8601 instant the token was captured. */
-    readonly at: string;
-}
-/**
- * Compose the composite reuse key a broker matches a persisted {@link RuntimeLink}
- * against. A single `source|model|bridge` string rather than three field
- * comparisons — a stored link is reattachable iff its key equals the key of the
- * exchange about to run.
- *
- * @param source the model provider slug
- * @param modelId the model id
- * @param bridge the bridge adapter id
- */
-export declare function runtimeSourceKey(source: string, modelId: string, bridge: string): string;
-/**
- * Injectable persistence boundary for resume tokens. The conductor's transcript
- * store binds a real implementation (appending a {@link RUNTIME_LINK_ENTRY} custom
- * entry to the active branch and scanning it backwards on lookup); tests pass an
- * in-memory fake. Both methods are async to match a disk-backed transcript.
- */
-export interface RuntimeLinkStore {
-    /**
-     * Persist a captured resume token as a renamed custom transcript entry. Called
-     * once per `resume` event a bridge surfaces during an exchange.
-     *
-     * @param link the renamed link record to append
-     */
-    save(link: RuntimeLink): Promise<void> | void;
-    /**
-     * Resolve the most recent reattachable token for a reuse key, or `undefined`
-     * when the active branch holds no matching {@link RUNTIME_LINK_ENTRY}. The key
-     * is {@link runtimeSourceKey}.
-     *
-     * @param sourceKey the composite `source|model|bridge` reuse key
-     */
-    find(sourceKey: string): Promise<string | undefined> | string | undefined;
-}
-/**
- * The context handed to a {@link ChildTransportFactory} when the broker needs a
- * transport for an external exchange. Carries everything a production factory
- * needs to launch + wire the child (the resolved spec's binary/args/env, the
- * working directory, a resume token to reattach) without the broker itself
- * touching `child_process`.
- */
-export interface TransportContext {
-    /** The resolved runtime spec (binary, args, env, delegate) for the child. */
-    readonly spec: ExternalRuntimeSpec;
-    /** The bound model the exchange runs for. */
-    readonly model: Model<Api>;
-    /** The per-exchange options (session id, cwd, resume, stream opts). */
-    readonly opts: ExchangeOptions;
-    /** A persisted resume token resolved for this exchange, if any. */
-    readonly resume?: string;
-}
-/**
- * Mints a {@link ChildTransport} for an external exchange. The single seam the
- * broker reaches the outside world through: a production factory spawns the
- * process and adapts its stdio/RPC into the transport; a test factory returns a
- * scripted fake. The broker calls it lazily, only on an external route.
- */
-export type ChildTransportFactory = (ctx: TransportContext) => ChildTransport;
-/** The framework network-stream signature the broker falls through to. */
-export type FrameworkStream = (model: Model<Api>, context: Context, opts: ExchangeOptions) => AssistantMessageEventStream;
-/**
- * Construction-time dependencies for {@link createRuntimeBroker}. All optional —
- * an empty broker registers bridges later, routes everything to the framework
- * until a transport factory is wired, and skips persistence when no store is set.
- */
-export interface RuntimeBrokerDeps {
-    /**
-     * The seam that builds a {@link ChildTransport} for an external exchange. When
-     * absent, an external route still *decides* `"external"` but {@link
-     * RuntimeBrokerRuntime.exchange} cannot drive a child — so it falls through to
-     * the framework path. Tests inject a fake-transport factory here.
-     */
-    readonly transportFactory?: ChildTransportFactory;
-    /** Where resume tokens persist; omitted ⇒ tokens are not persisted. */
-    readonly linkStore?: RuntimeLinkStore;
-    /**
-     * Override for the framework network stream (defaults to `streamSimple`).
-     * Injected in tests so the framework path is observable without a network.
-     */
-    readonly frameworkStream?: FrameworkStream;
-    /** Bridges to pre-register at construction (equivalent to calling `register`). */
-    readonly bridges?: readonly RuntimeBridge[];
-}
-/**
- * The broker the product drives. Extends the frozen {@link RuntimeBroker} routing
- * surface with {@link exchange}: the dispatch half that acts on a {@link route}
- * decision and returns the framework stream the turn streams into.
- */
-export interface RuntimeBrokerRuntime extends RuntimeBroker {
-    /**
-     * Produce the turn for `model`. Routes (via {@link RuntimeBroker.route}); on an
-     * `"external"` route with a wired transport factory it drives the bridge's
-     * `runExchange` over a freshly-built {@link ChildTransport} (resolving + later
-     * persisting the resume token); otherwise it runs the framework stream. Returns
-     * the {@link AssistantMessageEventStream} synchronously, like `streamSimple`.
-     *
-     * @param model   the model the turn is bound to
-     * @param context the framework conversation context
-     * @param opts    per-exchange options
-     */
-    exchange(model: Model<Api>, context: Context, opts?: ExchangeOptions): AssistantMessageEventStream;
-}
-/**
- * Construct a {@link RuntimeBrokerRuntime}. The single sanctioned way to obtain a
- * broker: build one with optional dependencies (a transport factory, a resume
- * link store, a framework-stream override, pre-registered bridges), then
- * {@link RuntimeBroker.register} further bridges and drive turns through
- * {@link RuntimeBrokerRuntime.exchange} / {@link RuntimeBroker.route}.
- *
- * @param deps optional construction-time dependencies
- */
-export declare function createRuntimeBroker(deps?: RuntimeBrokerDeps): RuntimeBrokerRuntime;
-/**
- * The normalized resume-event kind a bridge emits — re-exported so a transport
- * tap / consumer can name the same `"resume"` discriminant the sink ignores on
- * the stream but the broker persists out of band.
- */
-export type ResumeEvent = Extract<NormalizedEvent, {
-    kind: "resume";
-}>;

package/dist/types/runtime-bridge/contract.d.ts

@@ -1,436 +0,0 @@
-/**
- * Runtime-bridge contract — the FROZEN type surface of provider *routing*.
- *
- * This module is the single typed seam that decides, per model, **where a turn
- * is actually produced**: by the framework's own network stream
- * (`streamSimple` over an HTTP provider) or by an *external runtime* — a child
- * coding-agent process driven over its own protocol (an Anthropic-flavoured CLI
- * speaking line-delimited JSON, an OpenAI-flavoured CLI emitting `--json`
- * items, or a peer agent reachable over JSON-RPC). The product never calls a
- * bridge or the framework stream directly; it asks the {@link RuntimeBroker} to
- * route, and the broker picks the path.
- *
- * Design stance:
- *   - A model is *annotated*, not re-catalogued. The model catalog/matcher
- *     (Phase 2) own the {@link Model} list; this layer only attaches an optional
- *     {@link ExternalRuntimeSpec} that says "this model is backed by a spawned
- *     CLI / a peer agent, here is how to reach it and authenticate". A model
- *     with no spec routes normally.
- *   - Every external runtime speaks a *different* wire dialect, but the broker
- *     should not care. So each bridge is reduced to a **parser** that yields a
- *     provider-neutral {@link NormalizedEvent} stream, and the single
- *     {@link BridgeEventSink} translates those events into the framework's
- *     {@link AssistantMessageEventStream} push shape. The imperative
- *     `pushStart/pushTextDelta/pushDone` idiom lives in exactly one place.
- *   - The child process / RPC peer a bridge drives is reached through an
- *     **injectable** {@link ChildTransport}, never a hard-coded `spawn`. Tests
- *     hand the bridge a fake transport so no real `claude`/`codex` binary is
- *     launched.
- *   - Authentication policy is data, not control flow:
- *     {@link RuntimeBridge.requiresCredential} answers "does this model need a
- *     key on disk before it can be offered?" — a spawned-CLI runtime that owns
- *     its own auth returns `false`, letting the model appear available with no
- *     key.
- *
- * Framework anchors (all from the sibling rebuilt framework, the `indusagi`
- * package) — consumed verbatim, never re-derived:
- *   - `Model`, `Context`, `AssistantMessage`, `AssistantMessageEventStream`,
- *     `Api`, `StopReason`, `ToolCall`, `Usage`, `SimpleStreamOptions`,
- *     `KnownProvider` ← `indusagi/ai`
- *   - `streamSimple` is the network fallback the broker routes to.
- *
- * Interface-dictated shapes preserved as-is:
- *   - the `bridge:<adapter>` synthetic endpoint convention for runtime-backed
- *     models (so a catalog entry has a stable, non-HTTP `baseUrl`);
- *   - the external CLI protocol vocabularies (Anthropic stream-json content
- *     blocks, OpenAI `--json` items, peer JSON-RPC requests) — surfaced only as
- *     the opaque payloads a {@link ChildTransport} carries, never re-expressed.
- */
-import type { Api, AssistantMessage, AssistantMessageEventStream, Context, KnownProvider, Model, SimpleStreamOptions, StopReason, ToolCall } from "indusagi/ai";
-/** Re-exported framework vocabulary routing consumers routinely compose. */
-export type { Api, AssistantMessage, AssistantMessageEventStream, Context, KnownProvider, Model, SimpleStreamOptions, StopReason, ToolCall, };
-/**
- * The set of bridge adapters this layer ships.
- *
- * Each value names a concrete {@link RuntimeBridge} implementation and the wire
- * dialect it speaks:
- *   - `"claude-cli"`     — drives an Anthropic-flavoured CLI emitting
- *                          line-delimited stream-json content blocks.
- *   - `"codex-cli"`      — drives an OpenAI-flavoured CLI emitting `--json`
- *                          turn/item events.
- *   - `"indusagi-cli"`   — drives a peer agent over JSON-RPC; the child already
- *                          speaks the framework event vocabulary, so its events
- *                          map onto {@link NormalizedEvent} near-directly.
- *
- * Left open (`(string & {})`) so an extension can register a further adapter
- * without editing this union, while the three shipped ids keep autocompletion.
- */
-export type RuntimeAdapterId = "claude-cli" | "codex-cli" | "indusagi-cli" | (string & {});
-/**
- * How a model bound to an external runtime authenticates.
- *
- *   - `"external-cli"` — the spawned child owns its own auth (its own login /
- *     keychain); the product needs **no** key on disk, so the model can be
- *     offered as available with an empty vault. This is the policy that makes a
- *     CLI-backed model "just work" once the underlying tool is logged in.
- *   - `"api-key"` — the runtime still needs an API key resolved from the
- *     credential vault, same as a normal HTTP provider; only the *transport*
- *     differs.
- */
-export type RuntimeAuthMode = "external-cli" | "api-key";
-/**
- * The annotation that turns an ordinary {@link Model} into an external-runtime
- * model. Attached alongside a catalog card (it is *additive* metadata — the
- * catalog/matcher are unaware of it) and consulted by the {@link RuntimeBroker}
- * to decide routing.
- *
- * All transport fields are optional: a bridge may have a sensible default
- * binary, take no extra args, inherit the parent environment, and route to its
- * own downstream source. Only {@link adapter} is required, because it selects
- * which {@link RuntimeBridge} owns the exchange.
- */
-export interface ExternalRuntimeSpec {
-    /** Which bridge owns this model's exchange (the {@link RuntimeBridge.adapter}). */
-    readonly adapter: RuntimeAdapterId;
-    /** Whether the runtime needs a key on disk, or owns its own auth. */
-    readonly authMode: RuntimeAuthMode;
-    /** Override for the child executable to launch (defaults to the bridge's own). */
-    readonly binaryPath?: string;
-    /** Extra command-line arguments prepended to the bridge's protocol flags. */
-    readonly args?: readonly string[];
-    /** Environment overrides merged into the child process environment. */
-    readonly env?: Readonly<Record<string, string>>;
-    /**
-     * For a bridge that fronts another source (e.g. a peer agent that itself
-     * talks to a downstream provider), the provider slug the child should target.
-     * Ignored by bridges that terminate the exchange themselves.
-     */
-    readonly delegate?: string;
-}
-/**
- * The synthetic endpoint scheme stamped onto a runtime-backed model's
- * `baseUrl`. A model annotated with {@link ExternalRuntimeSpec} carries
- * `baseUrl === "${RUNTIME_ENDPOINT_SCHEME}${adapter}"` so it has a stable,
- * non-HTTP address that never resolves to a network host.
- */
-export declare const RUNTIME_ENDPOINT_SCHEME: "bridge:";
-/** The literal type of {@link RUNTIME_ENDPOINT_SCHEME}. */
-export type RuntimeEndpointScheme = typeof RUNTIME_ENDPOINT_SCHEME;
-/**
- * Compose the synthetic `bridge:<adapter>` endpoint for a runtime-backed model.
- * Inert string helper; the single sanctioned way to mint the convention so it
- * stays uniform across the catalog annotation and the broker's routing check.
- *
- * @param adapter the {@link RuntimeBridge.adapter} owning the model
- */
-export declare function runtimeEndpoint(adapter: RuntimeAdapterId): string;
-/**
- * A provider-neutral streamed event — the common currency between a bridge's
- * per-dialect parser and the {@link BridgeEventSink}.
- *
- * Each external runtime emits its own wire vocabulary (Anthropic content
- * blocks, OpenAI items, peer JSON-RPC events). A bridge's only job is to map
- * that vocabulary onto this small, closed union; the sink then translates a
- * {@link NormalizedEvent} into the matching framework
- * {@link AssistantMessageEventStream} push call. This is the seam that removes
- * the per-bridge `stream.push*` duplication.
- *
- * Variants:
- *   - `text`     — a chunk of assistant answer text.
- *   - `thinking` — a chunk of reasoning text (runtimes without a thinking
- *                  channel simply never emit this).
- *   - `tool_call`— a fully-formed tool invocation the child decided on.
- *   - `resume`   — the child reported a session/thread id the bridge can persist
- *                  to reattach the underlying CLI session after a restart.
- *   - `finish`   — the exchange settled successfully with a terminal reason.
- *   - `failed`   — the exchange ended in error.
- */
-export type NormalizedEvent = {
-    readonly kind: "text";
-    readonly delta: string;
-} | {
-    readonly kind: "thinking";
-    readonly delta: string;
-} | {
-    readonly kind: "tool_call";
-    readonly call: ToolCall;
-} | {
-    readonly kind: "resume";
-    readonly resumeToken: string;
-} | {
-    readonly kind: "finish";
-    readonly reason: FinishReason;
-} | {
-    readonly kind: "failed";
-    readonly error: BridgeFailure;
-};
-/** The discriminant literals of {@link NormalizedEvent}, for filtering/logging. */
-export type NormalizedEventKind = NormalizedEvent["kind"];
-/** Extract a single member of {@link NormalizedEvent} by its `kind`. */
-export type NormalizedEventOf<K extends NormalizedEventKind> = Extract<NormalizedEvent, {
-    kind: K;
-}>;
-/**
- * The terminal reasons an external exchange can settle on. A subset of the
- * framework's {@link StopReason} — the non-error outcomes a bridge reports to
- * the sink, which then emits the framework `done` event.
- */
-export type FinishReason = Extract<StopReason, "stop" | "length" | "toolUse">;
-/**
- * A typed failure surfaced by a bridge when an external exchange breaks. The
- * `aborted` flag distinguishes a caller-cancelled exchange (the child was
- * interrupted) from a genuine fault, so the sink can emit the matching
- * framework error reason (`aborted` vs `error`).
- */
-export interface BridgeFailure {
-    /** Human-readable, single-line summary of what went wrong. */
-    readonly message: string;
-    /** True when the exchange was cancelled rather than failing on its own. */
-    readonly aborted?: boolean;
-    /** Underlying error or structured detail, if any. */
-    readonly cause?: unknown;
-}
-/**
- * The single push-stream helper every bridge writes through.
- *
- * It owns the accumulating {@link AssistantMessage}, the content-block index
- * bookkeeping, and the lazily-started lifecycle (the first emission opens the
- * stream). A bridge never touches {@link AssistantMessageEventStream} directly;
- * it constructs a sink, drives it with normalized events, and returns the
- * sink's {@link stream}. This centralizes the
- * `ensureStarted → push* → finishSuccess/finishError` idiom so the per-bridge
- * code is purely a parser.
- *
- * The convenience methods cover the common path; {@link emit} accepts a raw
- * {@link NormalizedEvent} for parsers that prefer to yield the union directly.
- */
-export interface BridgeEventSink {
-    /**
-     * Open the underlying stream and push the framework `start` event, if it has
-     * not already started. Idempotent: safe to call before any emission, and a
-     * no-op once started. The convenience emitters call it implicitly.
-     */
-    start(): void;
-    /** Append a chunk of assistant answer text (opens a text block on first call). */
-    text(delta: string): void;
-    /** Append a chunk of reasoning text (opens a thinking block on first call). */
-    thinking(delta: string): void;
-    /** Emit a fully-formed tool call as its own content block. */
-    toolCall(call: ToolCall): void;
-    /**
-     * Map one {@link NormalizedEvent} onto the matching push call. The single
-     * entry point a parser can drive with the raw union; dispatches to
-     * {@link text} / {@link thinking} / {@link toolCall} / {@link finishSuccess} /
-     * {@link finishError} by `kind`. A `resume` event is informational and does
-     * not touch the stream.
-     */
-    emit(event: NormalizedEvent): void;
-    /**
-     * Settle the exchange successfully: close any open block, finalize the
-     * accumulated message, and push the framework `done` event with `reason`.
-     * Terminal — no further emissions are valid after this.
-     *
-     * @param reason the terminal stop reason (defaults to `"stop"`)
-     */
-    finishSuccess(reason?: FinishReason): void;
-    /**
-     * Settle the exchange in error: push the framework `error` event. The
-     * {@link BridgeFailure.aborted} flag selects the framework error reason
-     * (`aborted` vs `error`). Terminal.
-     *
-     * @param error the typed bridge failure
-     */
-    finishError(error: BridgeFailure): void;
-    /**
-     * The framework push stream the broker hands back to its caller. Populated
-     * asynchronously as the bridge drives the sink; consumers iterate it exactly
-     * as they would the stream `streamSimple` returns.
-     */
-    readonly stream: AssistantMessageEventStream;
-}
-/**
- * A single message exchanged with the child runtime over its {@link ChildTransport}.
- *
- * The `payload` is deliberately opaque: it is whatever the underlying protocol
- * carries — a parsed JSON line from a CLI's NDJSON stdout, a JSON-RPC
- * notification from a peer agent, a raw text chunk. The bridge that owns the
- * transport knows how to interpret it; the contract only fixes the envelope so
- * the transport interface itself is dialect-agnostic and mockable.
- */
-export interface ChildMessage {
-    /** The protocol payload (a parsed JSON value, a text line, an RPC frame). */
-    readonly payload: unknown;
-}
-/**
- * A request sent *to* the child runtime. The bridge formats the dialect-specific
- * body; the transport only relays it. `body` is opaque for the same reason
- * {@link ChildMessage.payload} is.
- */
-export interface ChildRequest {
-    /** The dialect-specific request body the bridge constructed. */
-    readonly body: unknown;
-}
-/**
- * The injectable boundary between a bridge and the actual child process / RPC
- * peer it drives.
- *
- * A production transport wraps a spawned process (its stdin/stdout, or a
- * JSON-RPC client over that process); a test transport is a hand-written fake
- * that records `send`s and replays canned {@link ChildMessage}s — so a bridge's
- * parser can be exercised with **no real binary launched**. The bridge depends
- * only on this interface, never on `child_process` directly.
- */
-export interface ChildTransport {
-    /**
-     * Relay one {@link ChildRequest} to the child (e.g. write a prompt to stdin or
-     * issue a JSON-RPC call). Resolves once the request has been handed off.
-     *
-     * @param request the dialect-specific request to deliver
-     */
-    send(request: ChildRequest): Promise<void>;
-    /**
-     * Register a listener for inbound {@link ChildMessage}s from the child
-     * (stdout lines, RPC notifications). Returns an unsubscribe function.
-     *
-     * @param listener invoked for each inbound message
-     * @returns a disposer that removes the listener
-     */
-    onMessage(listener: (message: ChildMessage) => void): () => void;
-    /**
-     * Terminate the child and release the transport. Idempotent; safe to call on
-     * an already-closed transport. After `close`, `send` rejects and no further
-     * messages are delivered.
-     */
-    close(): Promise<void>;
-}
-/**
- * Per-exchange options threaded into {@link RuntimeBridge.runExchange} (and the
- * framework `streamSimple` fallback the broker also drives).
- *
- * Extends the framework's {@link SimpleStreamOptions} (so `signal`, `apiKey`,
- * `reasoning`, etc. flow straight through to the network path) with the
- * routing-layer extras a bridge needs:
- *   - {@link sessionId} correlates the exchange with a persisted runtime session
- *     so the bridge can resume the underlying CLI session.
- *   - {@link cwd} is the working directory the child runtime is scoped to.
- *   - {@link resume} carries a previously-persisted token (e.g. a CLI session id
- *     / thread id) the bridge reattaches to instead of starting fresh.
- */
-export interface ExchangeOptions extends SimpleStreamOptions {
-    /** Stable session id to correlate / persist the runtime session under. */
-    readonly sessionId?: string;
-    /** Working directory the child runtime is scoped to (defaults to process cwd). */
-    readonly cwd?: string;
-    /** A resume token from a prior exchange to reattach the underlying session. */
-    readonly resume?: string;
-}
-/**
- * One external-runtime adapter: the strategy that produces a turn for a model
- * whose {@link ExternalRuntimeSpec} names it.
- *
- * A bridge is the dialect specialist. Given the bound {@link Model}, the
- * {@link Context}, per-exchange {@link ExchangeOptions}, and an **injected**
- * {@link ChildTransport}, it drives the child and returns the framework push
- * stream the turn streams into. The transport is a parameter (not constructed
- * internally) precisely so tests pass a fake and no real CLI is spawned.
- *
- * Bridges hold no per-session state on the contract surface; live session
- * handles and reuse/persistence are the {@link RuntimeBroker}'s concern.
- */
-export interface RuntimeBridge {
-    /** The adapter id this bridge answers to (matched against {@link ExternalRuntimeSpec.adapter}). */
-    readonly adapter: RuntimeAdapterId;
-    /**
-     * Drive one exchange against the external runtime and return the framework
-     * push stream it streams into. Returns the stream **synchronously** (the
-     * stream is populated asynchronously as the child emits), matching the shape
-     * of the framework's own `streamSimple`. The implementation reads inbound
-     * {@link ChildMessage}s off `transport`, parses them into
-     * {@link NormalizedEvent}s, and feeds a {@link BridgeEventSink}.
-     *
-     * @param model     the bound framework model for this exchange
-     * @param context   the framework conversation context
-     * @param opts      per-exchange options (session id, cwd, resume, stream opts)
-     * @param transport the injected child boundary to drive
-     */
-    runExchange(model: Model<Api>, context: Context, opts: ExchangeOptions, transport: ChildTransport): AssistantMessageEventStream;
-    /**
-     * Whether a model bound to this bridge needs a credential on disk before it
-     * can be offered. Returns `false` for an `"external-cli"` spec whose child
-     * owns its own auth (so the model is available with an empty vault), `true`
-     * for an `"api-key"` spec. The central auth-routing predicate.
-     *
-     * @param spec the external-runtime annotation to evaluate
-     */
-    requiresCredential(spec: ExternalRuntimeSpec): boolean;
-}
-/**
- * The outcome of a routing decision: either an external runtime owns the
- * exchange, or it falls through to the framework network stream.
- *
- *   - `"external"` carries the chosen {@link RuntimeBridge} and the resolved
- *     {@link ExternalRuntimeSpec} the broker will drive `runExchange` with.
- *   - `"framework"` signals the caller to run the framework `streamSimple` path
- *     unchanged.
- */
-export type RuntimeRoute = {
-    readonly target: "external";
-    readonly bridge: RuntimeBridge;
-    readonly spec: ExternalRuntimeSpec;
-} | {
-    readonly target: "framework";
-};
-/**
- * The router and registry over {@link RuntimeBridge}s — the single decision
- * point for "external runtime vs framework stream".
- *
- * The broker is asked to {@link route} every turn. If the model carries an
- * {@link ExternalRuntimeSpec} whose adapter resolves to a registered bridge,
- * the broker returns an `"external"` route the caller drives via the bridge's
- * `runExchange`; otherwise it returns a `"framework"` route and the caller runs
- * `streamSimple`. Bridges are {@link register}ed at assembly time and looked up
- * by adapter id.
- */
-export interface RuntimeBroker {
-    /**
-     * Add a {@link RuntimeBridge} to the registry, keyed by its
-     * {@link RuntimeBridge.adapter}. Registering an adapter id that already exists
-     * replaces the prior bridge.
-     *
-     * @param bridge the bridge to register
-     */
-    register(bridge: RuntimeBridge): void;
-    /**
-     * Decide how to produce a turn for `model`. Resolves the model's
-     * {@link ExternalRuntimeSpec} (via {@link resolveSpec}) and a matching
-     * registered bridge; returns an `"external"` route when both are present and
-     * the bridge's credential requirement is satisfiable, else a `"framework"`
-     * route. The framework `context`/`opts` are accepted so an implementation may
-     * factor them into routing, even though the base decision keys on the model.
-     *
-     * @param model   the model the turn is bound to
-     * @param context the framework conversation context for the turn
-     * @param opts    per-exchange options
-     */
-    route(model: Model<Api>, context: Context, opts: ExchangeOptions): RuntimeRoute;
-    /**
-     * Resolve the {@link ExternalRuntimeSpec} annotated onto a model, or
-     * `undefined` when the model is a plain HTTP-provider model. How the spec is
-     * attached (a side-table keyed by canonical id, a field on a catalog card, a
-     * `bridge:<adapter>` baseUrl decode) is the implementation's choice; the
-     * contract only fixes the lookup.
-     *
-     * @param model the model to inspect for a runtime annotation
-     */
-    resolveSpec(model: Model<Api>): ExternalRuntimeSpec | undefined;
-    /**
-     * Whether a runtime-annotated model needs a credential on disk before it can
-     * be offered as available. Delegates to the owning bridge's
-     * {@link RuntimeBridge.requiresCredential}; returns `false` for a model with
-     * no spec only when the caller treats "no runtime" as "framework auth applies
-     * elsewhere" — so this answers strictly the *runtime* credential question.
-     *
-     * @param spec the runtime annotation to evaluate
-     */
-    requiresCredential(spec: ExternalRuntimeSpec): boolean;
-}

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

@@ -1,21 +0,0 @@
-/**
- * Runtime-bridge subsystem — public barrel.
- *
- * Re-exports the FROZEN provider-routing contract: the external-runtime
- * annotation ({@link ExternalRuntimeSpec} + the `bridge:<adapter>` endpoint
- * convention), the provider-neutral {@link NormalizedEvent} union, the single
- * {@link BridgeEventSink} push-stream helper, the injectable
- * {@link ChildTransport} boundary, and the routing surface itself
- * ({@link RuntimeBridge}, {@link RuntimeBroker}, {@link RuntimeRoute}).
- *
- * Behavior modules (the concrete bridges under `bridges/`, the sink
- * implementation, the broker) are added to this barrel as they land; consumers
- * import the routing surface from `src/runtime-bridge` rather than reaching into
- * individual modules.
- */
-export type { RuntimeAdapterId, RuntimeAuthMode, ExternalRuntimeSpec, RuntimeEndpointScheme, NormalizedEvent, NormalizedEventKind, NormalizedEventOf, FinishReason, BridgeFailure, BridgeEventSink, ChildMessage, ChildRequest, ChildTransport, ExchangeOptions, RuntimeBridge, RuntimeBroker, RuntimeRoute, Api, AssistantMessage, AssistantMessageEventStream, Context, KnownProvider, Model, SimpleStreamOptions, StopReason, ToolCall, } from "./contract";
-export { RUNTIME_ENDPOINT_SCHEME, runtimeEndpoint } from "./contract";
-export type { BridgeMessageSeed } from "./sink";
-export { createBridgeSink } from "./sink";
-export { claudeCliBridge, codexCliBridge, indusagiCliBridge, makeIndusagiCliBridge, BUILTIN_RUNTIME_SPECS, BUILTIN_ADAPTERS, builtinRuntimeSpec, annotateCard, withRuntimeEndpoint, specFromModel, type RuntimeAnnotatedModel, driveExchange, seedFromModel, type ChildParser, type ParseStep, } from "./bridges";
-export { createRuntimeBroker, runtimeSourceKey, RUNTIME_LINK_ENTRY, type RuntimeBrokerRuntime, type RuntimeBrokerDeps, type ChildTransportFactory, type TransportContext, type FrameworkStream, type RuntimeLink, type RuntimeLinkStore, type RuntimeLinkEntryTag, type ResumeEvent, } from "./broker";