indusagi 0.12.32 → 0.12.34

package/dist/types/react-ink/types.d.ts

@@ -0,0 +1,133 @@
+import type { AgentMessage, ThinkingLevel } from "indusagi/agent";
+import type { AuthInputPrompt, AuthRedirectInfo, Model } from "indusagi/ai";
+export type StatusKind = "info" | "success" | "warning" | "error" | "busy";
+export interface StatusMessage {
+    kind: StatusKind;
+    text: string;
+}
+export interface ToolExecutionState {
+    toolCallId: string;
+    toolName: string;
+    argsText: string;
+    status: "running" | "success" | "error";
+    outputText: string;
+    args?: unknown;
+    output?: unknown;
+    updatedAt: number;
+}
+export interface PendingMessageItem {
+    id: string;
+    mode: "steer" | "followUp";
+    text: string;
+    source: "session" | "compaction";
+}
+export interface UserMessageOption {
+    entryId: string;
+    text: string;
+    preview: string;
+}
+export interface SessionTreeOption {
+    id: string | null;
+    label: string;
+    depth: number;
+    isLeaf: boolean;
+    isCurrent: boolean;
+}
+export interface LoginProviderOption {
+    id: string;
+    label: string;
+    authKind: "oauth" | "apiKey";
+}
+export interface SavedAccountOption {
+    provider: string;
+    accountId: string;
+    label: string;
+}
+export interface OAuthOverlayState {
+    kind: "oauth";
+    providerId: string;
+    providerName: string;
+    mode: "oauth" | "apiKey";
+    inputLabel: string;
+    inputValue: string;
+    accountId: string;
+    accountName: string;
+    authInfo?: AuthRedirectInfo;
+    prompt?: AuthInputPrompt;
+    progress?: string;
+}
+export interface SessionInfo {
+    id: string;
+    path: string;
+    name?: string;
+    modified: Date;
+    lastModified: number;
+    size?: number;
+    cwd?: string;
+    messageCount?: number;
+    firstMessage?: string;
+    allMessagesText?: string;
+}
+export interface SessionStats {
+    sessionFile?: string;
+    sessionId: string;
+    userMessages: number;
+    assistantMessages: number;
+    toolCalls: number;
+    toolResults: number;
+    totalMessages: number;
+    tokens: {
+        input: number;
+        output: number;
+        cacheRead: number;
+        cacheWrite: number;
+        total: number;
+    };
+    cost: number;
+}
+export interface SessionSnapshot {
+    messages: AgentMessage[];
+    model: Model<any> | undefined;
+    thinkingLevel: ThinkingLevel;
+    isStreaming: boolean;
+    isCompacting: boolean;
+    isBashRunning: boolean;
+    pendingMessageCount: number;
+    pendingToolCallCount: number;
+    sessionId: string;
+    sessionFile: string | undefined;
+    sessionName: string | undefined;
+    cwd: string;
+    autoCompactEnabled: boolean;
+    leafId: string | null | undefined;
+    error?: string;
+    stats: SessionStats;
+    contextUsage?: {
+        tokens: number;
+        contextWindow: number;
+        percent: number;
+    };
+}
+export interface StartupNotice {
+    kind: StatusKind;
+    text: string;
+}
+export interface StartupChangelog {
+    latestVersion: string;
+    markdown: string;
+}
+export interface StartupDiagnosticsSection {
+    title: string;
+    lines: string[];
+    tone?: "default" | "warning" | "error";
+}
+export interface StartupDiagnostics {
+    sections: StartupDiagnosticsSection[];
+}
+export interface UiDisplayBlock {
+    id: string;
+    kind: "changelog";
+    title: string;
+    markdown: string;
+    timestamp: number;
+}

package/dist/types/react-ink/utils/message-groups.d.ts

