@agentic-patterns/runtime 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,3406 @@
+import { LanguageModelV1, CoreMessage, LanguageModelV1CallOptions } from 'ai';
+import * as _anthropic_ai_claude_agent_sdk from '@anthropic-ai/claude-agent-sdk';
+import { Options } from '@anthropic-ai/claude-agent-sdk';
+import * as _agentic_patterns_core from '@agentic-patterns/core';
+import { Capability, ToolSchema, Toolbox, ToolDefinition, Agent, Agency, Role, Judgment, Responsibility } from '@agentic-patterns/core';
+import { z } from 'zod';
+
+/**
+ * Claude Code hook event — bridges Claude Code lifecycle hooks into the
+ * AgentEventBus.
+ *
+ * The Claude Code CLI emits hook callbacks (PreToolUse, PostToolUse,
+ * SessionStart, etc.) as JSON payloads to a configured command. The hook
+ * bridge in `@agentic-patterns/server` receives those payloads via HTTP
+ * and republishes each one as a `ClaudeCodeHookEvent`.
+ *
+ * The full raw hook payload is preserved on `payload` so downstream
+ * consumers (dashboards, exporters) never lose information. A small
+ * mappable subset (PreToolUse / PostToolUse) is also projected onto the
+ * canonical `agent.tool.start` / `agent.tool.end` events by the
+ * `mapClaudeCodeHookToAgentEvents` helper in
+ * `./claude-code-mapper.ts` — that lives in a separate file so this
+ * module stays a pure type/constant declaration.
+ */
+
+declare const CLAUDE_CODE_HOOK_EVENTS: readonly ["SessionStart", "InstructionsLoaded", "UserPromptSubmit", "PreToolUse", "PermissionRequest", "PermissionDenied", "PostToolUse", "PostToolUseFailure", "Notification", "SubagentStart", "SubagentStop", "TaskCreated", "TaskCompleted", "Stop", "StopFailure", "TeammateIdle", "ConfigChange", "CwdChanged", "FileChanged", "WorktreeCreate", "WorktreeRemove", "PreCompact", "PostCompact", "Elicitation", "ElicitationResult", "SessionEnd"];
+type ClaudeCodeHookName = (typeof CLAUDE_CODE_HOOK_EVENTS)[number];
+/**
+ * A single Claude Code hook callback, lifted into an AgentEvent.
+ *
+ * Every Claude Code hook invocation produces one of these. The full
+ * raw payload is preserved on `payload`; common fields (sessionId,
+ * cwd, toolName, ...) are also surfaced as top-level convenience
+ * properties for typed consumers. PreToolUse and PostToolUse can be
+ * additionally mapped to canonical `agent.tool.start` / `agent.tool.end`
+ * events via `mapClaudeCodeHookToAgentEvents`.
+ */
+interface ClaudeCodeHookEvent extends BaseEvent {
+    readonly type: "claude_code.hook";
+    readonly hookName: ClaudeCodeHookName;
+    readonly sessionId: string;
+    readonly transcriptPath?: string;
+    readonly cwd?: string;
+    readonly permissionMode?: string;
+    readonly toolName?: string;
+    readonly toolInput?: unknown;
+    readonly toolResponse?: unknown;
+    readonly toolUseId?: string;
+    /** Full raw hook payload, preserved verbatim. */
+    readonly payload: Record<string, unknown>;
+    /**
+     * Correlation id propagated from a runner (e.g. `ClaudeCodeRunner`) that
+     * is already observing this session. When present, the hook route SKIPS
+     * deriving `agent.tool.start`/`agent.tool.end` events — the runner
+     * already emits them — while still preserving the raw hook event for
+     * full fidelity (PreCompact, PermissionRequest, etc.).
+     */
+    readonly runnerCorrelationId?: string;
+}
+declare function isClaudeCodeHookName(s: unknown): s is ClaudeCodeHookName;
+
+/**
+ * Core event types for runner observability.
+ *
+ * All events use a discriminated union on the `type` field.
+ * Trace fields (traceId, runId, spanId, parentSpanId, timestamp) on every event.
+ */
+
+interface BaseEvent {
+    readonly type: string;
+    readonly traceId: string;
+    readonly runId: string;
+    readonly spanId: string;
+    readonly parentSpanId?: string;
+    readonly timestamp: Date;
+}
+interface MessageStartEvent extends BaseEvent {
+    readonly type: "agent.message.start";
+    readonly agentName: string;
+    readonly agentConfig?: Record<string, unknown>;
+}
+interface MessageChunkEvent extends BaseEvent {
+    readonly type: "agent.message.chunk";
+    readonly delta: string;
+    readonly chunkIndex: number;
+}
+interface MessageCompleteEvent extends BaseEvent {
+    readonly type: "agent.message.complete";
+    readonly content: string;
+    readonly inputTokens: number;
+    readonly outputTokens: number;
+    readonly model: string;
+}
+interface ReasoningEvent extends BaseEvent {
+    readonly type: "agent.reasoning";
+    readonly content: string;
+    readonly isComplete: boolean;
+}
+interface ToolCallIntent extends BaseEvent {
+    readonly type: "agent.tool.intent";
+    readonly toolCallId: string;
+    readonly toolName: string;
+    readonly arguments: Record<string, unknown>;
+}
+interface ToolCallRejectedEvent extends BaseEvent {
+    readonly type: "agent.tool.rejected";
+    readonly toolName: string;
+    readonly reason: string;
+    readonly gateName: string;
+    readonly gateCategory: string;
+    readonly originalIntent: ToolCallIntent;
+}
+interface ToolCallStartEvent extends BaseEvent {
+    readonly type: "agent.tool.start";
+    readonly toolCallId: string;
+    readonly toolName: string;
+    readonly arguments: Record<string, unknown>;
+    readonly parentEventId?: string;
+}
+interface ToolCallEndEvent extends BaseEvent {
+    readonly type: "agent.tool.end";
+    readonly toolCallId: string;
+    readonly toolName: string;
+    readonly arguments: Record<string, unknown>;
+    readonly result: unknown;
+    readonly error?: string;
+    readonly durationMs: number;
+    readonly resultTokens: number;
+}
+interface IterationStartEvent extends BaseEvent {
+    readonly type: "agent.iteration.start";
+    readonly iteration: number;
+    readonly maxIterations: number;
+}
+interface IterationEndEvent extends BaseEvent {
+    readonly type: "agent.iteration.end";
+    readonly iteration: number;
+    readonly toolCallsCount: number;
+    readonly hasMore: boolean;
+}
+interface LLMCallStartEvent extends BaseEvent {
+    readonly type: "agent.llm.start";
+    readonly model: string;
+    readonly messageCount: number;
+    readonly hasTools: boolean;
+}
+interface LLMCallEndEvent extends BaseEvent {
+    readonly type: "agent.llm.end";
+    readonly model: string;
+    readonly inputTokens: number;
+    readonly outputTokens: number;
+    readonly durationMs: number;
+    readonly hasToolCalls: boolean;
+    readonly finishReason: string;
+}
+interface ConversationStartEvent extends BaseEvent {
+    readonly type: "agent.conversation.start";
+    readonly conversationId: string;
+    readonly agentName: string;
+}
+interface ConversationEndEvent extends BaseEvent {
+    readonly type: "agent.conversation.end";
+    readonly conversationId: string;
+    readonly reason: "completed" | "error" | "cancelled";
+}
+interface MessageCancelEvent extends BaseEvent {
+    readonly type: "agent.message.cancel";
+    readonly reason?: string;
+}
+interface ThinkingStartEvent extends BaseEvent {
+    readonly type: "agent.thinking.start";
+}
+interface ToolProgressEvent extends BaseEvent {
+    readonly type: "agent.tool.progress";
+    readonly toolCallId: string;
+    readonly progress?: number;
+    readonly statusText?: string;
+}
+interface ErrorEvent extends BaseEvent {
+    readonly type: "agent.error";
+    readonly errorType: string;
+    readonly message: string;
+    readonly recoverable: boolean;
+    readonly stackTrace?: string;
+    readonly context: Record<string, unknown>;
+}
+type AgentEvent = ConversationStartEvent | ConversationEndEvent | MessageStartEvent | MessageChunkEvent | MessageCompleteEvent | MessageCancelEvent | ReasoningEvent | ThinkingStartEvent | ToolCallIntent | ToolCallRejectedEvent | ToolCallStartEvent | ToolCallEndEvent | ToolProgressEvent | IterationStartEvent | IterationEndEvent | LLMCallStartEvent | LLMCallEndEvent | ErrorEvent | ClaudeCodeHookEvent;
+/** All possible agent event type strings. */
+type AgentEventType = AgentEvent["type"];
+/** Subset of events for backward-compatible StreamEvent alias. */
+type StreamEvent = ConversationStartEvent | ConversationEndEvent | MessageStartEvent | MessageChunkEvent | MessageCompleteEvent | MessageCancelEvent | ReasoningEvent | ThinkingStartEvent | ToolCallIntent | ToolCallStartEvent | ToolCallEndEvent | ToolProgressEvent | IterationStartEvent | IterationEndEvent | LLMCallStartEvent | LLMCallEndEvent;
+/**
+ * Create an event with auto-filled timestamp and optional spanId.
+ *
+ * @param type - The event type discriminant
+ * @param data - Event fields (excluding type, timestamp; spanId optional)
+ * @returns A fully-formed event
+ */
+declare function createEvent<T extends AgentEventType>(type: T, data: Omit<Extract<AgentEvent, {
+    type: T;
+}>, "type" | "timestamp" | "spanId"> & {
+    spanId?: string;
+}): Extract<AgentEvent, {
+    type: T;
+}>;
+
+/**
+ * Map Claude Code hook events to canonical AgentEvent variants.
+ *
+ * Only PreToolUse / PostToolUse currently map to standard events
+ * (`agent.tool.start` / `agent.tool.end`). All other hook names yield
+ * an empty array — consumers that want full coverage should subscribe
+ * to `claude_code.hook` directly.
+ */
+
+declare function mapClaudeCodeHookToAgentEvents(event: ClaudeCodeHookEvent): AgentEvent[];
+
+/**
+ * Sandbox events for inter-agent communication and environment lifecycle.
+ *
+ * All sandbox events carry an AgentAddress origin and extend BaseEvent.
+ */
+
+interface AgentAddress {
+    readonly deviceId: string;
+    readonly instanceId: string;
+    readonly agentId: string;
+    readonly role: string;
+}
+declare function createAgentAddress(partial?: Partial<AgentAddress>): AgentAddress;
+declare function agentAddressToString(addr: AgentAddress): string;
+interface BaseSandboxEvent extends BaseEvent {
+    readonly origin: AgentAddress;
+    readonly target?: AgentAddress;
+    readonly correlationId?: string;
+    readonly agencyId: string;
+    readonly lineupRunId: string;
+}
+interface AgentMessageEvent extends BaseSandboxEvent {
+    readonly type: "sandbox.agent.message";
+    readonly content: string;
+    readonly metadata: Record<string, unknown>;
+}
+interface AgentBroadcastEvent extends BaseSandboxEvent {
+    readonly type: "sandbox.agent.broadcast";
+    readonly content: string;
+    readonly channel: string;
+}
+interface AgentJoinEvent extends BaseSandboxEvent {
+    readonly type: "sandbox.agent.join";
+    readonly reason: string;
+}
+interface AgentLeaveEvent extends BaseSandboxEvent {
+    readonly type: "sandbox.agent.leave";
+    readonly reason: string;
+}
+interface TaskCreateEvent extends BaseSandboxEvent {
+    readonly type: "sandbox.task.create";
+    readonly taskId: string;
+    readonly taskTitle: string;
+}
+interface TaskUpdateEvent extends BaseSandboxEvent {
+    readonly type: "sandbox.task.update";
+    readonly taskId: string;
+    readonly changes: Record<string, unknown>;
+}
+interface TaskAssignEvent extends BaseSandboxEvent {
+    readonly type: "sandbox.task.assign";
+    readonly taskId: string;
+    readonly assignee: AgentAddress;
+}
+interface HealthPingEvent extends BaseSandboxEvent {
+    readonly type: "sandbox.health.ping";
+}
+interface HealthPongEvent extends BaseSandboxEvent {
+    readonly type: "sandbox.health.pong";
+    readonly status: string;
+    readonly uptimeSeconds: number;
+}
+interface NodeLifecycleEvent extends BaseSandboxEvent {
+    readonly type: "sandbox.node.lifecycle";
+    readonly nodeEventType: "node.started" | "node.stopped" | "node.message_received" | "node.response_sent";
+    readonly message: string;
+    readonly metadata: Record<string, unknown>;
+}
+type SandboxEvent = AgentMessageEvent | AgentBroadcastEvent | AgentJoinEvent | AgentLeaveEvent | TaskCreateEvent | TaskUpdateEvent | TaskAssignEvent | HealthPingEvent | HealthPongEvent | NodeLifecycleEvent;
+type SandboxEventType = SandboxEvent["type"];
+/**
+ * Serialize a sandbox event to a JSON string for transport.
+ */
+declare function serializeSandboxEventToString(event: SandboxEvent): string;
+/**
+ * Serialize a sandbox event to bytes for transport.
+ */
+declare function serializeSandboxEvent(event: SandboxEvent): Uint8Array;
+/**
+ * Deserialize a sandbox event from a JSON string.
+ */
+declare function deserializeSandboxEventFromString(json: string): SandboxEvent;
+/**
+ * Deserialize a sandbox event from bytes.
+ */
+declare function deserializeSandboxEvent(data: Uint8Array): SandboxEvent;
+
+/**
+ * Async-capable event bus for publishing and subscribing to events.
+ *
+ * Handlers sorted by priority (higher = executed first).
+ * Middleware can transform or drop events (return null).
+ */
+
+/** Handler function that receives an event. Can be sync or async. */
+type EventHandlerFn<E extends BaseEvent = BaseEvent> = (event: E) => unknown | Promise<unknown>;
+/** Middleware function. Return null to stop propagation, or a new event to transform. */
+type MiddlewareFn<E extends BaseEvent = BaseEvent> = (event: E) => E | null | Promise<E | null>;
+declare class EventBus {
+    private _handlers;
+    private _globalHandlers;
+    private _middleware;
+    /**
+     * Subscribe a handler to a specific event type.
+     *
+     * @param eventType - Event type string to listen for
+     * @param handler - Handler function (sync or async)
+     * @param priority - Higher priority executes first (default 0)
+     */
+    subscribe(eventType: string, handler: EventHandlerFn, priority?: number): void;
+    /**
+     * Subscribe a handler to all events.
+     */
+    subscribeAll(handler: EventHandlerFn, priority?: number): void;
+    /**
+     * Unsubscribe a handler from a specific event type.
+     */
+    unsubscribe(eventType: string, handler: EventHandlerFn): void;
+    /**
+     * Unsubscribe a handler from all events.
+     */
+    unsubscribeAll(handler: EventHandlerFn): void;
+    /**
+     * Add middleware to process events before handlers.
+     *
+     * Middleware can modify events or stop propagation by returning null.
+     */
+    addMiddleware(middleware: MiddlewareFn): void;
+    /**
+     * Publish an event to all registered handlers.
+     *
+     * @returns List of handler results
+     */
+    publish(event: BaseEvent): Promise<unknown[]>;
+    /**
+     * Clear all handlers and middleware.
+     */
+    clear(): void;
+    /**
+     * Get the number of handlers for an event type or total.
+     */
+    getHandlerCount(eventType?: string): number;
+}
+declare function getEventBus(): EventBus;
+declare function setEventBus(bus: EventBus): void;
+
+/**
+ * Event profiles for curated event subscriptions.
+ *
+ * Profiles are handler groups that subscribe to specific event types
+ * for different use cases (UX rendering, observability, debugging).
+ */
+
+declare const EventProfile: {
+    readonly UX: "ux";
+    readonly OBSERVABILITY: "obs";
+    readonly DEBUG: "debug";
+    readonly TOOLS: "tools";
+    readonly STREAMING: "stream";
+};
+type EventProfile = (typeof EventProfile)[keyof typeof EventProfile];
+declare const PROFILE_EVENT_TYPES: Readonly<Record<EventProfile, readonly string[]>>;
+/**
+ * Subscribe handler to all event types in a profile.
+ *
+ * @returns List of event types subscribed to.
+ */
+declare function subscribeProfile(bus: EventBus, profile: EventProfile, handler: EventHandlerFn, priority?: number): string[];
+/**
+ * Unsubscribe handler from all event types in a profile.
+ */
+declare function unsubscribeProfile(bus: EventBus, profile: EventProfile, handler: EventHandlerFn): void;
+/**
+ * Subscribe to multiple profiles, deduplicating event types.
+ */
+declare function subscribeProfiles(bus: EventBus, profiles: EventProfile[], handler: EventHandlerFn, priority?: number): string[];
+
+/**
+ * Gate base interface and types.
+ *
+ * Gates intercept intent events and can block, allow, or modify them.
+ * They execute in category order: SAFETY -> RATE_LIMIT -> APPROVAL -> AUDIT.
+ */
+
+declare const GateCategory: {
+    readonly SAFETY: 0;
+    readonly RATE_LIMIT: 1;
+    readonly APPROVAL: 2;
+    readonly AUDIT: 3;
+};
+type GateCategory = (typeof GateCategory)[keyof typeof GateCategory];
+declare const GATE_CATEGORY_NAMES: Readonly<Record<GateCategory, string>>;
+type GateResult = {
+    action: "allow";
+} | {
+    action: "block";
+    reason: string;
+} | {
+    action: "modify";
+    event: BaseEvent;
+};
+declare const GateAllow: GateResult;
+declare function GateBlock(reason: string): GateResult;
+declare function GateModify(event: BaseEvent): GateResult;
+interface Gate {
+    /** Category of this gate for ordering. */
+    readonly category: GateCategory;
+    /** Gate name for rejection messages. */
+    readonly name: string;
+    /** Human-readable category name. */
+    readonly categoryName: string;
+    /** Check an intent event. */
+    check(event: BaseEvent): Promise<GateResult>;
+    /** Get reason why event was blocked. */
+    getBlockReason(event: BaseEvent): string;
+}
+/**
+ * Abstract base class for gates.
+ * Subclasses must implement check() and set category.
+ */
+declare abstract class BaseGate implements Gate {
+    abstract readonly category: GateCategory;
+    get name(): string;
+    get categoryName(): string;
+    abstract check(event: BaseEvent): Promise<GateResult>;
+    getBlockReason(_event: BaseEvent): string;
+}
+
+/**
+ * Agent-specific event bus with gate chain for intent filtering.
+ *
+ * Extends the base EventBus with safety gates that can intercept,
+ * block, or modify intent events before they're published.
+ */
+
+declare class AgentEventBus extends EventBus {
+    private _gateChain;
+    /**
+     * Add a gate to the chain, automatically sorted by category.
+     */
+    addGate(gate: Gate): void;
+    /**
+     * Remove a gate from the chain.
+     */
+    removeGate(gate: Gate): void;
+    /**
+     * Clear all gates from the chain.
+     */
+    clearGates(): void;
+    /**
+     * Get a copy of the gate chain.
+     */
+    get gates(): readonly Gate[];
+    /**
+     * Publish an event, running intent events through gate chain.
+     *
+     * Intent events (those with type ending in ".intent") are checked by each gate.
+     * If any gate blocks the event, a ToolCallRejected event is emitted instead.
+     * Regular events bypass gates entirely.
+     */
+    publish(event: BaseEvent): Promise<unknown[]>;
+    private _emitRejection;
+}
+declare function getAgentEventBus(): AgentEventBus;
+declare function setAgentEventBus(bus: AgentEventBus): void;
+
+/**
+ * Transport protocol abstraction for cross-agent communication.
+ *
+ * Defines the Transport interface and TransportMessage type.
+ * Only InProcessTransport is implemented for v1; the interface
+ * preserves the NATS upgrade path.
+ */
+/**
+ * Wrapper around raw transport message bytes.
+ */
+interface TransportMessage {
+    readonly data: Uint8Array;
+    readonly subject: string;
+    ack(): Promise<void>;
+}
+/**
+ * Abstract transport for inter-agent messaging.
+ *
+ * Implementations must support NATS-style subject wildcards:
+ * - `*` matches exactly one token
+ * - `>` matches one or more trailing tokens (must be last segment)
+ */
+interface Transport {
+    connect(): Promise<void>;
+    close(): Promise<void>;
+    ensureStream(name: string, subjects: string[]): Promise<void>;
+    publish(subject: string, data: Uint8Array): Promise<void>;
+    subscribe(subject: string, callback: (msg: TransportMessage) => void | Promise<void>, durable?: string): Promise<void>;
+    request(subject: string, data: Uint8Array, timeout?: number): Promise<Uint8Array>;
+}
+
+/**
+ * SandboxEventBus - AgentEventBus with pluggable transport for cross-agent messaging.
+ *
+ * Extends AgentEventBus with dual publish: local handlers + transport publish
+ * for SandboxEvents. Subscribes to both direct and broadcast channels.
+ */
+
+/**
+ * AgentEventBus extended with transport-aware publishing.
+ *
+ * - `publish()` dispatches both locally AND to transport for SandboxEvents.
+ * - Regular AgentEvents only dispatch locally.
+ * - Remote events received via transport are dispatched locally only (no echo loop).
+ */
+declare class SandboxEventBus extends AgentEventBus {
+    readonly address: AgentAddress;
+    private _transport;
+    /**
+     * Set of spanIds that this bus has already dispatched locally.
+     * Prevents duplicate local dispatch when the InProcessTransport
+     * echoes our own publish back to us via subscription.
+     */
+    private _locallyPublished;
+    constructor(address: AgentAddress, transport: Transport);
+    /**
+     * Connect transport and set up subscriptions for direct + broadcast channels.
+     */
+    start(): Promise<void>;
+    /**
+     * Close transport.
+     */
+    stop(): Promise<void>;
+    /**
+     * Publish event locally and to transport if it's a SandboxEvent.
+     *
+     * 1. Local gate chain + handlers (via super.publish)
+     * 2. If SandboxEvent, also publish to transport
+     */
+    publish(event: BaseEvent): Promise<unknown[]>;
+    /**
+     * Map event target to transport subject.
+     *
+     * Targeted: agency.{agencyId}.run.{lineupRunId}.agent.{targetId}
+     * Broadcast: agency.{agencyId}._broadcast
+     */
+    private _resolveSubject;
+    /**
+     * Inject remote transport message into local EventBus (no re-publish to transport).
+     *
+     * Skips events we already published locally (echo prevention for shared transport).
+     */
+    private _onRemoteEvent;
+}
+
+/**
+ * Safety gate for blocking dangerous operations.
+ *
+ * Category: SAFETY (runs first in chain)
+ */
+
+declare class SafetyGate extends BaseGate {
+    readonly category: 0;
+    private _blockedTools;
+    private _blockedPatterns;
+    private _blockMessage;
+    constructor(options?: {
+        blockedTools?: Set<string>;
+        blockedPatterns?: string[];
+        blockMessage?: string;
+    });
+    check(event: BaseEvent): Promise<GateResult>;
+    getBlockReason(event: BaseEvent): string;
+}
+
+/**
+ * Rate limit gate using token bucket algorithm.
+ *
+ * Category: RATE_LIMIT (runs second)
+ */
+
+declare class RateLimitGate extends BaseGate {
+    readonly category: 1;
+    private _rate;
+    private _burst;
+    private _tokens;
+    private _lastUpdate;
+    constructor(options?: {
+        callsPerMinute?: number;
+        burstSize?: number;
+    });
+    check(event: BaseEvent): Promise<GateResult>;
+    getBlockReason(_event: BaseEvent): string;
+}
+
+/**
+ * Human approval gate for tool calls.
+ *
+ * Category: APPROVAL (runs third)
+ */
+
+/** Callback that decides whether to approve a tool call. */
+type ApprovalCallback = (event: ToolCallIntent) => boolean | Promise<boolean>;
+declare class HumanApprovalGate extends BaseGate {
+    readonly category: 2;
+    private _approvalFn;
+    private _tools;
+    private _autoApprove;
+    constructor(options?: {
+        approvalFn?: ApprovalCallback;
+        tools?: Set<string>;
+        autoApprove?: boolean;
+    });
+    check(event: BaseEvent): Promise<GateResult>;
+    getBlockReason(event: BaseEvent): string;
+}
+
+/**
+ * Audit gate for logging all intents.
+ *
+ * Category: AUDIT (runs last, never blocks)
+ */
+
+/** Logger interface — matches console.info signature. */
+interface AuditLogger {
+    info(message: string, ...args: unknown[]): void;
+}
+declare class AuditGate extends BaseGate {
+    readonly category: 3;
+    /** Recorded entries for testing/inspection. */
+    readonly entries: Array<{
+        type: string;
+        toolName: string;
+        timestamp: Date;
+    }>;
+    private _logger;
+    constructor(options?: {
+        logger?: AuditLogger;
+    });
+    check(event: BaseEvent): Promise<GateResult>;
+}
+
+/**
+ * Runner types — AgentLike, RunResult, ToolExecutor, RunnerProtocol, RunOptions.
+ *
+ * Ported from Python: systems/runners/base.py
+ */
+
+/**
+ * The minimal agent shape consumed by runners, workflows, conversations,
+ * and transport adapters.
+ *
+ * This is a projection of the full `Agent` class (from @agentic-patterns/core)
+ * containing only the methods and properties needed to execute a tool loop.
+ * `getTools()` returns `unknown[]` so protocol consumers don't need to import
+ * `ToolSchema` from core — only `AgentRunner` itself narrows the type when
+ * converting tools for the LLM.
+ */
+interface AgentLike {
+    readonly role: {
+        readonly name: string;
+    };
+    getModel(): string;
+    getTools(): unknown[];
+    getSystemPrompt(): string;
+    renderInitialPrompt(): string;
+}
+/**
+ * Result of an agent execution.
+ */
+interface RunResult {
+    /** The final text response from the agent. */
+    readonly response: string;
+    /** Total input tokens used across all iterations. */
+    readonly inputTokens: number;
+    /** Total output tokens generated across all iterations. */
+    readonly outputTokens: number;
+    /** Total number of tool calls executed. */
+    readonly toolCallsCount: number;
+    /** Number of loop iterations completed. */
+    readonly iterations: number;
+    /** Reason the run finished (e.g. "stop", "max_iterations"). */
+    readonly finishReason: string;
+}
+/**
+ * Protocol for executing tools.
+ *
+ * Implementations handle the actual tool execution logic.
+ * The runner calls execute() for each tool call from the LLM.
+ */
+interface ToolExecutor {
+    execute(name: string, args: Record<string, unknown>): Promise<unknown>;
+}
+interface CanonicalMessagePart {
+    readonly type: string;
+    readonly content?: string;
+    readonly id?: string;
+    readonly name?: string;
+    readonly tool_name?: string;
+    readonly tool_call_id?: string;
+    readonly arguments?: Record<string, unknown>;
+}
+interface CanonicalMessage {
+    readonly kind: "request" | "response";
+    readonly parts: CanonicalMessagePart[];
+}
+/**
+ * Options for agent execution.
+ */
+interface RunOptions {
+    /** Optional conversation history in canonical format. */
+    messageHistory?: CanonicalMessage[];
+    /** Optional executor for tool calls. */
+    toolExecutor?: ToolExecutor;
+    /** Optional event bus for emitting agent events. */
+    eventBus?: AgentEventBus;
+    /** Maximum tool loop iterations (default 10). */
+    maxIterations?: number;
+    /** Optional trace ID for multi-agent orchestration. */
+    traceId?: string;
+    /** Optional parent span ID linking to orchestrator. */
+    parentSpanId?: string;
+}
+/**
+ * Protocol for agent runners.
+ *
+ * Runners execute agents with optional tool execution and hooks.
+ * Two modes: run() for single response, stream() for streaming.
+ */
+interface RunnerProtocol {
+    /**
+     * Execute an agent and return the final result.
+     */
+    run(agent: AgentLike, message: string, options?: RunOptions): Promise<RunResult>;
+    /**
+     * Execute an agent with streaming response.
+     * Optional — not all runners support streaming.
+     */
+    stream?(agent: AgentLike, message: string, options?: RunOptions): AsyncGenerator<AgentEvent>;
+}
+
+/**
+ * AgentRunner — The standard agentic execution loop on Vercel AI SDK.
+ *
+ * Ported from Python: systems/runners/agent.py
+ *
+ * Key differences from Python:
+ * - Parallel tool execution via Promise.all (Python is sequential)
+ * - Vercel AI SDK handles tool schema conversion (Python manually builds OpenAI JSON)
+ * - maxSteps: 1 forces one LLM call per iteration for gate interception control
+ * - MockLanguageModelV1 for testing (replaces Python's MockRunner)
+ */
+
+declare class ToolCallBlocked extends Error {
+    readonly toolName: string;
+    readonly reason: string;
+    constructor(toolName: string, reason: string);
+}
+/**
+ * The standard agentic execution loop.
+ *
+ * Executes agents using a tool loop pattern with the Vercel AI SDK.
+ *
+ * The runner implements an agentic tool loop:
+ * 1. Send message to LLM with system prompt and tools
+ * 2. If LLM returns tool_calls, execute them via toolExecutor (parallel)
+ * 3. Feed tool results back to LLM
+ * 4. Repeat until LLM returns final response or maxIterations reached
+ */
+declare class AgentRunner implements RunnerProtocol {
+    private _eventBus;
+    private readonly _model;
+    constructor(model: LanguageModelV1, eventBus?: AgentEventBus);
+    private get eventBus();
+    private emit;
+    /**
+     * Emit an intent event and check if it was blocked by a gate.
+     * Returns true if allowed, false if blocked.
+     */
+    private emitIntent;
+    /**
+     * Convert agent tools to Vercel AI SDK tool format.
+     */
+    private convertTools;
+    run(agent: AgentLike, message: string, options?: RunOptions): Promise<RunResult>;
+    stream(agent: AgentLike, message: string, options?: RunOptions): AsyncGenerator<AgentEvent>;
+}
+
+/**
+ * Message history conversion — canonical format to Vercel AI SDK CoreMessage[].
+ *
+ * Ported from Python: _convert_history_to_messages() in runners/agent.py
+ */
+
+/**
+ * Convert canonical internal message format to Vercel AI SDK CoreMessage[].
+ *
+ * Canonical format (from orchestration layer):
+ *   { kind: "request", parts: [{ type: "user_prompt", content: "..." }] }
+ *   { kind: "response", parts: [
+ *     { type: "text", content: "..." },
+ *     { type: "tool_call", tool_name: "...", tool_call_id: "...", arguments: {} },
+ *     { type: "tool_return", tool_name: "...", tool_call_id: "...", content: "..." },
+ *   ]}
+ *
+ * Vercel AI SDK format:
+ *   { role: "user", content: "..." }
+ *   { role: "assistant", content: [{ type: "text", text: "..." }, { type: "tool-call", ... }] }
+ *   { role: "tool", content: [{ type: "tool-result", ... }] }
+ */
+declare function convertHistory(history: CanonicalMessage[]): CoreMessage[];
+
+declare function buildCapabilityServer(capability: Capability): {
+    serverName: string;
+    serverConfig: _anthropic_ai_claude_agent_sdk.McpSdkServerConfigWithInstance;
+    allowedTools: string[];
+};
+interface AgentLikeForBridge {
+    readonly role: {
+        readonly name: string;
+        readonly capabilities: ReadonlyArray<Capability>;
+    };
+    getModel(): string;
+    getTools(): ToolSchema[];
+    getSystemPrompt(): string;
+    renderInitialPrompt(): string;
+}
+declare function buildAgentServers(agent: AgentLikeForBridge): {
+    mcpServers: Record<string, unknown>;
+    allowedTools: string[];
+};
+
+/**
+ * ClaudeCodeRunner — Runner backed by the Claude Agent SDK.
+ *
+ * Mirrors Python: agentic_patterns/core/systems/runners/claude_code.py
+ *
+ * Wraps the Claude Agent SDK's query() function to execute agents through
+ * Claude Code's subprocess-based architecture. Claude Code manages its own
+ * tool loop, so toolExecutor is accepted for interface compatibility but
+ * not used.
+ *
+ * Event bridging:
+ * - PreToolUse hook  → ToolCallIntent (gate chain) + ToolCallStartEvent
+ * - PostToolUse hook → ToolCallEndEvent with result
+ * - SDKAssistantMessage → MessageStart/Complete, Reasoning
+ * - SDKResultMessage → MessageComplete with usage stats
+ * - SDKPartialAssistantMessage → MessageChunk (streaming)
+ */
+
+interface ClaudeCodeRunnerOptions {
+    /** Default SDK options applied before per-run overrides. */
+    defaults?: Partial<Options>;
+    /** Optional event bus for emitting agent events. */
+    eventBus?: AgentEventBus;
+}
+/**
+ * Runner that delegates execution to Claude Code via the Agent SDK.
+ *
+ * Claude Code manages its own tool loop, permissions, and file access.
+ * This runner translates SDK messages into the AgentEvent stream so that
+ * the rest of the framework (gates, exporters, UX) works transparently.
+ *
+ * Gate enforcement is handled via PreToolUse hooks — if a gate blocks a
+ * ToolCallIntent, the hook returns `permissionDecision: 'deny'` to the
+ * SDK so the tool is never executed.
+ */
+declare class ClaudeCodeRunner implements RunnerProtocol {
+    protected _eventBus: AgentEventBus | undefined;
+    protected readonly _defaults: Partial<Options>;
+    constructor(opts?: ClaudeCodeRunnerOptions);
+    protected get eventBus(): AgentEventBus;
+    protected emit(event: AgentEvent): Promise<void>;
+    /**
+     * Publish a ToolCallIntent through the gate chain.
+     * Returns true if the intent was allowed, false if blocked.
+     */
+    protected emitIntent(intent: AgentEvent & {
+        type: "agent.tool.intent";
+    }): Promise<boolean>;
+    run(agent: AgentLikeForBridge, message: string, options?: RunOptions): Promise<RunResult>;
+    stream(agent: AgentLikeForBridge, message: string, options?: RunOptions): AsyncGenerator<AgentEvent>;
+    protected _buildOptions(agent: AgentLikeForBridge, options: RunOptions | undefined, context: {
+        runId: string;
+        traceId: string;
+        parentSpanId?: string;
+        includePartialMessages?: boolean;
+    }): Options;
+    /**
+     * Create SDK hook definitions that bridge to AgentEvent emissions.
+     *
+     * PreToolUse: emits ToolCallIntent through the gate chain. If gates
+     * block the intent, returns `permissionDecision: 'deny'` to the SDK
+     * so the tool is never executed. Otherwise emits ToolCallStartEvent.
+     *
+     * PostToolUse: emits ToolCallEndEvent with the tool result.
+     */
+    private _makeHooks;
+}
+
+/**
+ * ClaudeCodeAPIRunner — API-only mode wrapper on ClaudeCodeRunner.
+ *
+ * Uses Claude Code under the hood but blocks all Code-native tools
+ * (file, bash, agent, etc.) so the agent behaves like a plain Claude
+ * API call with a system prompt injected. MCP tools from agent
+ * capabilities remain available. Uses the same Max subscription OAuth token.
+ *
+ * Named "ClaudeCodeAPIRunner" (not "ClaudeAPIRunner") because it still
+ * runs through the Claude Code subprocess — a future ClaudeAPIRunner
+ * may talk directly to the Claude API without the Code layer.
+ *
+ * Mirrors Python: agentic_patterns/core/systems/runners/claude_api.py
+ */
+
+/**
+ * Runner that uses Claude Code SDK in API-only mode.
+ *
+ * Blocks all file/bash/agent tools so the agent behaves like a plain
+ * Claude API call with the framework's system prompt. MCP tools from
+ * agent capabilities remain available.
+ */
+declare class ClaudeCodeAPIRunner extends ClaudeCodeRunner {
+    protected _buildOptions(agent: AgentLikeForBridge, options: RunOptions | undefined, context: {
+        runId: string;
+        traceId: string;
+        parentSpanId?: string;
+        includePartialMessages?: boolean;
+    }): Options;
+}
+
+/**
+ * MockRunner — Deterministic runner for testing agents without LLM calls.
+ *
+ * Pattern-based response routing with tool call simulation and event emission.
+ * Implements RunnerProtocol for drop-in testing.
+ */
+
+/** A canned response for the mock runner. */
+interface MockResponse {
+    content: string;
+    toolCalls?: Array<{
+        name: string;
+        arguments: Record<string, unknown>;
+        result?: unknown;
+    }>;
+    inputTokens?: number;
+    outputTokens?: number;
+    delayMs?: number;
+    error?: Error;
+}
+/** A recorded call to the mock runner. */
+interface MockCall {
+    message: string;
+    agentName: string;
+    model: string;
+    timestamp: Date;
+}
+/**
+ * Deterministic runner for testing agents without LLM calls.
+ *
+ * Supports substring-based trigger matching, wildcard defaults,
+ * tool call simulation, delay simulation, and full event lifecycle.
+ *
+ * Example:
+ *   const runner = new MockRunner()
+ *     .addResponse("hello", { content: "Hi there!" })
+ *     .addResponse("*", { content: "Default response" });
+ */
+declare class MockRunner implements RunnerProtocol {
+    private _responses;
+    private _callHistory;
+    /** Read-only call history. */
+    get callHistory(): readonly MockCall[];
+    /**
+     * Add a canned response.
+     *
+     * @param trigger - Substring to match against the message, or "*" for wildcard default.
+     * @param response - The response to return when triggered.
+     * @returns this for fluent chaining.
+     */
+    addResponse(trigger: string, response: MockResponse): this;
+    /**
+     * Clear all responses and call history.
+     *
+     * @returns this for fluent chaining.
+     */
+    clear(): this;
+    /**
+     * Execute an agent and return a result (non-streaming).
+     */
+    run(agent: AgentLike, message: string, options?: RunOptions): Promise<RunResult>;
+    /**
+     * Execute an agent with streaming event emission.
+     */
+    stream(agent: AgentLike, message: string, options?: RunOptions): AsyncGenerator<AgentEvent>;
+    /** Find matching response: substring first, then wildcard, then auto-fallback. */
+    private _findResponse;
+}
+
+/**
+ * ToolboxExecutor — adapts an agent's Capability toolboxes into the
+ * ToolExecutor interface that AgentRunner needs to actually execute
+ * tool calls.
+ *
+ * Without this, AgentRunner can FORMAT tool schemas for the LLM but
+ * can't EXECUTE them — tool calls silently return
+ * "No tool executor configured".
+ */
+
+/** Minimal shape — matches what Agent.role.capabilities[].toolbox exposes. */
+interface ToolboxLike {
+    readonly name: string;
+    execute(name: string, args: unknown): Promise<unknown>;
+    readonly tools: Record<string, {
+        execute: (args: Record<string, unknown>) => Promise<unknown>;
+    }>;
+}
+/** Minimal shape — matches what Agent.role.capabilities[] exposes. */
+interface CapabilityLike {
+    readonly toolbox: ToolboxLike;
+}
+/** Minimal shape — matches what Agent.role exposes. */
+interface AgentWithCapabilities {
+    readonly role: {
+        readonly name: string;
+        readonly capabilities?: readonly CapabilityLike[];
+    };
+}
+/**
+ * Build a `ToolExecutor` from an agent's capability toolboxes.
+ *
+ * Iterates the agent's capabilities, indexes every tool by name, and
+ * dispatches `execute(name, args)` to the owning toolbox. Handles the
+ * `mcp__<toolbox>__<tool>` naming convention that MCP-bridged tools use.
+ */
+declare function createToolboxExecutor(agent: AgentWithCapabilities): ToolExecutor;
+
+/**
+ * Provider adapter protocol.
+ *
+ * A `ProviderProtocol` describes one LLM provider in three axes:
+ *   • which env vars indicate the provider is available
+ *   • a cross-provider tier map (opus / sonnet / haiku) giving default
+ *     model ids at each quality/cost rung
+ *   • a `load(modelId)` method that dynamically imports the provider
+ *     package and returns a Vercel AI SDK `LanguageModelV1`
+ *
+ * Adding a provider = dropping one file under `providers/`. No conditionals
+ * to grow — `createRunner()` reads the registry in `providers/index.ts`.
+ */
+
+/** Supported provider identifiers. Matches directory / file names below. */
+type SupportedProvider = "anthropic" | "openai" | "google" | "groq" | "mistral" | "xai" | "deepseek" | "openrouter" | "ollama";
+/**
+ * Cross-provider tier selector.
+ *
+ *   opus   — most capable / expensive / slowest
+ *   sonnet — balanced default
+ *   haiku  — fastest / cheapest / smallest
+ *
+ * Agents written against tiers stay portable across providers and hardware.
+ */
+type ProviderTier = "opus" | "sonnet" | "haiku";
+/** Per-provider adapter. One constant per provider file. */
+interface ProviderProtocol {
+    readonly name: SupportedProvider;
+    /** Default model id for each tier. */
+    readonly tiers: Readonly<Record<ProviderTier, string>>;
+    /**
+     * Env variables whose presence indicates this provider is usable.
+     * First-matched-first-wins during `createRunner()` auto-detection.
+     */
+    readonly envVars: readonly string[];
+    /**
+     * Dynamically import the provider's `@ai-sdk/*` (or equivalent) package
+     * and return a `LanguageModelV1` for the given model id. Throws a helpful
+     * error if the package isn't installed.
+     */
+    load(modelId: string): Promise<LanguageModelV1>;
+}
+
+declare const anthropicProvider: ProviderProtocol;
+
+declare const openaiProvider: ProviderProtocol;
+
+declare const googleProvider: ProviderProtocol;
+
+declare const groqProvider: ProviderProtocol;
+
+declare const mistralProvider: ProviderProtocol;
+
+declare const xaiProvider: ProviderProtocol;
+
+declare const deepseekProvider: ProviderProtocol;
+
+/**
+ * OpenRouter gateways 150+ models across every major provider. Our tier
+ * defaults route to Claude (repo's center of gravity); callers who want
+ * a non-Claude default pass `modelId` explicitly (e.g. "meta-llama/llama-3.3-70b").
+ */
+declare const openrouterProvider: ProviderProtocol;
+
+/**
+ * Ollama — local-only OSS models via HTTP.
+ *
+ * Default tier map uses the Qwen3 family because Qwen's team explicitly
+ * prioritizes tool-calling and keeps the same grammar across sizes — so
+ * agents scale between haiku↔sonnet↔opus without prompt changes.
+ *
+ * Sized for 16GB-class consumer GPUs (tested on 4080 Super):
+ *   opus  (30B MoE, activates 3B/token)  — ~14 GB VRAM, 50–80 tok/s
+ *   sonnet (14B dense)                   —  ~9 GB VRAM, 30–50 tok/s
+ *   haiku  (4B dense)                    —  ~3 GB VRAM, 100+ tok/s
+ *
+ * Override with `options.modelId` if you want a different family.
+ */
+declare const ollamaProvider: ProviderProtocol;
+
+/**
+ * Claude Code LanguageModelV1 provider.
+ *
+ * Wraps the Claude Agent SDK's `query()` function in a Vercel AI SDK
+ * `LanguageModelV1` so agents can be executed through `AgentRunner` using
+ * a Claude Max subscription (OAuth cached in ~/.claude) or an
+ * `ANTHROPIC_API_KEY` env var picked up by the SDK itself.
+ *
+ * Unlike `ClaudeCodeRunner` / `ClaudeCodeAPIRunner`, this provider plugs
+ * into the *standard* AgentRunner execution loop. That means the full
+ * canonical event vocabulary (`iteration.start`, `llm.start`, `tool.*`,
+ * `iteration.end`, `llm.end`, …) fires automatically — closing the
+ * observability gap those runners have.
+ *
+ * Each `doGenerate` / `doStream` call runs a fresh single-turn SDK query:
+ *
+ *   1. System prompt + conversation history (including prior tool
+ *      use / tool result parts) is flattened to a string prompt.
+ *   2. Tool schemas are registered as MCP tools on an in-process server.
+ *   3. `canUseTool` intercepts tool invocations, records them, and denies
+ *      with `interrupt: true` so the SDK stops immediately. The recorded
+ *      tool calls are surfaced in the LanguageModelV1 response as
+ *      `toolCalls`.
+ *   4. SDK assistant / result messages are translated back to
+ *      LanguageModelV1 output shape (`text`, `toolCalls`, `finishReason`,
+ *      `usage`).
+ *   5. Claude-Code-native tools (Read/Write/Edit/Bash/…) are disallowed so
+ *      only framework tools flow.
+ */
+
+interface ClaudeCodeProviderOptions {
+    /** Defaults merged with every SDK query call. */
+    defaults?: Partial<Options>;
+    /** Include Claude Code's built-in tools (Read/Write/Bash/…). Default: false. */
+    allowBuiltinTools?: boolean;
+    /** Max turns inside the SDK loop. Default: 1 (one Claude call per model step). */
+    maxTurns?: number;
+}
+declare class ClaudeCodeLanguageModel implements LanguageModelV1 {
+    readonly specificationVersion: "v1";
+    readonly provider = "claude-code";
+    readonly modelId: string;
+    readonly defaultObjectGenerationMode: "tool";
+    private readonly _opts;
+    constructor(modelId: string, opts?: ClaudeCodeProviderOptions);
+    doGenerate(options: LanguageModelV1CallOptions): ReturnType<LanguageModelV1["doGenerate"]>;
+    private _doGenerate;
+    doStream(options: LanguageModelV1CallOptions): ReturnType<LanguageModelV1["doStream"]>;
+    private _doStream;
+    private _prepare;
+}
+/**
+ * Create a `LanguageModelV1` backed by the Claude Agent SDK.
+ *
+ * @example
+ * ```ts
+ * import { claudeCode } from "@agentic-patterns/runtime/providers";
+ * import { AgentRunner } from "@agentic-patterns/runtime";
+ *
+ * const runner = new AgentRunner(claudeCode("sonnet"));
+ * const result = await runner.run(agent, "What is 17 + 28?");
+ * ```
+ */
+declare function claudeCode(modelId: string, opts?: ClaudeCodeProviderOptions): ClaudeCodeLanguageModel;
+
+/**
+ * Provider adapter registry.
+ *
+ * Each provider exports a `ProviderProtocol` constant that knows its env
+ * vars, tier map, and how to dynamically load the `@ai-sdk/*` (or
+ * equivalent) package. The registry below is consumed by `createRunner()`
+ * for provider auto-detection and tier resolution.
+ *
+ * Registry order matters for env-based auto-detection: the first provider
+ * with a matching env var wins. We lead with Anthropic (repo's center of
+ * gravity: the Claude Agent SDK is a peer dep). Callers who want a
+ * different order pass `options.provider` explicitly.
+ */
+
+/** All supported providers keyed by name. */
+declare const PROVIDERS: Readonly<Record<SupportedProvider, ProviderProtocol>>;
+/**
+ * Env-detection priority. First entry whose `envVars` include a set env
+ * variable wins. Order reflects repo defaults — Anthropic first, OSS local
+ * (Ollama) last so remote providers are preferred when both exist.
+ */
+declare const PROVIDER_PRIORITY: readonly SupportedProvider[];
+/** Resolve a model id for a (provider, tier?, explicitModelId?) triple. */
+declare function resolveModelId(provider: ProviderProtocol, explicitModelId?: string, tier?: ProviderTier): string;
+
+/**
+ * `createRunner()` — zero-config runner factory.
+ *
+ * Selection priority (first match wins):
+ *   1. options.runner                → use it verbatim
+ *   2. options.model (LanguageModelV1) → new AgentRunner(model)
+ *   3. options.provider + tier/modelId → new AgentRunner(provider.load(...))
+ *   4. env vars (in PROVIDER_PRIORITY order) → new AgentRunner(...)
+ *   5. claude CLI on PATH            → new ClaudeCodeAPIRunner()  (fallback, limited events)
+ *   6. options.fallbackToMock === true → new MockRunner()
+ *   7. throw
+ *
+ * See docs/runners.md (§4) for the design doc.
+ */
+
+interface CreateRunnerOptions {
+    /**
+     * Explicit runner instance. Wins over everything else — useful for
+     * tests (`runner: new MockRunner()`) or bespoke setups.
+     */
+    runner?: RunnerProtocol;
+    /**
+     * Explicit provider. Overrides env-based detection. Requires the
+     * corresponding `@ai-sdk/*` package to be installed.
+     */
+    provider?: SupportedProvider;
+    /**
+     * Explicit model id. Falls through to the provider's tier default.
+     * Ignored if `runner` or `model` is set.
+     */
+    modelId?: string;
+    /**
+     * Cross-provider tier selector — "opus" | "sonnet" | "haiku". Resolved
+     * via each `ProviderProtocol.tiers` map. Default: "sonnet".
+     * Ignored if `modelId` is set.
+     */
+    tier?: ProviderTier;
+    /**
+     * Pre-constructed `LanguageModelV1`. Short-circuits provider resolution;
+     * the factory wraps it in `AgentRunner`.
+     */
+    model?: LanguageModelV1;
+    /** Optional event bus. Passed through to the constructed runner. */
+    eventBus?: AgentEventBus;
+    /** Log the selection decision to console. Defaults to true. */
+    verbose?: boolean;
+    /**
+     * If no runnable configuration is found, fall back to `MockRunner`
+     * instead of throwing. Defaults to false.
+     */
+    fallbackToMock?: boolean;
+}
+type RunnerSource = "explicit-runner" | "explicit-model" | "explicit-provider" | `env-${SupportedProvider}` | "claude-cli" | "mock-fallback";
+interface RunnerSelection {
+    runner: RunnerProtocol;
+    /** Human-readable explanation, e.g. `"using anthropic (env ANTHROPIC_API_KEY)"`. */
+    reason: string;
+    /** Which branch of the priority tree fired. */
+    source: RunnerSource;
+}
+/**
+ * Construct a runner from explicit opts / env vars / Claude CLI presence.
+ * Returns the runner plus metadata about why it was chosen.
+ */
+declare function createRunner(opts?: CreateRunnerOptions): Promise<RunnerSelection>;
+
+/**
+ * In-process transport with NATS-compatible subject wildcards.
+ *
+ * Zero-dependency in-memory pub/sub for multi-agent communication.
+ * Supports NATS wildcard patterns: `*` (single token) and `>` (trailing tokens).
+ */
+
+/**
+ * Convert a NATS subject pattern to a RegExp.
+ *
+ * NATS wildcards:
+ *   `*` matches exactly one token (segment between dots)
+ *   `>` matches one or more trailing tokens (must be the last segment)
+ */
+declare function subjectToRegex(pattern: string): RegExp;
+/**
+ * Test whether a subject matches a NATS-style pattern.
+ */
+declare function matchSubject(pattern: string, subject: string): boolean;
+/**
+ * Zero-dependency in-process transport with NATS-compatible wildcards.
+ *
+ * All messaging is synchronous within the process -- no network I/O.
+ * `connect()` and `ensureStream()` are no-ops.
+ */
+declare class InProcessTransport implements Transport {
+    private _subscriptions;
+    private _connected;
+    connect(): Promise<void>;
+    close(): Promise<void>;
+    ensureStream(_name: string, _subjects: string[]): Promise<void>;
+    publish(subject: string, data: Uint8Array): Promise<void>;
+    subscribe(subject: string, callback: (msg: TransportMessage) => void | Promise<void>, _durable?: string): Promise<void>;
+    request(subject: string, data: Uint8Array, _timeout?: number): Promise<Uint8Array>;
+    /** Whether the transport is currently connected. */
+    get connected(): boolean;
+}
+
+/**
+ * MessagingToolbox - inter-agent communication tools over shared transport.
+ *
+ * Provides send_message, broadcast, and list_team tools that publish
+ * SandboxEvents to the bus, enabling fully event-driven agent conversations.
+ */
+
+/**
+ * Tools for inter-agent communication within an agency.
+ *
+ * Each tool publishes a SandboxEvent to the bus, which then dispatches
+ * both locally and over transport.
+ */
+declare class MessagingToolbox extends Toolbox {
+    readonly name = "Messaging";
+    readonly description = "Tools for sending messages to other agents on the team.";
+    private readonly _bus;
+    private readonly _address;
+    private readonly _agencyId;
+    private readonly _runId;
+    private readonly _roster;
+    readonly tools: Record<string, ToolDefinition>;
+    constructor(bus: SandboxEventBus, address: AgentAddress, agencyId: string, runId: string, roster: Record<string, AgentAddress>);
+    private _sendMessage;
+    private _broadcast;
+    private _listTeam;
+}
+
+/**
+ * SSE (Server-Sent Events) formatter for agent events.
+ *
+ * Converts internal AgentEvent types to SSE-formatted strings for streaming
+ * to clients over HTTP. Maps all 20 canonical events via a single typed
+ * discriminated-union switch (`toSSEMapping`) so event name, payload, and
+ * exhaustiveness live in one place.
+ */
+
+/**
+ * Client-facing SSE event name. Matches the 20 canonical events defined in
+ * the admin-observability spec. Used anywhere an SSE frame is produced so
+ * the compiler catches typos like `"thinking.complete"` vs `"thinking"`.
+ */
+type SSEEventName = "conversation.start" | "conversation.end" | "message.start" | "message.delta" | "message.complete" | "message.cancel" | "thinking.start" | "thinking" | "thinking.complete" | "tool.intent" | "tool.start" | "tool.progress" | "tool.end" | "tool.rejected" | "iteration.start" | "iteration.end" | "llm.start" | "llm.end" | "error" | "claude_code.hook" | "done";
+/** Result of mapping an AgentEvent to its canonical SSE shape. */
+interface SSEMapping {
+    readonly name: SSEEventName;
+    readonly payload: Record<string, unknown>;
+}
+/**
+ * Map an `AgentEvent` to its canonical SSE wire name and payload. The
+ * discriminated-union switch narrows `event` automatically so field access
+ * is fully typed without casts. The `never` default is a compile-time
+ * exhaustiveness check — adding a new variant to `AgentEvent` fails
+ * typechecking here until a branch is added.
+ *
+ * Returns `null` only when a non-AgentEvent slips through at runtime
+ * (e.g., a hand-constructed event with an unrecognised `type`).
+ */
+declare function toSSEMapping(event: AgentEvent): SSEMapping | null;
+/**
+ * Map from internal `AgentEvent.type` to canonical SSE wire name. Useful
+ * when a consumer only needs the name (routing, logging) and not the
+ * payload. For `agent.reasoning` the default entry is `"thinking"`; the
+ * `isComplete=true` variant produces `"thinking.complete"` via
+ * `toSSEMapping` — consumers that care should use that directly.
+ */
+declare const SSE_EVENT_NAMES: Readonly<Record<AgentEventType, SSEEventName>>;
+/**
+ * Formats `AgentEvent`s as SSE frames with canonical event names.
+ *
+ * Delegates all mapping to `toSSEMapping`; this class exists to carry the
+ * trace-context enrichment (traceId + timestamp) onto the payload so the
+ * runtime's admin SSE broadcast stays self-describing.
+ */
+declare class SSEFormatter {
+    /** Format an AgentEvent as an SSE frame string, or `null` if unmappable. */
+    format(event: AgentEvent): string | null;
+    /**
+     * Extract the payload from an event using canonical snake_case field
+     * names. Static so StdioAdapter and other consumers can reuse it without
+     * instantiating a formatter. Returns `null` if the event has no mapping.
+     */
+    static extractPayload(event: AgentEvent): Record<string, unknown> | null;
+    /** Format a stream-terminator "done" event. */
+    static formatDone(): string;
+}
+/**
+ * Format an AgentEvent as an SSE frame string.
+ *
+ * @deprecated Use `new SSEFormatter().format(event)` instead.
+ */
+declare function formatSSE(event: AgentEvent): string | null;
+
+/**
+ * AgentNode - event-driven agent wrapper for multi-agent systems.
+ *
+ * Wraps an Agent with a message queue and worker loop that listens to
+ * SandboxEventBus events, batches incoming messages, and runs them through
+ * a runner (LLM or mock).
+ *
+ * Architecture: Bus -> Queue -> Worker -> Runner -> Tools -> Bus
+ */
+
+declare const DEFAULT_IDLE_TIMEOUT = 10000;
+declare const DEFAULT_GLOBAL_TIMEOUT = 120000;
+declare const DEFAULT_MAX_TURNS = 20;
+declare const BATCH_WINDOW = 100;
+interface AgentNodeOptions {
+    readonly name: string;
+    readonly agent: Agent;
+    readonly bus: SandboxEventBus;
+    readonly address: AgentAddress;
+    readonly toolbox: MessagingToolbox;
+    readonly runner: RunnerProtocol;
+    readonly traceId?: string;
+    readonly maxTurns?: number;
+    readonly idleTimeout?: number;
+    readonly globalTimeout?: number;
+}
+/**
+ * Event-driven agent wrapper. Bus -> Queue -> Worker -> Runner -> Bus.
+ *
+ * Each node owns its own SandboxEventBus (wired to a shared transport)
+ * and listens for messages addressed to its AgentAddress.
+ *
+ * Lifecycle events emitted on the bus:
+ * - node.started: when the node begins listening
+ * - node.stopped: when the worker exits
+ * - node.message_received: when messages are dequeued for processing
+ * - node.response_sent: after the runner produces a response
+ */
+declare class AgentNode {
+    readonly name: string;
+    readonly agent: Agent;
+    readonly address: AgentAddress;
+    private readonly _bus;
+    private readonly _toolbox;
+    private readonly _runner;
+    private readonly _traceId;
+    private readonly _maxTurns;
+    private readonly _idleTimeout;
+    private readonly _globalTimeout;
+    private _queue;
+    private _queueResolve?;
+    private _conversation;
+    private _turnsTaken;
+    private _workerPromise;
+    private _stopped;
+    readonly transcript: string[];
+    constructor(options: AgentNodeOptions);
+    /**
+     * Subscribe to bus events and start the worker loop.
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the worker loop.
+     */
+    stop(): Promise<void>;
+    /**
+     * Seed a message into the queue from the orchestrator.
+     */
+    inject(content: string): Promise<void>;
+    /** Number of turns the worker has completed. */
+    get turnsTaken(): number;
+    /** Whether the worker is done (stopped or completed). */
+    get isDone(): boolean;
+    private _shouldHandle;
+    private _onMessage;
+    private _onBroadcast;
+    private _enqueue;
+    private _waitForMessage;
+    private _drainQueue;
+    private _worker;
+    private _formatIncoming;
+    private _emitLifecycle;
+}
+
+/**
+ * AgencyRuntime - takes an Agency atom and produces a running system of AgentNode instances.
+ *
+ * Bridges the declarative Agency definition (atoms layer) to the runtime systems layer
+ * by creating transport, building agents with roles/capabilities, and wiring up
+ * event-driven communication between nodes.
+ *
+ * Architecture:
+ *   Agency (atom) -> AgencyRuntime -> [AgentNode, AgentNode, ...] on shared transport
+ */
+
+/**
+ * Takes an Agency atom and creates an AgentNode swarm with transport wiring.
+ *
+ * Lifecycle:
+ *   const runtime = new AgencyRuntime(agency, runner);
+ *   await runtime.start();               // creates transport, builds nodes, starts all
+ *   await runtime.injectCoordinator("Go!");
+ *   ...
+ *   await runtime.stop();                // stops all nodes and transport
+ */
+declare class AgencyRuntime {
+    private readonly _agency;
+    private readonly _runner;
+    private readonly _runId;
+    private _transport;
+    private _nodes;
+    private _buses;
+    private _addresses;
+    private _started;
+    constructor(agency: Agency, runner: RunnerProtocol, runId?: string);
+    /**
+     * Create transport, build nodes, start all.
+     */
+    start(): Promise<void>;
+    /**
+     * Stop all nodes and transport.
+     */
+    stop(): Promise<void>;
+    /**
+     * Inject a message to a specific agent by role.
+     */
+    inject(role: string, content: string): Promise<void>;
+    /**
+     * Inject a message to the coordinator agent.
+     */
+    injectCoordinator(content: string): Promise<void>;
+    /**
+     * Get the coordinator's address.
+     */
+    get coordinatorAddress(): AgentAddress | undefined;
+    /**
+     * Return role -> state mapping for all nodes.
+     */
+    status(): Record<string, "running" | "stopped">;
+    /**
+     * Access the underlying nodes (read-only view).
+     */
+    get nodes(): Record<string, AgentNode>;
+    /**
+     * The run ID for this runtime instance.
+     */
+    get runId(): string;
+    /**
+     * Build a single AgentNode from an AgentSpec.
+     */
+    private _buildNode;
+}
+
+/**
+ * ConversationStoreProtocol — structured persistence for conversations.
+ *
+ * Ported from Python: systems/stores/base.py
+ */
+/** A stored conversation record. */
+interface StoredConversation {
+    readonly id: string;
+    readonly agentName: string;
+    readonly model: string;
+    readonly createdAt: Date;
+    readonly updatedAt: Date;
+    readonly metadata: Record<string, unknown>;
+}
+/** A stored message within a conversation. */
+interface StoredMessage {
+    readonly id: string;
+    readonly conversationId: string;
+    readonly kind: "request" | "response";
+    readonly runId?: string;
+    readonly inputTokens: number;
+    readonly outputTokens: number;
+    readonly createdAt: Date;
+    readonly parts: StoredMessagePart[];
+}
+/** A part of a stored message. */
+interface StoredMessagePart {
+    readonly id: string;
+    readonly messageId: string;
+    readonly type: string;
+    readonly content?: string;
+    readonly metadata: Record<string, unknown>;
+}
+/** Structured conversation persistence protocol. */
+interface ConversationStoreProtocol {
+    createConversation(agentName: string, model: string): Promise<StoredConversation>;
+    getConversation(conversationId: string): Promise<StoredConversation | null>;
+    updateConversation(conversationId: string, updates: Record<string, unknown>): Promise<StoredConversation>;
+    addMessage(conversationId: string, kind: "request" | "response", parts: Array<{
+        type: string;
+        content?: string;
+        metadata?: Record<string, unknown>;
+    }>, options?: {
+        runId?: string;
+        inputTokens?: number;
+        outputTokens?: number;
+    }): Promise<StoredMessage>;
+    getMessages(conversationId: string, limit?: number): Promise<StoredMessage[]>;
+    getMessageParts(messageId: string): Promise<StoredMessagePart[]>;
+}
+/** In-memory implementation of ConversationStoreProtocol. */
+declare class MemoryStore implements ConversationStoreProtocol {
+    private _conversations;
+    private _messages;
+    private _parts;
+    createConversation(agentName: string, model: string): Promise<StoredConversation>;
+    getConversation(conversationId: string): Promise<StoredConversation | null>;
+    updateConversation(conversationId: string, updates: Record<string, unknown>): Promise<StoredConversation>;
+    addMessage(conversationId: string, kind: "request" | "response", parts: Array<{
+        type: string;
+        content?: string;
+        metadata?: Record<string, unknown>;
+    }>, options?: {
+        runId?: string;
+        inputTokens?: number;
+        outputTokens?: number;
+    }): Promise<StoredMessage>;
+    getMessages(conversationId: string, limit?: number): Promise<StoredMessage[]>;
+    getMessageParts(messageId: string): Promise<StoredMessagePart[]>;
+}
+
+/**
+ * Conversation runtime - stateful multi-turn conversation management.
+ *
+ * Ported from Python: systems/conversation.py
+ */
+
+/** A single tool call record within an exchange. */
+interface ToolCallRecord {
+    readonly name: string;
+    readonly id?: string;
+    readonly arguments?: Record<string, unknown>;
+}
+/** A complete user->assistant exchange in a conversation. */
+interface Exchange {
+    readonly number: number;
+    readonly invocationId: string;
+    readonly user: string;
+    readonly assistant: string;
+    readonly toolCalls: ToolCallRecord[];
+    readonly inputTokens: number;
+    readonly outputTokens: number;
+    readonly timestamp: Date;
+}
+/**
+ * Total tokens for an exchange.
+ */
+declare function exchangeTotalTokens(exchange: Exchange): number;
+/**
+ * A live conversation that can be continued.
+ *
+ * Core runtime abstraction for multi-turn conversations.
+ * Tracks state, history, and manages execution.
+ *
+ * Example:
+ *   const conversation = new Conversation(agent, runner);
+ *   const exchange = await conversation.send("Hello!");
+ *   console.log(exchange.assistant);
+ */
+declare class Conversation {
+    readonly id: string;
+    readonly agent: AgentLike;
+    readonly runner: RunnerProtocol;
+    private _store;
+    private _storeConversationId;
+    private _toolExecutor;
+    private _state;
+    private _history;
+    private _exchangeCount;
+    constructor(agent: AgentLike, runner: RunnerProtocol, options?: {
+        id?: string;
+        store?: ConversationStoreProtocol;
+        toolExecutor?: ToolExecutor;
+        state?: Record<string, unknown>;
+        history?: Exchange[];
+    });
+    /** String session ID for SDK compatibility. */
+    get sessionId(): string;
+    /** Number of completed exchanges. */
+    get exchangeCount(): number;
+    /** All completed exchanges (copy). */
+    get history(): Exchange[];
+    /** Alias for history — matches spec's `exchanges` getter. */
+    get exchanges(): Exchange[];
+    /** Working state. */
+    get state(): Record<string, unknown>;
+    /** Aggregate token usage across all exchanges. */
+    get totalTokens(): {
+        input: number;
+        output: number;
+        total: number;
+    };
+    /** Most recent exchange, or undefined if no history. */
+    get lastExchange(): Exchange | undefined;
+    /** Clear conversation history. */
+    clear(): void;
+    /** Rollback conversation to a specific exchange (inclusive). */
+    rollback(toExchange: number): void;
+    /**
+     * Send a message and get a response.
+     */
+    send(message: string): Promise<Exchange>;
+    /**
+     * Send a message and stream the response.
+     *
+     * Yields AgentEvents as they arrive. After streaming completes,
+     * the exchange is recorded in history.
+     */
+    stream(message: string, options?: {
+        eventBus?: AgentEventBus;
+    }): AsyncGenerator<AgentEvent>;
+    /**
+     * Create a new conversation branch.
+     *
+     * @param atExchange - Exchange number to branch from (undefined = current)
+     */
+    fork(atExchange?: number): Promise<Conversation>;
+    /**
+     * Persist an exchange to the store using the new protocol.
+     */
+    private _persistExchange;
+    /**
+     * Convert history to canonical message format for runners.
+     */
+    private _toMessageHistory;
+}
+
+/**
+ * Base exporter protocol and class for event-driven observability.
+ *
+ * Exporters subscribe to EventBus profiles and handle events for
+ * rendering, tracing, or metrics collection.
+ *
+ * Ported from Python: systems/exporters/base.py
+ */
+
+/** Protocol for event exporters. */
+interface Exporter {
+    attach(bus: EventBus): void;
+    detach(bus: EventBus): void;
+}
+/**
+ * Base class with profile-based subscription.
+ *
+ * Subclasses set `profile` and implement `_on<Suffix>` methods.
+ * The `handleEvent` dispatcher converts event_type to method name:
+ *   "agent.message.start" -> "_onMessageStart"
+ *   "agent.tool.end"      -> "_onToolEnd"
+ *   "agent.reasoning"     -> "_onReasoning"
+ *   "agent.error"         -> "_onError"
+ */
+declare abstract class BaseExporter implements Exporter {
+    profile: EventProfile;
+    /** Subscribe to all event types in this exporter's profile. */
+    attach(bus: EventBus): void;
+    /** Unsubscribe from all event types in this exporter's profile. */
+    detach(bus: EventBus): void;
+    /**
+     * Dispatch to _on<Suffix> methods by event type.
+     *
+     * Converts event type (e.g. "agent.message.start") to handler
+     * method name (e.g. "_onMessageStart") by stripping the "agent."
+     * prefix and converting dot-separated segments to camelCase.
+     */
+    handleEvent(event: BaseEvent): Promise<void>;
+    /** Bound reference for subscribe/unsubscribe identity. */
+    private _boundHandleEvent;
+}
+
+/**
+ * Console exporter - plain text output for agent execution.
+ *
+ * Provides terminal output via EventBus subscription.
+ * Uses a Logger interface to avoid hard dependency on Node globals.
+ *
+ * Ported from Python: systems/exporters/console.py
+ */
+
+/** Logger interface for console output. */
+interface ConsoleLogger {
+    log(message: string): void;
+    error(message: string): void;
+    write(text: string): void;
+}
+/**
+ * Console exporter that prints agent events to stdout.
+ *
+ * Subscribes to UX profile events and renders them as plain text.
+ */
+declare class ConsoleExporter extends BaseExporter {
+    profile: "ux";
+    private _verbose;
+    private _logger;
+    private _contentBuffer;
+    private _toolNames;
+    constructor(options?: {
+        verbose?: boolean;
+        logger?: ConsoleLogger;
+    });
+    /** @internal */
+    _onMessageStart(_event: MessageStartEvent): Promise<void>;
+    /** @internal */
+    _onMessageChunk(event: MessageChunkEvent): Promise<void>;
+    /** @internal */
+    _onMessageComplete(event: MessageCompleteEvent): Promise<void>;
+    /** @internal */
+    _onReasoning(event: ReasoningEvent): Promise<void>;
+    /** @internal */
+    _onToolStart(event: ToolCallStartEvent): Promise<void>;
+    /** @internal */
+    _onToolEnd(event: ToolCallEndEvent): Promise<void>;
+    /** @internal */
+    _onError(event: ErrorEvent): Promise<void>;
+}
+/**
+ * Factory function for console exporter.
+ */
+declare function createConsoleExporter(options?: {
+    verbose?: boolean;
+    logger?: ConsoleLogger;
+}): ConsoleExporter;
+
+/**
+ * Langfuse exporter - LLM observability with traces and generations.
+ *
+ * Exports agent events to Langfuse for LLM-specific observability
+ * including traces, generations (LLM calls), and spans (tool calls).
+ *
+ * Requires @langfuse/langfuse as an optional peer dependency.
+ *
+ * Ported from Python: systems/exporters/langfuse.py
+ */
+
+/**
+ * Minimal interface for Langfuse client.
+ *
+ * Users provide the real Langfuse client from @langfuse/langfuse.
+ * We define this interface to avoid a hard dependency.
+ */
+interface LangfuseClient {
+    startSpan(params: Record<string, unknown>): LangfuseSpan;
+    flush(): void;
+}
+/** Minimal Langfuse span interface. */
+interface LangfuseSpan {
+    startSpan(params: Record<string, unknown>): LangfuseSpan;
+    startObservation(params: Record<string, unknown>): LangfuseObservation;
+    update(params: Record<string, unknown>): void;
+    updateTrace(params: Record<string, unknown>): void;
+    end(): void;
+}
+/** Minimal Langfuse observation interface. */
+interface LangfuseObservation {
+    update(params: Record<string, unknown>): void;
+    end(): void;
+}
+/**
+ * Export agent events to Langfuse for LLM observability.
+ *
+ * Maps the agent event hierarchy to Langfuse concepts:
+ *   - MessageStart -> Root span (creates trace implicitly)
+ *   - LLM calls -> Generation (nested under root/iteration span)
+ *   - Tool calls -> Generation (nested under root/iteration span)
+ *   - MessageComplete -> Trace update with final output
+ */
+declare class LangfuseExporter extends BaseExporter {
+    profile: "obs";
+    private langfuse;
+    private captureContent;
+    private _rootSpans;
+    private _iterationSpans;
+    private _generations;
+    private _spans;
+    private _traceInputSet;
+    private _iterToolNames;
+    private _iterOutputTokens;
+    private _iterUserMessage;
+    private _prevIterToolNames;
+    constructor(options: {
+        client: LangfuseClient;
+        captureContent?: boolean;
+    });
+    private _toHexId;
+    /** @internal */
+    _onMessageStart(event: MessageStartEvent): Promise<void>;
+    /** @internal */
+    _onIterationStart(event: IterationStartEvent): Promise<void>;
+    /** @internal */
+    _onIterationEnd(event: IterationEndEvent): Promise<void>;
+    /** @internal */
+    _onLlmStart(event: LLMCallStartEvent): Promise<void>;
+    /** @internal */
+    _onLlmEnd(event: LLMCallEndEvent): Promise<void>;
+    /** @internal */
+    _onToolStart(event: ToolCallStartEvent): Promise<void>;
+    /** @internal */
+    _onToolEnd(event: ToolCallEndEvent): Promise<void>;
+    /** @internal */
+    _onReasoning(event: ReasoningEvent): Promise<void>;
+    /** @internal */
+    _onError(event: ErrorEvent): Promise<void>;
+    /** @internal */
+    _onMessageComplete(event: MessageCompleteEvent): Promise<void>;
+    /** Flush pending events to Langfuse. */
+    flush(): void;
+}
+
+/**
+ * OpenTelemetry exporter - spans to OTLP collector.
+ *
+ * Exports agent events as OpenTelemetry spans following Gen AI
+ * semantic conventions for LLM observability.
+ *
+ * Requires @opentelemetry/api as an optional peer dependency.
+ *
+ * Ported from Python: systems/exporters/otel.py
+ */
+
+/** Minimal OTel Span interface. */
+interface OTelSpan {
+    setAttribute(key: string, value: string | number | boolean): void;
+    setStatus(status: {
+        code: number;
+        message?: string;
+    }): void;
+    recordException(error: Error): void;
+    end(): void;
+}
+/** Minimal OTel Tracer interface. */
+interface OTelTracer {
+    startSpan(name: string, options?: Record<string, unknown>): OTelSpan;
+}
+/** OTel StatusCode constants. */
+declare const OTelStatusCode: {
+    readonly OK: 1;
+    readonly ERROR: 2;
+};
+/**
+ * Export agent events as OpenTelemetry spans.
+ *
+ * Maps the agent event hierarchy to OTel spans:
+ *   agent.run (root) -> iteration -> llm_call / tool_call
+ *
+ * Follows Gen AI semantic conventions:
+ *   - gen_ai.system = "vercel-ai-sdk"
+ *   - gen_ai.request.model = model name
+ *   - gen_ai.usage.input_tokens / output_tokens
+ */
+declare class OTelExporter extends BaseExporter {
+    profile: "obs";
+    private tracer;
+    /** Whether to capture prompt/completion content in spans. */
+    readonly captureContent: boolean;
+    private _spans;
+    constructor(options: {
+        tracer: OTelTracer;
+        captureContent?: boolean;
+    });
+    /** @internal */
+    _onMessageStart(event: MessageStartEvent): Promise<void>;
+    /** @internal */
+    _onIterationStart(event: IterationStartEvent): Promise<void>;
+    /** @internal */
+    _onIterationEnd(event: IterationEndEvent): Promise<void>;
+    /** @internal */
+    _onLlmStart(event: LLMCallStartEvent): Promise<void>;
+    /** @internal */
+    _onLlmEnd(event: LLMCallEndEvent): Promise<void>;
+    /** @internal */
+    _onToolStart(event: ToolCallStartEvent): Promise<void>;
+    /** @internal */
+    _onToolEnd(event: ToolCallEndEvent): Promise<void>;
+    /** @internal */
+    _onError(event: ErrorEvent): Promise<void>;
+    /** @internal */
+    _onMessageComplete(event: MessageCompleteEvent): Promise<void>;
+}
+
+/**
+ * SSE Exporter — Fan-out broadcast to connected admin dashboard clients.
+ *
+ * Extends BaseExporter with UX profile. Formats events using SSEFormatter
+ * and broadcasts to all connected ReadableStream clients.
+ */
+
+/**
+ * Broadcasts agent events as SSE frames to connected clients.
+ *
+ * Usage:
+ *   const exporter = new SSEExporter();
+ *   exporter.attach(eventBus);
+ *   const stream = exporter.connect(); // return to HTTP response
+ *   // Later:
+ *   exporter.disconnect(stream);
+ */
+declare class SSEExporter extends BaseExporter {
+    profile: "ux";
+    private _clients;
+    private _formatter;
+    private _encoder;
+    /** Connect a new client. Returns a ReadableStream to pipe to the HTTP response. */
+    connect(): ReadableStream<Uint8Array>;
+    /** Disconnect a client stream. */
+    disconnect(stream: ReadableStream<Uint8Array>): void;
+    /** Number of connected clients. */
+    get clientCount(): number;
+    /** Handle any event by broadcasting to all connected clients. */
+    handleEvent(event: BaseEvent): Promise<void>;
+}
+
+/**
+ * Coordinator role preset - orchestrates specialist agents within an agency.
+ *
+ * Ported from Python: library/orchestration/archetypes.py
+ */
+
+/**
+ * Role that orchestrates specialist agents within an agency.
+ *
+ * A coordinator routes work to specialists, manages execution
+ * sequence, and reviews output quality. It never performs
+ * specialist work directly.
+ */
+declare function coordinatorRole(options?: {
+    capability?: Capability;
+}): Role;
+
+/**
+ * Orchestrator role preset - conversational routing agent.
+ *
+ * Ported from Python: library/orchestration/archetypes.py
+ */
+
+/**
+ * Role that understands user intent and routes to agencies/agents.
+ *
+ * An orchestrator is the chat-facing agent that interprets what
+ * users want, routes to the right specialist team, and synthesizes
+ * responses. It maintains conversational context across turns.
+ */
+declare function orchestratorRole(options?: {
+    capability?: Capability;
+}): Role;
+
+/**
+ * Analyst role preset - specialized judgment for evidence-based assessments.
+ *
+ * Ported from Python: library/orchestration/archetypes.py
+ */
+
+/**
+ * Role that applies specialized judgment to produce typed assessments.
+ *
+ * An analyst receives pre-gathered context and applies domain-specific
+ * judgment heuristics to produce a structured, evidence-backed
+ * assessment. Analysts do not gather data -- they reason over it.
+ */
+declare function analystRole(options?: {
+    domain?: string;
+    capability?: Capability;
+    extraJudgments?: Judgment[];
+}): Role;
+
+/**
+ * Retrieval role preset - knowledge researcher.
+ *
+ * Ported from Python: library/orchestration/archetypes.py
+ */
+
+/**
+ * Role that finds and organizes relevant evidence from data sources.
+ *
+ * A retrieval agent decomposes information requests into targeted
+ * search queries, executes them systematically, and organizes results
+ * by the requester's stated dimensions.
+ */
+declare function retrievalRole(options?: {
+    capability?: Capability;
+    extraJudgments?: Judgment[];
+}): Role;
+
+/**
+ * Judgments for orchestration archetypes.
+ *
+ * Ported from Python: library/orchestration/judgments.py
+ */
+
+declare const ROUTING: Judgment;
+declare const QUALITY_REVIEW: Judgment;
+declare const INTENT_CLASSIFICATION: Judgment;
+declare const RETRIEVAL_STRATEGY: Judgment;
+declare const EVIDENCE_QUALITY: Judgment;
+
+/**
+ * Responsibilities for orchestration archetypes.
+ *
+ * Ported from Python: library/orchestration/responsibilities.py
+ */
+
+declare const ORCHESTRATION: Responsibility;
+declare const QUALITY_GATE: Responsibility;
+declare const INTENT_ROUTING: Responsibility;
+declare const RESPONSE_SYNTHESIS: Responsibility;
+declare const INFORMATION_RETRIEVAL: Responsibility;
+declare const ANALYSIS: Responsibility;
+
+declare class CalculatorToolbox extends Toolbox {
+    readonly name = "calculator_operations";
+    readonly description = "Arithmetic and algebraic calculator operations";
+    readonly tools: Record<string, ToolDefinition>;
+}
+declare function buildCalculatorAgent(): _agentic_patterns_core.Agent;
+
+declare class TodoToolbox extends Toolbox {
+    readonly name = "task_management";
+    readonly description = "In-memory task list management";
+    readonly tools: Record<string, ToolDefinition>;
+}
+declare function buildTodoAgent(): _agentic_patterns_core.Agent;
+
+/**
+ * Writing Coach — a tools-free agent preset that demonstrates
+ * pure persona + reasoning without any toolbox or capability.
+ */
+declare function buildWritingCoachAgent(): _agentic_patterns_core.Agent;
+
+/**
+ * Workflow base types — shared types, events, hooks, and helpers
+ * that all workflow patterns depend on.
+ *
+ * Ported from Python: workflows/base.py
+ */
+
+/** Shared context passed through workflow steps. */
+type PatternContext = Record<string, unknown>;
+/** A message template: either a static string or a function that builds one. */
+type MessageTemplate = string | ((context: PatternContext) => string);
+/** A single step in a workflow pattern. */
+interface Step {
+    readonly agent: AgentLike;
+    readonly messageTemplate: MessageTemplate;
+    readonly name?: string;
+    readonly outputKey?: string;
+    readonly contextExtractor?: (result: StepResult, context: PatternContext) => PatternContext;
+}
+/** Result of executing a single step. */
+interface StepResult {
+    readonly stepName: string;
+    readonly runResult: RunResult;
+    /** Shortcut for `runResult.response`. */
+    readonly content: string;
+    readonly inputTokens: number;
+    readonly outputTokens: number;
+}
+/**
+ * Create a frozen StepResult from a RunResult.
+ */
+declare function createStepResult(stepName: string, runResult: RunResult): StepResult;
+/** Aggregate result of a workflow pattern execution. */
+interface PatternResult {
+    readonly totalInputTokens: number;
+    readonly totalOutputTokens: number;
+    readonly succeeded: boolean;
+    readonly finalContent: string;
+}
+interface PatternStartEvent {
+    readonly type: "pattern.start";
+    readonly patternName: string;
+    readonly timestamp: Date;
+}
+interface PatternStepStartEvent {
+    readonly type: "pattern.step.start";
+    readonly stepName: string;
+    readonly stepIndex: number;
+    readonly timestamp: Date;
+}
+interface PatternStepCompleteEvent {
+    readonly type: "pattern.step.complete";
+    readonly stepName: string;
+    readonly stepIndex: number;
+    readonly result: StepResult;
+    readonly timestamp: Date;
+}
+interface PatternStepErrorEvent {
+    readonly type: "pattern.step.error";
+    readonly stepName: string;
+    readonly stepIndex: number;
+    readonly error: Error;
+    readonly timestamp: Date;
+}
+interface PatternIterationStartEvent {
+    readonly type: "pattern.iteration.start";
+    readonly iteration: number;
+    readonly timestamp: Date;
+}
+interface PatternIterationCompleteEvent {
+    readonly type: "pattern.iteration.complete";
+    readonly iteration: number;
+    readonly timestamp: Date;
+}
+interface PatternCompleteEvent {
+    readonly type: "pattern.complete";
+    readonly patternName: string;
+    readonly result: PatternResult;
+    readonly timestamp: Date;
+}
+type PatternEvent = PatternStartEvent | PatternStepStartEvent | PatternStepCompleteEvent | PatternStepErrorEvent | PatternIterationStartEvent | PatternIterationCompleteEvent | PatternCompleteEvent;
+/**
+ * Callbacks for pattern lifecycle events.
+ *
+ * NOTE: These are workflow-level hooks for pattern orchestration.
+ * They are NOT the same as the deprecated runner-level Hooks interface.
+ */
+interface PatternHooks {
+    onPatternStart?: (event: PatternStartEvent) => void | Promise<void>;
+    onStepStart?: (event: PatternStepStartEvent) => void | Promise<void>;
+    onStepComplete?: (event: PatternStepCompleteEvent) => void | Promise<void>;
+    onStepError?: (event: PatternStepErrorEvent) => void | Promise<void>;
+    onIterationStart?: (event: PatternIterationStartEvent) => void | Promise<void>;
+    onIterationComplete?: (event: PatternIterationCompleteEvent) => void | Promise<void>;
+    onPatternComplete?: (event: PatternCompleteEvent) => void | Promise<void>;
+}
+/** Options passed to pattern.run(). */
+interface PatternRunOptions {
+    readonly runner: RunnerProtocol;
+    readonly hooks?: PatternHooks;
+    readonly toolExecutor?: ToolExecutor;
+    readonly traceId?: string;
+}
+/** Interface that all workflow patterns implement. */
+interface PatternProtocol {
+    run(context?: PatternContext, options?: PatternRunOptions): Promise<PatternResult>;
+}
+/** Result tuple: [achieved, reason, confident]. */
+type GoalEvaluationResult = readonly [achieved: boolean, reason: string, confident: boolean];
+/** Protocol for evaluating whether a goal has been achieved. */
+interface GoalEvaluatorProtocol {
+    evaluate(goal: string, output: string, context?: PatternContext): Promise<GoalEvaluationResult>;
+}
+/**
+ * Resolve a message template to a string.
+ */
+declare function resolveMessage(template: MessageTemplate, context: PatternContext): string;
+/**
+ * Generate a step name, falling back to `step_<index>` if none provided.
+ */
+declare function makeStepName(name: string | undefined, index: number): string;
+/**
+ * Execute a single step: resolve message, run agent, return result.
+ */
+declare function executeStep(step: Step, context: PatternContext, runner: RunnerProtocol, toolExecutor?: ToolExecutor): Promise<StepResult>;
+
+/**
+ * Sequential — Chain agents in sequence, threading context through the pipeline.
+ *
+ * Ported from Python: workflows/compositions/sequential.py
+ */
+
+interface SequentialResult extends PatternResult {
+    readonly steps: ReadonlyArray<StepResult | PatternResult>;
+    readonly finalContext: Readonly<PatternContext>;
+}
+interface SequentialOptions {
+    readonly continueOnError?: boolean;
+}
+/**
+ * Chain agents in sequence, threading context through the pipeline.
+ *
+ * Each step reads context, writes via `outputKey` and `contextExtractor`.
+ * Supports nested patterns (any PatternProtocol) as steps.
+ *
+ * Example:
+ *   const seq = new Sequential([
+ *     { agent: writer, messageTemplate: "Write about {topic}" },
+ *     { agent: reviewer, messageTemplate: (ctx) => `Review: ${ctx.draft}` },
+ *   ]);
+ */
+declare class Sequential implements PatternProtocol {
+    private readonly steps;
+    private readonly continueOnError;
+    constructor(steps: Array<Step | PatternProtocol>, options?: SequentialOptions);
+    run(context?: PatternContext, options?: PatternRunOptions): Promise<SequentialResult>;
+}
+
+/**
+ * Parallel — Fan-out agents in parallel with optional concurrency limiting.
+ *
+ * Ported from Python: workflows/compositions/parallel.py
+ */
+
+/** Consolidator: reduce step results to a single value. */
+type Consolidator = (results: StepResult[]) => unknown;
+/** Collect all step contents into an array. */
+declare function collectContents(results: StepResult[]): string[];
+/** Collect step contents keyed by step name. */
+declare function collectByName(results: StepResult[]): Record<string, string>;
+interface ParallelResult extends PatternResult {
+    readonly results: ReadonlyArray<StepResult | Error>;
+    readonly successful: ReadonlyArray<StepResult>;
+    readonly failed: ReadonlyArray<readonly [number, Error]>;
+    readonly consolidatedOutput: Readonly<Record<string, unknown>>;
+    readonly allSucceeded: boolean;
+}
+interface ParallelOptions {
+    readonly outputKey?: string;
+    readonly consolidator?: Consolidator;
+    readonly returnExceptions?: boolean;
+    readonly maxConcurrency?: number;
+}
+/**
+ * Fan-out agents in parallel with optional concurrency limiting.
+ *
+ * All steps receive the same context snapshot.
+ * Results preserve input order.
+ *
+ * Example:
+ *   const par = new Parallel([
+ *     { agent: analyst1, messageTemplate: "Analyze data" },
+ *     { agent: analyst2, messageTemplate: "Analyze data" },
+ *   ], { maxConcurrency: 2 });
+ */
+declare class Parallel implements PatternProtocol {
+    private readonly steps;
+    private readonly outputKey;
+    private readonly consolidator;
+    private readonly returnExceptions;
+    private readonly maxConcurrency;
+    constructor(steps: Step[], options?: ParallelOptions);
+    run(context?: PatternContext, options?: PatternRunOptions): Promise<ParallelResult>;
+}
+
+/**
+ * RetryLoop — Generic async retry wrapper with pluggable backoff strategies.
+ *
+ * Not agent-specific — wraps any `() => Promise<T>`.
+ *
+ * Ported from Python: workflows/loops/retry.py
+ */
+
+/** Backoff strategy: given an attempt number (0-based), return delay in ms. */
+interface BackoffStrategy {
+    getDelay(attempt: number): number;
+}
+/** Fixed delay between retries. */
+declare class FixedBackoff implements BackoffStrategy {
+    private readonly delayMs;
+    constructor(delayMs: number);
+    getDelay(_attempt: number): number;
+}
+/** Exponential backoff: baseMs * 2^attempt, capped at maxMs. */
+declare class ExponentialBackoff implements BackoffStrategy {
+    private readonly baseMs;
+    private readonly maxMs;
+    constructor(baseMs?: number, maxMs?: number);
+    getDelay(attempt: number): number;
+}
+/** Jittered exponential backoff: adds random jitter to exponential delay. */
+declare class JitteredBackoff implements BackoffStrategy {
+    private readonly exponential;
+    constructor(baseMs?: number, maxMs?: number);
+    getDelay(attempt: number): number;
+}
+/** Exit reason for a retry loop. */
+type RetryExitReason = "success" | "max_attempts" | "fatal_error" | "timeout";
+/** Result of a retry loop execution. */
+interface RetryResult<T> extends PatternResult {
+    readonly exitReason: RetryExitReason;
+    readonly attempts: number;
+    readonly value?: T;
+    readonly lastError?: Error;
+}
+interface RetryLoopOptions {
+    readonly maxAttempts?: number;
+    readonly backoff?: BackoffStrategy;
+    readonly timeoutMs?: number;
+    readonly fatalErrors?: ReadonlyArray<abstract new (...args: never[]) => Error>;
+    readonly onRetry?: (attempt: number, error: Error) => void | Promise<void>;
+    readonly hooks?: PatternHooks;
+}
+interface RetryRunOptions {
+    readonly hooks?: PatternHooks;
+}
+/**
+ * Generic async retry wrapper with pluggable backoff.
+ *
+ * Example:
+ *   const loop = new RetryLoop<string>({ maxAttempts: 3 });
+ *   const result = await loop.run(async () => fetchData());
+ */
+declare class RetryLoop<T> {
+    private readonly maxAttempts;
+    private readonly backoff;
+    private readonly timeoutMs;
+    private readonly fatalErrors;
+    private readonly onRetry;
+    private readonly defaultHooks;
+    constructor(options?: RetryLoopOptions);
+    run(fn: () => Promise<T>, options?: RetryRunOptions): Promise<RetryResult<T>>;
+    private isFatal;
+    private buildResult;
+}
+
+/**
+ * Goal Evaluators — Four implementations of GoalEvaluatorProtocol,
+ * ranked cheapest to most expensive.
+ *
+ * Ported from Python: workflows/evaluators.py
+ */
+
+interface SimpleGoalEvaluatorOptions {
+    readonly successPatterns?: readonly string[];
+    readonly failurePatterns?: readonly string[];
+}
+/**
+ * Pattern-matching evaluator: checks output for success/failure substrings.
+ * Returns not-confident if no patterns match.
+ */
+declare class SimpleGoalEvaluator implements GoalEvaluatorProtocol {
+    private readonly successPatterns;
+    private readonly failurePatterns;
+    constructor(options?: SimpleGoalEvaluatorOptions);
+    evaluate(_goal: string, output: string, _context?: PatternContext): Promise<GoalEvaluationResult>;
+}
+/**
+ * Parses agent output for structured markers:
+ *   GOAL_STATUS: ACHIEVED|NOT_ACHIEVED
+ *   PROGRESS: <text>
+ */
+declare class SelfEvalGoalEvaluator implements GoalEvaluatorProtocol {
+    evaluate(_goal: string, output: string, _context?: PatternContext): Promise<GoalEvaluationResult>;
+}
+interface LLMGoalEvaluatorOptions {
+    readonly agent: AgentLike;
+    readonly runner: RunnerProtocol;
+}
+/**
+ * Sends goal + output to an evaluator agent, parses GOAL_STATUS from response.
+ */
+declare class LLMGoalEvaluator implements GoalEvaluatorProtocol {
+    private readonly agent;
+    private readonly runner;
+    constructor(options: LLMGoalEvaluatorOptions);
+    evaluate(goal: string, output: string, _context?: PatternContext): Promise<GoalEvaluationResult>;
+}
+/**
+ * Tries evaluators in order, stops on first confident result.
+ * Falls back to last result if none are confident.
+ */
+declare class EvaluatorChain implements GoalEvaluatorProtocol {
+    private readonly evaluators;
+    constructor(evaluators: GoalEvaluatorProtocol[]);
+    evaluate(goal: string, output: string, context?: PatternContext): Promise<GoalEvaluationResult>;
+}
+
+/**
+ * TaskLoop — Goal-driven iterative loop.
+ *
+ * Runs an agent toward a goal, evaluating progress each iteration.
+ *
+ * Ported from Python: workflows/loops/task.py
+ */
+
+type TaskExitReason = "goal_achieved" | "max_iterations" | "explicit_stop" | "error";
+interface TaskState {
+    readonly iteration: number;
+    readonly history: readonly string[];
+    getHistorySummary(): string;
+}
+interface TaskResult extends PatternResult {
+    readonly exitReason: TaskExitReason;
+    readonly iterations: number;
+    readonly state: TaskState;
+}
+interface TaskLoopOptions {
+    readonly maxIterations?: number;
+    readonly stopPhrases?: readonly string[];
+    readonly includeHistory?: boolean;
+    readonly hooks?: PatternHooks;
+}
+interface TaskRunOptions {
+    readonly runner: RunnerProtocol;
+    readonly toolExecutor?: ToolExecutor;
+    readonly hooks?: PatternHooks;
+}
+/**
+ * Iterative loop that runs an agent toward a goal, evaluating progress.
+ *
+ * Example:
+ *   const loop = new TaskLoop(agent, evaluator, { maxIterations: 5 });
+ *   const result = await loop.run("Write a poem about TypeScript", {}, { runner });
+ */
+declare class TaskLoop {
+    private readonly agent;
+    private readonly goalEvaluator;
+    private readonly maxIterations;
+    private readonly stopPhrases;
+    private readonly includeHistory;
+    private readonly defaultHooks;
+    constructor(agent: AgentLike, goalEvaluator: GoalEvaluatorProtocol, options?: TaskLoopOptions);
+    run(goal: string, context?: PatternContext, options?: TaskRunOptions): Promise<TaskResult>;
+    private buildPrompt;
+    private containsStopPhrase;
+}
+
+/**
+ * EvaluatorLoop — Producer-Evaluator Refinement Loop.
+ *
+ * Producer generates output → evaluator scores + critiques → producer refines.
+ * Tracks best output by score, exits on quality/max/plateau/error.
+ *
+ * Ported from Python: workflows/loops/evaluator.py
+ */
+
+type RefinementExitReason = "quality_met" | "max_refinements" | "no_improvement" | "error";
+/** A single evaluation of produced output. */
+interface Refinement {
+    readonly iteration: number;
+    readonly content: string;
+    readonly score: number;
+    readonly feedback: string;
+}
+/** Protocol for evaluating produced output and providing refinement feedback. */
+interface RefinementEvaluator {
+    evaluate(input: string, output: string, context?: PatternContext): Promise<{
+        score: number;
+        feedback: string;
+        qualityMet: boolean;
+    }>;
+}
+/** Result of the evaluator loop. */
+interface RefinementResult extends PatternResult {
+    readonly exitReason: RefinementExitReason;
+    readonly refinements: readonly Refinement[];
+    readonly bestOutput: string;
+    readonly bestScore: number;
+    readonly iterations: number;
+}
+interface EvaluatorLoopOptions {
+    readonly maxRefinements?: number;
+    readonly minImprovement?: number;
+    readonly hooks?: PatternHooks;
+}
+interface EvaluatorRunOptions {
+    readonly runner: RunnerProtocol;
+    readonly toolExecutor?: ToolExecutor;
+    readonly hooks?: PatternHooks;
+}
+/**
+ * Self-critique refinement loop: producer generates, evaluator scores,
+ * producer refines until quality is met or exit conditions are reached.
+ *
+ * Example:
+ *   const loop = new EvaluatorLoop(writerAgent, evaluator, { maxRefinements: 3 });
+ *   const result = await loop.run("Write a haiku", { runner });
+ */
+declare class EvaluatorLoop {
+    private readonly producer;
+    private readonly evaluator;
+    private readonly maxRefinements;
+    private readonly minImprovement;
+    private readonly defaultHooks;
+    constructor(producer: AgentLike, evaluator: RefinementEvaluator, options?: EvaluatorLoopOptions);
+    run(input: string, options?: EvaluatorRunOptions): Promise<RefinementResult>;
+    private buildPrompt;
+}
+interface LLMRefinementEvaluatorOptions {
+    readonly qualityThreshold?: number;
+}
+/**
+ * Uses an LLM agent to evaluate output quality, parse score and feedback.
+ */
+declare class LLMRefinementEvaluator implements RefinementEvaluator {
+    private readonly agent;
+    private readonly runner;
+    private readonly qualityThreshold;
+    constructor(agent: AgentLike, runner: RunnerProtocol, options?: LLMRefinementEvaluatorOptions);
+    evaluate(input: string, output: string): Promise<{
+        score: number;
+        feedback: string;
+        qualityMet: boolean;
+    }>;
+}
+/** A single rubric criterion with name, weight, and scoring function. */
+interface RubricCriterion {
+    readonly name: string;
+    readonly weight: number;
+    readonly score: (input: string, output: string) => number | Promise<number>;
+}
+/**
+ * Scores output against a set of weighted rubric criteria.
+ */
+declare class RubricEvaluator implements RefinementEvaluator {
+    private readonly criteria;
+    private readonly qualityThreshold;
+    constructor(criteria: readonly RubricCriterion[], qualityThreshold?: number);
+    evaluate(input: string, output: string): Promise<{
+        score: number;
+        feedback: string;
+        qualityMet: boolean;
+    }>;
+}
+/** An evaluator with an associated weight for compositing. */
+interface WeightedEvaluator {
+    readonly evaluator: RefinementEvaluator;
+    readonly weight: number;
+}
+/**
+ * Combines multiple evaluators into a weighted average score.
+ */
+declare class CompositeRefinementEvaluator implements RefinementEvaluator {
+    private readonly evaluators;
+    private readonly qualityThreshold;
+    constructor(evaluators: readonly WeightedEvaluator[], qualityThreshold?: number);
+    evaluate(input: string, output: string, context?: PatternContext): Promise<{
+        score: number;
+        feedback: string;
+        qualityMet: boolean;
+    }>;
+}
+
+/**
+ * ConversationLoop — Multi-turn conversation orchestration.
+ *
+ * Wraps the Conversation class, driving exchanges via external
+ * inputFn/outputFn callbacks. Exits on exit phrase, max exchanges, or error.
+ *
+ * Ported from Python: workflows/loops/conversation.py
+ */
+
+type ConversationExitReason = "exit_phrase" | "max_exchanges" | "input_closed" | "error";
+interface ConversationResult extends PatternResult {
+    readonly exitReason: ConversationExitReason;
+    readonly exchangeCount: number;
+    readonly conversation: Conversation;
+}
+interface ConversationLoopOptions {
+    readonly maxExchanges?: number;
+    readonly exitPhrases?: readonly string[];
+    readonly store?: ConversationStoreProtocol;
+    readonly toolExecutor?: ToolExecutor;
+    readonly hooks?: PatternHooks;
+}
+interface ConversationRunOptions {
+    readonly runner: RunnerProtocol;
+    readonly inputFn: () => string | null | Promise<string | null>;
+    readonly outputFn?: (response: string) => void | Promise<void>;
+    readonly hooks?: PatternHooks;
+}
+/**
+ * Multi-turn conversation loop with external I/O callbacks.
+ *
+ * Example:
+ *   const loop = new ConversationLoop(agent, { maxExchanges: 10 });
+ *   const result = await loop.run({
+ *     runner,
+ *     inputFn: () => readLine(),
+ *     outputFn: (r) => console.log(r),
+ *   });
+ */
+declare class ConversationLoop {
+    private readonly agent;
+    private readonly maxExchanges;
+    private readonly exitPhrases;
+    private readonly store;
+    private readonly toolExecutor;
+    private readonly defaultHooks;
+    constructor(agent: AgentLike, options?: ConversationLoopOptions);
+    run(options: ConversationRunOptions): Promise<ConversationResult>;
+    private isExitPhrase;
+}
+
+/**
+ * Admin Zod schemas for dashboard and observability.
+ *
+ * Defines validated data shapes for agent statistics,
+ * token usage, conversations, and trace data.
+ */
+
+declare const TokenUsageRowSchema: z.ZodObject<{
+    timestamp: z.ZodDate;
+    inputTokens: z.ZodNumber;
+    outputTokens: z.ZodNumber;
+    totalTokens: z.ZodNumber;
+    model: z.ZodString;
+    agentName: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    timestamp: Date;
+    agentName: string;
+    inputTokens: number;
+    outputTokens: number;
+    model: string;
+    totalTokens: number;
+}, {
+    timestamp: Date;
+    agentName: string;
+    inputTokens: number;
+    outputTokens: number;
+    model: string;
+    totalTokens: number;
+}>;
+type TokenUsageRow = z.infer<typeof TokenUsageRowSchema>;
+declare const ToolStatsSchema: z.ZodObject<{
+    toolName: z.ZodString;
+    callCount: z.ZodNumber;
+    errorCount: z.ZodNumber;
+    totalDurationMs: z.ZodNumber;
+    avgDurationMs: z.ZodNumber;
+    lastUsed: z.ZodOptional<z.ZodDate>;
+}, "strip", z.ZodTypeAny, {
+    toolName: string;
+    callCount: number;
+    errorCount: number;
+    totalDurationMs: number;
+    avgDurationMs: number;
+    lastUsed?: Date | undefined;
+}, {
+    toolName: string;
+    callCount: number;
+    errorCount: number;
+    totalDurationMs: number;
+    avgDurationMs: number;
+    lastUsed?: Date | undefined;
+}>;
+type ToolStats = z.infer<typeof ToolStatsSchema>;
+declare const AgentStatsSchema: z.ZodObject<{
+    agentName: z.ZodString;
+    status: z.ZodEnum<["idle", "running", "error", "completed"]>;
+    totalIterations: z.ZodNumber;
+    totalToolCalls: z.ZodNumber;
+    totalInputTokens: z.ZodNumber;
+    totalOutputTokens: z.ZodNumber;
+    totalErrors: z.ZodNumber;
+    startedAt: z.ZodOptional<z.ZodDate>;
+    lastEventAt: z.ZodOptional<z.ZodDate>;
+    toolStats: z.ZodArray<z.ZodObject<{
+        toolName: z.ZodString;
+        callCount: z.ZodNumber;
+        errorCount: z.ZodNumber;
+        totalDurationMs: z.ZodNumber;
+        avgDurationMs: z.ZodNumber;
+        lastUsed: z.ZodOptional<z.ZodDate>;
+    }, "strip", z.ZodTypeAny, {
+        toolName: string;
+        callCount: number;
+        errorCount: number;
+        totalDurationMs: number;
+        avgDurationMs: number;
+        lastUsed?: Date | undefined;
+    }, {
+        toolName: string;
+        callCount: number;
+        errorCount: number;
+        totalDurationMs: number;
+        avgDurationMs: number;
+        lastUsed?: Date | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    agentName: string;
+    status: "completed" | "error" | "running" | "idle";
+    totalInputTokens: number;
+    totalOutputTokens: number;
+    totalIterations: number;
+    totalToolCalls: number;
+    totalErrors: number;
+    toolStats: {
+        toolName: string;
+        callCount: number;
+        errorCount: number;
+        totalDurationMs: number;
+        avgDurationMs: number;
+        lastUsed?: Date | undefined;
+    }[];
+    startedAt?: Date | undefined;
+    lastEventAt?: Date | undefined;
+}, {
+    agentName: string;
+    status: "completed" | "error" | "running" | "idle";
+    totalInputTokens: number;
+    totalOutputTokens: number;
+    totalIterations: number;
+    totalToolCalls: number;
+    totalErrors: number;
+    toolStats: {
+        toolName: string;
+        callCount: number;
+        errorCount: number;
+        totalDurationMs: number;
+        avgDurationMs: number;
+        lastUsed?: Date | undefined;
+    }[];
+    startedAt?: Date | undefined;
+    lastEventAt?: Date | undefined;
+}>;
+type AgentStats = z.infer<typeof AgentStatsSchema>;
+declare const DashboardStatsSchema: z.ZodObject<{
+    agents: z.ZodArray<z.ZodObject<{
+        agentName: z.ZodString;
+        status: z.ZodEnum<["idle", "running", "error", "completed"]>;
+        totalIterations: z.ZodNumber;
+        totalToolCalls: z.ZodNumber;
+        totalInputTokens: z.ZodNumber;
+        totalOutputTokens: z.ZodNumber;
+        totalErrors: z.ZodNumber;
+        startedAt: z.ZodOptional<z.ZodDate>;
+        lastEventAt: z.ZodOptional<z.ZodDate>;
+        toolStats: z.ZodArray<z.ZodObject<{
+            toolName: z.ZodString;
+            callCount: z.ZodNumber;
+            errorCount: z.ZodNumber;
+            totalDurationMs: z.ZodNumber;
+            avgDurationMs: z.ZodNumber;
+            lastUsed: z.ZodOptional<z.ZodDate>;
+        }, "strip", z.ZodTypeAny, {
+            toolName: string;
+            callCount: number;
+            errorCount: number;
+            totalDurationMs: number;
+            avgDurationMs: number;
+            lastUsed?: Date | undefined;
+        }, {
+            toolName: string;
+            callCount: number;
+            errorCount: number;
+            totalDurationMs: number;
+            avgDurationMs: number;
+            lastUsed?: Date | undefined;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        agentName: string;
+        status: "completed" | "error" | "running" | "idle";
+        totalInputTokens: number;
+        totalOutputTokens: number;
+        totalIterations: number;
+        totalToolCalls: number;
+        totalErrors: number;
+        toolStats: {
+            toolName: string;
+            callCount: number;
+            errorCount: number;
+            totalDurationMs: number;
+            avgDurationMs: number;
+            lastUsed?: Date | undefined;
+        }[];
+        startedAt?: Date | undefined;
+        lastEventAt?: Date | undefined;
+    }, {
+        agentName: string;
+        status: "completed" | "error" | "running" | "idle";
+        totalInputTokens: number;
+        totalOutputTokens: number;
+        totalIterations: number;
+        totalToolCalls: number;
+        totalErrors: number;
+        toolStats: {
+            toolName: string;
+            callCount: number;
+            errorCount: number;
+            totalDurationMs: number;
+            avgDurationMs: number;
+            lastUsed?: Date | undefined;
+        }[];
+        startedAt?: Date | undefined;
+        lastEventAt?: Date | undefined;
+    }>, "many">;
+    activeAgentCount: z.ZodNumber;
+    totalTokensUsed: z.ZodNumber;
+    totalToolCalls: z.ZodNumber;
+    totalErrors: z.ZodNumber;
+    activeConversationCount: z.ZodNumber;
+    uptimeMs: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    agents: {
+        agentName: string;
+        status: "completed" | "error" | "running" | "idle";
+        totalInputTokens: number;
+        totalOutputTokens: number;
+        totalIterations: number;
+        totalToolCalls: number;
+        totalErrors: number;
+        toolStats: {
+            toolName: string;
+            callCount: number;
+            errorCount: number;
+            totalDurationMs: number;
+            avgDurationMs: number;
+            lastUsed?: Date | undefined;
+        }[];
+        startedAt?: Date | undefined;
+        lastEventAt?: Date | undefined;
+    }[];
+    totalToolCalls: number;
+    totalErrors: number;
+    activeAgentCount: number;
+    totalTokensUsed: number;
+    activeConversationCount: number;
+    uptimeMs: number;
+}, {
+    agents: {
+        agentName: string;
+        status: "completed" | "error" | "running" | "idle";
+        totalInputTokens: number;
+        totalOutputTokens: number;
+        totalIterations: number;
+        totalToolCalls: number;
+        totalErrors: number;
+        toolStats: {
+            toolName: string;
+            callCount: number;
+            errorCount: number;
+            totalDurationMs: number;
+            avgDurationMs: number;
+            lastUsed?: Date | undefined;
+        }[];
+        startedAt?: Date | undefined;
+        lastEventAt?: Date | undefined;
+    }[];
+    totalToolCalls: number;
+    totalErrors: number;
+    activeAgentCount: number;
+    totalTokensUsed: number;
+    activeConversationCount: number;
+    uptimeMs: number;
+}>;
+type DashboardStats = z.infer<typeof DashboardStatsSchema>;
+declare const ConversationSummarySchema: z.ZodObject<{
+    conversationId: z.ZodString;
+    agentName: z.ZodString;
+    messageCount: z.ZodNumber;
+    tokenCount: z.ZodNumber;
+    startedAt: z.ZodDate;
+    lastMessageAt: z.ZodOptional<z.ZodDate>;
+    status: z.ZodEnum<["active", "completed", "error"]>;
+}, "strip", z.ZodTypeAny, {
+    agentName: string;
+    messageCount: number;
+    conversationId: string;
+    status: "completed" | "error" | "active";
+    startedAt: Date;
+    tokenCount: number;
+    lastMessageAt?: Date | undefined;
+}, {
+    agentName: string;
+    messageCount: number;
+    conversationId: string;
+    status: "completed" | "error" | "active";
+    startedAt: Date;
+    tokenCount: number;
+    lastMessageAt?: Date | undefined;
+}>;
+type ConversationSummary = z.infer<typeof ConversationSummarySchema>;
+declare const TraceEventSchema: z.ZodObject<{
+    type: z.ZodString;
+    timestamp: z.ZodDate;
+    spanId: z.ZodString;
+    parentSpanId: z.ZodOptional<z.ZodString>;
+    data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    type: string;
+    timestamp: Date;
+    spanId: string;
+    data: Record<string, unknown>;
+    parentSpanId?: string | undefined;
+}, {
+    type: string;
+    timestamp: Date;
+    spanId: string;
+    data: Record<string, unknown>;
+    parentSpanId?: string | undefined;
+}>;
+type TraceEvent = z.infer<typeof TraceEventSchema>;
+declare const TraceIterationSchema: z.ZodObject<{
+    iteration: z.ZodNumber;
+    events: z.ZodArray<z.ZodObject<{
+        type: z.ZodString;
+        timestamp: z.ZodDate;
+        spanId: z.ZodString;
+        parentSpanId: z.ZodOptional<z.ZodString>;
+        data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, "strip", z.ZodTypeAny, {
+        type: string;
+        timestamp: Date;
+        spanId: string;
+        data: Record<string, unknown>;
+        parentSpanId?: string | undefined;
+    }, {
+        type: string;
+        timestamp: Date;
+        spanId: string;
+        data: Record<string, unknown>;
+        parentSpanId?: string | undefined;
+    }>, "many">;
+    toolCalls: z.ZodNumber;
+    inputTokens: z.ZodNumber;
+    outputTokens: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    inputTokens: number;
+    outputTokens: number;
+    iteration: number;
+    toolCalls: number;
+    events: {
+        type: string;
+        timestamp: Date;
+        spanId: string;
+        data: Record<string, unknown>;
+        parentSpanId?: string | undefined;
+    }[];
+}, {
+    inputTokens: number;
+    outputTokens: number;
+    iteration: number;
+    toolCalls: number;
+    events: {
+        type: string;
+        timestamp: Date;
+        spanId: string;
+        data: Record<string, unknown>;
+        parentSpanId?: string | undefined;
+    }[];
+}>;
+type TraceIteration = z.infer<typeof TraceIterationSchema>;
+declare const TraceResponseSchema: z.ZodObject<{
+    traceId: z.ZodString;
+    agentName: z.ZodString;
+    iterations: z.ZodArray<z.ZodObject<{
+        iteration: z.ZodNumber;
+        events: z.ZodArray<z.ZodObject<{
+            type: z.ZodString;
+            timestamp: z.ZodDate;
+            spanId: z.ZodString;
+            parentSpanId: z.ZodOptional<z.ZodString>;
+            data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, "strip", z.ZodTypeAny, {
+            type: string;
+            timestamp: Date;
+            spanId: string;
+            data: Record<string, unknown>;
+            parentSpanId?: string | undefined;
+        }, {
+            type: string;
+            timestamp: Date;
+            spanId: string;
+            data: Record<string, unknown>;
+            parentSpanId?: string | undefined;
+        }>, "many">;
+        toolCalls: z.ZodNumber;
+        inputTokens: z.ZodNumber;
+        outputTokens: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        inputTokens: number;
+        outputTokens: number;
+        iteration: number;
+        toolCalls: number;
+        events: {
+            type: string;
+            timestamp: Date;
+            spanId: string;
+            data: Record<string, unknown>;
+            parentSpanId?: string | undefined;
+        }[];
+    }, {
+        inputTokens: number;
+        outputTokens: number;
+        iteration: number;
+        toolCalls: number;
+        events: {
+            type: string;
+            timestamp: Date;
+            spanId: string;
+            data: Record<string, unknown>;
+            parentSpanId?: string | undefined;
+        }[];
+    }>, "many">;
+    totalDurationMs: z.ZodNumber;
+    status: z.ZodEnum<["running", "completed", "error"]>;
+}, "strip", z.ZodTypeAny, {
+    traceId: string;
+    agentName: string;
+    status: "completed" | "error" | "running";
+    iterations: {
+        inputTokens: number;
+        outputTokens: number;
+        iteration: number;
+        toolCalls: number;
+        events: {
+            type: string;
+            timestamp: Date;
+            spanId: string;
+            data: Record<string, unknown>;
+            parentSpanId?: string | undefined;
+        }[];
+    }[];
+    totalDurationMs: number;
+}, {
+    traceId: string;
+    agentName: string;
+    status: "completed" | "error" | "running";
+    iterations: {
+        inputTokens: number;
+        outputTokens: number;
+        iteration: number;
+        toolCalls: number;
+        events: {
+            type: string;
+            timestamp: Date;
+            spanId: string;
+            data: Record<string, unknown>;
+            parentSpanId?: string | undefined;
+        }[];
+    }[];
+    totalDurationMs: number;
+}>;
+type TraceResponse = z.infer<typeof TraceResponseSchema>;
+declare const TraceSummarySchema: z.ZodObject<{
+    traceId: z.ZodString;
+    agentName: z.ZodString;
+    startedAt: z.ZodDate;
+    durationMs: z.ZodOptional<z.ZodNumber>;
+    status: z.ZodEnum<["running", "completed", "error"]>;
+    iterationCount: z.ZodNumber;
+    totalTokens: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    traceId: string;
+    agentName: string;
+    status: "completed" | "error" | "running";
+    totalTokens: number;
+    startedAt: Date;
+    iterationCount: number;
+    durationMs?: number | undefined;
+}, {
+    traceId: string;
+    agentName: string;
+    status: "completed" | "error" | "running";
+    totalTokens: number;
+    startedAt: Date;
+    iterationCount: number;
+    durationMs?: number | undefined;
+}>;
+type TraceSummary = z.infer<typeof TraceSummarySchema>;
+declare const DateFiltersSchema: z.ZodObject<{
+    from: z.ZodOptional<z.ZodDate>;
+    to: z.ZodOptional<z.ZodDate>;
+}, "strip", z.ZodTypeAny, {
+    to?: Date | undefined;
+    from?: Date | undefined;
+}, {
+    to?: Date | undefined;
+    from?: Date | undefined;
+}>;
+type DateFilters = z.infer<typeof DateFiltersSchema>;
+declare const ToolAnalyticsSchema: z.ZodObject<{
+    toolName: z.ZodString;
+    totalCalls: z.ZodNumber;
+    totalErrors: z.ZodNumber;
+    totalDurationMs: z.ZodNumber;
+    avgDurationMs: z.ZodNumber;
+    agentBreakdown: z.ZodArray<z.ZodObject<{
+        agentName: z.ZodString;
+        callCount: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        agentName: string;
+        callCount: number;
+    }, {
+        agentName: string;
+        callCount: number;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    toolName: string;
+    totalDurationMs: number;
+    avgDurationMs: number;
+    totalErrors: number;
+    totalCalls: number;
+    agentBreakdown: {
+        agentName: string;
+        callCount: number;
+    }[];
+}, {
+    toolName: string;
+    totalDurationMs: number;
+    avgDurationMs: number;
+    totalErrors: number;
+    totalCalls: number;
+    agentBreakdown: {
+        agentName: string;
+        callCount: number;
+    }[];
+}>;
+type ToolAnalytics = z.infer<typeof ToolAnalyticsSchema>;
+declare const TokenUsageGroupSchema: z.ZodObject<{
+    key: z.ZodString;
+    inputTokens: z.ZodNumber;
+    outputTokens: z.ZodNumber;
+    totalTokens: z.ZodNumber;
+    conversationCount: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    inputTokens: number;
+    outputTokens: number;
+    key: string;
+    totalTokens: number;
+    conversationCount: number;
+}, {
+    inputTokens: number;
+    outputTokens: number;
+    key: string;
+    totalTokens: number;
+    conversationCount: number;
+}>;
+type TokenUsageGroup = z.infer<typeof TokenUsageGroupSchema>;
+
+/**
+ * In-memory event collector for admin observability.
+ *
+ * Extends BaseExporter to subscribe to agent events and maintain
+ * live statistics, ring-buffered recent events, and per-agent state.
+ */
+
+/**
+ * Collects agent events in memory for admin dashboard queries.
+ *
+ * Subscribes to the UX event profile and maintains:
+ * - Per-agent statistics (iterations, tokens, tool calls, errors)
+ * - Per-tool statistics (call count, duration, errors)
+ * - Ring buffer of recent trace events (capped at 1000)
+ * - Trace summaries by traceId
+ * - Token usage by model
+ * - Active conversation tracking
+ */
+declare class InMemoryEventCollector extends BaseExporter {
+    profile: "ux";
+    private _startedAt;
+    private _agents;
+    private _recentEvents;
+    /** Bounded log of individual tool calls, used for date-filtered analytics. */
+    private _toolCallLog;
+    private _traces;
+    private _tokensByModel;
+    private _activeConversations;
+    /** Get dashboard-level aggregate statistics. */
+    getDashboardStats(): DashboardStats;
+    /** Get statistics for a specific agent. */
+    getAgentStats(agentName: string): AgentStats | undefined;
+    /** Get all agent statistics. */
+    getAllAgentStats(): AgentStats[];
+    /** Get recent trace events from the ring buffer. */
+    getRecentEvents(limit?: number): TraceEvent[];
+    /** Get all trace summaries. */
+    getTraceSummaries(): TraceSummary[];
+    /** Get conversations (derived from traces). */
+    getConversations(): ConversationSummary[];
+    /**
+     * Get cross-agent tool analytics.
+     *
+     * When `filters` specify a date range, aggregation runs over the
+     * per-call log (bounded to the most recent 10,000 calls). Without
+     * filters, uses the lifetime aggregates on each agent.
+     */
+    getToolAnalytics(filters?: DateFilters): ToolAnalytics[];
+    /** Get token usage grouped by agent or model. */
+    getTokenUsage(params: {
+        groupBy: "agent" | "model";
+    }): TokenUsageGroup[];
+    handleEvent(event: BaseEvent): Promise<void>;
+    /** @internal */
+    _onConversationStart(event: ConversationStartEvent): Promise<void>;
+    /** @internal */
+    _onConversationEnd(event: ConversationEndEvent): Promise<void>;
+    /** @internal */
+    _onMessageStart(event: MessageStartEvent): Promise<void>;
+    /** @internal */
+    _onMessageComplete(event: MessageCompleteEvent): Promise<void>;
+    /** @internal */
+    _onMessageCancel(event: MessageCancelEvent): Promise<void>;
+    /** @internal */
+    _onIterationStart(event: IterationStartEvent): Promise<void>;
+    /** @internal */
+    _onIterationEnd(event: IterationEndEvent): Promise<void>;
+    /** @internal */
+    _onToolStart(event: ToolCallStartEvent): Promise<void>;
+    /** @internal */
+    _onToolEnd(event: ToolCallEndEvent): Promise<void>;
+    /** @internal */
+    _onLlmEnd(event: LLMCallEndEvent): Promise<void>;
+    /** @internal */
+    _onError(event: ErrorEvent): Promise<void>;
+    private _ensureAgent;
+    private _recordEvent;
+    private _toAgentStats;
+    private _getAgentStatsList;
+    private _getToolAnalyticsFromLog;
+}
+
+/**
+ * Admin service protocol and in-memory implementation.
+ *
+ * AdminServiceProtocol defines the async interface for admin queries.
+ * InMemoryAdminService delegates to an InMemoryEventCollector.
+ */
+
+/** Async interface for admin dashboard queries. */
+interface AdminServiceProtocol {
+    getDashboardStats(): Promise<DashboardStats>;
+    getAgentStats(agentName: string): Promise<AgentStats | undefined>;
+    getAllAgentStats(): Promise<AgentStats[]>;
+    getRecentEvents(limit?: number): Promise<TraceEvent[]>;
+    getTraceSummaries(): Promise<TraceSummary[]>;
+    getConversations(): Promise<ConversationSummary[]>;
+    getToolAnalytics(filters?: DateFilters): Promise<ToolAnalytics[]>;
+    getTokenUsage(params: {
+        groupBy: "agent" | "model";
+    }): Promise<TokenUsageGroup[]>;
+}
+/**
+ * In-memory admin service backed by an InMemoryEventCollector.
+ *
+ * All methods delegate directly to the collector's synchronous query
+ * methods, wrapped in Promise resolution for protocol compliance.
+ */
+declare class InMemoryAdminService implements AdminServiceProtocol {
+    private _collector;
+    constructor(collector: InMemoryEventCollector);
+    getDashboardStats(): Promise<DashboardStats>;
+    getAgentStats(agentName: string): Promise<AgentStats | undefined>;
+    getAllAgentStats(): Promise<AgentStats[]>;
+    getRecentEvents(limit?: number): Promise<TraceEvent[]>;
+    getTraceSummaries(): Promise<TraceSummary[]>;
+    getConversations(): Promise<ConversationSummary[]>;
+    getToolAnalytics(filters?: DateFilters): Promise<ToolAnalytics[]>;
+    getTokenUsage(params: {
+        groupBy: "agent" | "model";
+    }): Promise<TokenUsageGroup[]>;
+}
+
+/**
+ * StdioAdapter — JSON-RPC 2.0 over stdin/stdout for subprocess mode.
+ *
+ * Handles methods: listAgents, createConversation, sendMessage,
+ * listConversations, getConversation. Uses SSEFormatter.extractPayload()
+ * for event data in stream.event notifications.
+ */
+
+interface JSONRPCRequest {
+    jsonrpc: "2.0";
+    id?: number | string;
+    method: string;
+    params?: Record<string, unknown>;
+}
+interface JSONRPCResponse {
+    jsonrpc: "2.0";
+    id: number | string | null;
+    result?: unknown;
+    error?: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+}
+interface JSONRPCNotification {
+    jsonrpc: "2.0";
+    method: string;
+    params: unknown;
+}
+type NotificationCallback = (notification: JSONRPCNotification) => void;
+declare class StdioAdapter {
+    private _agents;
+    private _agentMap;
+    private _runner;
+    private _store;
+    private _conversations;
+    constructor(opts: {
+        agents: AgentLike[];
+        runner: RunnerProtocol;
+        store?: ConversationStoreProtocol;
+    });
+    /** Start reading JSON-RPC from stdin, writing to stdout. */
+    start(): Promise<void>;
+    /** Handle a single JSON-RPC request. Testable without stdin/stdout. */
+    handleRequest(request: JSONRPCRequest, onNotification?: NotificationCallback): Promise<JSONRPCResponse>;
+    private _listAgents;
+    private _createConversation;
+    private _sendMessage;
+    private _listConversations;
+    private _getConversation;
+}
+
+export { ANALYSIS, type AdminServiceProtocol, AgencyRuntime, type AgentAddress, type AgentBroadcastEvent, type AgentEvent, AgentEventBus, type AgentEventType, type AgentJoinEvent, type AgentLeaveEvent, type AgentLike, type AgentLikeForBridge, type AgentMessageEvent, AgentNode, type AgentNodeOptions, AgentRunner, type AgentStats, AgentStatsSchema, type ApprovalCallback, AuditGate, type AuditLogger, BATCH_WINDOW, type BackoffStrategy, type BaseEvent, BaseExporter, BaseGate, type BaseSandboxEvent, CLAUDE_CODE_HOOK_EVENTS, CalculatorToolbox, type CanonicalMessage, type CanonicalMessagePart, ClaudeCodeAPIRunner, type ClaudeCodeHookEvent, type ClaudeCodeHookName, ClaudeCodeLanguageModel, type ClaudeCodeProviderOptions, ClaudeCodeRunner, type ClaudeCodeRunnerOptions, CompositeRefinementEvaluator, ConsoleExporter, type ConsoleLogger, type Consolidator, Conversation, type ConversationEndEvent, type ConversationExitReason, ConversationLoop, type ConversationLoopOptions, type ConversationResult, type ConversationRunOptions, type ConversationStartEvent, type ConversationStoreProtocol, type ConversationSummary, ConversationSummarySchema, type CreateRunnerOptions, DEFAULT_GLOBAL_TIMEOUT, DEFAULT_IDLE_TIMEOUT, DEFAULT_MAX_TURNS, type DashboardStats, DashboardStatsSchema, type DateFilters, DateFiltersSchema, EVIDENCE_QUALITY, type ErrorEvent, EvaluatorChain, EvaluatorLoop, type EvaluatorLoopOptions, type EvaluatorRunOptions, EventBus, type EventHandlerFn, EventProfile, type Exchange, ExponentialBackoff, type Exporter, FixedBackoff, GATE_CATEGORY_NAMES, type Gate, GateAllow, GateBlock, GateCategory, GateModify, type GateResult, type GoalEvaluationResult, type GoalEvaluatorProtocol, type HealthPingEvent, type HealthPongEvent, HumanApprovalGate, INFORMATION_RETRIEVAL, INTENT_CLASSIFICATION, INTENT_ROUTING, InMemoryAdminService, InMemoryEventCollector, InProcessTransport, type IterationEndEvent, type IterationStartEvent, JitteredBackoff, type LLMCallEndEvent, type LLMCallStartEvent, LLMGoalEvaluator, type LLMGoalEvaluatorOptions, LLMRefinementEvaluator, type LLMRefinementEvaluatorOptions, type LangfuseClient, LangfuseExporter, type LangfuseObservation, type LangfuseSpan, MemoryStore, type MessageCancelEvent, type MessageChunkEvent, type MessageCompleteEvent, type MessageStartEvent, type MessageTemplate, MessagingToolbox, type MiddlewareFn, type MockCall, type MockResponse, MockRunner, type NodeLifecycleEvent, ORCHESTRATION, OTelExporter, type OTelSpan, OTelStatusCode, type OTelTracer, PROFILE_EVENT_TYPES, PROVIDERS, PROVIDER_PRIORITY, Parallel, type ParallelOptions, type ParallelResult, type PatternCompleteEvent, type PatternContext, type PatternEvent, type PatternHooks, type PatternIterationCompleteEvent, type PatternIterationStartEvent, type PatternProtocol, type PatternResult, type PatternRunOptions, type PatternStartEvent, type PatternStepCompleteEvent, type PatternStepErrorEvent, type PatternStepStartEvent, type ProviderProtocol, type ProviderTier, QUALITY_GATE, QUALITY_REVIEW, RESPONSE_SYNTHESIS, RETRIEVAL_STRATEGY, ROUTING, RateLimitGate, type ReasoningEvent, type Refinement, type RefinementEvaluator, type RefinementExitReason, type RefinementResult, type RetryExitReason, RetryLoop, type RetryLoopOptions, type RetryResult, type RetryRunOptions, type RubricCriterion, RubricEvaluator, type RunOptions, type RunResult, type RunnerProtocol, type RunnerSelection, type RunnerSource, type SSEEventName, SSEExporter, SSEFormatter, type SSEMapping, SSE_EVENT_NAMES, SafetyGate, type SandboxEvent, SandboxEventBus, type SandboxEventType, SelfEvalGoalEvaluator, Sequential, type SequentialOptions, type SequentialResult, SimpleGoalEvaluator, type SimpleGoalEvaluatorOptions, StdioAdapter, type Step, type StepResult, type StoredConversation, type StoredMessage, type StoredMessagePart, type StreamEvent, type SupportedProvider, type TaskAssignEvent, type TaskCreateEvent, type TaskExitReason, TaskLoop, type TaskLoopOptions, type TaskResult, type TaskRunOptions, type TaskState, type TaskUpdateEvent, type ThinkingStartEvent, TodoToolbox, type TokenUsageGroup, TokenUsageGroupSchema, type TokenUsageRow, TokenUsageRowSchema, type ToolAnalytics, ToolAnalyticsSchema, ToolCallBlocked, type ToolCallEndEvent, type ToolCallIntent, type ToolCallRecord, type ToolCallRejectedEvent, type ToolCallStartEvent, type ToolExecutor, type ToolProgressEvent, type ToolStats, ToolStatsSchema, type TraceEvent, TraceEventSchema, type TraceIteration, TraceIterationSchema, type TraceResponse, TraceResponseSchema, type TraceSummary, TraceSummarySchema, type Transport, type TransportMessage, type WeightedEvaluator, agentAddressToString, analystRole, anthropicProvider, buildAgentServers, buildCalculatorAgent, buildCapabilityServer, buildTodoAgent, buildWritingCoachAgent, claudeCode, collectByName, collectContents, convertHistory, coordinatorRole, createAgentAddress, createConsoleExporter, createEvent, createRunner, createStepResult, createToolboxExecutor, deepseekProvider, deserializeSandboxEvent, deserializeSandboxEventFromString, exchangeTotalTokens, executeStep, formatSSE, getAgentEventBus, getEventBus, googleProvider, groqProvider, isClaudeCodeHookName, makeStepName, mapClaudeCodeHookToAgentEvents, matchSubject, mistralProvider, ollamaProvider, openaiProvider, openrouterProvider, orchestratorRole, resolveMessage, resolveModelId, retrievalRole, serializeSandboxEvent, serializeSandboxEventToString, setAgentEventBus, setEventBus, subjectToRegex, subscribeProfile, subscribeProfiles, toSSEMapping, unsubscribeProfile, xaiProvider };