@botbotgo/agent-harness 0.0.107 → 0.0.109

package/dist/runtime/harness/run/resume-runtime.d.ts

@@ -0,0 +1,55 @@
+import type { CompiledAgentBinding, InternalApprovalRecord, MessageContent, ResumeOptions, RunResult, ThreadSummary, TranscriptMessage, WorkspaceBundle } from "../../../contracts/types.js";
+import type { RuntimePersistence } from "../../../persistence/types.js";
+import type { AgentRuntimeAdapter } from "../../agent-runtime-adapter.js";
+type Binding = WorkspaceBundle["bindings"] extends Map<any, infer T> ? T : never;
+export declare function createResumeRunRuntime(input: {
+    persistence: RuntimePersistence;
+    workspace: WorkspaceBundle;
+    runtimeAdapter: AgentRuntimeAdapter;
+    getSession: (threadId: string) => Promise<ThreadSummary | null>;
+    getRunCancellation: (runId: string) => Promise<{
+        requested: boolean;
+        reason?: string;
+    }>;
+    finalizeCancelledRun: (threadId: string, runId: string, previousState: RunResult["state"] | null, reason?: string) => Promise<RunResult>;
+    acquireRunSlot: (threadId?: string, runId?: string, activeState?: RunResult["state"], priority?: number) => Promise<() => Promise<void>>;
+    resolvePersistedRunPriority: (threadId: string, runId: string) => Promise<number>;
+    emit: (threadId: string, runId: string, sequence: number, eventType: string, payload: Record<string, unknown>) => Promise<unknown>;
+    loadRunInput: (threadId: string, runId: string) => Promise<MessageContent>;
+    recordLlmSuccess: (startedAt: number) => void;
+    recordLlmFailure: (startedAt: number) => void;
+    finalizeContinuedRun: (binding: Binding, threadId: string, runId: string, input: MessageContent, actual: RunResult, options: {
+        previousState: RunResult["state"] | null;
+        stateSequence: number;
+        approvalSequence?: number;
+    }) => Promise<RunResult>;
+}): {
+    getApprovalById: (approvalId: string) => Promise<InternalApprovalRecord | null>;
+    getSession: (threadId: string) => Promise<ThreadSummary | null>;
+    resolveApprovalRecord: (resumeOptions: ResumeOptions, thread: ThreadSummary) => Promise<InternalApprovalRecord>;
+    getBinding: (agentId: string) => CompiledAgentBinding | undefined;
+    buildResumePayload: (binding: CompiledAgentBinding, approval: InternalApprovalRecord, resumeOptions: ResumeOptions) => unknown;
+    getRunCancellation: (runId: string) => Promise<{
+        requested: boolean;
+        reason?: string;
+    }>;
+    finalizeCancelledRun: (threadId: string, runId: string, previousState: RunResult["state"] | null, reason?: string) => Promise<RunResult>;
+    setRunState: (threadId: string, runId: string, state: RunResult["state"], checkpointRef: string | null) => Promise<void>;
+    acquireRunSlot: (threadId?: string, runId?: string, activeState?: RunResult["state"], priority?: number) => Promise<() => Promise<void>>;
+    resolvePersistedRunPriority: (threadId: string, runId: string) => Promise<number>;
+    saveRecoveryIntent: (threadId: string, runId: string, payload: Record<string, unknown>) => Promise<void>;
+    emit: (threadId: string, runId: string, sequence: number, eventType: string, payload: Record<string, unknown>) => Promise<unknown>;
+    resolveApproval: (threadId: string, runId: string, approvalId: string, resolution: "approved" | "edited" | "rejected" | "expired") => Promise<InternalApprovalRecord>;
+    listThreadMessages: (threadId: string) => Promise<TranscriptMessage[]>;
+    loadRunInput: (threadId: string, runId: string) => Promise<MessageContent>;
+    invoke: (binding: CompiledAgentBinding, message: MessageContent, threadId: string, runId: string, resumePayload: unknown, priorHistory: TranscriptMessage[]) => Promise<RunResult>;
+    recordLlmSuccess: (startedAt: number) => void;
+    recordLlmFailure: (startedAt: number) => void;
+    clearRecoveryIntent: (threadId: string, runId: string) => Promise<void>;
+    finalizeContinuedRun: (binding: Binding, threadId: string, runId: string, message: MessageContent, actual: RunResult, options: {
+        previousState: RunResult["state"] | null;
+        stateSequence: number;
+        approvalSequence?: number;
+    }) => Promise<RunResult>;
+};
+export {};

