@andorra-labs/code 0.0.0-stage → 0.1.5

package/dist/vendor/engine/runtime/agent/harness/runtime/drive/tools.js

@@ -0,0 +1,448 @@
+import { AndorraAbortRequested } from "../../execution/effect-gate.js";
+import { andorraApplyBeforeToolDecision, andorraCreateToolResultMessage, andorraExecuteToolCall, andorraFinalizeToolCall, andorraPrepareToolCall, andorraToolResultFromMessage, } from "../../execution/tools.js";
+import { AndorraSessionInvariantError } from "../../session/session.js";
+import { andorraDeleteValue, andorraOperationToolArgs, andorraOperationToolMemo, andorraOperationToolMemoPrefix, andorraPendingEntry, andorraPendingToolOutput, andorraSetValue, } from "../../session/values.js";
+import { andorraOpenToolProgress } from "../progress.js";
+import { andorraMaterializeReady, andorraReadToolBatchSource, andorraToolCallFor, andorraWithToolBatch, } from "./tool-placement.js";
+const INTERRUPTION_MARKER = "[Tool execution was interrupted. The preceding output is the latest durable progress snapshot; newer live output may be missing, and the external outcome is unknown.]";
+class AndorraToolInvocationEnded extends Error {
+    constructor() {
+        super("Tool invocation no longer owns its durable effect");
+        this.name = "ToolInvocationEnded";
+    }
+}
+function andorraCurrentBatch(lane) {
+    const operation = lane.state.operation;
+    if (operation?.state.at !== "tools")
+        return undefined;
+    return { run: operation.state, batch: operation.state.batch };
+}
+function andorraFindCall(batch, sourceIndex, resultEntryId) {
+    return batch.calls.find((call) => call.sourceIndex === sourceIndex && call.resultEntryId === resultEntryId);
+}
+function andorraReplaceCall(batch, replacement) {
+    return {
+        ...batch,
+        calls: batch.calls.map((call) => call.sourceIndex === replacement.sourceIndex && call.resultEntryId === replacement.resultEntryId
+            ? replacement
+            : call),
+    };
+}
+function andorraValidateMemoName(name) {
+    if (name.length === 0)
+        throw new TypeError("Tool invocation memo name must not be empty");
+    if (name.includes(":"))
+        throw new TypeError("Tool invocation memo name must not contain ':'");
+}
+function andorraInvocationCapability(lane, drive, batch, call) {
+    let active = true;
+    const andorraOwnsEffect = (state) => {
+        const operation = state.operation;
+        if (operation?.state.at !== "tools")
+            return false;
+        return andorraFindCall(operation.state.batch, call.sourceIndex, call.resultEntryId)?.status === "effect_pending";
+    };
+    const andorraEnded = () => new AndorraToolInvocationEnded();
+    return {
+        invocation: {
+            invocationId: call.resultEntryId,
+            operationId: drive.operationId,
+            turnId: batch.turnId,
+            getMemo(name) {
+                andorraValidateMemoName(name);
+                if (!active)
+                    return Promise.reject(andorraEnded());
+                return lane.command(async (state, reader) => {
+                    if (!andorraOwnsEffect(state))
+                        return { kind: "reject", error: andorraEnded() };
+                    const stored = await reader.getValue(andorraOperationToolMemo(drive.operationId, call.resultEntryId, name), drive.context);
+                    return { kind: "return", result: stored?.value };
+                }, drive.context);
+            },
+            setMemo(name, value) {
+                andorraValidateMemoName(name);
+                if (!active)
+                    return Promise.reject(andorraEnded());
+                return lane.command((state) => {
+                    if (!andorraOwnsEffect(state))
+                        return { kind: "reject", error: andorraEnded() };
+                    const address = andorraOperationToolMemo(drive.operationId, call.resultEntryId, name);
+                    return {
+                        kind: "commit",
+                        writes: [value === undefined ? andorraDeleteValue(address) : andorraSetValue(address, value)],
+                        next: state,
+                        materialize: () => undefined,
+                    };
+                }, drive.context);
+            },
+        },
+        expire() {
+            active = false;
+        },
+    };
+}
+function andorraSyntheticMessage(toolCall, content, options = {}) {
+    return {
+        role: "toolResult",
+        toolCallId: toolCall.id,
+        toolName: toolCall.name,
+        content,
+        ...(options.details === undefined ? {} : { details: options.details }),
+        ...(options.usage === undefined ? {} : { usage: options.usage }),
+        isError: true,
+        timestamp: Date.now(),
+    };
+}
+function andorraAbortedOutcome(toolCall) {
+    return {
+        toolCall,
+        message: andorraSyntheticMessage(toolCall, [{ type: "text", text: "Tool execution was cancelled before completion." }]),
+        terminate: false,
+    };
+}
+function andorraInterruptedOutcome(toolCall, checkpoint) {
+    return {
+        toolCall,
+        message: andorraSyntheticMessage(toolCall, [...(checkpoint?.content ?? []), { type: "text", text: INTERRUPTION_MARKER }], checkpoint === undefined ? {} : { details: checkpoint.details, usage: checkpoint.usage }),
+        terminate: false,
+    };
+}
+function andorraTruncatedOutcome(toolCall) {
+    return {
+        toolCall,
+        message: andorraSyntheticMessage(toolCall, [
+            {
+                type: "text",
+                text: `Tool call ${JSON.stringify(toolCall.name)} was not executed because the assistant response hit the output token limit, so its arguments may be truncated. Re-issue the tool call with complete arguments.`,
+            },
+        ]),
+        terminate: false,
+    };
+}
+function andorraOutcomeFromFinalizedCall(finalized) {
+    return { toolCall: finalized.toolCall, message: andorraCreateToolResultMessage(finalized), terminate: finalized.terminate };
+}
+async function andorraPublishToolIntent(lane, drive, run, planned, toolCall, args, replay, recovery) {
+    return lane.continueOperation(run, (_state, run) => {
+        const effectPending = {
+            status: "effect_pending",
+            sourceIndex: planned.sourceIndex,
+            resultEntryId: planned.resultEntryId,
+            replay,
+        };
+        return {
+            kind: "commit",
+            writes: [andorraSetValue(andorraOperationToolArgs(drive.operationId, run.batch.turnId, planned.sourceIndex), args)],
+            operationState: andorraWithToolBatch(run, andorraReplaceCall(run.batch, effectPending)),
+            materialize: () => effectPending,
+            events: () => [
+                {
+                    type: "tool_start",
+                    lane: lane.name,
+                    runId: drive.operationId,
+                    turnId: run.batch.turnId,
+                    toolCallId: toolCall.id,
+                    toolName: toolCall.name,
+                    args,
+                    ...(recovery ? { recovery: true } : {}),
+                },
+            ],
+        };
+    }, drive.context);
+}
+async function andorraPublishToolOutcome(lane, drive, capability, call, finalized, recovery) {
+    await lane.settleOperation(capability, async (_state, run, _meta, reader) => {
+        const { toolCall } = finalized;
+        const memos = await reader.scanValues(andorraOperationToolMemoPrefix(drive.operationId, call.resultEntryId), drive.context);
+        const durableTerminate = run.control.status === "running" && finalized.terminate;
+        const outcome = {
+            status: "outcome_ready",
+            sourceIndex: call.sourceIndex,
+            resultEntryId: call.resultEntryId,
+            terminate: durableTerminate,
+        };
+        return {
+            kind: "commit",
+            writes: [
+                andorraSetValue(andorraPendingEntry(call.resultEntryId), { type: "message", payload: finalized.message }),
+                andorraDeleteValue(andorraPendingToolOutput(drive.operationId, call.resultEntryId)),
+                ...memos.map(({ address }) => andorraDeleteValue(address)),
+            ],
+            operationState: andorraWithToolBatch(run, andorraReplaceCall(run.batch, outcome)),
+            materialize: () => undefined,
+            events: () => [
+                ...(call.status === "planned"
+                    ? [
+                        {
+                            type: "tool_start",
+                            lane: lane.name,
+                            runId: drive.operationId,
+                            turnId: run.batch.turnId,
+                            toolCallId: toolCall.id,
+                            toolName: toolCall.name,
+                            args: toolCall.arguments,
+                            ...(recovery ? { recovery: true } : {}),
+                        },
+                    ]
+                    : []),
+                {
+                    type: "tool_end",
+                    lane: lane.name,
+                    runId: drive.operationId,
+                    turnId: run.batch.turnId,
+                    toolCallId: toolCall.id,
+                    toolName: toolCall.name,
+                    result: andorraToolResultFromMessage(finalized.message, durableTerminate),
+                    isError: finalized.message.isError,
+                    terminate: durableTerminate,
+                    ...(recovery ? { recovery: true } : {}),
+                },
+            ],
+        };
+    }, drive.context);
+}
+async function andorraClearReplayCheckpoint(lane, drive, batch, call, toolCall) {
+    return lane.command(async (state, reader) => {
+        const stored = await reader.getValue(andorraOperationToolArgs(drive.operationId, batch.turnId, call.sourceIndex), drive.context);
+        if (stored === undefined) {
+            throw new AndorraSessionInvariantError(`Tool call ${call.resultEntryId} is missing persisted arguments`);
+        }
+        return {
+            kind: "commit",
+            writes: [andorraDeleteValue(andorraPendingToolOutput(drive.operationId, call.resultEntryId))],
+            next: state,
+            materialize: () => stored.value,
+            events: () => [
+                {
+                    type: "tool_start",
+                    lane: lane.name,
+                    runId: drive.operationId,
+                    turnId: batch.turnId,
+                    toolCallId: toolCall.id,
+                    toolName: toolCall.name,
+                    args: stored.value,
+                    recovery: true,
+                },
+            ],
+        };
+    }, drive.context);
+}
+function andorraReadCheckpoint(lane, drive, call) {
+    return lane.command(async (_state, reader) => {
+        const stored = await reader.getValue(andorraPendingToolOutput(drive.operationId, call.resultEntryId), drive.context);
+        return { kind: "return", result: stored?.value };
+    }, drive.context);
+}
+async function andorraResolveToolContext(lane, drive) {
+    const source = lane.readConfig().toolContext;
+    return (typeof source === "function" ? await source(drive.context) : source);
+}
+async function andorraPerformToolInvocation(lane, drive, batch, call, cleared, toolContext, recovery) {
+    const capability = andorraInvocationCapability(lane, drive, batch, call);
+    const progress = andorraOpenToolProgress(lane, drive, batch.turnId, call.sourceIndex, call.resultEntryId);
+    let latestUpdateDelivery = Promise.resolve();
+    const andorraPublishUpdate = (partial) => {
+        latestUpdateDelivery = lane.emitBatch([
+            {
+                type: "tool_update",
+                lane: lane.name,
+                runId: drive.operationId,
+                turnId: batch.turnId,
+                toolCallId: cleared.toolCall.id,
+                toolName: cleared.toolCall.name,
+                partialResult: partial,
+                ...(recovery ? { recovery: true } : {}),
+            },
+        ], drive.context);
+        void latestUpdateDelivery.catch(() => { });
+    };
+    let execution;
+    try {
+        execution = andorraExecuteToolCall(cleared, drive.gate, (partial, options) => {
+            andorraPublishUpdate(partial);
+            if (options?.checkpoint === true)
+                progress.write(partial);
+        }, toolContext, capability.invocation, drive.context);
+    }
+    catch (error) {
+        capability.expire();
+        progress.seal();
+        await progress.drain();
+        if (!(error instanceof AndorraAbortRequested))
+            throw error;
+        await error.cancellation;
+        return recovery ? andorraInterruptedOutcome(cleared.toolCall, undefined) : andorraAbortedOutcome(cleared.toolCall);
+    }
+    const executed = await execution.finally(() => {
+        capability.expire();
+        progress.seal();
+    });
+    await latestUpdateDelivery;
+    await progress.drain();
+    let patch;
+    try {
+        patch = await lane.hooks.runToolWithGate("after_tool", {
+            lane: lane.name,
+            runId: drive.operationId,
+            toolCallId: cleared.toolCall.id,
+            toolName: cleared.toolCall.name,
+            args: cleared.args,
+            content: executed.result.content,
+            ...(executed.result.details === undefined ? {} : { details: executed.result.details }),
+            isError: executed.isError,
+            ...(executed.result.usage === undefined ? {} : { usage: executed.result.usage }),
+        }, drive.gate, drive.context);
+    }
+    catch (error) {
+        if (!(error instanceof AndorraAbortRequested))
+            throw error;
+        patch = undefined;
+    }
+    const finalized = andorraFinalizeToolCall(cleared, executed, patch);
+    return { toolCall: finalized.toolCall, message: andorraCreateToolResultMessage(finalized), terminate: finalized.terminate };
+}
+async function andorraPrepareToolInvocation(lane, drive, sources, call, tools) {
+    const toolCall = andorraToolCallFor(sources, call);
+    if (sources.assistant.stopReason === "length") {
+        return { kind: "outcome", outcome: andorraTruncatedOutcome(toolCall) };
+    }
+    const prepared = andorraPrepareToolCall(toolCall, tools);
+    if ("kind" in prepared)
+        return { kind: "outcome", outcome: andorraOutcomeFromFinalizedCall(prepared) };
+    let decision;
+    try {
+        decision = await lane.hooks.runToolWithGate("before_tool", {
+            lane: lane.name,
+            runId: drive.operationId,
+            toolCallId: toolCall.id,
+            toolName: toolCall.name,
+            args: prepared.args,
+        }, drive.gate, drive.context);
+    }
+    catch (error) {
+        if (!(error instanceof AndorraAbortRequested))
+            throw error;
+        await error.cancellation;
+        return { kind: "outcome", outcome: andorraAbortedOutcome(toolCall) };
+    }
+    const cleared = andorraApplyBeforeToolDecision(prepared, decision);
+    return "kind" in cleared
+        ? { kind: "outcome", outcome: andorraOutcomeFromFinalizedCall(cleared) }
+        : { kind: "ready", cleared };
+}
+async function andorraStartToolInvocation(lane, drive, run, sources, call, tools, toolContext, recovery) {
+    const prepared = await andorraPrepareToolInvocation(lane, drive, sources, call, tools);
+    if (prepared.kind === "outcome") {
+        return { completion: andorraPublishToolOutcome(lane, drive, run, call, prepared.outcome, recovery) };
+    }
+    const effectPending = await andorraPublishToolIntent(lane, drive, run, call, prepared.cleared.toolCall, prepared.cleared.args, prepared.cleared.tool.replay ?? "never", recovery);
+    return {
+        completion: effectPending.kind === "cancel_requested"
+            ? andorraPublishToolOutcome(lane, drive, run, call, andorraAbortedOutcome(prepared.cleared.toolCall), recovery)
+            : andorraPerformToolInvocation(lane, drive, run.batch, effectPending.value, prepared.cleared, toolContext, recovery).then((outcome) => andorraPublishToolOutcome(lane, drive, run, effectPending.value, outcome, recovery)),
+    };
+}
+async function andorraRecoverToolInvocation(lane, drive, run, sources, call, toolsByName, toolContext, cancelled) {
+    const toolCall = andorraToolCallFor(sources, call);
+    const tool = toolsByName.get(toolCall.name);
+    if (!cancelled && call.replay === "safe" && tool?.replay === "safe") {
+        const args = await andorraClearReplayCheckpoint(lane, drive, run.batch, call, toolCall);
+        const cleared = { toolCall, tool, args };
+        return {
+            completion: andorraPerformToolInvocation(lane, drive, run.batch, call, cleared, toolContext, true).then((outcome) => andorraPublishToolOutcome(lane, drive, run, call, outcome, true)),
+        };
+    }
+    const checkpoint = await andorraReadCheckpoint(lane, drive, call);
+    return {
+        completion: andorraPublishToolOutcome(lane, drive, run, call, andorraInterruptedOutcome(toolCall, checkpoint), true),
+    };
+}
+async function andorraRunSequential(lane, drive, run, sources, execution, recovery) {
+    const { batch } = run;
+    for (let transition = 0; transition <= batch.calls.length * 2 + 1; transition += 1) {
+        await andorraMaterializeReady(lane, drive, run, sources, recovery);
+        const current = andorraCurrentBatch(lane);
+        if (current === undefined)
+            return { kind: "continue" };
+        const call = current.batch.calls.find((candidate) => candidate.status !== "completed");
+        if (call === undefined)
+            throw new AndorraSessionInvariantError("Tool batch remained open after every call completed");
+        if (call.status === "outcome_ready")
+            throw new AndorraSessionInvariantError("Ready tool outcome was not materialized");
+        if (current.run.control.status === "cancel_requested") {
+            const toolCall = andorraToolCallFor(sources, call);
+            if (call.status === "planned") {
+                await andorraPublishToolOutcome(lane, drive, current.run, call, andorraAbortedOutcome(toolCall), recovery);
+            }
+            else {
+                const checkpoint = await andorraReadCheckpoint(lane, drive, call);
+                await andorraPublishToolOutcome(lane, drive, current.run, call, andorraInterruptedOutcome(toolCall, checkpoint), recovery);
+            }
+            continue;
+        }
+        if (execution === undefined)
+            throw new AndorraSessionInvariantError("Running tool batch is missing execution context");
+        const started = call.status === "planned"
+            ? await andorraStartToolInvocation(lane, drive, current.run, sources, call, execution.tools, execution.toolContext, recovery)
+            : await andorraRecoverToolInvocation(lane, drive, current.run, sources, call, execution.toolsByName, execution.toolContext, false);
+        await started.completion;
+    }
+    throw new AndorraSessionInvariantError("Sequential tool batch exceeded its bounded transition count");
+}
+async function andorraRunParallel(lane, drive, run, sources, tools, toolsByName, toolContext, recovery) {
+    const { batch } = run;
+    let materialization = Promise.resolve();
+    const andorraScheduleMaterialization = () => {
+        const scheduled = materialization.then(() => andorraMaterializeReady(lane, drive, run, sources, recovery));
+        materialization = scheduled.catch(() => { });
+        return scheduled;
+    };
+    const jobs = [];
+    for (const call of batch.calls) {
+        if (call.status === "completed" || call.status === "outcome_ready")
+            continue;
+        const started = call.status === "planned"
+            ? await andorraStartToolInvocation(lane, drive, run, sources, call, tools, toolContext, recovery)
+            : await andorraRecoverToolInvocation(lane, drive, run, sources, call, toolsByName, toolContext, lane.state.operation.state.control.status === "cancel_requested");
+        const job = started.completion.then(async () => {
+            await andorraScheduleMaterialization();
+        });
+        void job.catch(() => { });
+        jobs.push(job);
+    }
+    await Promise.all(jobs);
+    await andorraScheduleMaterialization();
+    return { kind: "continue" };
+}
+/** Execute, recover, stage, and source-order one complete durable tool batch. */
+export async function andorraRunTools(lane, drive, run) {
+    const batch = run.batch;
+    const recovery = batch.calls.some((call) => call.status === "effect_pending" || call.status === "outcome_ready");
+    if (recovery) {
+        await lane.emitBatch([
+            {
+                type: "turn_start",
+                lane: lane.name,
+                runId: drive.operationId,
+                turnId: batch.turnId,
+                recovery: true,
+            },
+        ], drive.context);
+    }
+    const sources = await andorraReadToolBatchSource(lane, drive, batch);
+    await andorraMaterializeReady(lane, drive, run, sources, recovery);
+    const current = andorraCurrentBatch(lane);
+    if (current === undefined)
+        return { kind: "continue" };
+    if (current.run.control.status === "cancel_requested") {
+        return andorraRunSequential(lane, drive, current.run, sources, undefined, recovery);
+    }
+    const config = lane.readConfig();
+    const active = new Set(batch.configuration.activeToolNames);
+    const tools = config.tools.filter((tool) => active.has(tool.name));
+    const toolsByName = new Map(tools.map((tool) => [tool.name, tool]));
+    const toolContext = await andorraResolveToolContext(lane, drive);
+    return run.settings.toolExecution === "sequential"
+        ? andorraRunSequential(lane, drive, current.run, sources, { tools, toolsByName, toolContext }, recovery)
+        : andorraRunParallel(lane, drive, current.run, sources, tools, toolsByName, toolContext, recovery);
+}

