@botbotgo/agent-harness 0.0.100 → 0.0.102

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.d.ts

@@ -37,10 +37,6 @@ export declare class AgentHarnessRuntime {
     private defaultRunRoot;
     private getDefaultHostAgentId;
     private resolveSelectedAgentId;
-    private resolveStore;
-    private resolveStoreFromConfig;
-    private resolveEmbeddingModel;
-    private resolveVectorStore;
     constructor(workspace: WorkspaceBundle, runtimeAdapterOptions?: RuntimeAdapterOptions);
     private createHealthMonitor;
     private recordLlmSuccess;
@@ -48,8 +44,6 @@ export declare class AgentHarnessRuntime {
     initialize(): Promise<void>;
     subscribe(listener: (event: HarnessEvent) => void): () => void;
     getHealth(): Promise<RuntimeHealthSnapshot>;
-    private getBinding;
-    private listAgentTools;
     private resolveAgentTools;
     private supportsRunningReplay;
     listThreads(filter?: {
@@ -86,34 +80,25 @@ export declare class AgentHarnessRuntime {
     private ensureThreadStarted;
     private loadPriorHistory;
     private loadRunInput;
-    private appendAssistantMessage;
     private getRunCancellation;
-    private expirePendingApprovals;
     private finalizeCancelledRun;
     private invokeWithHistory;
     private resolvePersistedRunPriority;
     private enqueuePendingRunSlot;
     private executeQueuedRun;
-    private checkpointRefForState;
     private finalizeContinuedRun;
-    private emitOutputDeltaAndCreateItem;
-    private createContentBlocksItem;
-    private createToolResultKey;
-    private emitRunCreated;
     private setRunStateAndEmit;
     private requestApprovalAndEmit;
-    private emitSyntheticFallback;
-    private persistApproval;
-    private resolveApprovalRecord;
     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>;
-    private buildResumePayload;
     restartConversation(options: RestartConversationOptions): Promise<RunResult & {
         restart: Record<string, string>;
     }>;