package/dist/runtime/harness/run/resume-runtime.js

@@ -0,0 +1,26 @@
+import { getWorkspaceBinding } from "../bindings.js";
+import { buildResumePayload as buildHarnessResumePayload, resolveApprovalRecord as resolveHarnessApprovalRecord } from "./resume.js";
+export function createResumeRunRuntime(input) {
+    return {
+        getApprovalById: (approvalId) => input.persistence.getApproval(approvalId),
+        getSession: (threadId) => input.getSession(threadId),
+        resolveApprovalRecord: (resumeOptions, thread) => resolveHarnessApprovalRecord(input.persistence, resumeOptions, thread),
+        getBinding: (agentId) => getWorkspaceBinding(input.workspace, agentId),
+        buildResumePayload: (binding, approval, resumeOptions) => buildHarnessResumePayload(binding, approval, resumeOptions),
+        getRunCancellation: (runId) => input.getRunCancellation(runId),
+        finalizeCancelledRun: (threadId, runId, previousState, reason) => input.finalizeCancelledRun(threadId, runId, previousState, reason),
+        setRunState: (threadId, runId, state, checkpointRef) => input.persistence.setRunState(threadId, runId, state, checkpointRef),
+        acquireRunSlot: (threadId, runId, activeState, priority) => input.acquireRunSlot(threadId, runId, activeState, priority),
+        resolvePersistedRunPriority: (threadId, runId) => input.resolvePersistedRunPriority(threadId, runId),
+        saveRecoveryIntent: (threadId, runId, payload) => input.persistence.saveRecoveryIntent(threadId, runId, payload),
+        emit: (threadId, runId, sequence, eventType, payload) => input.emit(threadId, runId, sequence, eventType, payload),
+        resolveApproval: (threadId, runId, approvalId, resolution) => input.persistence.resolveApproval(threadId, runId, approvalId, resolution),
+        listThreadMessages: (threadId) => input.persistence.listThreadMessages(threadId),
+        loadRunInput: (threadId, runId) => input.loadRunInput(threadId, runId),
+        invoke: (binding, message, threadId, runId, resumePayload, priorHistory) => input.runtimeAdapter.invoke(binding, message, threadId, runId, resumePayload, priorHistory),
+        recordLlmSuccess: (startedAt) => input.recordLlmSuccess(startedAt),
+        recordLlmFailure: (startedAt) => input.recordLlmFailure(startedAt),
+        clearRecoveryIntent: (threadId, runId) => input.persistence.clearRecoveryIntent(threadId, runId),
+        finalizeContinuedRun: (binding, threadId, runId, message, actual, options) => input.finalizeContinuedRun(binding, threadId, runId, message, actual, options),
+    };
+}

package/dist/runtime/harness/run/routing.d.ts

@@ -1,4 +1,5 @@
 import { type MessageContent, type ThreadSummary, type WorkspaceBundle } from "../../../contracts/types.js";