package/dist/vendor/engine/runtime/agent/harness/runtime/drive.d.ts

@@ -0,0 +1,5 @@
+import type { DriveOutcome } from "../agent-harness.js";
+import type { AndorraLane } from "./lane.js";
+import type { AndorraDrive } from "./types.js";
+/** Drive one installed pass through direct durable procedures until settlement or a durable wait. */
+export declare function andorraDriveOperation<TContext extends object | undefined>(lane: AndorraLane<TContext>, drive: AndorraDrive): Promise<DriveOutcome>;

package/dist/vendor/engine/runtime/agent/harness/runtime/drive.js

@@ -0,0 +1,92 @@
+import { AndorraAbortRequested } from "../execution/effect-gate.js";
+import { AndorraSessionInvariantError } from "../session/session.js";
+import { andorraRunCheckpoint, andorraStartRun } from "./drive/checkpoint.js";
+import { andorraRunDeferred } from "./drive/deferred.js";
+import { andorraRunGeneration } from "./drive/generation.js";
+import { andorraReconcileOperation } from "./drive/reconcile.js";
+import { andorraRecoverAssistantGeneration } from "./drive/recovery.js";
+import { andorraCommitNavigation, andorraRecoverStructuralGeneration, andorraRunStructuralDecision, andorraRunStructuralGeneration, andorraRunStructuralRetryWait, } from "./drive/structural.js";
+import { andorraRunTools } from "./drive/tools.js";
+function andorraCurrentOperation(lane, drive) {
+    const operation = lane.state.operation;
+    if (operation === null || operation.meta.operationId !== drive.operationId) {
+        throw new AndorraSessionInvariantError(`Drive ${drive.operationId} has no matching current operation`);
+    }
+    return operation;
+}
+/** Drive one installed pass through direct durable procedures until settlement or a durable wait. */
+export async function andorraDriveOperation(lane, drive) {
+    let operation = andorraCurrentOperation(lane, drive);
+    if (operation.state.control.status === "running") {
+        try {
+            await lane.hooks.runWithGate("before_drive", { lane: lane.name, runId: drive.operationId, operation: operation.meta.intent.kind }, drive.gate, drive.context);
+        }
+        catch (error) {
+            if (!(error instanceof AndorraAbortRequested))
+                throw error;
+            await error.cancellation;
+        }
+    }
+    for (;;) {
+        operation = andorraCurrentOperation(lane, drive);
+        const state = operation.state;
+        let result;
+        try {
+            if (state.control.status === "cancel_requested") {
+                result = await andorraReconcileOperation(lane, drive);
+            }
+            else
+                switch (state.at) {
+                    case "starting":
+                        result = await andorraStartRun(lane, drive, state);
+                        break;
+                    case "checkpoint":
+                        result = await andorraRunCheckpoint(lane, drive, state);
+                        break;
+                    case "assistant.ready":
+                    case "assistant.retry_wait":
+                        result = await andorraRunGeneration(lane, drive, state);
+                        break;
+                    case "assistant.effect_pending":
+                        result = await andorraRecoverAssistantGeneration(lane, drive, state);
+                        break;
+                    case "tools":
+                        result = await andorraRunTools(lane, drive, state);
+                        break;
+                    case "deferred.suspended":
+                    case "deferred.effect_pending":
+                        result = await andorraRunDeferred(lane, drive, state);
+                        break;
+                    case "summary.deciding":
+                        result = await andorraRunStructuralDecision(lane, drive, state);
+                        break;
+                    case "summary.ready":
+                        result = await andorraRunStructuralGeneration(lane, drive, state);
+                        break;
+                    case "summary.effect_pending":
+                        result = await andorraRecoverStructuralGeneration(lane, drive, state);
+                        break;
+                    case "summary.retry_wait":
+                        result = await andorraRunStructuralRetryWait(lane, drive, state);
+                        break;
+                    case "navigation.ready_to_commit":
+                        result = await andorraCommitNavigation(lane, drive, state);
+                        break;
+                }
+        }
+        catch (error) {
+            if (!(error instanceof AndorraAbortRequested))
+                throw error;
+            await error.cancellation;
+            result = { kind: "continue" };
+        }
+        if (result.kind === "settled")
+            return { kind: "settled", outcome: result.outcome };
+        if (result.kind === "waiting")
+            return result.outcome;
+        const next = andorraCurrentOperation(lane, drive).state;
+        if (next === state && next.control.status !== "cancel_requested") {
+            throw new AndorraSessionInvariantError(`Drive procedure made no progress from ${state.at}`);
+        }
+    }
+}

