@botbotgo/agent-harness 0.0.100 → 0.0.102

package/dist/runtime/adapter/stream-runtime.d.ts

@@ -0,0 +1,46 @@
+import type { CompiledAgentBinding, CompiledTool, MessageContent, TranscriptMessage } from "../../contracts/types.js";
+import type { RuntimeStreamChunk } from "../parsing/stream-event-parsing.js";
+import type { ToolNameMapping } from "./tool/tool-name-mapping.js";
+type RunnableLike = {
+    stream?: (input: unknown, config?: Record<string, unknown>) => Promise<AsyncIterable<unknown>>;
+    streamEvents?: (input: unknown, config?: Record<string, unknown>) => Promise<AsyncIterable<unknown>>;
+};
+export declare function streamRuntimeExecution(options: {
+    binding: CompiledAgentBinding;
+    input: MessageContent;
+    threadId: string;
+    history: TranscriptMessage[];
+    runtimeOptions: {
+        context?: Record<string, unknown>;
+        state?: Record<string, unknown>;
+        files?: Record<string, unknown>;
+        runId?: string;
+    };
+    primaryTools: CompiledTool[];
+    toolNameMapping: ToolNameMapping;
+    forceInvokeFallback: boolean;
+    canUseDirectModelStream: boolean;
+    langChainStreamModel?: {
+        stream?: (input: unknown) => Promise<AsyncIterable<unknown>>;
+    };
+    createRunnable: () => Promise<RunnableLike>;
+    withTimeout: <T>(producer: () => T | Promise<T>, timeoutMs: number | undefined, operation: string, stage?: "stream" | "invoke") => Promise<T>;
+    iterateWithTimeout: <T>(iterable: AsyncIterable<T>, timeoutMs: number | undefined, operation: string, deadlineAt?: number, deadlineTimeoutMs?: number) => AsyncGenerator<T>;
+    invokeTimeoutMs?: number;
+    streamIdleTimeoutMs?: number;
+    streamDeadlineAt?: number;
+    invoke: (binding: CompiledAgentBinding, input: MessageContent, threadId: string, runId: string, resumePayload?: unknown, history?: TranscriptMessage[], options?: {
+        context?: Record<string, unknown>;
+        state?: Record<string, unknown>;
+        files?: Record<string, unknown>;
+    }) => Promise<{
+        output: string;
+        metadata?: Record<string, unknown>;
+    }>;
+    applyStrictToolJsonInstruction: (binding: CompiledAgentBinding) => CompiledAgentBinding;
+    getSystemPrompt: (binding: CompiledAgentBinding) => string | undefined;
+    isLangChainBinding: (binding: CompiledAgentBinding) => boolean;
+    isDeepAgentBinding: (binding: CompiledAgentBinding) => boolean;
+    countConfiguredTools: (binding: CompiledAgentBinding) => number;
+}): AsyncGenerator<RuntimeStreamChunk | string>;
+export {};

package/dist/runtime/adapter/stream-runtime.js