@@ -0,0 +1,25 @@
+import type { AgentMessage } from "indusagi/agent";
+import type { AssistantMessage, ImageContent, TextContent, ToolCall, ToolResultMessage, UserMessage } from "indusagi/ai";
+export declare function previewText(value: string, maxLength?: number): string;
+export declare function safeStringify(value: unknown): string;
+export declare function extractToolText(value: unknown, showImages: boolean): string;
+export declare function previewMultiline(value: string, options?: {
+    maxLines?: number;
+    maxChars?: number;
+}): string;
+export declare function formatUserContent(content: UserMessage["content"], showImages: boolean): string;
+export declare function splitAssistantMessage(message: AssistantMessage, showThinking: boolean): {
+    text: string;
+    thinking: string[];
+    toolCalls: ToolCall[];
+};
+export declare function formatToolCall(toolCall: ToolCall): string;
+export declare function formatToolResult(message: ToolResultMessage, showImages: boolean): string;
+export declare function formatCustomContent(content: string | (TextContent | ImageContent)[], showImages: boolean): string;
+export declare function formatMessageTimestamp(timestamp: number): string;
+export declare function extractMessagePreview(message: AgentMessage): string;
+export declare function parseSkillInvocation(content: string): {
+    name: string;
+    location: string;
+    userMessage?: string;
+} | null;

package/dist/types/react-ink/utils/selection-dialog.d.ts

@@ -0,0 +1,2 @@
+export declare function matchesSearchQuery(value: string, query: string): boolean;
+export declare function wrapSelectionIndex(current: number, direction: 1 | -1, length: number): number;

package/dist/types/react-ink/utils/session-browser.d.ts

@@ -0,0 +1,27 @@
+import type { SessionInfo } from "../types.js";
+export type SessionSortMode = "recent" | "relevance";
+export type SessionScope = "current" | "all";
+type TokenKind = "fuzzy" | "phrase";
+interface ParsedSearchQuery {
+    mode: "tokens" | "regex";
+    tokens: {
+        kind: TokenKind;
+        value: string;
+    }[];
+    regex: RegExp | null;
+    error?: string;
+}
+export interface SessionBrowserProgress {
+    loaded: number;
+    total: number;
+}
+export declare function wrapSelectionIndex(current: number, direction: 1 | -1, length: number): number;
+export declare function parseSessionSearchQuery(query: string): ParsedSearchQuery;
+export declare function filterAndSortSessions(sessions: SessionInfo[], query: string, sortMode: SessionSortMode): {
+    items: SessionInfo[];
+    error?: string;
+};
+export declare function formatSessionAge(lastModified: number): string;
+export declare function formatSessionSize(bytes: number): string;
+export declare function shrinkSessionId(id: string): string;
+export {};

package/dist/types/react-ink/utils/tool-display.d.ts

@@ -0,0 +1,37 @@
+import type { ToolCall, ToolResultMessage } from "indusagi/ai";
+import type { InkThemeAdapter } from "../theme-adapter.js";
+import type { ToolExecutionState } from "../types.js";
+import { type StructuredDiff } from "../diff/structured.js";
+export interface ToolCardDescriptor {
+    title: string;
+    summary?: string;
+    body?: string;
+    emptyText: string;
+    /**
+     * When true the `body` already carries syntax-highlight ANSI and must be
+     * rendered verbatim — the renderer keeps the escapes instead of stripping
+     * them. Set for read/write/edit bodies highlighted from their file path.
+     */
+    preformatted?: boolean;
+    /**
+     * A structured edit/write diff. When present the renderer draws a colored
+     * diff block (line-number gutter, +/- backgrounds, word-level emphasis)
+     * instead of the plain `body`.
+     */
+    diff?: StructuredDiff;
+}
+interface ToolSource {
+    toolName: string;
+    args?: unknown;
+    output?: unknown;
+    fallbackArgsText?: string;
+    fallbackOutputText?: string;
+    showImages?: boolean;
+    /** When present, read/write/edit bodies are syntax-highlighted against it. */
+    theme?: InkThemeAdapter;
+}
+export declare function describeToolSource(source: ToolSource): ToolCardDescriptor;
+export declare function describeToolExecution(tool: ToolExecutionState): ToolCardDescriptor;
+export declare function describeToolCall(toolCall: ToolCall): ToolCardDescriptor;
+export declare function describeToolResult(message: ToolResultMessage, showImages: boolean, args?: unknown, theme?: InkThemeAdapter): ToolCardDescriptor;
+export {};