+import type { RoutingRule } from "../../../workspace/support/workspace-ref-utils.js";
 export declare function getDefaultHostAgentId(workspace: WorkspaceBundle, preferredHostAgentId?: string): string;
 export declare function resolveSelectedAgentId(options: {
     workspace: WorkspaceBundle;
@@ -8,3 +9,10 @@ export declare function resolveSelectedAgentId(options: {
     preferredHostAgentId?: string;
     getThreadSummary: (threadId: string) => Promise<ThreadSummary | null>;
 }): Promise<string>;
+export declare function routeAgentId(options: {
+    workspace: WorkspaceBundle;
+    input: MessageContent;
+    routingRules: RoutingRule[];
+    routingDefaultAgentId?: string;
+    threadId?: string;
+}): string;

package/dist/runtime/harness/run/routing.js

@@ -1,4 +1,7 @@
 import { AUTO_AGENT_ID } from "../../../contracts/types.js";
+import { extractMessageText } from "../../../utils/message-content.js";
+import { matchRoutingRule } from "../../../workspace/support/workspace-ref-utils.js";
+import { getWorkspaceBinding } from "../bindings.js";
 import { inferRoutingBindings } from "../../support/harness-support.js";
 export function getDefaultHostAgentId(workspace, preferredHostAgentId) {
     const preferredBinding = preferredHostAgentId ? workspace.bindings.get(preferredHostAgentId) : undefined;
@@ -21,3 +24,21 @@ export async function resolveSelectedAgentId(options) {
     }
     return requestedAgentId;
 }
+export function routeAgentId(options) {
+    const { workspace, input, routingRules, routingDefaultAgentId, threadId } = options;
+    const rawInput = extractMessageText(input);
+    const configuredRule = routingRules.find((rule) => matchRoutingRule(rawInput, rule, { threadId }));
+    if (configuredRule) {
+        const configuredBinding = getWorkspaceBinding(workspace, configuredRule.agentId);
+        if (configuredBinding) {
+            return configuredBinding.agent.id;
+        }
+    }
+    const defaultBinding = routingDefaultAgentId
+        ? getWorkspaceBinding(workspace, routingDefaultAgentId)
+        : undefined;
+    if (defaultBinding) {
+        return defaultBinding.agent.id;
+    }
+    return getDefaultHostAgentId(workspace, routingDefaultAgentId);
+}

package/dist/runtime/harness/run/run-operations.d.ts

@@ -45,6 +45,53 @@ type CancelOperationRuntime = {
         error?: string;
     }) => Promise<unknown>;
 };
+type ExecuteQueuedRunOperationRuntime = {
+    persistence: {
+        getRun: (runId: string) => Promise<{
+            state: RunResult["state"];
+        } | null>;
+        clearRunRequest: (threadId: string, runId: string) => Promise<void>;
+    };
+    getRunCancellation: (runId: string) => Promise<{
+        requested: boolean;
+        reason?: string;
+    }>;
+    finalizeCancelledRun: (threadId: string, runId: string, previousState: RunResult["state"] | null, reason?: string) => Promise<RunResult>;
+    emit: (threadId: string, runId: string, sequence: number, eventType: string, payload: Record<string, unknown>) => Promise<unknown>;
+    setRunStateAndEmit: (threadId: string, runId: string, sequence: number, state: RunResult["state"], options: {
+        previousState: string | null;
+        checkpointRef?: string | null;
+        error?: string;
+    }) => Promise<unknown>;
+    invokeWithHistory: (binding: CompiledAgentBinding, input: MessageContent, threadId: string, runId: string, resumePayload?: unknown, priorHistory?: TranscriptMessage[], options?: {
+        context?: Record<string, unknown>;
+        state?: Record<string, unknown>;
+        files?: Record<string, unknown>;
+    }) => Promise<RunResult>;
+    finalizeContinuedRun: (binding: CompiledAgentBinding, threadId: string, runId: string, input: MessageContent, actual: RunResult, options: {
+        previousState: RunResult["state"] | null;
+        stateSequence: number;
+        approvalSequence?: number;
+    }) => Promise<RunResult>;
+    emitSyntheticFallback: (threadId: string, runId: string, agentId: string, error: unknown) => Promise<void>;
+    renderRuntimeFailure: (error: unknown) => string;
+};
 export declare function resumeRun(runtime: ResumeOperationRuntime, options: ResumeOptions): Promise<RunResult>;
 export declare function cancelRunOperation(runtime: CancelOperationRuntime, options: CancelOptions): Promise<RunResult>;
