@botbotgo/agent-harness 0.0.101 → 0.0.102

package/dist/runtime/harness/run/run-slot-acquisition.js

@@ -0,0 +1,157 @@
+import { shiftNextPendingRunSlot } from "./run-queue.js";
+export async function acquireRunSlot(runtime, options = {}) {
+    const { threadId, runId } = options;
+    const activeState = options.activeState ?? "running";
+    const priority = options.priority ?? 0;
+    let stopHeartbeat = () => undefined;
+    const beginLease = async (mode) => {
+        if (!threadId || !runId) {
+            return;
+        }
+        const claimedAt = new Date().toISOString();
+        const leaseExpiresAt = new Date(Date.now() + runtime.concurrencyConfig.leaseMs).toISOString();
+        if (mode === "queue-claim") {
+            await runtime.persistence.claimQueuedRun({
+                threadId,
+                runId,
+                workerId: runtime.workerId,
+                claimedAt,
+                leaseExpiresAt,
+            });
+        }
+        else {
+            await runtime.persistence.renewRunLease({
+                runId,
+                workerId: runtime.workerId,
+                heartbeatAt: claimedAt,
+                leaseExpiresAt,
+            });
+        }
+        if (runtime.concurrencyConfig.heartbeatIntervalMs <= 0) {
+            return;
+        }
+        const timer = setInterval(() => {
+            void runtime.persistence.renewRunLease({
+                runId,
+                workerId: runtime.workerId,
+                heartbeatAt: new Date().toISOString(),
+                leaseExpiresAt: new Date(Date.now() + runtime.concurrencyConfig.leaseMs).toISOString(),
+            });
+        }, runtime.concurrencyConfig.heartbeatIntervalMs);
+        timer.unref?.();
+        stopHeartbeat = () => {
+            clearInterval(timer);
+        };
+    };
+    const releaseLease = async () => {
+        stopHeartbeat();
+        if (runId) {
+            await runtime.persistence.releaseRunClaim(runId);
+        }
+    };
+    const releaseAndAdvance = async (shiftNext) => {
+        await releaseLease();
+        runtime.setActiveRunSlots(Math.max(0, runtime.getActiveRunSlots() - 1));
+        const next = shiftNext();
+        void next?.activate();
+    };
+    const maxConcurrentRuns = runtime.concurrencyConfig.maxConcurrentRuns;
+    if (!maxConcurrentRuns) {
+        await beginLease("direct-heartbeat");
+        return async () => {
+            await releaseLease();
+        };
+    }
+    const canActivateImmediately = runtime.getActiveRunSlots() < maxConcurrentRuns;
+    const useDirectHeartbeatFastPath = canActivateImmediately && maxConcurrentRuns > 1;
+    if (canActivateImmediately) {
+        runtime.setActiveRunSlots(runtime.getActiveRunSlots() + 1);
+        if (threadId && runId && !useDirectHeartbeatFastPath) {
+            await runtime.persistence.enqueueRun({ threadId, runId, priority });
+        }
+        await beginLease(useDirectHeartbeatFastPath ? "direct-heartbeat" : "queue-claim");
+        let released = false;
+        return async () => {
+            if (released) {
+                return;
+            }
+            released = true;
+            await releaseAndAdvance(() => shiftNextPendingRunSlot(runtime.pendingRunSlots));
+        };
+    }
+    const activateQueuedRun = async () => {
+        const currentRun = runId ? await runtime.persistence.getRun(runId) : null;
+        if (currentRun?.state === "cancelled") {
+            return "abort";
+        }
+        runtime.setActiveRunSlots(runtime.getActiveRunSlots() + 1);
+        if (threadId && runId) {
+            await runtime.emit(threadId, runId, 4, "run.dequeued", {
+                queuePosition: 0,
+                activeRunCount: runtime.getActiveRunSlots(),
+                maxConcurrentRuns,
+                priority,
+            });
+            await runtime.setRunStateAndEmit(threadId, runId, 5, activeState, {
+                previousState: "queued",
+            });
+            await beginLease("queue-claim");
+        }
+        return "activate";
+    };
+    if (threadId && runId) {
+        await runtime.persistence.enqueueRun({ threadId, runId, priority });
+        const slotAcquisition = new Promise((resolve, reject) => {
+            const displacedEntries = runtime.enqueuePendingRunSlot({
+                threadId,
+                runId,
+                priority,
+                activate: async () => {
+                    try {
+                        resolve(await activateQueuedRun());
+                    }
+                    catch (error) {
+                        reject(error);
+                    }
+                },
+                abort: () => resolve("abort"),
+            });
+            void Promise.all(displacedEntries.map((candidate) => runtime.emit(candidate.threadId, candidate.runId, 3, "run.queued", {
+                queuePosition: candidate.queuePosition,
+                activeRunCount: runtime.getActiveRunSlots(),
+                maxConcurrentRuns,
+                priority: candidate.priority,
+            })));
+        });
+        const queuePosition = runtime.pendingRunSlots.findIndex((entry) => entry.runId === runId) + 1;
+        await runtime.setRunStateAndEmit(threadId, runId, 2, "queued", {
+            previousState: activeState,
+        });
+        await runtime.emit(threadId, runId, 3, "run.queued", {
+            queuePosition,
+            activeRunCount: runtime.getActiveRunSlots(),
+            maxConcurrentRuns,
+            priority,
+        });
+        const slotAcquisitionResult = await slotAcquisition;
+        if (slotAcquisitionResult === "abort") {
+            return async () => undefined;
+        }
+        let released = false;
+        return async () => {
+            if (released) {
+                return;
+            }
+            released = true;
+            await releaseAndAdvance(() => runtime.pendingRunSlots.shift());
+        };
+    }
+    let released = false;
+    return async () => {
+        if (released) {
+            return;
+        }
+        released = true;
+        await releaseAndAdvance(() => shiftNextPendingRunSlot(runtime.pendingRunSlots));
+    };
+}

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