package/dist/types/runtime/cadence/cadence.test.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Behavioural tests for the pure cadence FSM. Each test threads signals through
+ * the bound step function and asserts on the derived snapshot and the requested
+ * effects — no I/O, no mocks of the outside world.
+ */
+export {};

package/dist/types/runtime/cadence/fold.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Folding emissions into an assistant turn.
+ *
+ * The reducer keeps the in-flight assistant {@link Turn} as an ordinary
+ * immutable value and grows it one {@link Emission} at a time. These helpers do
+ * that growth purely: each returns a brand-new block list (or turn, or usage)
+ * rather than mutating its argument. Streaming a response means appending text
+ * and reasoning deltas, opening tool-call blocks and concatenating their
+ * argument fragments, and summing token accounting.
+ *
+ * While arguments stream in, a tool-call block's `input` holds the raw,
+ * still-growing JSON string. {@link sealToolArgs} converts those strings into
+ * parsed values once the stream ends, so partial JSON never escapes the turn.
+ * A terminal `done` emission's fully-assembled blocks supersede the accumulated
+ * ones entirely.
+ */
+import type { AssistantTurn, Block, Emission, ToolCallBlock, Usage } from "../../llmgateway/contract";
+/** A neutral, all-zero usage accumulator. */
+export declare const ZERO_USAGE: Usage;
+/** Sum two usage records field by field, preserving present cache tiers only. */
+export declare function addUsage(base: Usage, more: Usage): Usage;
+/** Parse an accumulated argument buffer, tolerating empty/invalid JSON. */
+export declare function parseToolArgs(raw: string): unknown;
+/**
+ * Fold a single emission into a block list, returning a new list.
+ *
+ * Text and thinking deltas extend the trailing block of their kind when one is
+ * open, otherwise they start a fresh one. A `tool_call_start` opens a new
+ * tool-call block whose `input` begins as an empty raw buffer; each
+ * `tool_call_delta` concatenates onto that buffer in place. A terminal `done`
+ * replaces the whole list with the reply's authoritative blocks. Emissions that
+ * carry no content leave the list untouched (the same array reference is
+ * returned, which callers may use to detect "no change").
+ */
+export declare function foldBlocks(blocks: readonly Block[], emission: Emission): readonly Block[];
+/**
+ * Finalize an assistant turn after its stream ends: every tool-call block whose
+ * `input` is still a raw JSON string is parsed into a structured value. Returns
+ * the same turn reference when nothing needed sealing.
+ */
+export declare function sealToolArgs(turn: AssistantTurn): AssistantTurn;
+/**
+ * Fold an emission into an assistant turn, returning a new turn. A thin wrapper
+ * over {@link foldBlocks} that preserves the `assistant` role.
+ */
+export declare function foldTurn(turn: AssistantTurn, emission: Emission): AssistantTurn;
+/** Collect the tool-call blocks present in an assistant turn, in order. */
+export declare function toolCallsOf(turn: AssistantTurn): readonly ToolCallBlock[];

package/dist/types/runtime/cadence/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The cadence — the pure finite-state machine that drives a run.
+ *
+ * This barrel exposes the reducer factory and its supporting fold helpers. A
+ * host binds {@link cadence} to a static {@link import("../contract").AgentConfig}
+ * to obtain a `(state, signal) => { state, effects }` step function, threads
+ * signals through it, and interprets the returned effects. Everything here is
+ * pure: no I/O, no awaiting, no mutation of inputs.
+ */
+export type { Transition, StepFn } from "./reducer";
+export { cadence, initialSnapshot } from "./reducer";
+export { ZERO_USAGE, addUsage, parseToolArgs, foldBlocks, foldTurn, sealToolArgs, toolCallsOf, } from "./fold";