+export declare function executeQueuedRunOperation(runtime: ExecuteQueuedRunOperationRuntime, input: {
+    binding: CompiledAgentBinding;
+    message: MessageContent;
+    threadId: string;
+    runId: string;
+    agentId: string;
+    options?: {
+        context?: Record<string, unknown>;
+        state?: Record<string, unknown>;
+        files?: Record<string, unknown>;
+        priorHistory?: TranscriptMessage[];
+        previousState?: RunResult["state"];
+        stateSequence?: number;
+        approvalSequence?: number;
+    };
+}): Promise<RunResult>;
 export {};

package/dist/runtime/harness/run/run-operations.js

@@ -111,3 +111,70 @@ export async function cancelRunOperation(runtime, options) {
         output: options.reason ? `cancelling: ${options.reason}` : "cancelling",
     };
 }
+export async function executeQueuedRunOperation(runtime, input) {
+    const { binding, message, threadId, runId, agentId } = input;
+    const options = input.options ?? {};
+    const previousState = options.previousState ?? "running";
+    const currentRun = await runtime.persistence.getRun(runId);
+    if (currentRun?.state === "cancelled") {
+        return {
+            threadId,
+            runId,
+            agentId,
+            state: "cancelled",
+            output: "cancelled",
+        };
+    }
+    const cancellation = await runtime.getRunCancellation(runId);
+    if (cancellation.requested) {
+        return runtime.finalizeCancelledRun(threadId, runId, previousState, cancellation.reason);
+    }
+    if (previousState === "queued") {
+        await runtime.emit(threadId, runId, 101, "run.dequeued", {
+            queuePosition: 0,
+            activeRunCount: 0,
+            maxConcurrentRuns: 0,
+            recoveredOnStartup: true,
+        });
+        await runtime.setRunStateAndEmit(threadId, runId, 102, "running", {
+            previousState: "queued",
+        });
+    }
+    try {
+        const actual = await runtime.invokeWithHistory(binding, message, threadId, runId, undefined, options.priorHistory, {
+            context: options.context,
+            state: options.state,
+            files: options.files,
+        });
+        const cancelledAfterInvoke = await runtime.getRunCancellation(runId);
+        if (cancelledAfterInvoke.requested) {
+            return runtime.finalizeCancelledRun(threadId, runId, previousState === "queued" ? "running" : previousState, cancelledAfterInvoke.reason);
+        }
+        const finalized = await runtime.finalizeContinuedRun(binding, threadId, runId, message, actual, {
+            previousState: previousState === "queued" ? "running" : previousState,
+            stateSequence: options.stateSequence ?? 103,
+            approvalSequence: options.approvalSequence ?? 104,
+        });
+        return {
+            ...finalized,
+            agentId,
+        };
+    }
+    catch (error) {
+        await runtime.emitSyntheticFallback(threadId, runId, agentId, error);
+        await runtime.setRunStateAndEmit(threadId, runId, 104, "failed", {
+            previousState: previousState === "queued" ? "running" : previousState,
+            error: error instanceof Error ? error.message : String(error),
+        });
+        return {
+            threadId,
+            runId,
+            agentId,
+            state: "failed",
+            output: runtime.renderRuntimeFailure(error),
+        };
+    }
+    finally {
+        await runtime.persistence.clearRunRequest(threadId, runId);
+    }
+}

package/dist/runtime/harness/run/start-run.d.ts