package/dist/vendor/engine/runtime/agent/harness/runtime/harness.d.ts

@@ -0,0 +1,58 @@
+import type { Models, RetryPolicy } from "../../../ai/index.js";
+import type { QueueMode } from "../../types.js";
+import type { AcquireLaneOptions, AgentHarness, AgentHarnessOptions, AgentLane, LaneInfo, OpenOperation, Resources } from "../agent-harness.js";
+import { type CompactionSettings } from "../compaction/compaction.js";
+import type { Context } from "../context.js";
+import { AndorraHarnessEventBus } from "../events.js";
+import { AndorraHookRegistry } from "../hooks.js";
+import type { LaneConfiguration, Session } from "../session/types.js";
+import type { AgentHarnessStreamOptions, AgentHarnessTool } from "../types.js";
+import { AndorraLane } from "./lane.js";
+import { type LaneState } from "./types.js";
+/** Runtime implementation of AgentHarness. The harness manages lanes but is not itself a lane. */
+export declare class AndorraHarness<TContext extends object | undefined> implements AgentHarness<TContext> {
+    readonly session: Session;
+    readonly models: Models;
+    readonly hooks: AndorraHookRegistry;
+    readonly events: AndorraHarnessEventBus;
+    readonly lanesByName: Map<string, AndorraLane<TContext>>;
+    private readonly seed;
+    private readonly configStore;
+    private closePromise;
+    private closedError;
+    private faultError;
+    constructor(options: AgentHarnessOptions<TContext>, seed: LaneConfiguration, restored: Map<string, LaneState>);
+    lane(name: string, context: Context): Promise<AgentLane>;
+    lane(name: string, options: AcquireLaneOptions, context: Context): Promise<AgentLane>;
+    lanes(context: Context): Promise<LaneInfo[]>;
+    getName(context: Context): Promise<string | undefined>;
+    setName(name: string | undefined, context: Context): Promise<void>;
+    getLabel(targetId: string, context: Context): Promise<string | undefined>;
+    setLabel(targetId: string, label: string | undefined, context: Context): Promise<void>;
+    getTools(context: Context): Promise<AgentHarnessTool<TContext>[]>;
+    setTools(tools: AgentHarnessTool<TContext>[], context: Context): Promise<void>;
+    getResources(context: Context): Promise<Resources>;
+    setResources(resources: Resources, context: Context): Promise<void>;
+    getStreamOptions(context: Context): Promise<AgentHarnessStreamOptions>;
+    setStreamOptions(options: AgentHarnessStreamOptions, context: Context): Promise<void>;
+    getRetryPolicy(context: Context): Promise<RetryPolicy>;
+    setRetryPolicy(policy: RetryPolicy, context: Context): Promise<void>;
+    getCompactionSettings(context: Context): Promise<CompactionSettings>;
+    setCompactionSettings(compaction: CompactionSettings, context: Context): Promise<void>;
+    getSteeringMode(context: Context): Promise<QueueMode>;
+    setSteeringMode(steeringMode: QueueMode, context: Context): Promise<void>;
+    getFollowUpMode(context: Context): Promise<QueueMode>;
+    setFollowUpMode(followUpMode: QueueMode, context: Context): Promise<void>;
+    watchSession(_context: Context): Promise<never>;
+    fault(cause: unknown, context: Context): Error;
+    close(context: Context): Promise<void>;
+    private buildLane;
+    private getConfig;
+    private setConfig;
+    private assertOpen;
+}
+/** Attach runtime without starting provider, tool, hook, or timer effects. */
+export declare function andorraCreateAgentHarness<TContext extends object | undefined = object | undefined>(options: AgentHarnessOptions<TContext>, context: Context): Promise<{
+    harness: AgentHarness<TContext>;
+    open: OpenOperation[];
+}>;