@botbotgo/agent-harness 0.0.100 → 0.0.102

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

@@ -3,28 +3,25 @@ import { Command, MemorySaver } from "@langchain/langgraph";
 import { HumanMessage } from "@langchain/core/messages";
 import { DEFAULT_SUBAGENT_PROMPT, createDeepAgent, createMemoryMiddleware, createPatchToolCallsMiddleware, createSkillsMiddleware, createSummarizationMiddleware, createSubAgentMiddleware, FilesystemBackend, StateBackend, } from "deepagents";
 import { createAgent, humanInTheLoopMiddleware } from "langchain";
-import { extractToolFallbackContext, extractVisibleOutput, isToolCallParseFailure, STRICT_TOOL_JSON_INSTRUCTION, sanitizeVisibleText, wrapResolvedModel, } from "./parsing/output-parsing.js";
+import { extractToolFallbackContext, extractVisibleOutput, isToolCallParseFailure, STRICT_TOOL_JSON_INSTRUCTION, wrapResolvedModel, } from "./parsing/output-parsing.js";
 import { readStreamDelta, } from "./parsing/stream-event-parsing.js";
 import { wrapToolForExecution } from "./adapter/tool/tool-hitl.js";
 import { resolveDeclaredMiddleware } from "./adapter/tool/declared-middleware.js";
-import { extractMessageText } from "../utils/message-content.js";
 import { applyDeepAgentDelegationPromptCompatibility, materializeDeepAgentSkillSourcePaths, } from "./adapter/compat/deepagent-compat.js";
 import { buildToolNameMapping, } from "./adapter/tool/tool-name-mapping.js";
 import { createBuiltinMiddlewareTools } from "./adapter/tool/builtin-middleware-tools.js";
 import { finalizeInvocationResult } from "./adapter/invocation-result.js";
-import { runLocalToolInvocationLoop } from "./adapter/local-tool-invocation.js";
-import { createStreamEventProjectionState, projectRuntimeStreamEvent } from "./adapter/stream-event-projection.js";
-import { projectTextStreamChunks } from "./adapter/stream-text-consumption.js";
+import { invokeRuntimeWithLocalTools } from "./adapter/invoke-runtime.js";
+import { streamRuntimeExecution } from "./adapter/stream-runtime.js";
 import { buildDeepAgentRunnableConfig } from "./adapter/deepagent-runnable-config.js";
 import { buildLangChainRunnableConfig } from "./adapter/langchain-runnable-config.js";
 import { computeRemainingTimeoutMs, isRetryableProviderError, resolveBindingTimeout, resolveProviderRetryPolicy, resolveStreamIdleTimeout, } from "./adapter/resilience.js";
 import { createResolvedModel } from "./adapter/model/model-providers.js";
-import { buildInvocationRequest, buildSlashCommandSkillInstruction, } from "./adapter/model/invocation-request.js";
+import { buildInvocationRequest, } from "./adapter/model/invocation-request.js";
 import { compileInterruptOn } from "./adapter/tool/interrupt-policy.js";
-import { buildRawModelMessages } from "./adapter/model/message-assembly.js";
 import { asStructuredExecutableTool, hasCallableToolHandler, normalizeResolvedToolSchema, wrapResolvedToolWithModelFacingName, } from "./adapter/tool/resolved-tool.js";
 import { instantiateProviderTool } from "./adapter/tool/provider-tool.js";
-import { asObject, countConfiguredTools, hasConfiguredMiddlewareKind, hasConfiguredSubagentSupport, isObject, isRecord, sleep, } from "./adapter/runtime-adapter-support.js";
+import { countConfiguredTools, hasConfiguredMiddlewareKind, hasConfiguredSubagentSupport, isObject, isRecord, sleep, } from "./adapter/runtime-adapter-support.js";
 export { applyDeepAgentDelegationPromptCompatibility, materializeDeepAgentSkillSourcePaths, relativizeDeepAgentSkillSourcePaths, shouldRelaxDeepAgentDelegationPrompt, } from "./adapter/compat/deepagent-compat.js";
 export { buildAuthOmittingFetch, normalizeOpenAICompatibleInit } from "./adapter/compat/openai-compatible.js";
 export { buildToolNameMapping, createModelFacingToolNameCandidates, createModelFacingToolNameLookupCandidates, resolveModelFacingToolName, sanitizeToolNameForModel, } from "./adapter/tool/tool-name-mapping.js";