package/dist/types/runtime/cadence/reducer.d.ts

@@ -0,0 +1,44 @@
+/**
+ * The pure finite-state machine at the heart of the runtime.
+ *
+ * {@link step} takes the current immutable {@link RunSnapshot} and one incoming
+ * {@link Signal}, and returns the next snapshot plus the {@link Effect}s a driver
+ * must perform. It performs no I/O and never awaits; every transition derives a
+ * fresh snapshot (the input is treated as frozen) and a flat list of effects.
+ *
+ * The agent loop is encoded as a transition table rather than nested control
+ * flow:
+ *
+ *   submit                         → invoke_model              · phase invoking
+ *   emission (text/thinking)       → fold + publish delta      · phase streaming
+ *   emission (tool start/delta)    → fold + tool_started       · phase streaming
+ *   emission (usage)               → accumulate usage          · (phase kept)
+ *   emission (error)               → faulted                   · phase faulted
+ *   stream_end · has tool calls    → run_tool × N              · phase dispatching
+ *   stream_end · no tool calls     → persist + settled         · phase settled
+ *   tool_settled · more pending    → (mark done, keep waiting) · phase dispatching
+ *   tool_settled · all done        → append tool turn,         · phase invoking
+ *                                     invoke_model (next turn)
+ *   compacted                      → splice summary,           · phase invoking
+ *                                     invoke_model
+ *   abort                          → faulted (aborted)         · phase faulted
+ *   fault                          → faulted                   · phase faulted
+ *
+ * Bind the machine to its static {@link AgentConfig} with {@link cadence}; the
+ * returned function has the exact `(state, signal) => { state, effects }` shape.
+ */
+import type { AgentConfig, Effect, RunSnapshot, Signal } from "../contract";
+/** The result of one transition: the next snapshot and the effects to run. */
+export interface Transition {
+    readonly state: RunSnapshot;
+    readonly effects: Effect[];
+}
+/** A reducer bound to its static configuration. */
+export type StepFn = (state: RunSnapshot, signal: Signal) => Transition;
+/**
+ * Build a clean starting snapshot for a session. Phase is `idle` until the
+ * first `submit` signal arrives.
+ */
+export declare function initialSnapshot(sessionId: string, model: string, runId?: string): RunSnapshot;
+/** A factory binding the FSM to its static config. */
+export declare function cadence(config: AgentConfig): StepFn;

package/dist/types/runtime/conductor/agent.d.ts