@@ -0,0 +1,82 @@
+import type { HarnessEvent, InvocationEnvelope, MessageContent, RunResult, RunStartOptions, WorkspaceBundle } from "../../../contracts/types.js";
+import type { PersistedRunRequest } from "../../../persistence/types.js";
+import type { PolicyEngine } from "../system/policy-engine.js";
+type Binding = WorkspaceBundle["bindings"] extends Map<any, infer T> ? T : never;
+type EnsureThreadStartedRuntime = {
+    persistence: {
+        bootstrapRun?: (input: {
+            threadId: string;
+            agentId: string;
+            runId: string;
+            status: RunResult["state"];
+            createdAt: string;
+            executionMode: string;
+            adapterKind: string;
+            userMessage: {
+                role: "user";
+                content: MessageContent;
+                runId: string;
+                createdAt: string;
+            };
+            runRequest: PersistedRunRequest;
+            createThread: boolean;
+        }) => Promise<void>;
+        createThread: (input: {
+            threadId: string;
+            agentId: string;
+            runId: string;
+            status: RunResult["state"];
+            createdAt: string;
+        }) => Promise<void>;
+        appendThreadMessage: (threadId: string, message: {
+            role: "user";
+            content: MessageContent;
+            runId: string;
+            createdAt: string;
+        }) => Promise<void>;
+        createRun: (input: {
+            threadId: string;
+            runId: string;
+            agentId: string;
+            executionMode: string;
+            adapterKind: string;
+            createdAt: string;
+        }) => Promise<void>;
+        saveRunRequest: (threadId: string, runId: string, runRequest: PersistedRunRequest) => Promise<void>;
+    };
+};
+type PrepareRunStartRuntime = EnsureThreadStartedRuntime & {
+    workspace: WorkspaceBundle;
+    policyEngine: PolicyEngine;
+    resolveSelectedAgentId: (input: MessageContent, requestedAgentId?: string, threadId?: string) => Promise<string>;
+    emitRunCreated: (threadId: string, runId: string, payload: Record<string, unknown>) => Promise<HarnessEvent>;
+    acquireRunSlot: (threadId?: string, runId?: string, activeState?: RunResult["state"], priority?: number) => Promise<() => Promise<void>>;
+};
+export declare function ensureThreadStarted(runtime: EnsureThreadStartedRuntime, input: {
+    selectedAgentId: string;
+    binding: Binding;
+    message: MessageContent;
+    runRequest: PersistedRunRequest;
+    existingThreadId?: string;
+}): Promise<{
+    threadId: string;
+    runId: string;
+    createdAt: string;
+    isNewThread: boolean;
+}>;
+export declare function prepareRunStart(runtime: PrepareRunStartRuntime, input: {
+    options: Pick<RunStartOptions, "input" | "agentId" | "threadId" | "priority">;
+    invocation: InvocationEnvelope;
+    runCreatedPayload: (binding: Binding, selectedAgentId: string) => Record<string, unknown>;
+}): Promise<{
+    binding: Binding;
+    selectedAgentId: string;
+    priority: number;
+    threadId: string;
+    runId: string;
+    isNewThread: boolean;
+    runCreatedEventPromise: Promise<HarnessEvent>;
+    releaseRunSlotPromise: Promise<() => Promise<void>>;
+}>;
+export declare function defaultRequestedAgentId(agentId?: string): string;
+export {};

package/dist/runtime/harness/run/start-run.js