@@ -0,0 +1,93 @@
+import { isToolCallParseFailure, sanitizeVisibleText, } from "../parsing/output-parsing.js";
+import { buildInvocationRequest } from "./model/invocation-request.js";
+import { buildRawModelMessages } from "./model/message-assembly.js";
+import { projectRuntimeStreamEvent, createStreamEventProjectionState } from "./stream-event-projection.js";
+import { projectTextStreamChunks } from "./stream-text-consumption.js";
+import { computeRemainingTimeoutMs } from "./resilience.js";
+export async function* streamRuntimeExecution(options) {
+    const request = buildInvocationRequest(options.binding, options.history, options.input, options.runtimeOptions);
+    try {
+        if (options.isLangChainBinding(options.binding) && options.canUseDirectModelStream && options.langChainStreamModel?.stream) {
+            const stream = await options.withTimeout(() => options.langChainStreamModel.stream(buildRawModelMessages(options.binding, options.getSystemPrompt(options.binding), options.history, options.input)), computeRemainingTimeoutMs(options.streamDeadlineAt, options.invokeTimeoutMs), "model stream start", "stream");
+            let emitted = false;
+            const projected = projectTextStreamChunks(options.iterateWithTimeout(stream, options.streamIdleTimeoutMs, "model stream", options.streamDeadlineAt, options.invokeTimeoutMs));
+            let nextChunk = await projected.next();
+            while (!nextChunk.done) {
+                if (nextChunk.value.kind === "content") {
+                    emitted = true;
+                }
+                yield nextChunk.value;
+                nextChunk = await projected.next();
+            }
+            if (nextChunk.value.emittedContent || emitted) {
+                return;
+            }
+        }
+        const runnable = await options.createRunnable();
+        if (!options.forceInvokeFallback && typeof runnable.streamEvents === "function") {
+            const events = await options.withTimeout(() => runnable.streamEvents(request, { configurable: { thread_id: options.threadId, run_id: options.runtimeOptions.runId }, version: "v2", ...(options.runtimeOptions.context ? { context: options.runtimeOptions.context } : {}) }), computeRemainingTimeoutMs(options.streamDeadlineAt, options.invokeTimeoutMs), "agent streamEvents start", "stream");
+            const projectionState = createStreamEventProjectionState();
+            for await (const event of options.iterateWithTimeout(events, options.streamIdleTimeoutMs, "agent streamEvents", options.streamDeadlineAt, options.invokeTimeoutMs)) {
+                const projectedChunks = projectRuntimeStreamEvent({
+                    event,
+                    allowVisibleStreamDeltas: options.isLangChainBinding(options.binding),
+                    includeStateStreamOutput: options.isDeepAgentBinding(options.binding),
+                    toolNameMapping: options.toolNameMapping,
+                    primaryTools: options.primaryTools,
+                    state: projectionState,
+                });
+                for (const chunk of projectedChunks) {
+                    yield chunk;
+                }
+            }
+            if (projectionState.emittedOutput || projectionState.emittedToolResult || projectionState.emittedToolError) {
+                return;
+            }
+        }
+        if (!options.forceInvokeFallback && options.isLangChainBinding(options.binding) && typeof runnable.stream === "function") {
+            const stream = await options.withTimeout(() => runnable.stream(request, { configurable: { thread_id: options.threadId, run_id: options.runtimeOptions.runId } }), computeRemainingTimeoutMs(options.streamDeadlineAt, options.invokeTimeoutMs), "agent stream start", "stream");
+            let emitted = false;
+            const projected = projectTextStreamChunks(options.iterateWithTimeout(stream, options.streamIdleTimeoutMs, "agent stream", options.streamDeadlineAt, options.invokeTimeoutMs));
+            let nextChunk = await projected.next();
+            while (!nextChunk.done) {
+                if (nextChunk.value.kind === "content") {
+                    emitted = true;
+                }
+                yield nextChunk.value;
+                nextChunk = await projected.next();
+            }
+            if (nextChunk.value.emittedContent || emitted) {
+                return;
+            }
+        }
+        const result = await options.invoke(options.binding, options.input, options.threadId, options.runtimeOptions.runId ?? options.threadId, undefined, options.history, options.runtimeOptions);
+        const executedToolResults = Array.isArray(result.metadata?.executedToolResults)
+            ? result.metadata.executedToolResults
+            : [];
+        for (const toolResult of executedToolResults) {
+            yield {
+                kind: "tool-result",
+                toolName: toolResult.toolName,
+                output: toolResult.output,
+                isError: toolResult.isError,
+            };
+        }
+        if (result.output) {
+            yield { kind: "content", content: sanitizeVisibleText(result.output) };
+        }
+    }
+    catch (error) {
+        if (options.countConfiguredTools(options.binding) > 0 &&
+            error instanceof Error &&
+            error.message.includes("does not support tool binding")) {
+            throw error;
+        }
+        if (!isToolCallParseFailure(error)) {
+            throw error;
+        }
+        const retried = await options.invoke(options.applyStrictToolJsonInstruction(options.binding), options.input, options.threadId, options.runtimeOptions.runId ?? options.threadId, undefined, options.history, options.runtimeOptions);
+        if (retried.output) {
+            yield { kind: "content", content: sanitizeVisibleText(retried.output) };
+        }
+    }
+}

package/dist/runtime/agent-runtime-adapter.d.ts

@@ -29,28 +29,17 @@ export declare class AgentRuntimeAdapter {
     private createModelFallbackRunnable;
     private applyStrictToolJsonInstruction;
     private resolveModel;
-    private buildToolNameMapping;
-    private buildSlashCommandSkillInstruction;
-    private buildInvocationRequest;
-    private buildRawModelMessages;
     private resolveTools;
-    private compileInterruptOn;
-    private resolveInterruptOn;
     private resolveFilesystemBackend;
     private resolveBuiltinMiddlewareBackend;
+    private createDeclaredMiddlewareResolverOptions;
     private invokeBuiltinTaskTool;
     private resolveBuiltinMiddlewareTools;
     private resolveAutomaticSummarizationMiddleware;
     private resolveLangChainAutomaticMiddleware;
-    private resolveDeepAgentAutomaticMiddleware;
     private resolveMiddleware;
-    private resolveCheckpointer;
     private resolveSubagents;
     private createLangChainRunnable;
-    private extractInvocationRequestText;
-    private prependSystemMessage;
-    private replaceLastUserMessage;
-    private extractExecutedToolResults;
     private createRunnable;
     private createDeepAgentRunnable;
     create(binding: CompiledAgentBinding): Promise<RunnableLike>;