@@ -0,0 +1,71 @@
+/**
+ * The conductor — the only stateful, side-effecting layer of the runtime.
+ *
+ * Everything beneath it is pure or single-purpose: the {@link cadence} reducer
+ * decides *what* should happen by returning {@link Effect}s; the conductor is
+ * the sole place those effects are actually carried out. It threads a serial
+ * stream of {@link Signal}s through the reducer, performs each emitted effect
+ * (reach the model, run tools, persist, condense, publish), and folds the
+ * resulting signals back in — turning over and over until the run reaches a
+ * `settled` or `faulted` terminal phase.
+ *
+ * The public {@link createAgent} returns an {@link Agent} whose `submit` drives
+ * one prompt to settlement, `subscribe` taps the live event stream, `abort`
+ * tears the current run down, `snapshot` reads the latest state, and `resume`
+ * rehydrates an earlier session from the store.
+ *
+ * The model entrypoint is injectable: by default it is the gateway bound to the
+ * configured model id, but tests pass a scripted {@link ModelInvoker} to make a
+ * run deterministic without touching the network.
+ */
+import type { Turn } from "../../llmgateway/contract";
+import type { AgentConfig, ModelInvoker, RunSnapshot } from "../contract";
+import type { RunEventHandler, Unsubscribe } from "../ledger";
+/** The handler shape a caller registers with {@link Agent.subscribe}. */
+export type AgentEventHandler = RunEventHandler;
+/**
+ * The optional collaborators a host may inject. All default to a production
+ * wiring; tests override `invokeModel` to script the model deterministically.
+ */
+export interface AgentDeps {
+    /**
+     * The seam through which the conductor reaches a model. Defaults to the
+     * gateway's `stream`, bound to {@link AgentConfig.model}.
+     */
+    readonly invokeModel?: ModelInvoker;
+    /** Where settled history is durably written. Typed loose to stay swappable. */
+    readonly store?: unknown;
+    /** Where run events are published. Typed loose to stay swappable. */
+    readonly ledger?: unknown;
+}
+/**
+ * The driveable agent. One agent owns one logical session; each {@link submit}
+ * opens a fresh run that streams to settlement.
+ */
+export interface Agent {
+    /**
+     * Drive a prompt to settlement and resolve the terminal snapshot.
+     *
+     * `input` is either a ready list of {@link Turn}s or a bare string (sugar for
+     * a single user text turn). If a run is already in flight, the input is folded
+     * into it as steering rather than starting a competing run.
+     */
+    submit(input: Turn[] | string): Promise<RunSnapshot>;
+    /** Tap the live {@link RunEvent} stream; returns a disposer. */
+    subscribe(handler: AgentEventHandler): Unsubscribe;
+    /** Tear down the current run, faulting it with an `aborted` error. */
+    abort(): void;
+    /** Read the latest {@link RunSnapshot}. */
+    snapshot(): RunSnapshot;
+    /** Rehydrate this agent's messages from a persisted session. */
+    resume(sessionId: string): Promise<void>;
+}
+/**
+ * Build a runnable {@link Agent} over a static {@link AgentConfig}.
+ *
+ * Wires the pure reducer to its real-world effect handlers: the model invoker
+ * (default = gateway), the tool scheduler (over `config.tools?.runner`), the
+ * session store, the condensation engine, and the event ledger. The returned
+ * agent is the host-facing handle.
+ */
+export declare function createAgent(config: AgentConfig, deps?: AgentDeps): Agent;

package/dist/types/runtime/conductor/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The conductor — public surface.
+ *
+ * The top-level orchestrator that ties the pure {@link import("../cadence").cadence}
+ * reducer to its real-world effect handlers (model, tools, store, condensation,
+ * ledger) and exposes the host-facing {@link Agent}. {@link createAgent} is the
+ * single entry point; everything beneath the conductor stays pure or
+ * single-purpose.
+ */
+export { createAgent } from "./agent";
+export type { Agent, AgentDeps, AgentEventHandler } from "./agent";

package/dist/types/runtime/contract/config.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Static configuration for a run.
+ *
+ * An {@link AgentConfig} is the immutable setup a caller supplies before any
+ * signals flow: which model to use, an optional system preamble, the tools the
+ * model may call, output and reasoning ceilings, and the policy that governs
+ * when history is condensed.
+ */
+import type { ThinkingLevel } from "../../llmgateway/contract";
+import type { ToolBox } from "./tools";
+/**
+ * The threshold policy for context condensation.
+ *
+ * When accumulated usage crosses `triggerRatio` of the model's window, the
+ * oldest history is condensed while the most recent `keepRecent` turns are
+ * preserved verbatim.
+ */
+export interface CompactionPolicy {
+    /** Fraction of the context window (0..1) at which condensation triggers. */
+    readonly triggerRatio: number;
+    /** Number of trailing turns kept untouched during condensation. */
+    readonly keepRecent: number;
+}
+/** The immutable setup for a run. */
+export interface AgentConfig {
+    /** The model id to bind the run to. */
+    readonly model: string;
+    /** Optional system preamble prepended to every model invocation. */
+    readonly system?: string;
+    /** The tools the model may call, and the runner that fulfils them. */
+    readonly tools?: ToolBox;
+    /** Hard ceiling on output tokens per model invocation. */
+    readonly maxOutputTokens?: number;
+    /** Requested reasoning depth for reasoning-capable models. */
+    readonly thinking?: ThinkingLevel;
+    /** When and how aggressively to condense history; absent disables it. */
+    readonly compaction?: CompactionPolicy;
+    /**
+     * Maximum number of model turns a single run may take before it is
+     * force-faulted. Guards against a model that loops forever (e.g. repeatedly
+     * requesting the same tool). Defaults to 64.
+     */
+    readonly maxTurns?: number;
+}