@@ -0,0 +1,88 @@
+import { AUTO_AGENT_ID } from "../../../contracts/types.js";
+import { createPersistentId } from "../../../utils/id.js";
+import { normalizeMessageContent } from "../../../utils/message-content.js";
+import { buildPersistedRunRequest, normalizeRunPriority } from "./helpers.js";
+import { getRequiredWorkspaceBinding } from "../bindings.js";
+import { getBindingAdapterKind } from "../../support/compiled-binding.js";
+export async function ensureThreadStarted(runtime, input) {
+    const { selectedAgentId, binding, message, runRequest, existingThreadId } = input;
+    const threadId = existingThreadId ?? createPersistentId();
+    const runId = createPersistentId();
+    const createdAt = new Date().toISOString();
+    const isNewThread = !existingThreadId;
+    const userMessage = {
+        role: "user",
+        content: normalizeMessageContent(message),
+        runId,
+        createdAt,
+    };
+    if (typeof runtime.persistence.bootstrapRun === "function") {
+        await runtime.persistence.bootstrapRun({
+            threadId,
+            agentId: binding.agent.id,
+            runId,
+            status: "running",
+            createdAt,
+            executionMode: getBindingAdapterKind(binding),
+            adapterKind: getBindingAdapterKind(binding),
+            userMessage,
+            runRequest,
+            createThread: isNewThread,
+        });
+    }
+    else {
+        if (isNewThread) {
+            await runtime.persistence.createThread({
+                threadId,
+                agentId: selectedAgentId,
+                runId,
+                status: "running",
+                createdAt,
+            });
+        }
+        await Promise.all([
+            runtime.persistence.appendThreadMessage(threadId, userMessage),
+            runtime.persistence.createRun({
+                threadId,
+                runId,
+                agentId: binding.agent.id,
+                executionMode: getBindingAdapterKind(binding),
+                adapterKind: getBindingAdapterKind(binding),
+                createdAt,
+            }),
+            runtime.persistence.saveRunRequest(threadId, runId, runRequest),
+        ]);
+    }
+    return { threadId, runId, createdAt, isNewThread };
+}
+export async function prepareRunStart(runtime, input) {
+    const { options, invocation, runCreatedPayload } = input;
+    const selectedAgentId = await runtime.resolveSelectedAgentId(options.input, options.agentId, options.threadId);
+    const binding = getRequiredWorkspaceBinding(runtime.workspace, selectedAgentId);
+    const policyDecision = runtime.policyEngine.evaluate(binding);
+    if (!policyDecision.allowed) {
+        throw new Error(`Policy evaluation blocked agent ${selectedAgentId}: ${policyDecision.reasons.join(", ")}`);
+    }
+    const priority = normalizeRunPriority(options.priority);
+    const runRequest = buildPersistedRunRequest(options.input, invocation, priority);
+    const { threadId, runId, isNewThread } = await ensureThreadStarted(runtime, {
+        selectedAgentId,
+        binding,
+        message: options.input,
+        runRequest,
+        existingThreadId: options.threadId,
+    });
+    return {
+        binding,
+        selectedAgentId,
+        priority,
+        threadId,
+        runId,
+        isNewThread,
+        runCreatedEventPromise: runtime.emitRunCreated(threadId, runId, runCreatedPayload(binding, selectedAgentId)),
+        releaseRunSlotPromise: runtime.acquireRunSlot(threadId, runId, "running", priority),
+    };
+}
+export function defaultRequestedAgentId(agentId) {
+    return agentId ?? AUTO_AGENT_ID;
+}

package/dist/runtime/harness/run/startup-runtime.d.ts

@@ -1,6 +1,7 @@
 import type { RunResult, ThreadSummary } from "../../../contracts/types.js";
 import type { RuntimePersistence } from "../../../persistence/types.js";
 import type { ConcurrencyConfig, RecoveryConfig } from "../../../workspace/support/workspace-ref-utils.js";
+import { type StartupRecoveryContext } from "./recovery.js";
 type Startable = {
     start(): Promise<void>;
 };
