@botbotgo/agent-harness 0.0.101 → 0.0.103

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();
+    }
+}

package/dist/runtime/harness/run/thread-records.d.ts

@@ -0,0 +1,21 @@
+import type { ApprovalRecord, ThreadRecord, ThreadSummary } from "../../../contracts/types.js";
+import type { RuntimePersistence } from "../../../persistence/types.js";
+export declare function getThreadRecord(input: {
+    persistence: RuntimePersistence;
+    getSession: (threadId: string) => Promise<ThreadSummary | null>;
+}, threadId: string): Promise<ThreadRecord | null>;
+export declare function listPublicApprovals(input: {
+    persistence: RuntimePersistence;
+}, filter?: {
+    status?: ApprovalRecord["status"];
+    threadId?: string;
+    runId?: string;
+}): Promise<ApprovalRecord[]>;
+export declare function getPublicApproval(input: {
+    persistence: RuntimePersistence;
+}, approvalId: string): Promise<ApprovalRecord | null>;
+export declare function deleteThreadRecord(input: {
+    getThread: (threadId: string) => Promise<ThreadRecord | null>;
+    deleteThread: (threadId: string) => Promise<boolean>;
+    deleteThreadCheckpoints: (threadId: string) => Promise<void>;
+}, threadId: string): Promise<boolean>;

package/dist/runtime/harness/run/thread-records.js

@@ -0,0 +1,59 @@
+import { isTerminalRunState, toPublicApprovalRecord } from "./helpers.js";
+export async function getThreadRecord(input, threadId) {
+    const [threadSummary, meta, messages, runs] = await Promise.all([
+        input.getSession(threadId),
+        input.persistence.getThreadMeta(threadId),
+        input.persistence.listThreadMessages(threadId, 200),
+        input.persistence.listThreadRuns(threadId),
+    ]);
+    if (!threadSummary || !meta) {
+        return null;
+    }
+    const latestRunId = threadSummary.latestRunId;
+    const latestApprovals = await input.persistence.getRunApprovals(threadId, latestRunId);
+    const pendingApproval = latestApprovals
+        .filter((approval) => approval.status === "pending")
+        .sort((left, right) => right.requestedAt.localeCompare(left.requestedAt))[0];
+    return {
+        threadId,
+        entryAgentId: meta.entryAgentId,
+        currentState: threadSummary.status,
+        latestRunId,
+        createdAt: meta.createdAt,
+        updatedAt: threadSummary.updatedAt,
+        messages,
+        runs,
+        pendingDecision: pendingApproval
+            ? {
+                approvalId: pendingApproval.approvalId,
+                pendingActionId: pendingApproval.pendingActionId,
+                toolName: pendingApproval.toolName,
+                allowedDecisions: pendingApproval.allowedDecisions,
+                requestedAt: pendingApproval.requestedAt,
+            }
+            : undefined,
+    };
+}
+export async function listPublicApprovals(input, filter) {
+    const approvals = await input.persistence.listApprovals(filter);
+    return approvals.map((approval) => toPublicApprovalRecord(approval));
+}
+export async function getPublicApproval(input, approvalId) {
+    const approval = await input.persistence.getApproval(approvalId);
+    return approval ? toPublicApprovalRecord(approval) : null;
+}
+export async function deleteThreadRecord(input, threadId) {
+    const thread = await input.getThread(threadId);
+    if (!thread) {
+        return false;
+    }
+    const activeRun = thread.runs.find((run) => !isTerminalRunState(run.state));
+    if (activeRun) {
+        throw new Error(`Cannot delete thread ${threadId} while run ${activeRun.runId} is ${activeRun.state}`);
+    }
+    const deleted = await input.deleteThread(threadId);
+    if (deleted) {
+        await input.deleteThreadCheckpoints(threadId);
+    }
+    return deleted;
+}