package/dist/types/runtime/contract/effect.d.ts

@@ -0,0 +1,41 @@
+/**
+ * The side-effects the pure loop requests.
+ *
+ * The reducer performs no I/O. Instead it returns a list of {@link Effect}s
+ * describing what the outside world should do next: invoke the model, run a
+ * tool, persist a snapshot, condense history, or publish an event. A thin
+ * driver interprets each effect and feeds the results back in as
+ * {@link import("./signal").Signal}s, closing the loop.
+ */
+import type { Conversation, StreamOptions, Turn } from "../../llmgateway/contract";
+import type { RunSnapshot } from "./run-state";
+import type { ToolCall } from "./tools";
+import type { RunEvent } from "./events";
+/** Ask the driver to start a streaming model invocation for this conversation. */
+export interface InvokeModelEffect {
+    readonly kind: "invoke_model";
+    readonly conversation: Conversation;
+    readonly options: StreamOptions;
+}
+/** Ask the driver to execute one tool the model requested. */
+export interface RunToolEffect {
+    readonly kind: "run_tool";
+    readonly call: ToolCall;
+}
+/** Ask the driver to durably record the given snapshot. */
+export interface PersistEffect {
+    readonly kind: "persist";
+    readonly snapshot: RunSnapshot;
+}
+/** Ask the driver to condense the given history into a summary turn. */
+export interface CompactEffect {
+    readonly kind: "compact";
+    readonly messages: readonly Turn[];
+}
+/** Ask the driver to broadcast an event to subscribers. */
+export interface PublishEffect {
+    readonly kind: "publish";
+    readonly event: RunEvent;
+}
+/** The tagged union of every side-effect the pure loop can request. */
+export type Effect = InvokeModelEffect | RunToolEffect | PersistEffect | CompactEffect | PublishEffect;

package/dist/types/runtime/contract/errors.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The run error model.
+ *
+ * Failures inside a run are surfaced as a typed, discriminable value rather
+ * than thrown exceptions or synthetic assistant messages. A {@link RunError}
+ * becomes the `error` field of a faulted {@link import("./run-state").RunSnapshot}
+ * and the payload of a `fault` signal, so callers branch on `kind` instead of
+ * matching message strings.
+ */
+/** The class of failure a {@link RunError} represents. */
+export type RunErrorKind = "model_failed" | "tool_failed" | "aborted" | "compaction_failed" | "turn_budget" | "invalid_state";
+/** A normalized, discriminable failure raised anywhere inside a run. */
+export interface RunError {
+    /** Which failure class this is. */
+    readonly kind: RunErrorKind;
+    /** A human-readable description. */
+    readonly message: string;
+    /** The underlying error or value that triggered this one, if any. */
+    readonly cause?: unknown;
+}
+/** Construct a {@link RunError}. Convenience over an object literal. */
+export declare function runError(kind: RunErrorKind, message: string, cause?: unknown): RunError;

package/dist/types/runtime/contract/events.d.ts