@@ -11,7 +12,7 @@ export declare function initializeHarnessRuntime(input: {
 export declare function recoverStartupRuns(input: {
     recoveryConfig: RecoveryConfig;
     persistence: RuntimePersistence;
-    createStartupRecoveryContext: () => unknown;
+    createStartupRecoveryContext: () => StartupRecoveryContext;
     reclaimExpiredClaimedRuns: (nowIso?: string) => Promise<void>;
 }): Promise<void>;
 export declare function reclaimExpiredClaimedRuns(input: {

package/dist/runtime/harness/run/startup-runtime.js

@@ -1,13 +1,48 @@
+import { recoverQueuedStartupRun, recoverResumingStartupRun, recoverRunningStartupRun, } from "./recovery.js";
 export async function initializeHarnessRuntime(input) {
     await input.persistence.initialize();
     await input.healthMonitor?.start();
 }
 export async function recoverStartupRuns(input) {
-    void input;
+    if (!input.recoveryConfig.enabled) {
+        return;
+    }
+    await input.reclaimExpiredClaimedRuns();
+    const threads = await input.persistence.listSessions();
+    if (threads.length === 0) {
+        return;
+    }
+    const context = input.createStartupRecoveryContext();
+    for (const thread of threads) {
+        if (await recoverQueuedStartupRun(context, thread)) {
+            continue;
+        }
+        if (await recoverRunningStartupRun(context, thread)) {
+            continue;
+        }
+        await recoverResumingStartupRun(context, thread);
+    }
 }
 export async function reclaimExpiredClaimedRuns(input, nowIso = new Date().toISOString()) {
-    void input;
-    void nowIso;
+    const expiredRuns = await input.persistence.listExpiredClaimedRuns(nowIso);
+    if (expiredRuns.length === 0) {
+        return;
+    }
+    const activeRunCount = input.getActiveRunSlots();
+    const maxConcurrentRuns = input.concurrencyConfig.maxConcurrentRuns;
+    for (const [index, claimedRun] of expiredRuns.entries()) {
+        await input.persistence.releaseRunClaim(claimedRun.runId);
+        await input.setRunStateAndEmit(claimedRun.threadId, claimedRun.runId, 100, "queued", {
+            previousState: "claimed",
+        });
+        await input.emit(claimedRun.threadId, claimedRun.runId, 101, "run.queued", {
+            queuePosition: activeRunCount + index + 1,
+            activeRunCount,
+            ...(maxConcurrentRuns !== undefined ? { maxConcurrentRuns } : {}),
+            priority: claimedRun.priority,
+            recoveryKind: "startup-claim-recovery",
+        });
+    }
 }
 export async function isStaleRunningRun(input, thread, nowMs = Date.now()) {
     const control = await input.persistence.getRunControl(thread.latestRunId);

package/dist/runtime/harness/run/stream-runtime.d.ts

@@ -0,0 +1,48 @@
+import type { CompiledAgentBinding, HarnessEvent, MessageContent, RunResult, TranscriptMessage } from "../../../contracts/types.js";
+import type { RuntimePersistence } from "../../../persistence/types.js";
+import type { AgentRuntimeAdapter } from "../../agent-runtime-adapter.js";
+export declare function createStreamRunRuntime(input: {
+    persistence: RuntimePersistence;
+    runtimeAdapter: AgentRuntimeAdapter;
+    emit: (threadId: string, runId: string, sequence: number, eventType: string, payload: Record<string, unknown>) => Promise<HarnessEvent>;
+    setRunStateAndEmit: (threadId: string, runId: string, sequence: number, state: RunResult["state"], options: {
+        previousState: string | null;
+        checkpointRef?: string | null;
+        error?: string;
+    }) => Promise<HarnessEvent>;
+    requestApprovalAndEmit: (threadId: string, runId: string, input: MessageContent, interruptContent: string | undefined, checkpointRef: string, sequence: number) => Promise<{
+        approval: {
+            approvalId: string;
+            pendingActionId: string;
+        };
+        event: HarnessEvent;
+    }>;
+    loadPriorHistory: (threadId: string, runId: string) => Promise<TranscriptMessage[]>;
+    invokeWithHistory: (binding: CompiledAgentBinding, input: MessageContent, threadId: string, runId: string) => Promise<RunResult>;
+    emitSyntheticFallback: (threadId: string, runId: string, selectedAgentId: string, error: unknown) => Promise<void>;
+}): {
+    loadPriorHistory: (threadId: string, runId: string) => Promise<TranscriptMessage[]>;
+    stream: (binding: CompiledAgentBinding, message: MessageContent, threadId: string, priorHistory: TranscriptMessage[], options: {
+        context?: Record<string, unknown>;
+        state?: Record<string, unknown>;
+        files?: Record<string, unknown>;
+        runId: string;
+    }) => AsyncGenerator<string | import("../../parsing/stream-event-parsing.js").RuntimeStreamChunk, any, any>;
+    invokeWithHistory: (binding: CompiledAgentBinding, message: MessageContent, threadId: string, runId: string) => Promise<RunResult>;
+    emit: (threadId: string, runId: string, sequence: number, eventType: string, payload: Record<string, unknown>) => Promise<HarnessEvent>;
+    setRunStateAndEmit: (threadId: string, runId: string, sequence: number, state: RunResult["state"], options: {
+        previousState: string | null;
+        checkpointRef?: string | null;
+        error?: string;
+    }) => Promise<HarnessEvent>;
+    requestApprovalAndEmit: (threadId: string, runId: string, message: MessageContent, interruptContent: string | undefined, checkpointRef: string, sequence: number) => Promise<{
+        approval: {
+            approvalId: string;
+            pendingActionId: string;
+        };
+        event: HarnessEvent;
+    }>;
+    appendAssistantMessage: (threadId: string, runId: string, content?: string) => Promise<void>;
+    clearRunRequest: (threadId: string, runId: string) => Promise<void>;
+    emitSyntheticFallback: (threadId: string, runId: string, selectedAgentId: string, error: unknown) => Promise<void>;
+};

package/dist/runtime/harness/run/stream-runtime.js

@@ -0,0 +1,14 @@
+import { appendAssistantMessage as appendLifecycleAssistantMessage } from "./run-lifecycle.js";
+export function createStreamRunRuntime(input) {
+    return {
+        loadPriorHistory: (threadId, runId) => input.loadPriorHistory(threadId, runId),
+        stream: (binding, message, threadId, priorHistory, options) => input.runtimeAdapter.stream(binding, message, threadId, priorHistory, options),
+        invokeWithHistory: (binding, message, threadId, runId) => input.invokeWithHistory(binding, message, threadId, runId),
+        emit: (threadId, runId, sequence, eventType, payload) => input.emit(threadId, runId, sequence, eventType, payload),
+        setRunStateAndEmit: (threadId, runId, sequence, state, options) => input.setRunStateAndEmit(threadId, runId, sequence, state, options),
+        requestApprovalAndEmit: (threadId, runId, message, interruptContent, checkpointRef, sequence) => input.requestApprovalAndEmit(threadId, runId, message, interruptContent, checkpointRef, sequence),
+        appendAssistantMessage: (threadId, runId, content) => appendLifecycleAssistantMessage(input.persistence, threadId, runId, content),
+        clearRunRequest: (threadId, runId) => input.persistence.clearRunRequest(threadId, runId),
+        emitSyntheticFallback: (threadId, runId, selectedAgentId, error) => input.emitSyntheticFallback(threadId, runId, selectedAgentId, error),
+    };
+}

package/dist/runtime/harness.d.ts

@@ -33,6 +33,10 @@ export declare class AgentHarnessRuntime {
     private pendingRunInsertionOrder;
     private readonly pendingRunSlots;
     private runtimeEventSequence;
+    private initialized;
+    private closed;
+    private readonly backgroundEventRuntime;
+    private readonly runtimeEventOperations;
     private defaultRunRoot;
     private getDefaultHostAgentId;
     private resolveSelectedAgentId;
@@ -43,8 +47,6 @@ export declare class AgentHarnessRuntime {
     initialize(): Promise<void>;
     subscribe(listener: (event: HarnessEvent) => void): () => void;
     getHealth(): Promise<RuntimeHealthSnapshot>;
-    private resolveAgentTools;
-    private supportsRunningReplay;
     listThreads(filter?: {
         agentId?: string;
     }): Promise<ThreadSummary[]>;
@@ -76,7 +78,7 @@ export declare class AgentHarnessRuntime {
     }): Promise<string>;
     private emit;
     private trackBackgroundTask;
-    private ensureThreadStarted;
+    private resolveToolMcpServerTools;
     private loadPriorHistory;
     private loadRunInput;
     private getRunCancellation;
@@ -90,11 +92,8 @@ export declare class AgentHarnessRuntime {
     private requestApprovalAndEmit;
     private isDecisionRun;
     private notifyListener;
-    private prepareRunStart;
-    private createStartupRecoveryContext;
     private acquireRunSlot;
     private dropPendingRunSlot;
-    private dispatchRunListeners;
     run(options: RunOptions): Promise<RunResult>;
     streamEvents(options: RunStartOptions): AsyncGenerator<HarnessStreamItem>;
     resume(options: ResumeOptions): Promise<RunResult>;