@rowan-agent/agent 0.29.0 → 0.31.0

package/dist/runtime.d.ts

@@ -0,0 +1,947 @@
+import { E as ExtensionHost, H as HostApiExtension, A as AgentRuntime$1, a as AgentRuntimeOptions, L as LoadInput, b as AgentDefinition, c as LoadResult, S as Skill, P as Phase, T as Tool, R as ResourceKind, d as AgentConfiguration, e as HistorySeed, f as AgentId, g as AgentDeletionRequest, M as MessageId, U as UserContent, h as MessageRevisionResult, i as RunId, j as ToolCallId, k as EventCursor, C as ContextStatus, l as UserInput, m as AgentRun, n as EntryPhaseSpec, o as AgentListCursor, p as Page, q as AgentSummary, r as RunState, s as RunListCursor, t as RunSummary, I as InvocationSource, u as InvocationCatalogEntry, D as DurableRunEvent, v as DurableConsumer, w as ExtensionCapability, x as RunSnapshot, y as Message, z as RunBoundary, B as RunEvent, F as DurableStore, G as AgentRecord, J as RunRecord, K as ToolCallSnapshot, N as ContextCompactionRecord, O as OwnerLease, Q as OwnedStore, V as ConfigToken, W as ExecutionId, X as ContextCandidate, Y as RunClaim, Z as RunFailure, _ as ExecutionToken, $ as AssistantMessage, a0 as ExecutionCheckpoint, a1 as RunInteraction, a2 as ToolCommit, a3 as ToolCallReservation, a4 as ToolBatchCommit, a5 as Outcome, a6 as ConsumerRegistration, a7 as RetentionResult, a8 as ConfigProvider, a9 as ConfigurationSnapshot, aa as ConfigPutResult, ab as ConfigResolution, ac as PhaseRegistry, ad as LoadedExtension } from './index-jC_-oKbx.js';
+export { ae as DefinitionLayer, af as ExtensionActivationError, ag as ExtensionActivationResult, ah as ExtensionContribution, ai as ExtensionLifetimeError, aj as ExtensionLifetimeErrorCode, ak as ExtensionLoadInput, al as LoadExtensionsResult, am as ModelRetry, an as OpaqueId, ao as OwnerToken, ap as PhaseRegistrySelection, aq as ResolvedResourceView, ar as ResourceDiagnostic, as as ResourceRef, at as ResourceRegistry, au as ResourceRegistryError, av as ResourceRegistryErrorCode, aw as ResourceSourceId, ax as ResourceView, ay as RuntimeBootstrapRegistry, az as RuntimeExtensionLifetime, aA as extensionSourceId, aB as isConfigurationSnapshot, aC as mergeToolCall, aD as parseAgentDefinition, aE as resolveConfigurationSnapshot } from './index-jC_-oKbx.js';
+import * as _rowan_agent_models from '@rowan-agent/models';
+import { JsonObject, JsonValue, ScopeRef, ModelRef, LlmTokenUsage, StreamBlock, ToolKind, ToolCallLocation, ToolCallContent, ToolResult, ToolCall, ToolCallUpdate } from '@rowan-agent/models';
+import 'typebox';
+
+declare class InMemoryExtensionHost implements ExtensionHost {
+    private readonly configs;
+    private readonly agentState;
+    private readonly globalState;
+    private readonly listeners;
+    extendApi?(extensionId: string): HostApiExtension | undefined;
+    constructor(options?: {
+        configs?: Record<string, Record<string, JsonObject>>;
+        agentState?: Record<string, Record<string, Record<string, JsonValue>>>;
+        globalState?: Record<string, Record<string, JsonValue>>;
+        extendApi?: (extensionId: string) => HostApiExtension | undefined;
+    });
+    setConfig(extensionId: string, config: JsonObject | null, scope?: ScopeRef): void;
+    getConfig(extensionId: string, scope?: ScopeRef): JsonObject | null;
+    onConfigChanged(listener: (extensionId: string, scope: ScopeRef) => void): () => void;
+    notifyConfigChanged(extensionId: string, scope?: ScopeRef): void;
+    getAgentState(extensionId: string, agentId: string, key: string): JsonValue | undefined;
+    setAgentState(extensionId: string, agentId: string, key: string, value: JsonValue): void;
+    deleteAgentState(extensionId: string, agentId: string, key: string): void;
+    getGlobalState(extensionId: string, key: string): JsonValue | undefined;
+    setGlobalState(extensionId: string, key: string, value: JsonValue): void;
+    deleteGlobalState(extensionId: string, key: string): void;
+}
+
+declare class AgentRuntime implements AgentRuntime$1 {
+    private readonly concurrency;
+    private readonly owned;
+    private readonly commands;
+    private readonly storeIncarnation;
+    private readonly activeAgents;
+    private readonly executions;
+    private readonly executionDone;
+    private readonly cancellationRequested;
+    private readonly cancellationReasons;
+    private readonly autoCompactionRuns;
+    private readonly consumers;
+    private readonly transientEvents;
+    readonly host: ExtensionHost;
+    private readonly resources;
+    private readonly startedRuns;
+    private readonly liveInteractions;
+    private heartbeat?;
+    private pumping;
+    private closed;
+    private readonly retryDelayMs?;
+    private constructor();
+    static init(options: AgentRuntimeOptions): Promise<AgentRuntime>;
+    private publishLiveInteraction;
+    private cancelLiveInteractions;
+    private handleRunEnd;
+    loadAgents(input: LoadInput<AgentDefinition>): Promise<LoadResult>;
+    loadSkills(input: LoadInput<Skill>): Promise<LoadResult>;
+    loadPhases(input: LoadInput<Phase>): Promise<LoadResult>;
+    loadTools(input: Readonly<{
+        sourceId: string;
+        values: readonly Tool[];
+    }>): Promise<LoadResult>;
+    unload(input: Readonly<{
+        kind: ResourceKind;
+        sourceId: string;
+    }>): Promise<LoadResult>;
+    createAgent(config: AgentConfiguration, options?: {
+        idempotencyKey?: string;
+        metadata?: JsonObject;
+        historySeed?: HistorySeed;
+    }): Promise<AgentId>;
+    updateAgentConfig(agentId: AgentId, config: AgentConfiguration, options: {
+        idempotencyKey: string;
+    }): Promise<void>;
+    deleteAgent(input: AgentDeletionRequest): Promise<void>;
+    revise(agentId: AgentId, input: {
+        messageId: MessageId;
+        expectedMessageRevision: number;
+        content: UserContent;
+        operationId: string;
+        effectDigestConfirmation?: string;
+    }): Promise<MessageRevisionResult>;
+    compact(input?: {
+        now?: string;
+        retentionMs?: number;
+    }): Promise<Readonly<{
+        deletedRunIds: readonly RunId[];
+        deletedToolCallIds: readonly ToolCallId[];
+        deletedEventCount: number;
+        retentionFloor: EventCursor;
+        skipped?: "active_consumers" | "no_eligible_events";
+    }>>;
+    contextStatus(agentId: AgentId, options?: {
+        contextWindow?: number;
+    }): Promise<ContextStatus>;
+    runPhase(agentId: AgentId, options: {
+        phase: string;
+        payload?: JsonValue;
+        input?: UserInput;
+        yieldToInput?: boolean;
+        idempotencyKey?: string;
+    }): Promise<AgentRun>;
+    compactContext(agentId: AgentId, options?: {
+        input?: UserInput;
+        instructions?: string;
+        idempotencyKey?: string;
+    }): Promise<AgentRun>;
+    start(agentId: AgentId, input: UserInput, options: {
+        idempotencyKey: string;
+        metadata?: JsonObject;
+        scope?: ScopeRef;
+        cwd?: string;
+        phasePayload?: JsonValue;
+        entryPhases?: ReadonlyArray<EntryPhaseSpec>;
+    }): Promise<AgentRun>;
+    run(runId: RunId): AgentRun;
+    listAgents(input?: {
+        after?: AgentListCursor;
+        limit?: number;
+    }): Promise<Page<AgentSummary, AgentListCursor>>;
+    listRuns(input?: {
+        agentId?: AgentId;
+        states?: readonly RunState[];
+        after?: RunListCursor;
+        limit?: number;
+    }): Promise<Page<RunSummary, RunListCursor>>;
+    listInvocations(agentId: AgentId, options: {
+        source: InvocationSource;
+    }): Promise<readonly InvocationCatalogEntry[]>;
+    consume(input: {
+        consumerId: string;
+        signal: AbortSignal;
+        onEvent(event: DurableRunEvent, context: Readonly<{
+            signal: AbortSignal;
+        }>): void | Promise<void>;
+    }): Promise<DurableConsumer>;
+    listCapabilities(): readonly ExtensionCapability[];
+    onCapabilitiesChanged(listener: (capabilities: readonly ExtensionCapability[]) => void): () => void;
+    triggerUiAction(event: {
+        contributionId: string;
+        actionId: string;
+        scope?: ScopeRef;
+    }): void;
+    private liveInteract;
+    close(): Promise<void>;
+    snapshot(runId: RunId): Promise<RunSnapshot>;
+    history(agentId: AgentId): Promise<readonly Message[]>;
+    respondInteraction(runId: RunId, input: {
+        interactionId: string;
+        input?: JsonValue;
+        cancel?: boolean;
+    }): Promise<void>;
+    cancel(runId: RunId, reason?: string): Promise<RunBoundary>;
+    private pump;
+    private execute;
+    private failQueued;
+    private resolveContextWindow;
+    private executeTool;
+    private executeToolBatch;
+    private executeAndCommitTool;
+    private foldToolInteractionRecords;
+    private requireAgent;
+    private archiveDirFor;
+    private runConsumer;
+    observe(runId: RunId, options?: {
+        after?: EventCursor;
+        signal?: AbortSignal;
+    }): AsyncIterable<RunEvent>;
+    wait(runId: RunId, options?: {
+        signal?: AbortSignal;
+    }): Promise<RunBoundary>;
+    private assertOpen;
+    /** Resolve one stored configuration to the snapshot this execution uses. A
+     * stored snapshot is already source-qualified and is used as it stands. */
+    private resolveConfig;
+    private startHeartbeat;
+}
+
+type Mutable<T> = {
+    -readonly [Key in keyof T]: T[Key];
+};
+type StoredAgent = Mutable<AgentRecord>;
+type StoredRun = Mutable<RunRecord>;
+type StoredToolCall = Mutable<ToolCallSnapshot>;
+type IdempotencyReceipt = {
+    payload: string;
+    result: unknown;
+};
+type StoreMutationRecorder = {
+    onAgentUpsert(agent: StoredAgent): void;
+    onAgentDelete(agentId: AgentId): void;
+    onRunUpsert(run: StoredRun): void;
+    onRunDelete(runId: RunId): void;
+    onMessageInsert(message: Message): void;
+    onMessageDelete(messageId: MessageId): void;
+    onToolCallUpsert(toolCall: StoredToolCall): void;
+    onToolCallDelete(toolCallId: ToolCallId): void;
+    onEventAppend(event: DurableRunEvent): void;
+    onEventsTruncate(deletedEventIds: string[]): void;
+    onIdempotencyUpsert(scope: string, receipt: IdempotencyReceipt): void;
+    onIdempotencyDelete(scope: string): void;
+    onOperationReceiptUpsert(key: string, receipt: IdempotencyReceipt): void;
+    onOperationReceiptDelete(key: string): void;
+    onConsumerCheckpointUpsert(consumerId: string, cursor: EventCursor): void;
+    onConsumerCheckpointDelete(consumerId: string): void;
+    onContextCompactionUpsert(agentId: AgentId, record: ContextCompactionRecord): void;
+    onRetentionFloorChange(floor: number): void;
+};
+type InMemoryStoreState = Readonly<{
+    incarnation: string;
+    agents: readonly AgentRecord[];
+    runs: readonly RunRecord[];
+    messages: readonly Message[];
+    toolCalls: readonly ToolCallSnapshot[];
+    events: readonly DurableRunEvent[];
+    idempotency: readonly (readonly [string, IdempotencyReceipt])[];
+    operationReceipts: readonly (readonly [string, IdempotencyReceipt])[];
+    historySeeds?: readonly (readonly [AgentId, readonly Message[]])[];
+    consumerCheckpoints?: readonly (readonly [string, EventCursor])[];
+    retentionFloor?: number;
+    nextAgentSequence: readonly (readonly [AgentId, number])[];
+    nextReadySequence: readonly (readonly [AgentId, number])[];
+    eventSequence: number;
+    contextCompactions?: readonly (readonly [AgentId, ContextCompactionRecord])[];
+}>;
+declare class InMemoryStore implements DurableStore {
+    private readonly incarnation;
+    private readonly agents;
+    private readonly runs;
+    private readonly messages;
+    private readonly toolCalls;
+    private readonly events;
+    private readonly idempotency;
+    private readonly operationReceipts;
+    private readonly historySeeds;
+    private readonly consumerCheckpoints;
+    private readonly nextAgentSequence;
+    private readonly nextReadySequence;
+    private owner?;
+    private ownerEpoch;
+    private eventSequence;
+    private retentionFloor;
+    private readonly contextCompactions;
+    private recorder?;
+    private readonly runReceiptKeys;
+    constructor(options?: {
+        incarnation?: string;
+    });
+    setChangeRecorder(recorder?: StoreMutationRecorder): void;
+    private touchAgent;
+    private touchRun;
+    private storeMessage;
+    private storeToolCall;
+    private appendEvent;
+    inferRunIdForReceipt(key: string, payload: string): RunId | undefined;
+    dropRunOperationReceipts(runId: RunId): void;
+    compactTerminalReceipts(): number;
+    static fromState(state: InMemoryStoreState): InMemoryStore;
+    exportState(): InMemoryStoreState;
+    exportMetadata(): Record<string, unknown>;
+    attachOwner(lease: OwnerLease): void;
+    interruptOwner(ownerEpoch: number, message?: string): void;
+    openOwner(input: {
+        ownerId: string;
+        leaseMs: number;
+    }): Promise<OwnedStore>;
+    assertOwner(lease: OwnerLease, requireLive?: boolean): void;
+    renewOwner(lease: OwnerLease, leaseMs: number): OwnerLease;
+    releaseOwner(lease: OwnerLease): void;
+    reserveAgent(lease: OwnerLease, input: {
+        idempotencyKey: string;
+        metadata?: JsonObject;
+        configIdentity?: string;
+        historySeed?: HistorySeed;
+    }): AgentRecord;
+    activateAgent(lease: OwnerLease, agentId: AgentId, configToken?: ConfigToken, configIdentity?: string): AgentRecord;
+    updateAgentConfigToken(lease: OwnerLease, input: {
+        agentId: AgentId;
+        token: ConfigToken;
+        configIdentity?: string;
+        idempotencyKey: string;
+    }): AgentRecord;
+    deleteAgent(lease: OwnerLease, input: AgentDeletionRequest): void;
+    reviseMessage(lease: OwnerLease, input: {
+        agentId: AgentId;
+        messageId: MessageId;
+        expectedMessageRevision: number;
+        content: UserContent;
+        operationId: string;
+        effectDigestConfirmation?: string;
+    }): MessageRevisionResult;
+    private commitInteractionRecord;
+    createRun(lease: OwnerLease, input: {
+        agentId: AgentId;
+        input: UserInput;
+        metadata?: JsonObject;
+        scope?: ScopeRef;
+        cwd?: string;
+        phasePayload?: JsonValue;
+        entryPhases?: readonly EntryPhaseSpec[];
+        pinnedConfigToken?: ConfigToken;
+        idempotencyKey: string;
+    }): RunRecord;
+    claimRun(lease: OwnerLease, input: {
+        runId: RunId;
+        expectedRevision: number;
+        executionId?: ExecutionId;
+        messageId?: MessageId;
+        configToken?: ConfigToken;
+        additionalContexts?: readonly ContextCandidate[];
+    }): RunClaim;
+    failQueuedRun(lease: OwnerLease, input: {
+        runId: RunId;
+        expectedRevision: number;
+        failure: Extract<RunFailure, {
+            code: "configuration_unavailable" | "checkpoint_incompatible";
+        }>;
+    }): RunRecord;
+    commitPhaseEntered(lease: OwnerLease, input: {
+        runId: RunId;
+        execution: ExecutionToken;
+        expectedRevision: number;
+        phaseId: string;
+        visit: number;
+    }): RunRecord;
+    /** Commit a parallel Phase's reply while its Run is still running. */
+    commitPhaseOutput(lease: OwnerLease, input: {
+        runId: RunId;
+        execution: ExecutionToken;
+        expectedRevision: number;
+        message: AssistantMessage;
+    }): RunRecord;
+    commitInputRequired(lease: OwnerLease, input: {
+        runId: RunId;
+        execution: ExecutionToken;
+        expectedRevision: number;
+        phase: string;
+        prompt?: AssistantMessage;
+        checkpoint: ExecutionCheckpoint;
+        interactions?: readonly RunInteraction[];
+        interactionAnswers?: Readonly<Record<string, JsonValue>>;
+        pendingToolCallIds?: readonly ToolCallId[];
+    }): RunRecord;
+    answerInteraction(lease: OwnerLease, input: {
+        runId: RunId;
+        interactionId: string;
+        expectedRevision: number;
+        input?: JsonValue;
+        cancel?: boolean;
+    }): RunRecord;
+    reserveToolCall(lease: OwnerLease, input: {
+        runId: RunId;
+        execution: ExecutionToken;
+        expectedRevision: number;
+        requestMessageId: MessageId;
+        name: string;
+        args: JsonValue;
+        toolCallId?: ToolCallId;
+        providerToolCallId?: string;
+        model?: ModelRef;
+        usage?: LlmTokenUsage;
+    }): ToolCommit;
+    reserveToolCalls(lease: OwnerLease, input: {
+        runId: RunId;
+        execution: ExecutionToken;
+        expectedRevision: number;
+        requestMessageId: MessageId;
+        calls: readonly ToolCallReservation[];
+        /** The model response's blocks, so the request message keeps what preceded the Tool Calls. */
+        contentBlocks?: readonly StreamBlock[];
+        model?: ModelRef;
+        usage?: LlmTokenUsage;
+    }): ToolBatchCommit;
+    startToolCall(lease: OwnerLease, input: {
+        runId: RunId;
+        execution: ExecutionToken;
+        expectedRevision: number;
+        toolCallId: ToolCallId;
+        title?: string;
+        kind?: ToolKind;
+        locations?: ToolCallLocation[];
+        content?: ToolCallContent[];
+        _meta?: JsonObject;
+    }): ToolCommit;
+    suspendToolCall(lease: OwnerLease, input: {
+        runId: RunId;
+        execution: ExecutionToken;
+        expectedRevision: number;
+        toolCallId: ToolCallId;
+    }): ToolCommit;
+    commitToolResult(lease: OwnerLease, input: {
+        runId: RunId;
+        execution: ExecutionToken;
+        expectedRevision: number;
+        toolCallId: ToolCallId;
+        result: ToolResult;
+        state: "completed" | "failed" | "indeterminate";
+        reason?: string;
+        title?: string;
+        kind?: ToolKind;
+        content?: ToolCallContent[];
+        locations?: ToolCallLocation[];
+        rawOutput?: JsonValue;
+        _meta?: JsonObject;
+    }): ToolCommit;
+    commitOutcome(lease: OwnerLease, input: {
+        runId: RunId;
+        execution: ExecutionToken;
+        expectedRevision: number;
+        outcome?: Outcome;
+        failure?: RunFailure;
+        output?: AssistantMessage;
+    }): RunRecord;
+    cancelRun(lease: OwnerLease, input: {
+        runId: RunId;
+        expectedRevision?: number;
+        reason?: string;
+        output?: AssistantMessage;
+    }): RunRecord;
+    recordToolCall(lease: OwnerLease, input: {
+        runId: RunId;
+        execution?: ExecutionToken;
+        update: ToolCall | ToolCallUpdate;
+        external?: boolean;
+        contentIndex?: number;
+    }): DurableRunEvent;
+    snapshotRun(lease: OwnerLease, runId: RunId): RunSnapshot;
+    listAgents(lease: OwnerLease): readonly AgentRecord[];
+    listRuns(lease: OwnerLease, input?: {
+        agentId?: AgentId;
+        states?: readonly RunState[];
+    }): readonly RunRecord[];
+    listEvents(lease: OwnerLease, input?: {
+        after?: EventCursor;
+    }): readonly DurableRunEvent[];
+    openConsumer(lease: OwnerLease, consumerId: string): ConsumerRegistration;
+    advanceConsumerCheckpoint(lease: OwnerLease, input: {
+        consumerId: string;
+        cursor: EventCursor;
+    }): void;
+    compact(lease: OwnerLease, input?: {
+        now?: string;
+        retentionMs?: number;
+    }): RetentionResult;
+    private replay;
+    private writeReceipt;
+    private replayOperation;
+    private writeOperationReceipt;
+    /**
+     * A Claim receipt exists for idempotent replay of one live Execution Attempt
+     * and carries that Attempt's history. Dropping it when the Attempt ends keeps
+     * one history snapshot per Agent instead of one per Attempt.
+     */
+    private dropClaimReceipt;
+    /**
+     * A new owner fences the Execution Attempts of the previous one, so no Claim
+     * receipt from before the takeover can be replayed. Sweeping them reclaims
+     * the history snapshots a store accumulated while no Attempt ended under
+     * this Runtime.
+     */
+    dropSettledClaimReceipts(): void;
+    private requireAgent;
+    private requireRun;
+    private requireToolCall;
+    private assertNoOpenTools;
+    private interruptToolCall;
+    private assertState;
+    private assertRevision;
+    private assertExecution;
+    private nextSequence;
+    private nextReady;
+    private nextMessageSequence;
+    private messagesForRun;
+    private withdrawUserInputIfNoOutput;
+    history(lease: OwnerLease, agentId: AgentId): readonly Message[];
+    contextStatus(lease: OwnerLease, agentId: AgentId, contextWindow: number): ContextStatus;
+    contextMessages(lease: OwnerLease, agentId: AgentId, recentTokenBudget?: number): readonly Message[];
+    commitContextCompaction(lease: OwnerLease, record: ContextCompactionRecord): ContextCompactionRecord;
+    private activeHistory;
+    private appendMessage;
+    private appendTransition;
+    private appendToolTransition;
+    private baseEvent;
+    private cursorForRun;
+    private parseCursor;
+}
+
+declare class SqliteStore implements DurableStore {
+    private readonly database;
+    private readonly archiveRoot;
+    private readonly mirroredEventIds;
+    private readonly mirroredCompactionIds;
+    private mirroredAgents;
+    private closed;
+    private configured;
+    private cachedMemory?;
+    private cachedOwner?;
+    private isLegacyState;
+    private stmtUpsertAgent?;
+    private stmtDeleteAgent?;
+    private stmtUpsertRun?;
+    private stmtDeleteRun?;
+    private stmtInsertMessage?;
+    private stmtDeleteMessage?;
+    private stmtUpsertToolCall?;
+    private stmtDeleteToolCall?;
+    private stmtInsertEvent?;
+    private stmtDeleteEvent?;
+    private stmtUpsertIdempotency?;
+    private stmtDeleteIdempotency?;
+    private stmtUpsertCheckpoint?;
+    private stmtDeleteCheckpoint?;
+    private stmtUpdateMeta?;
+    private stmtUpdateState?;
+    constructor(filename?: string);
+    openOwner(input: {
+        ownerId: string;
+        leaseMs: number;
+    }): Promise<OwnedStore>;
+    close(): void;
+    exportState(): InMemoryStoreState;
+    /** Filesystem location owned by this Store for one Agent's readable archive. */
+    contextArchiveDir(agentId: AgentId): string;
+    reserveAgent(lease: OwnerLease, input: {
+        idempotencyKey: string;
+        metadata?: JsonObject;
+        configIdentity?: string;
+        historySeed?: HistorySeed;
+    }): Promise<AgentRecord>;
+    activateAgent(lease: OwnerLease, agentId: AgentId, configToken?: ConfigToken, configIdentity?: string): Promise<AgentRecord>;
+    updateAgentConfigToken(lease: OwnerLease, input: {
+        agentId: AgentId;
+        token: ConfigToken;
+        configIdentity?: string;
+        idempotencyKey: string;
+    }): Promise<AgentRecord>;
+    deleteAgent(lease: OwnerLease, input: AgentDeletionRequest): Promise<void>;
+    reviseMessage(lease: OwnerLease, input: {
+        agentId: AgentId;
+        messageId: MessageId;
+        expectedMessageRevision: number;
+        content: UserContent;
+        operationId: string;
+        effectDigestConfirmation?: string;
+    }): Promise<MessageRevisionResult>;
+    contextStatus(lease: OwnerLease, agentId: AgentId, contextWindow: number): Promise<ContextStatus>;
+    contextMessages(lease: OwnerLease, agentId: AgentId, recentTokenBudget?: number): Promise<readonly Message[]>;
+    commitContextCompaction(lease: OwnerLease, record: ContextCompactionRecord): Promise<ContextCompactionRecord>;
+    createRun(lease: OwnerLease, input: {
+        agentId: AgentId;
+        input: UserInput;
+        metadata?: JsonObject;
+        scope?: ScopeRef;
+        cwd?: string;
+        phasePayload?: JsonValue;
+        entryPhases?: readonly EntryPhaseSpec[];
+        pinnedConfigToken?: ConfigToken;
+        idempotencyKey: string;
+    }): Promise<RunRecord>;
+    claimRun(lease: OwnerLease, input: {
+        runId: RunId;
+        expectedRevision: number;
+        executionId?: ExecutionId;
+        messageId?: MessageId;
+        configToken?: ConfigToken;
+        additionalContexts?: readonly ContextCandidate[];
+    }): Promise<RunClaim>;
+    failQueuedRun(lease: OwnerLease, input: {
+        runId: RunId;
+        expectedRevision: number;
+        failure: Extract<RunFailure, {
+            code: "configuration_unavailable" | "checkpoint_incompatible";
+        }>;
+    }): Promise<RunRecord>;
+    commitPhaseEntered(lease: OwnerLease, input: {
+        runId: RunId;
+        execution: ExecutionToken;
+        expectedRevision: number;
+        phaseId: string;
+        visit: number;
+    }): Promise<RunRecord>;
+    commitPhaseOutput(lease: OwnerLease, input: {
+        runId: RunId;
+        execution: ExecutionToken;
+        expectedRevision: number;
+        message: AssistantMessage;
+    }): Promise<RunRecord>;
+    commitInputRequired(lease: OwnerLease, input: {
+        runId: RunId;
+        execution: ExecutionToken;
+        expectedRevision: number;
+        phase: string;
+        prompt?: AssistantMessage;
+        checkpoint: ExecutionCheckpoint;
+        interactions?: readonly RunInteraction[];
+        interactionAnswers?: Readonly<Record<string, JsonValue>>;
+        pendingToolCallIds?: readonly ToolCallId[];
+    }): Promise<RunRecord>;
+    answerInteraction(lease: OwnerLease, input: {
+        runId: RunId;
+        interactionId: string;
+        expectedRevision: number;
+        input?: JsonValue;
+        cancel?: boolean;
+    }): Promise<RunRecord>;
+    commitOutcome(lease: OwnerLease, input: {
+        runId: RunId;
+        execution: ExecutionToken;
+        expectedRevision: number;
+        outcome?: Outcome;
+        failure?: RunFailure;
+        output?: AssistantMessage;
+    }): Promise<RunRecord>;
+    reserveToolCall(lease: OwnerLease, input: {
+        runId: RunId;
+        execution: ExecutionToken;
+        expectedRevision: number;
+        requestMessageId: MessageId;
+        name: string;
+        args: JsonValue;
+        toolCallId?: ToolCallId;
+        providerToolCallId?: string;
+        title?: string;
+        kind?: ToolKind;
+        locations?: ToolCallLocation[];
+        content?: ToolCallContent[];
+        _meta?: JsonObject;
+        model?: _rowan_agent_models.ModelRef;
+        usage?: _rowan_agent_models.LlmTokenUsage;
+    }): Promise<ToolCommit>;
+    reserveToolCalls(lease: OwnerLease, input: {
+        runId: RunId;
+        execution: ExecutionToken;
+        expectedRevision: number;
+        requestMessageId: MessageId;
+        calls: readonly ToolCallReservation[];
+        contentBlocks?: readonly StreamBlock[];
+        model?: _rowan_agent_models.ModelRef;
+        usage?: _rowan_agent_models.LlmTokenUsage;
+    }): Promise<ToolBatchCommit>;
+    startToolCall(lease: OwnerLease, input: {
+        runId: RunId;
+        execution: ExecutionToken;
+        expectedRevision: number;
+        toolCallId: ToolCallId;
+        title?: string;
+        kind?: ToolKind;
+        locations?: ToolCallLocation[];
+        content?: ToolCallContent[];
+        _meta?: JsonObject;
+    }): Promise<ToolCommit>;
+    suspendToolCall(lease: OwnerLease, input: {
+        runId: RunId;
+        execution: ExecutionToken;
+        expectedRevision: number;
+        toolCallId: ToolCallId;
+    }): Promise<ToolCommit>;
+    commitToolResult(lease: OwnerLease, input: {
+        runId: RunId;
+        execution: ExecutionToken;
+        expectedRevision: number;
+        toolCallId: ToolCallId;
+        result: ToolResult;
+        state: "completed" | "failed" | "indeterminate";
+        reason?: string;
+        title?: string;
+        kind?: ToolKind;
+        content?: ToolCallContent[];
+        locations?: ToolCallLocation[];
+        rawOutput?: JsonValue;
+        _meta?: JsonObject;
+    }): Promise<ToolCommit>;
+    cancelRun(lease: OwnerLease, input: {
+        runId: RunId;
+        expectedRevision?: number;
+        reason?: string;
+        output?: AssistantMessage;
+    }): Promise<RunRecord>;
+    recordToolCall(lease: OwnerLease, input: {
+        runId: RunId;
+        execution?: ExecutionToken;
+        update: ToolCall | ToolCallUpdate;
+        external?: boolean;
+        contentIndex?: number;
+    }): Promise<DurableRunEvent>;
+    snapshotRun(lease: OwnerLease, runId: RunId): Promise<RunSnapshot>;
+    history(lease: OwnerLease, agentId: AgentId): Promise<readonly Message[]>;
+    listAgents(lease: OwnerLease): Promise<readonly AgentRecord[]>;
+    listRuns(lease: OwnerLease, input?: {
+        agentId?: AgentId;
+        states?: readonly RunState[];
+    }): Promise<readonly RunRecord[]>;
+    listEvents(lease: OwnerLease, input?: {
+        after?: EventCursor;
+    }): Promise<readonly DurableRunEvent[]>;
+    openConsumer(lease: OwnerLease, consumerId: string): Promise<ConsumerRegistration>;
+    advanceConsumerCheckpoint(lease: OwnerLease, input: {
+        consumerId: string;
+        cursor: EventCursor;
+    }): Promise<void>;
+    compact(lease: OwnerLease, input?: {
+        now?: string;
+        retentionMs?: number;
+    }): Promise<RetentionResult>;
+    renewOwner(lease: OwnerLease, leaseMs: number): Promise<OwnerLease>;
+    sealAndReleaseOwner(lease: OwnerLease): Promise<void>;
+    private read;
+    private write;
+    private invoke;
+    private ensureSchema;
+    private isCurrentSchema;
+    private configure;
+    private catalog;
+    private readOwner;
+    private writeOwner;
+    private readState;
+    private loadTableBackedState;
+    private ensureTableBackedStorage;
+    private getStmtUpsertAgent;
+    private getStmtDeleteAgent;
+    private getStmtUpsertRun;
+    private getStmtDeleteRun;
+    private getStmtInsertMessage;
+    private getStmtDeleteMessage;
+    private getStmtUpsertToolCall;
+    private getStmtDeleteToolCall;
+    private getStmtInsertEvent;
+    private getStmtDeleteEvent;
+    private getStmtUpsertIdempotency;
+    private getStmtDeleteIdempotency;
+    private getStmtUpsertCheckpoint;
+    private getStmtDeleteCheckpoint;
+    private getStmtUpdateMeta;
+    private getStmtUpdateState;
+    private persistChanges;
+    private writeFullStateToTables;
+    private mirrorChanges;
+    /** Append the semantic durable event mirror and remove deleted Agent sidecars. */
+    private mirrorInitialState;
+    private requireMatchingOwner;
+    private immediateTransaction;
+    private readTransaction;
+    private assertOpen;
+}
+
+/** A deterministic provider for tests and embedded hosts without a separate registry. */
+declare class InMemoryConfigProvider implements ConfigProvider {
+    private readonly entries;
+    private readonly operations;
+    put(input: {
+        agentId: AgentId;
+        agentMetadata?: JsonObject;
+        config: AgentConfiguration | ConfigurationSnapshot;
+        operationId: string;
+        signal: AbortSignal;
+    }): Promise<ConfigPutResult>;
+    resolve(input: {
+        agentId: AgentId;
+        agentMetadata?: JsonObject;
+        token: ConfigToken;
+        signal: AbortSignal;
+    }): Promise<ConfigResolution>;
+}
+declare function brandConfigToken(raw: unknown): ConfigToken;
+
+type RuntimeErrorCode = "invalid_argument" | "runtime_closed" | "runtime_already_owned" | "runtime_ownership_lost" | "agent_not_found" | "run_not_found" | "run_state_conflict" | "context_busy" | "message_history_compacted" | "message_revision_conflict" | "tool_effect_confirmation_required" | "input_request_conflict" | "idempotency_conflict" | "configuration_unavailable" | "checkpoint_incompatible" | "consumer_already_active" | "invalid_cursor" | "store_unavailable" | "unsupported_store_version";
+type RuntimeErrorDetails = {
+    invalid_argument: Readonly<{
+        argument: string;
+        reason: string;
+    }>;
+    runtime_closed: null;
+    runtime_already_owned: Readonly<{
+        expiresAt: string;
+        retryAfterMs: number;
+    }>;
+    runtime_ownership_lost: Readonly<{
+        reason: "expired" | "released" | "epoch_advanced";
+        expectedEpoch: number;
+        actualEpoch: number;
+        expiresAt?: string;
+    }>;
+    agent_not_found: Readonly<{
+        agentId: AgentId;
+    }>;
+    run_not_found: Readonly<{
+        runId: RunId;
+    }>;
+    run_state_conflict: Readonly<{
+        runId: RunId;
+        expected: readonly RunState[];
+        actual: RunState;
+    }>;
+    context_busy: Readonly<{
+        agentId: AgentId;
+        runId?: RunId;
+        actual: RunState;
+    }>;
+    message_history_compacted: Readonly<{
+        agentId: AgentId;
+        messageId: MessageId;
+    }>;
+    message_revision_conflict: Readonly<{
+        agentId: AgentId;
+        messageId: MessageId;
+        expected: number;
+        actual: number;
+    }>;
+    tool_effect_confirmation_required: Readonly<{
+        agentId: AgentId;
+        messageId: MessageId;
+        effectDigest: string;
+        toolCallIds: readonly ToolCallId[];
+    }>;
+    input_request_conflict: Readonly<{
+        runId: RunId;
+        interactionId?: string;
+        requestId?: string;
+        reason: "not_found" | "wrong_run" | "different_answer";
+    }>;
+    idempotency_conflict: Readonly<{
+        scope: "create_agent" | "update_agent_config" | "start_run";
+        idempotencyKey: string;
+    }>;
+    configuration_unavailable: Readonly<{
+        agentId: AgentId;
+        runId?: RunId;
+        retryable: boolean;
+        reason: string;
+    }>;
+    checkpoint_incompatible: Readonly<{
+        runId: RunId;
+        expected: Readonly<{
+            codec: string;
+            versions: readonly number[];
+        }>;
+        actual: Readonly<{
+            codec: string;
+            version: number;
+        }>;
+    }>;
+    consumer_already_active: Readonly<{
+        consumerId: string;
+    }>;
+    invalid_cursor: Readonly<{
+        cursorType: "agent_list" | "run_list" | "event";
+        reason: "malformed" | "wrong_store" | "wrong_collection" | "filter_mismatch" | "beyond_waterline" | "expired";
+    }>;
+    store_unavailable: Readonly<{
+        operation: string;
+        retryable: boolean;
+        reason: string;
+    }>;
+    unsupported_store_version: Readonly<{
+        found: string | null;
+        supported: string;
+    }>;
+};
+type AnyRuntimeError = {
+    [Code in RuntimeErrorCode]: RuntimeError<Code>;
+}[RuntimeErrorCode];
+declare class RuntimeError<Code extends RuntimeErrorCode = RuntimeErrorCode> extends Error {
+    readonly code: Code;
+    readonly details: RuntimeErrorDetails[Code];
+    constructor(code: Code, details: RuntimeErrorDetails[Code], message?: Code);
+}
+declare function isRuntimeError(value: unknown): value is AnyRuntimeError;
+
+declare function loadSkill(path: string): Promise<Skill>;
+declare function loadSkills(targetPath: string): Promise<Skill[]>;
+
+/**
+ * Load a single phase from a PHASE.md file or phase directory.
+ *
+ * If a directory is provided, the loader reads its PHASE.md.
+ */
+declare function loadPhase(targetPath: string): Promise<Phase>;
+/**
+ * Load all phases from the target directory.
+ *
+ * Scans for subdirectories containing PHASE.md files.
+ * Returns PhaseRegistry with entryPhaseId:
+ * - null by default (caller must explicitly set to start from a specific phase)
+ * - Set to a specific phase name to start from that phase
+ *
+ * When entryPhaseId is null, Agent normalizes the registry to start from its default phase.
+ */
+declare function loadPhases(targetPath: string): Promise<PhaseRegistry>;
+
+declare const DEFAULT_PHASE_ID = "default";
+declare const STOP_PHASE_ID = "stop";
+declare const COMPACT_PHASE_ID = "compact";
+declare function createDefaultPhase(): Phase;
+declare function createStopPhase(): Phase;
+declare function createCompactPhase(): Phase;
+declare function createCorePhases(): Phase[];
+
+/**
+ * Extension loader — discovers and loads extensions from the filesystem.
+ *
+ * Uses the new LoadedExtension type that works with ExtensionRunner.
+ */
+
+/**
+ * Load extensions from the exact target path.
+ *
+ * If the target is a directory with its own extension entry, load that extension.
+ * Otherwise, scan its immediate children for extension packages/files.
+ */
+declare function loadExtensionsFromPath(path: string): Promise<{
+    extensions: LoadedExtension[];
+    errors: Array<{
+        path: string;
+        error: string;
+    }>;
+}>;
+
+/** Parsed frontmatter result */
+interface FrontmatterResult<T = Record<string, unknown>> {
+    frontmatter: T;
+    body: string;
+}
+/**
+ * Parse YAML frontmatter from markdown content.
+ * Parse YAML frontmatter and return the markdown body after the closing delimiter.
+ */
+declare function parseFrontmatter<T = Record<string, unknown>>(raw: string): FrontmatterResult<T>;
+
+/**
+ * `root` anchors relative paths and the Bash working directory. It is not a
+ * filesystem sandbox: core Tools use the permissions of the host process.
+ */
+type CoreToolContext = {
+    root?: string;
+    /** Directory for complete Tool Result spill files. */
+    archiveDir?: string;
+    maxReadBytes?: number;
+    maxReadLines?: number;
+    bashTimeoutMs?: number;
+    maxBashOutputBytes?: number;
+};
+
+/** Adapt the established host-filesystem Core Tools to the durable Runtime Tool contract. */
+declare function createRuntimeCoreTools(input?: CoreToolContext): Tool[];
+
+export { AgentConfiguration, AgentDefinition, AgentRecord, AgentRuntime, AgentRuntimeOptions, type AnyRuntimeError, COMPACT_PHASE_ID, ConfigProvider, ConfigPutResult, ConfigResolution, ConfigToken, ConfigurationSnapshot, type CoreToolContext, DEFAULT_PHASE_ID, DurableStore, EntryPhaseSpec, ExecutionCheckpoint, ExecutionId, ExecutionToken, ExtensionHost, type FrontmatterResult, HistorySeed, HostApiExtension, InMemoryConfigProvider, InMemoryExtensionHost, InMemoryStore, InvocationCatalogEntry, InvocationSource, LoadInput, LoadResult, LoadedExtension, Outcome, OwnerLease, PhaseRegistry, ResourceKind, RetentionResult, RunClaim, RunRecord, RuntimeError, type RuntimeErrorCode, type RuntimeErrorDetails, STOP_PHASE_ID, Skill, SqliteStore, brandConfigToken, createCompactPhase, createCorePhases, createRuntimeCoreTools as createCoreTools, createDefaultPhase, createStopPhase, isRuntimeError, loadExtensionsFromPath as loadExtensions, loadPhase, loadPhases, loadSkill, loadSkills, parseFrontmatter };