@@ -227,21 +224,9 @@ export class AgentRuntimeAdapter {
             throw error;
         }
     }
-    buildToolNameMapping(tools) {
-        return buildToolNameMapping(tools);
-    }
-    buildSlashCommandSkillInstruction(binding, input) {
-        return buildSlashCommandSkillInstruction(binding, input);
-    }
-    buildInvocationRequest(binding, history, input, options = {}) {
-        return buildInvocationRequest(binding, history, input, options);
-    }
-    buildRawModelMessages(binding, systemPrompt, history, input) {
-        return buildRawModelMessages(binding, systemPrompt, history, input);
-    }
     resolveTools(tools, binding) {
         const resolved = this.options.toolResolver ? this.options.toolResolver(tools.map((tool) => tool.id), binding) : [];
-        const toolNameMapping = this.buildToolNameMapping(tools);
+        const toolNameMapping = buildToolNameMapping(tools);
         return tools.flatMap((compiledTool, index) => {
             const resolvedTool = resolved[index] ?? (compiledTool.type === "provider" ? instantiateProviderTool(compiledTool) : undefined);
             if (resolvedTool === undefined) {
@@ -256,12 +241,6 @@ export class AgentRuntimeAdapter {
             return modelFacingName === compiledTool.name ? wrappedTool : wrapResolvedToolWithModelFacingName(wrappedTool, modelFacingName);
         });
     }
-    compileInterruptOn(tools, compatibilityRules) {
-        return compileInterruptOn(tools, compatibilityRules);
-    }
-    resolveInterruptOn(binding) {
-        return this.compileInterruptOn(getBindingPrimaryTools(binding), getBindingInterruptCompatibilityRules(binding));
-    }
     resolveFilesystemBackend(binding) {
         const filesystemConfig = getBindingLangChainParams(binding)?.filesystem;
         const configuredRootDir = typeof filesystemConfig?.rootDir === "string" && filesystemConfig.rootDir.trim().length > 0
@@ -299,6 +278,21 @@ export class AgentRuntimeAdapter {
         }
         return new StateBackend(runtimeLike);
     }
+    createDeclaredMiddlewareResolverOptions(binding) {
+        return {
+            resolveModel: (model) => this.resolveModel(model),
+            resolveBackend: (resolvedBinding) => {
+                const targetBinding = resolvedBinding ?? binding;
+                return targetBinding ? this.options.backendResolver?.(targetBinding) : undefined;
+            },
+            resolveFilesystemBackend: (resolvedBinding) => {
+                const targetBinding = resolvedBinding ?? binding;
+                return targetBinding ? this.resolveFilesystemBackend(targetBinding) : undefined;
+            },
+            resolveCustom: this.options.declaredMiddlewareResolver,
+            binding,
+        };
+    }
     async invokeBuiltinTaskTool(binding, input, options = {}) {
         if (!isDeepAgentBinding(binding)) {
             throw new Error("The built-in task tool is only available for deepagent bindings.");
@@ -340,7 +334,7 @@ export class AgentRuntimeAdapter {
                 ]),
             ...(selectedSubagent.interruptOn
                 ? [humanInTheLoopMiddleware({
-                        interruptOn: this.compileInterruptOn(selectedSubagent.tools ?? [], selectedSubagent.interruptOn),
+                        interruptOn: compileInterruptOn(selectedSubagent.tools ?? [], selectedSubagent.interruptOn),
                     })]
                 : []),
         ];
@@ -376,13 +370,7 @@ export class AgentRuntimeAdapter {
         if (!primaryModel) {
             return [];
         }
-        return resolveDeclaredMiddleware([{ kind: "summarization", model: primaryModel }], {
-            resolveModel: (model) => this.resolveModel(model),
-            resolveBackend: (resolvedBinding) => this.options.backendResolver?.(resolvedBinding ?? binding),
-            resolveFilesystemBackend: (resolvedBinding) => this.resolveFilesystemBackend(resolvedBinding ?? binding),
-            resolveCustom: this.options.declaredMiddlewareResolver,
-            binding,
-        });
+        return resolveDeclaredMiddleware([{ kind: "summarization", model: primaryModel }], this.createDeclaredMiddlewareResolverOptions(binding));
     }
     async resolveLangChainAutomaticMiddleware(binding) {
         const params = getBindingLangChainParams(binding);
@@ -417,23 +405,11 @@ export class AgentRuntimeAdapter {
         }
         return automaticMiddleware;
     }
-    async resolveDeepAgentAutomaticMiddleware(binding) {
-        if (!isDeepAgentBinding(binding)) {
-            return [];
-        }
-        return [];
-    }
     async resolveMiddleware(binding, interruptOn) {
-        const declarativeMiddleware = await resolveDeclaredMiddleware(getBindingMiddlewareConfigs(binding), {
-            resolveModel: (model) => this.resolveModel(model),
-            resolveBackend: (resolvedBinding) => this.options.backendResolver?.(resolvedBinding ?? binding),
-            resolveFilesystemBackend: (resolvedBinding) => this.resolveFilesystemBackend(resolvedBinding ?? binding),
-            resolveCustom: this.options.declaredMiddlewareResolver,
-            binding,
-        });
+        const declarativeMiddleware = await resolveDeclaredMiddleware(getBindingMiddlewareConfigs(binding), this.createDeclaredMiddlewareResolverOptions(binding));
         const automaticMiddleware = isLangChainBinding(binding)
             ? await this.resolveLangChainAutomaticMiddleware(binding)
-            : await this.resolveDeepAgentAutomaticMiddleware(binding);
+            : [];
         const middleware = [
             ...declarativeMiddleware,
             ...automaticMiddleware,
@@ -444,9 +420,6 @@ export class AgentRuntimeAdapter {
         }
         return middleware;
     }
-    resolveCheckpointer(binding) {
-        return this.options.checkpointerResolver ? this.options.checkpointerResolver(binding) : new MemorySaver();
-    }
     async resolveSubagents(subagents, binding) {
         return Promise.all(subagents.map(async (subagent) => ({
             ...subagent,
@@ -459,27 +432,15 @@ export class AgentRuntimeAdapter {
                 ownerId: `${binding?.agent.id ?? "agent"}-${subagent.name}`,
                 skillPaths: subagent.skills,
             }),
-            interruptOn: this.compileInterruptOn(subagent.tools ?? [], subagent.interruptOn),
+            interruptOn: compileInterruptOn(subagent.tools ?? [], subagent.interruptOn),
             responseFormat: subagent.responseFormat,
             contextSchema: subagent.contextSchema,
-            middleware: (await resolveDeclaredMiddleware(subagent.middleware, {
-                resolveModel: (model) => this.resolveModel(model),
-                resolveBackend: (resolvedBinding) => {
-                    const targetBinding = resolvedBinding ?? binding;
-                    return targetBinding ? this.options.backendResolver?.(targetBinding) : undefined;
-                },
-                resolveFilesystemBackend: (resolvedBinding) => {
-                    const targetBinding = resolvedBinding ?? binding;
-                    return targetBinding ? this.resolveFilesystemBackend(targetBinding) : undefined;
-                },
-                resolveCustom: this.options.declaredMiddlewareResolver,
-                binding,
-            })),
+            middleware: (await resolveDeclaredMiddleware(subagent.middleware, this.createDeclaredMiddlewareResolverOptions(binding))),
         })));
     }
     async createLangChainRunnable(binding, options = {}) {
         const params = getBindingLangChainParams(binding);
-        const interruptOn = this.resolveInterruptOn(binding);
+        const interruptOn = compileInterruptOn(getBindingPrimaryTools(binding), getBindingInterruptCompatibilityRules(binding));
         const model = (await this.resolveModel(params.model));
         const tools = this.resolveTools(params.tools, binding);
         if (tools.length > 0 && typeof model.bindTools !== "function") {
@@ -490,90 +451,12 @@ export class AgentRuntimeAdapter {
             resolvedModel: model,
             resolvedTools: tools,
             resolvedMiddleware: await this.resolveMiddleware(binding, interruptOn),
-            resolvedCheckpointer: this.resolveCheckpointer(binding),
+            resolvedCheckpointer: this.options.checkpointerResolver ? this.options.checkpointerResolver(binding) : new MemorySaver(),
             resolvedStore: this.options.storeResolver?.(binding),
             passthroughOverride: options.passthroughOverride,
             systemPromptOverride: options.systemPromptOverride,
         }));
     }
-    extractInvocationRequestText(request) {
-        if (!isRecord(request) || !Array.isArray(request.messages)) {
-            return "";
-        }
-        for (let index = request.messages.length - 1; index >= 0; index -= 1) {
-            const message = request.messages[index];
-            if (!isRecord(message)) {
-                continue;
-            }
-            const role = typeof message.role === "string" ? message.role : undefined;
-            if (role !== "user") {
-                continue;
-            }
-            return extractMessageText(message.content);
-        }
-        return "";
-    }
-    prependSystemMessage(request, content) {
-        if (!content.trim() || !isRecord(request) || !Array.isArray(request.messages)) {
-            return request;
-        }
-        return {
-            ...request,
-            messages: [{ role: "system", content }, ...request.messages],
-        };
-    }
-    replaceLastUserMessage(request, content) {
-        if (!content.trim() || !isRecord(request) || !Array.isArray(request.messages)) {
-            return request;
-        }
-        const messages = [...request.messages];
-        for (let index = messages.length - 1; index >= 0; index -= 1) {
-            const message = messages[index];
-            if (!isRecord(message) || message.role !== "user") {
-                continue;
-            }
-            messages[index] = {
-                ...message,
-                content,
-            };
-            return {
-                ...request,
-                messages,
-            };
-        }
-        return {
-            ...request,
-            messages: [...messages, { role: "user", content }],
-        };
-    }
-    extractExecutedToolResults(result) {
-        const metadata = asObject(result?.metadata);
-        if (Array.isArray(metadata?.executedToolResults)) {
-            return metadata.executedToolResults;
-        }
-        const messages = Array.isArray(result?.messages) ? result.messages : [];
-        return messages.flatMap((message) => {
-            const typed = asObject(message);
-            const kwargs = asObject(typed?.kwargs);
-            const typeId = Array.isArray(typed?.id) ? typed.id.at(-1) : undefined;
-            const runtimeType = typeof typed?.type === "string" ? typed.type : undefined;
-            if (typeId !== "ToolMessage" && runtimeType !== "tool") {
-                return [];
-            }
-            const toolName = typeof typed?.name === "string"
-                ? typed.name
-                : typeof kwargs?.name === "string"
-                    ? kwargs.name
-                    : "tool";
-            const output = typed?.content ??
-                kwargs?.content ??
-                "";
-            return [{
-                    toolName,
-                    output,
-                }];
-        });
-    }
     async createRunnable(binding) {
         if (getBindingAdapterKind(binding) === "langgraph") {
             throw new Error(`Agent ${binding.agent.id} uses removed backend langgraph; use langchain-v1 or deepagent`);
@@ -595,10 +478,10 @@ export class AgentRuntimeAdapter {
             resolvedTools: this.resolveTools(compatibleParams.tools, binding),
             resolvedMiddleware: await this.resolveMiddleware(binding),
             resolvedSubagents: await this.resolveSubagents(compatibleParams.subagents, binding),
-            resolvedCheckpointer: this.resolveCheckpointer(binding),
+            resolvedCheckpointer: this.options.checkpointerResolver ? this.options.checkpointerResolver(binding) : new MemorySaver(),
             resolvedStore: this.options.storeResolver?.(binding),
             resolvedBackend: this.options.backendResolver?.(binding),
-            resolvedInterruptOn: this.resolveInterruptOn(binding),
+            resolvedInterruptOn: compileInterruptOn(getBindingPrimaryTools(binding), getBindingInterruptCompatibilityRules(binding)),
             resolvedSkills: (await materializeDeepAgentSkillSourcePaths({
                 workspaceRoot: binding.harnessRuntime.workspaceRoot,
                 runRoot: binding.harnessRuntime.runRoot,
@@ -625,9 +508,8 @@ export class AgentRuntimeAdapter {
     }
     async invoke(binding, input, threadId, runId, resumePayload, history = [], options = {}) {
         const request = resumePayload === undefined
-            ? this.buildInvocationRequest(binding, history, input, options)
+            ? buildInvocationRequest(binding, history, input, options)
             : new Command({ resume: resumePayload });
-        let result;
         const callRuntime = async (activeBinding, activeRequest) => {
             return this.invokeWithProviderRetry(activeBinding, async () => {
                 const runnable = await this.create(activeBinding);
@@ -645,64 +527,54 @@ export class AgentRuntimeAdapter {
                 return callRuntime(this.applyStrictToolJsonInstruction(binding), activeRequest);
             }
         };
-        const executedToolResults = [];
-        if (resumePayload !== undefined) {
-            result = await callRuntimeWithToolParseRecovery(request);
-        }
-        else {
-            const primaryTools = getBindingPrimaryTools(binding);
-            const defersToUpstreamHitlExecution = primaryTools.some((tool) => tool.hitl?.enabled === true);
-            if (defersToUpstreamHitlExecution) {
-                result = await callRuntimeWithToolParseRecovery(request);
+        const primaryTools = getBindingPrimaryTools(binding);
+        const resolvedTools = this.resolveTools(primaryTools, binding);
+        const toolNameMapping = buildToolNameMapping(primaryTools);
+        const executableTools = new Map();
+        for (let index = 0; index < primaryTools.length; index += 1) {
+            const compiledTool = primaryTools[index];
+            const resolvedTool = resolvedTools[index];
+            if (!compiledTool || !resolvedTool || !hasCallableToolHandler(resolvedTool)) {
+                continue;
             }
-            else {
-                const resolvedTools = this.resolveTools(primaryTools, binding);
-                const toolNameMapping = this.buildToolNameMapping(primaryTools);
-                const executableTools = new Map();
-                const builtinExecutableTools = await this.resolveBuiltinMiddlewareTools(binding, options);
-                for (let index = 0; index < primaryTools.length; index += 1) {
-                    const compiledTool = primaryTools[index];
-                    const resolvedTool = resolvedTools[index];
-                    if (!compiledTool || !resolvedTool || !hasCallableToolHandler(resolvedTool)) {
-                        continue;
-                    }
-                    const handler = async (toolInput) => {
-                        const callable = typeof resolvedTool.invoke === "function"
-                            ? resolvedTool.invoke
-                            : typeof resolvedTool.call === "function"
-                                ? resolvedTool.call
-                                : resolvedTool.func;
-                        if (!callable) {
-                            throw new Error(`Tool ${compiledTool.name} has no callable handler.`);
-                        }
-                        return Promise.resolve(callable.call(resolvedTool, toolInput, options.context ? { context: options.context } : undefined));
-                    };
-                    const modelFacingName = toolNameMapping.originalToModelFacing.get(compiledTool.name) ?? compiledTool.name;
-                    const normalizedSchema = normalizeResolvedToolSchema(resolvedTool);
-                    executableTools.set(modelFacingName, {
-                        name: compiledTool.name,
-                        schema: normalizedSchema,
-                        invoke: handler,
-                    });
-                    executableTools.set(compiledTool.name, {
-                        name: compiledTool.name,
-                        schema: normalizedSchema,
-                        invoke: handler,
-                    });
+            const handler = async (toolInput) => {
+                const callable = typeof resolvedTool.invoke === "function"
+                    ? resolvedTool.invoke
+                    : typeof resolvedTool.call === "function"
+                        ? resolvedTool.call
+                        : resolvedTool.func;
+                if (!callable) {
+                    throw new Error(`Tool ${compiledTool.name} has no callable handler.`);
                 }
-                const localInvocation = await runLocalToolInvocationLoop({
-                    binding,
-                    request,
-                    primaryTools,
-                    toolNameMapping,
-                    executableTools: executableTools,
-                    builtinExecutableTools: builtinExecutableTools,
-                    callRuntimeWithToolParseRecovery,
-                });
-                result = localInvocation.result;
-                executedToolResults.push(...localInvocation.executedToolResults);
-            }
+                return Promise.resolve(callable.call(resolvedTool, toolInput, options.context ? { context: options.context } : undefined));
+            };
+            const modelFacingName = toolNameMapping.originalToModelFacing.get(compiledTool.name) ?? compiledTool.name;
+            const normalizedSchema = normalizeResolvedToolSchema(resolvedTool);
+            executableTools.set(modelFacingName, {
+                name: compiledTool.name,
+                schema: normalizedSchema,
+                invoke: handler,
+            });
+            executableTools.set(compiledTool.name, {
+                name: compiledTool.name,
+                schema: normalizedSchema,
+                invoke: handler,
+            });
         }
+        const builtinExecutableTools = await this.resolveBuiltinMiddlewareTools(binding, options);
+        const localOrUpstreamInvocation = await invokeRuntimeWithLocalTools({
+            binding,
+            request,
+            resumePayload,
+            primaryTools,
+            defersToUpstreamHitlExecution: primaryTools.some((tool) => tool.hitl?.enabled === true),
+            toolNameMapping,
+            executableTools,
+            builtinExecutableTools: builtinExecutableTools,
+            callRuntimeWithToolParseRecovery,
+        });
+        const result = localOrUpstreamInvocation.result;
+        const executedToolResults = [...localOrUpstreamInvocation.executedToolResults];
         if (!result) {
             throw new Error("Agent invocation returned no result");
         }
@@ -715,113 +587,51 @@ export class AgentRuntimeAdapter {
         });
     }
     async *stream(binding, input, threadId, history = [], options = {}) {
-        try {
-            const invokeTimeoutMs = resolveBindingTimeout(binding);
-            const streamIdleTimeoutMs = resolveStreamIdleTimeout(binding);
-            const streamDeadlineAt = invokeTimeoutMs ? Date.now() + invokeTimeoutMs : undefined;
-            const primaryTools = getBindingPrimaryTools(binding);
-            const toolNameMapping = this.buildToolNameMapping(primaryTools);
-            const primaryModel = getBindingPrimaryModel(binding);
-            const forceInvokeFallback = isLangChainBinding(binding) &&
-                primaryTools.length > 0 &&
-                primaryModel?.provider === "openai-compatible";
-            if (isLangChainBinding(binding)) {
-                const langchainParams = getBindingLangChainParams(binding);
-                const resolvedModel = (await this.resolveModel(langchainParams.model));
-                const tools = this.resolveTools(langchainParams.tools, binding);
-                const canUseDirectModelStream = tools.length === 0 || typeof resolvedModel.bindTools !== "function";
-                const model = canUseDirectModelStream
-                    ? resolvedModel
-                    : typeof resolvedModel.bindTools === "function" && tools.length > 0
-                        ? resolvedModel.bindTools(tools)
-                        : resolvedModel;
-                // For tool-using langchain agents, a raw model.stream pass cannot execute the
-                // agent loop and only adds an extra model round-trip before the runnable path.
-                if (canUseDirectModelStream && typeof model.stream === "function") {
-                    const stream = await this.withTimeout(() => model.stream(this.buildRawModelMessages(binding, getBindingSystemPrompt(binding), history, input)), computeRemainingTimeoutMs(streamDeadlineAt, invokeTimeoutMs), "model stream start", "stream");
-                    let emitted = false;
-                    const projected = projectTextStreamChunks(this.iterateWithTimeout(stream, streamIdleTimeoutMs, "model stream", streamDeadlineAt, 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 this.create(binding);
-            const request = this.buildInvocationRequest(binding, history, input, options);
-            if (!forceInvokeFallback && typeof runnable.streamEvents === "function") {
-                const events = await this.withTimeout(() => runnable.streamEvents(request, { configurable: { thread_id: threadId, run_id: options.runId }, version: "v2", ...(options.context ? { context: options.context } : {}) }), computeRemainingTimeoutMs(streamDeadlineAt, invokeTimeoutMs), "agent streamEvents start", "stream");
-                const projectionState = createStreamEventProjectionState();
-                for await (const event of this.iterateWithTimeout(events, streamIdleTimeoutMs, "agent streamEvents", streamDeadlineAt, invokeTimeoutMs)) {
-                    const projectedChunks = projectRuntimeStreamEvent({
-                        event,
-                        allowVisibleStreamDeltas: isLangChainBinding(binding),
-                        includeStateStreamOutput: isDeepAgentBinding(binding),
-                        toolNameMapping,
-                        primaryTools,
-                        state: projectionState,
-                    });
-                    for (const chunk of projectedChunks) {
-                        yield chunk;
-                    }
-                }
-                if (projectionState.emittedOutput || projectionState.emittedToolResult || projectionState.emittedToolError) {
-                    return;
-                }
-            }
-            if (!forceInvokeFallback && isLangChainBinding(binding) && typeof runnable.stream === "function") {
-                const stream = await this.withTimeout(() => runnable.stream(request, { configurable: { thread_id: threadId, run_id: options.runId } }), computeRemainingTimeoutMs(streamDeadlineAt, invokeTimeoutMs), "agent stream start", "stream");
-                let emitted = false;
-                const projected = projectTextStreamChunks(this.iterateWithTimeout(stream, streamIdleTimeoutMs, "agent stream", streamDeadlineAt, 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 this.invoke(binding, input, threadId, options.runId ?? threadId, undefined, history, options);
-            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 (countConfiguredTools(binding) > 0 &&
-                error instanceof Error &&
-                error.message.includes("does not support tool binding")) {
-                throw error;
-            }
-            if (!isToolCallParseFailure(error)) {
-                throw error;
-            }
-            const retried = await this.invoke(this.applyStrictToolJsonInstruction(binding), input, threadId, options.runId ?? threadId, undefined, history, options);
-            if (retried.output) {
-                yield { kind: "content", content: sanitizeVisibleText(retried.output) };
-            }
-        }
+        const invokeTimeoutMs = resolveBindingTimeout(binding);
+        const streamIdleTimeoutMs = resolveStreamIdleTimeout(binding);
+        const streamDeadlineAt = invokeTimeoutMs ? Date.now() + invokeTimeoutMs : undefined;
+        const primaryTools = getBindingPrimaryTools(binding);
+        const toolNameMapping = buildToolNameMapping(primaryTools);
+        const primaryModel = getBindingPrimaryModel(binding);
+        const forceInvokeFallback = isLangChainBinding(binding) &&
+            primaryTools.length > 0 &&
+            primaryModel?.provider === "openai-compatible";
+        const langchainParams = isLangChainBinding(binding) ? getBindingLangChainParams(binding) : undefined;
+        const resolvedLangChainModel = langchainParams
+            ? (await this.resolveModel(langchainParams.model))
+            : undefined;
+        const resolvedLangChainTools = langchainParams ? this.resolveTools(langchainParams.tools, binding) : [];
+        const canUseDirectModelStream = !!resolvedLangChainModel &&
+            (resolvedLangChainTools.length === 0 || typeof resolvedLangChainModel.bindTools !== "function");
+        const langChainStreamModel = resolvedLangChainModel && canUseDirectModelStream
+            ? resolvedLangChainModel
+            : resolvedLangChainModel && typeof resolvedLangChainModel.bindTools === "function" && resolvedLangChainTools.length > 0
+                ? resolvedLangChainModel.bindTools(resolvedLangChainTools)
+                : undefined;
+        yield* streamRuntimeExecution({
+            binding,
+            input,
+            threadId,
+            history,
+            runtimeOptions: options,
+            primaryTools,
+            toolNameMapping,
+            forceInvokeFallback,
+            canUseDirectModelStream,
+            langChainStreamModel,
+            createRunnable: () => this.create(binding),
+            withTimeout: (producer, timeoutMs, operation, stage) => this.withTimeout(producer, timeoutMs, operation, stage),
+            iterateWithTimeout: (iterable, timeoutMs, operation, deadlineAt, deadlineTimeoutMs) => this.iterateWithTimeout(iterable, timeoutMs, operation, deadlineAt, deadlineTimeoutMs),
+            invokeTimeoutMs: computeRemainingTimeoutMs(streamDeadlineAt, invokeTimeoutMs),
+            streamIdleTimeoutMs,
+            streamDeadlineAt,
+            invoke: (activeBinding, activeInput, activeThreadId, runId, resumePayload, activeHistory, invokeOptions) => this.invoke(activeBinding, activeInput, activeThreadId, runId, resumePayload, activeHistory, invokeOptions),
+            applyStrictToolJsonInstruction: (activeBinding) => this.applyStrictToolJsonInstruction(activeBinding),
+            getSystemPrompt: (activeBinding) => getBindingSystemPrompt(activeBinding),
+            isLangChainBinding,
+            isDeepAgentBinding,
+            countConfiguredTools,
+        });
     }
 }
 export { AgentRuntimeAdapter as RuntimeAdapter, AGENT_INTERRUPT_SENTINEL_PREFIX, AGENT_INTERRUPT_SENTINEL_PREFIX as INTERRUPT_SENTINEL_PREFIX, RuntimeOperationTimeoutError, };

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

@@ -0,0 +1,42 @@
+import type { MessageContent, RunResult, ThreadSummary, WorkspaceBundle } from "../../../contracts/types.js";
+import type { RuntimePersistence } from "../../../persistence/types.js";
+import type { AgentRuntimeAdapter } from "../../agent-runtime-adapter.js";
+import type { ConcurrencyConfig, RecoveryConfig } from "../../../workspace/support/workspace-ref-utils.js";
+type RecoveryBinding = WorkspaceBundle["bindings"] extends Map<any, infer T> ? T : never;
+type StartupRecoveryContext = {
+    persistence: RuntimePersistence;
+    workspace: WorkspaceBundle;
+    runtimeAdapter: AgentRuntimeAdapter;
+    recoveryConfig: RecoveryConfig;
+    concurrencyConfig: ConcurrencyConfig;
+    getBinding: (agentId: string) => RecoveryBinding | undefined;
+    acquireRunSlot: (threadId?: string, runId?: string, activeState?: RunResult["state"], priority?: number) => Promise<() => Promise<void>>;
+    executeQueuedRun: (binding: RecoveryBinding, input: MessageContent, threadId: string, runId: string, agentId: string, options?: {
+        context?: Record<string, unknown>;
+        state?: Record<string, unknown>;
+        files?: Record<string, unknown>;
+        previousState?: RunResult["state"];
+        stateSequence?: number;
+        approvalSequence?: number;
+    }) => Promise<RunResult>;
+    setRunStateAndEmit: (threadId: string, runId: string, sequence: number, state: RunResult["state"], options: {
+        previousState: string | null;
+        checkpointRef?: string | null;
+        error?: string;
+    }) => Promise<unknown>;
+    emit: (threadId: string, runId: string, sequence: number, eventType: string, payload: Record<string, unknown>) => Promise<unknown>;
+    loadRunInput: (threadId: string, runId: string) => Promise<MessageContent>;
+    finalizeContinuedRun: (binding: RecoveryBinding, threadId: string, runId: string, input: MessageContent, actual: RunResult, options: {
+        previousState: RunResult["state"] | null;
+        stateSequence: number;
+        approvalSequence?: number;
+    }) => Promise<RunResult>;
+    supportsRunningReplay: (binding: RecoveryBinding) => boolean;
+    isStaleRunningRun: (thread: ThreadSummary, nowMs?: number) => Promise<boolean>;
+    recordLlmSuccess: (startedAt: number) => void;
+    recordLlmFailure: (startedAt: number) => void;
+};
+export declare function recoverQueuedStartupRun(context: StartupRecoveryContext, thread: ThreadSummary): Promise<boolean>;
+export declare function recoverRunningStartupRun(context: StartupRecoveryContext, thread: ThreadSummary): Promise<boolean>;
+export declare function recoverResumingStartupRun(context: StartupRecoveryContext, thread: ThreadSummary): Promise<boolean>;
+export {};