@@ -0,0 +1,63 @@
+/**
+ * What subscribers observe, and how the model is reached.
+ *
+ * A {@link RunEvent} is the outward-facing notification the loop publishes (via
+ * a `publish` effect) so hosts can render progress: each new snapshot, each
+ * incremental text/thinking delta, the lifecycle of every tool, and the
+ * terminal settle/fault. A {@link ModelInvoker} is the single injectable seam
+ * through which the loop reaches a model — defaulted to the gateway later, but
+ * swappable so tests can script a deterministic channel.
+ */
+import type { Channel, Conversation, StreamOptions } from "../../llmgateway/contract";
+import type { RunSnapshot } from "./run-state";
+import type { RunError } from "./errors";
+import type { ToolOutcome } from "./tools";
+/** A fresh immutable snapshot was produced. */
+export interface SnapshotEvent {
+    readonly kind: "snapshot";
+    readonly snapshot: RunSnapshot;
+}
+/** An incremental fragment of assistant prose arrived from the model. */
+export interface TextDeltaEvent {
+    readonly kind: "text_delta";
+    readonly delta: string;
+}
+/** An incremental fragment of model reasoning arrived. */
+export interface ThinkingDeltaEvent {
+    readonly kind: "thinking_delta";
+    readonly delta: string;
+}
+/** A tool the model requested began executing. */
+export interface ToolStartedEvent {
+    readonly kind: "tool_started";
+    readonly id: string;
+    readonly name: string;
+}
+/** A tool finished, successfully or not. */
+export interface ToolFinishedEvent {
+    readonly kind: "tool_finished";
+    readonly id: string;
+    readonly name: string;
+    readonly outcome: ToolOutcome;
+}
+/** The run reached a clean terminal state. */
+export interface SettledEvent {
+    readonly kind: "settled";
+    readonly snapshot: RunSnapshot;
+}
+/** The run reached a faulted terminal state. */
+export interface FaultedEvent {
+    readonly kind: "faulted";
+    readonly error: RunError;
+    readonly snapshot: RunSnapshot;
+}
+/** The tagged union of every notification a subscriber can receive. */
+export type RunEvent = SnapshotEvent | TextDeltaEvent | ThinkingDeltaEvent | ToolStartedEvent | ToolFinishedEvent | SettledEvent | FaultedEvent;
+/**
+ * The injectable model entrypoint.
+ *
+ * Given a provider-neutral conversation and per-call options, it returns a
+ * {@link Channel} of streaming emissions. The production wiring delegates to the
+ * gateway's `stream`; tests supply a function that yields a scripted channel.
+ */
+export type ModelInvoker = (conversation: Conversation, options: StreamOptions) => Channel;

package/dist/types/runtime/contract/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Frozen type vocabulary for the agent runtime.
+ *
+ * Every runtime module imports its shared types from this barrel. The contract
+ * is deliberately pure: types and the small `runError` helper only — no I/O, no
+ * loop logic. Gateway types (`Conversation`, `Turn`, `Reply`, `Emission`,
+ * `Channel`, `StreamOptions`, etc.) are re-exported by the modules that consume
+ * them and are not duplicated here.
+ */
+export type { RunPhase, PendingTool, RunSnapshot } from "./run-state";
+export type { SubmitSignal, EmissionSignal, StreamEndSignal, ToolSettledSignal, CompactedSignal, AbortSignalInput, FaultSignal, Signal, } from "./signal";
+export type { InvokeModelEffect, RunToolEffect, PersistEffect, CompactEffect, PublishEffect, Effect, } from "./effect";
+export type { ToolCall, ToolOutcome, ToolRunner, ToolBox } from "./tools";
+export type { RunErrorKind, RunError } from "./errors";
+export { runError } from "./errors";
+export type { SnapshotEvent, TextDeltaEvent, ThinkingDeltaEvent, ToolStartedEvent, ToolFinishedEvent, SettledEvent, FaultedEvent, RunEvent, ModelInvoker, } from "./events";
+export type { SessionNode, SessionHead, Migrator } from "./session";
+export type { CompactionPolicy, AgentConfig } from "./config";