@@ -0,0 +1,53 @@
+import type { CompiledAgentBinding, HarnessEvent, HarnessStreamItem, MessageContent, RunResult, TranscriptMessage } from "../../../contracts/types.js";
+type RuntimeStreamChunk = string | {
+    kind: "content" | "interrupt" | "reasoning" | "step" | "tool-result" | "upstream-event";
+    content?: string;
+    toolName?: string;
+    output?: unknown;
+    isError?: boolean;
+    event?: {
+        format?: string;
+        raw?: unknown;
+    } | Record<string, unknown>;
+};
+type StreamRunOptions = {
+    binding: CompiledAgentBinding;
+    input: MessageContent;
+    invocation: {
+        context?: Record<string, unknown>;
+        state?: Record<string, unknown>;
+        files?: Record<string, unknown>;
+    };
+    threadId: string;
+    runId: string;
+    selectedAgentId: string;
+    isNewThread: boolean;
+    runCreatedEventPromise: Promise<HarnessEvent>;
+    releaseRunSlotPromise: Promise<() => Promise<void>>;
+    loadPriorHistory: (threadId: string, runId: string) => Promise<TranscriptMessage[]>;
+    stream: (binding: CompiledAgentBinding, input: MessageContent, threadId: string, priorHistory: TranscriptMessage[], options: {
+        context?: Record<string, unknown>;
+        state?: Record<string, unknown>;
+        files?: Record<string, unknown>;
+        runId: string;
+    }) => AsyncIterable<RuntimeStreamChunk>;
+    invokeWithHistory: (binding: CompiledAgentBinding, input: 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, input: 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>;
+};
+export declare function streamHarnessRun(options: StreamRunOptions): AsyncGenerator<HarnessStreamItem>;
+export {};

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

@@ -0,0 +1,304 @@
+import { AGENT_INTERRUPT_SENTINEL_PREFIX, RuntimeOperationTimeoutError } from "../../agent-runtime-adapter.js";
+import { normalizeUpstreamRuntimeEvent } from "../../parsing/stream-event-parsing.js";
+import { renderRuntimeFailure, renderToolFailure } from "../../support/harness-support.js";
+import { createContentBlocksItem, createToolResultKey, emitOutputDeltaAndCreateItem, } from "../events/streaming.js";
+function normalizeStreamChunk(chunk) {
+    if (typeof chunk === "string") {
+        if (chunk.startsWith(AGENT_INTERRUPT_SENTINEL_PREFIX)) {
+            return { kind: "interrupt", content: chunk.slice(AGENT_INTERRUPT_SENTINEL_PREFIX.length) };
+        }
+        return { kind: "content", content: chunk };
+    }
+    if (chunk.kind === "upstream-event") {
+        return { kind: "upstream-event", event: (chunk.event ?? {}) };
+    }
+    if (chunk.kind === "interrupt") {
+        return { kind: "interrupt", content: chunk.content };
+    }
+    if (chunk.kind === "reasoning") {
+        return { kind: "reasoning", content: chunk.content ?? "" };
+    }
+    if (chunk.kind === "step") {
+        return { kind: "step", content: chunk.content ?? "" };
+    }
+    if (chunk.kind === "tool-result") {
+        return {
+            kind: "tool-result",
+            toolName: chunk.toolName ?? "unknown_tool",
+            output: chunk.output,
+            isError: chunk.isError,
+        };
+    }
+    return { kind: "content", content: chunk.content ?? "" };
+}
+function isUpstreamRuntimeEvent(event) {
+    return event.format === "langgraph-v2" && "normalized" in event && "streamPart" in event;
+}
+export async function* streamHarnessRun(options) {
+    const priorHistoryPromise = Promise.resolve(options.isNewThread ? [] : undefined).then((historyHint) => historyHint ?? options.loadPriorHistory(options.threadId, options.runId));
+    yield { type: "event", event: await options.runCreatedEventPromise };
+    let releaseRunSlot = async () => undefined;
+    let emitted = false;
+    let streamActivityObserved = false;
+    const emitOutputDelta = (content) => emitOutputDeltaAndCreateItem(options.emit, options.threadId, options.runId, options.selectedAgentId, content);
+    try {
+        const [priorHistory, acquiredReleaseRunSlot] = await Promise.all([
+            priorHistoryPromise,
+            options.releaseRunSlotPromise,
+        ]).then(([loadedPriorHistory, resolvedReleaseRunSlot]) => [loadedPriorHistory, resolvedReleaseRunSlot]);
+        releaseRunSlot = acquiredReleaseRunSlot;
+        let assistantOutput = "";
+        const toolErrors = [];
+        let lastToolResultKey = null;
+        for await (const rawChunk of options.stream(options.binding, options.input, options.threadId, priorHistory, {
+            context: options.invocation.context,
+            state: options.invocation.state,
+            files: options.invocation.files,
+            runId: options.runId,
+        })) {
+            if (!rawChunk) {
+                continue;
+            }
+            streamActivityObserved = true;
+            const normalizedChunk = normalizeStreamChunk(rawChunk);
+            if (normalizedChunk.kind === "upstream-event") {
+                const rawEvent = normalizedChunk.event;
+                yield {
+                    type: "upstream-event",
+                    threadId: options.threadId,
+                    runId: options.runId,
+                    agentId: options.selectedAgentId,
+                    event: isUpstreamRuntimeEvent(rawEvent)
+                        ? rawEvent
+                        : normalizeUpstreamRuntimeEvent(rawEvent.raw ?? rawEvent),
+                };
+                continue;
+            }
+            if (normalizedChunk.kind === "interrupt") {
+                const checkpointRef = `checkpoints/${options.threadId}/${options.runId}/cp-1`;
+                const waitingEvent = await options.setRunStateAndEmit(options.threadId, options.runId, 6, "waiting_for_approval", {
+                    previousState: "running",
+                    checkpointRef,
+                });
+                const approvalRequest = await options.requestApprovalAndEmit(options.threadId, options.runId, options.input, normalizedChunk.content, checkpointRef, 7);
+                yield { type: "event", event: waitingEvent };
+                yield { type: "event", event: approvalRequest.event };
+                yield {
+                    type: "result",
+                    result: {
+                        threadId: options.threadId,
+                        runId: options.runId,
+                        agentId: options.selectedAgentId,
+                        state: "waiting_for_approval",
+                        output: assistantOutput,
+                        finalMessageText: assistantOutput,
+                        interruptContent: normalizedChunk.content,
+                        approvalId: approvalRequest.approval.approvalId,
+                        pendingActionId: approvalRequest.approval.pendingActionId,
+                    },
+                };
+                return;
+            }
+            if (normalizedChunk.kind === "reasoning") {
+                await options.emit(options.threadId, options.runId, 3, "reasoning.delta", {
+                    content: normalizedChunk.content,
+                });
+                yield {
+                    type: "reasoning",
+                    threadId: options.threadId,
+                    runId: options.runId,
+                    agentId: options.selectedAgentId,
+                    content: normalizedChunk.content,
+                };
+                continue;
+            }
+            if (normalizedChunk.kind === "step") {
+                yield {
+                    type: "step",
+                    threadId: options.threadId,
+                    runId: options.runId,
+                    agentId: options.selectedAgentId,
+                    content: normalizedChunk.content,
+                };
+                continue;
+            }
+            if (normalizedChunk.kind === "tool-result") {
+                const toolResultKey = createToolResultKey(normalizedChunk.toolName, normalizedChunk.output, normalizedChunk.isError);
+                if (toolResultKey === lastToolResultKey) {
+                    continue;
+                }
+                lastToolResultKey = toolResultKey;
+                if (normalizedChunk.isError) {
+                    toolErrors.push(renderToolFailure(normalizedChunk.toolName, normalizedChunk.output));
+                }
+                yield {
+                    type: "tool-result",
+                    threadId: options.threadId,
+                    runId: options.runId,
+                    agentId: options.selectedAgentId,
+                    toolName: normalizedChunk.toolName,
+                    output: normalizedChunk.output,
+                    isError: normalizedChunk.isError,
+                };
+                continue;
+            }
+            emitted = true;
+            assistantOutput += normalizedChunk.content;
+            yield await emitOutputDelta(normalizedChunk.content);
+        }
+        if (!assistantOutput && toolErrors.length > 0) {
+            assistantOutput = toolErrors.join("\n\n");
+            emitted = true;
+            yield await emitOutputDelta(assistantOutput);
+        }
+        if (!assistantOutput) {
+            const actual = await options.invokeWithHistory(options.binding, options.input, options.threadId, options.runId);
+            if (Array.isArray(actual.contentBlocks) && actual.contentBlocks.length > 0) {
+                yield createContentBlocksItem(options.threadId, options.runId, options.selectedAgentId, actual.contentBlocks);
+            }
+            if (actual.output) {
+                assistantOutput = actual.output;
+                emitted = true;
+                yield await emitOutputDelta(actual.output);
+            }
+        }
+        await options.appendAssistantMessage(options.threadId, options.runId, assistantOutput);
+        yield {
+            type: "result",
+            result: {
+                threadId: options.threadId,
+                runId: options.runId,
+                agentId: options.selectedAgentId,
+                state: "completed",
+                output: assistantOutput,
+                finalMessageText: assistantOutput,
+            },
+        };
+        yield {
+            type: "event",
+            event: await options.setRunStateAndEmit(options.threadId, options.runId, 6, "completed", {
+                previousState: "running",
+            }),
+        };
+    }
+    catch (error) {
+        if (emitted || streamActivityObserved) {
+            const runtimeFailure = renderRuntimeFailure(error);
+            yield {
+                type: "event",
+                event: await options.setRunStateAndEmit(options.threadId, options.runId, 6, "failed", {
+                    previousState: "running",
+                    error: error instanceof Error ? error.message : String(error),
+                }),
+            };
+            yield {
+                type: "content",
+                threadId: options.threadId,
+                runId: options.runId,
+                agentId: options.selectedAgentId,
+                content: runtimeFailure,
+            };
+            yield {
+                type: "result",
+                result: {
+                    threadId: options.threadId,
+                    runId: options.runId,
+                    agentId: options.selectedAgentId,
+                    state: "failed",
+                    output: runtimeFailure,
+                    finalMessageText: runtimeFailure,
+                },
+            };
+            return;
+        }
+        if (error instanceof RuntimeOperationTimeoutError && error.stage === "invoke") {
+            const runtimeFailure = renderRuntimeFailure(error);
+            yield {
+                type: "event",
+                event: await options.setRunStateAndEmit(options.threadId, options.runId, 6, "failed", {
+                    previousState: "running",
+                    error: error.message,
+                }),
+            };
+            yield {
+                type: "content",
+                threadId: options.threadId,
+                runId: options.runId,
+                agentId: options.selectedAgentId,
+                content: runtimeFailure,
+            };
+            yield {
+                type: "result",
+                result: {
+                    threadId: options.threadId,
+                    runId: options.runId,
+                    agentId: options.selectedAgentId,
+                    state: "failed",
+                    output: runtimeFailure,
+                    finalMessageText: runtimeFailure,
+                },
+            };
+            return;
+        }
+        try {
+            const actual = await options.invokeWithHistory(options.binding, options.input, options.threadId, options.runId);
+            await options.appendAssistantMessage(options.threadId, options.runId, actual.output);
+            if (Array.isArray(actual.contentBlocks) && actual.contentBlocks.length > 0) {
+                yield createContentBlocksItem(options.threadId, options.runId, options.selectedAgentId, actual.contentBlocks);
+            }
+            if (actual.output) {
+                yield await emitOutputDelta(actual.output);
+            }
+            yield {
+                type: "result",
+                result: {
+                    ...actual,
+                    threadId: options.threadId,
+                    runId: options.runId,
+                    agentId: options.selectedAgentId,
+                },
+            };
+            yield {
+                type: "event",
+                event: await options.setRunStateAndEmit(options.threadId, options.runId, 6, actual.state, {
+                    previousState: "running",
+                }),
+            };
+            return;
+        }
+        catch (invokeError) {
+            await options.emitSyntheticFallback(options.threadId, options.runId, options.selectedAgentId, invokeError);
+            const runtimeFailure = renderRuntimeFailure(invokeError);
+            yield {
+                type: "event",
+                event: await options.setRunStateAndEmit(options.threadId, options.runId, 6, "failed", {
+                    previousState: "running",
+                    error: invokeError instanceof Error ? invokeError.message : String(invokeError),
+                }),
+            };
+            yield {
+                type: "content",
+                threadId: options.threadId,
+                runId: options.runId,
+                agentId: options.selectedAgentId,
+                content: runtimeFailure,
+            };
+            yield {
+                type: "result",
+                result: {
+                    threadId: options.threadId,
+                    runId: options.runId,
+                    agentId: options.selectedAgentId,
+                    state: "failed",
+                    output: runtimeFailure,
+                    finalMessageText: runtimeFailure,
+                },
+            };
+            return;
+        }
+    }
+    finally {
+        await options.clearRunRequest(options.threadId, options.runId);
+        await releaseRunSlot();
+    }
+}