@botbotgo/agent-harness 0.0.107 → 0.0.109

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.106";
+export declare const AGENT_HARNESS_VERSION = "0.0.108";

package/dist/package-version.js

@@ -1 +1 @@
-export const AGENT_HARNESS_VERSION = "0.0.106";
+export const AGENT_HARNESS_VERSION = "0.0.108";

package/dist/runtime/adapter/execution-context.d.ts

@@ -0,0 +1,34 @@
+import type { CompiledAgentBinding, CompiledTool } from "../../contracts/types.js";
+import type { ToolNameMapping } from "./tool/tool-name-mapping.js";
+import { getBindingPrimaryModel } from "../support/compiled-binding.js";
+export declare function buildBindingToolCatalog(input: {
+    binding: CompiledAgentBinding;
+    getToolNameMapping: (binding: CompiledAgentBinding) => ToolNameMapping;
+}): {
+    primaryTools: CompiledTool[];
+    toolNameMapping: ToolNameMapping;
+};
+export declare function buildBindingToolExecutionContext(input: {
+    binding: CompiledAgentBinding;
+    resolveTools: (tools: CompiledTool[], binding?: CompiledAgentBinding) => unknown[];
+    getToolNameMapping: (binding: CompiledAgentBinding) => ToolNameMapping;
+    context?: Record<string, unknown>;
+}): {
+    primaryTools: CompiledTool[];
+    resolvedTools: unknown[];
+    toolNameMapping: ToolNameMapping;
+    executableTools: Map<string, import("./invoke-runtime.js").ExecutableTool>;
+    defersToUpstreamHitlExecution: boolean;
+};
+export declare function resolveLangChainStreamContext(input: {
+    binding: CompiledAgentBinding;
+    resolveModel: (model: NonNullable<ReturnType<typeof getBindingPrimaryModel>>) => Promise<unknown>;
+    resolveTools: (tools: CompiledTool[], binding?: CompiledAgentBinding) => unknown[];
+}): Promise<{
+    primaryTools: CompiledTool[];
+    forceInvokeFallback: boolean;
+    canUseDirectModelStream: boolean;
+    langChainStreamModel: {
+        stream?: (input: unknown) => Promise<AsyncIterable<unknown>>;
+    } | undefined;
+}>;

package/dist/runtime/adapter/execution-context.js

@@ -0,0 +1,52 @@
+import { buildExecutableToolMap } from "./tool-resolution.js";
+import { getBindingLangChainParams, getBindingPrimaryModel, getBindingPrimaryTools, isLangChainBinding } from "../support/compiled-binding.js";
+export function buildBindingToolCatalog(input) {
+    const primaryTools = getBindingPrimaryTools(input.binding);
+    const toolNameMapping = input.getToolNameMapping(input.binding);
+    return {
+        primaryTools,
+        toolNameMapping,
+    };
+}
+export function buildBindingToolExecutionContext(input) {
+    const { primaryTools, toolNameMapping } = buildBindingToolCatalog(input);
+    const resolvedTools = input.resolveTools(primaryTools, input.binding);
+    const executableTools = buildExecutableToolMap({
+        primaryTools,
+        resolvedTools,
+        toolNameMapping,
+        context: input.context,
+    });
+    return {
+        primaryTools,
+        resolvedTools,
+        toolNameMapping,
+        executableTools,
+        defersToUpstreamHitlExecution: primaryTools.some((tool) => tool.hitl?.enabled === true),
+    };
+}
+export async function resolveLangChainStreamContext(input) {
+    const primaryTools = getBindingPrimaryTools(input.binding);
+    const primaryModel = getBindingPrimaryModel(input.binding);
+    const forceInvokeFallback = isLangChainBinding(input.binding) &&
+        primaryTools.length > 0 &&
+        primaryModel?.provider === "openai-compatible";
+    const langchainParams = isLangChainBinding(input.binding) ? getBindingLangChainParams(input.binding) : undefined;
+    const resolvedLangChainModel = langchainParams
+        ? (await input.resolveModel(langchainParams.model))
+        : undefined;
+    const resolvedLangChainTools = langchainParams ? input.resolveTools(langchainParams.tools, input.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;
+    return {
+        primaryTools,
+        forceInvokeFallback,
+        canUseDirectModelStream,
+        langChainStreamModel,
+    };
+}

package/dist/runtime/adapter/middleware-assembly.js

@@ -4,10 +4,32 @@ import { createAgent, humanInTheLoopMiddleware } from "langchain";
 import { createBuiltinMiddlewareTools } from "./tool/builtin-middleware-tools.js";
 import { compileInterruptOn } from "./tool/interrupt-policy.js";
 import { extractToolFallbackContext, extractVisibleOutput } from "../parsing/output-parsing.js";
-import { hasConfiguredMiddlewareKind, hasConfiguredSubagentSupport, isObject, isRecord } from "./runtime-adapter-support.js";
+import { hasConfiguredMiddlewareKind, hasConfiguredSubagentSupport, isRecord } from "./runtime-adapter-support.js";
 import { resolveDeclaredMiddleware } from "./tool/declared-middleware.js";
 import { getBindingDeepAgentParams, getBindingInterruptCompatibilityRules, getBindingLangChainParams, getBindingMiddlewareConfigs, getBindingPrimaryModel, isDeepAgentBinding, isLangChainBinding, } from "../support/compiled-binding.js";
 import { applyDeepAgentDelegationPromptCompatibility, materializeDeepAgentSkillSourcePaths } from "./compat/deepagent-compat.js";
+function buildLangChainContextMiddleware(params) {
+    const middleware = [];
+    const hasSkills = (params.compatibleParams.skills?.length ?? 0) > 0;
+    const hasMemory = (params.compatibleParams.memory?.length ?? 0) > 0;
+    if (!hasSkills && !hasMemory) {
+        return middleware;
+    }
+    const backend = params.resolveFilesystemBackend(params.binding);
+    if (hasSkills) {
+        middleware.push(createSkillsMiddleware({
+            backend,
+            sources: params.compatibleParams.skills,
+        }));
+    }
+    if (hasMemory) {
+        middleware.push(createMemoryMiddleware({
+            backend,
+            sources: params.compatibleParams.memory,
+        }));
+    }
+    return middleware;
+}
 export function resolveBuiltinMiddlewareBackend(input) {
     const runtimeState = {
         ...(input.options?.state ?? {}),
@@ -54,7 +76,7 @@ export async function invokeBuiltinTaskTool(input) {
     if (!params) {
         throw new Error(`Agent ${input.binding.agent.id} has no deepagent params`);
     }
-    const typedInput = isObject(input.toolInput) ? input.toolInput : {};
+    const typedInput = isRecord(input.toolInput) ? input.toolInput : {};
     const description = typeof typedInput.description === "string" ? typedInput.description : "";
     const subagentType = typeof typedInput.subagent_type === "string" ? typedInput.subagent_type : "";
     const builtinBackend = input.resolveBuiltinMiddlewareBackend(input.binding, input.options);
@@ -134,18 +156,11 @@ export async function resolveLangChainAutomaticMiddleware(input) {
     const automaticMiddleware = [];
     automaticMiddleware.push(createPatchToolCallsMiddleware());
     automaticMiddleware.push(...(await input.resolveAutomaticSummarizationMiddleware(input.binding)));
-    if ((compatibleParams.skills?.length ?? 0) > 0) {
-        automaticMiddleware.push(createSkillsMiddleware({
-            backend: input.resolveFilesystemBackend(input.binding),
-            sources: compatibleParams.skills,
-        }));
-    }
-    if ((compatibleParams.memory?.length ?? 0) > 0) {
-        automaticMiddleware.push(createMemoryMiddleware({
-            backend: input.resolveFilesystemBackend(input.binding),
-            sources: compatibleParams.memory,
-        }));
-    }
+    automaticMiddleware.push(...buildLangChainContextMiddleware({
+        binding: input.binding,
+        compatibleParams,
+        resolveFilesystemBackend: input.resolveFilesystemBackend,
+    }));
     if (hasConfiguredSubagentSupport(input.binding)) {
         automaticMiddleware.push(createSubAgentMiddleware({
             defaultModel: (await input.resolveModel(compatibleParams.model)),

package/dist/runtime/adapter/runnable-config.d.ts

@@ -0,0 +1,57 @@
+export type ResolvedRunnableDependencies = {
+    resolvedModel: unknown;
+    resolvedTools: unknown[];
+    resolvedMiddleware: unknown[];
+    resolvedCheckpointer: unknown;
+    resolvedStore: unknown;
+};
+type LangChainRunnableConfigParams = {
+    langchainParams: {
+        passthrough?: Record<string, unknown>;
+        systemPrompt?: string;
+        stateSchema?: unknown;
+        responseFormat?: unknown;
+        contextSchema?: unknown;
+        includeAgentName?: unknown;
+        version?: unknown;
+        name?: unknown;
+        description?: unknown;
+    };
+    resolvedModel: unknown;
+    resolvedTools: unknown[];
+    resolvedMiddleware: unknown[];
+    resolvedCheckpointer: unknown;
+    resolvedStore: unknown;
+    passthroughOverride?: Record<string, unknown>;
+    systemPromptOverride?: string;
+};
+type DeepAgentRunnableConfigParams = {
+    compatibleParams: {
+        passthrough?: Record<string, unknown>;
+        systemPrompt?: string;
+        responseFormat?: unknown;
+        contextSchema?: unknown;
+        name?: unknown;
+        memory?: unknown;
+        generalPurposeAgent?: unknown;
+        taskDescription?: unknown;
+    };
+    resolvedModel: unknown;
+    resolvedTools: unknown[];
+    resolvedMiddleware: unknown[];
+    resolvedSubagents: unknown[];
+    resolvedCheckpointer: unknown;
+    resolvedStore: unknown;
+    resolvedBackend: unknown;
+    resolvedInterruptOn: unknown;
+    resolvedSkills: string[];
+};
+export declare function buildResolvedRunnableConfig(params: {
+    passthrough?: Record<string, unknown>;
+    staticConfig?: Record<string, unknown>;
+    resolved: ResolvedRunnableDependencies;
+    extraConfig?: Record<string, unknown>;
+}): Record<string, unknown>;
+export declare function buildLangChainRunnableConfig(params: LangChainRunnableConfigParams): Record<string, unknown>;
+export declare function buildDeepAgentRunnableConfig(params: DeepAgentRunnableConfigParams): Record<string, unknown>;
+export {};

package/dist/runtime/adapter/runnable-config.js

@@ -0,0 +1,64 @@
+export function buildResolvedRunnableConfig(params) {
+    const { passthrough, staticConfig, resolved, extraConfig } = params;
+    return {
+        ...(passthrough ?? {}),
+        ...(staticConfig ?? {}),
+        model: resolved.resolvedModel,
+        tools: resolved.resolvedTools,
+        middleware: resolved.resolvedMiddleware,
+        checkpointer: resolved.resolvedCheckpointer,
+        store: resolved.resolvedStore,
+        ...(extraConfig ?? {}),
+    };
+}
+export function buildLangChainRunnableConfig(params) {
+    const { langchainParams, resolvedModel, resolvedTools, resolvedMiddleware, resolvedCheckpointer, resolvedStore, passthroughOverride, systemPromptOverride, } = params;
+    return buildResolvedRunnableConfig({
+        passthrough: passthroughOverride ?? langchainParams.passthrough ?? {},
+        staticConfig: {
+            systemPrompt: systemPromptOverride ?? langchainParams.systemPrompt,
+            stateSchema: langchainParams.stateSchema,
+            responseFormat: langchainParams.responseFormat,
+            contextSchema: langchainParams.contextSchema,
+            includeAgentName: langchainParams.includeAgentName,
+            version: langchainParams.version,
+            name: langchainParams.name,
+            description: langchainParams.description,
+        },
+        resolved: {
+            resolvedModel,
+            resolvedTools,
+            resolvedMiddleware,
+            resolvedCheckpointer,
+            resolvedStore,
+        },
+    });
+}
+export function buildDeepAgentRunnableConfig(params) {
+    const { compatibleParams, resolvedModel, resolvedTools, resolvedMiddleware, resolvedSubagents, resolvedCheckpointer, resolvedStore, resolvedBackend, resolvedInterruptOn, resolvedSkills, } = params;
+    return buildResolvedRunnableConfig({
+        passthrough: compatibleParams.passthrough ?? {},
+        staticConfig: {
+            systemPrompt: compatibleParams.systemPrompt,
+            responseFormat: compatibleParams.responseFormat,
+            contextSchema: compatibleParams.contextSchema,
+            name: compatibleParams.name,
+            memory: compatibleParams.memory,
+            skills: resolvedSkills,
+            generalPurposeAgent: compatibleParams.generalPurposeAgent,
+            taskDescription: compatibleParams.taskDescription,
+        },
+        resolved: {
+            resolvedModel,
+            resolvedTools,
+            resolvedMiddleware,
+            resolvedCheckpointer,
+            resolvedStore,
+        },
+        extraConfig: {
+            subagents: resolvedSubagents,
+            backend: resolvedBackend,
+            interruptOn: resolvedInterruptOn,
+        },
+    });
+}

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

@@ -1,6 +1,5 @@
 import type { CompiledAgentBinding } from "../../contracts/types.js";
 export declare function countConfiguredTools(binding: CompiledAgentBinding): number;
-export declare function asObject(value: unknown): Record<string, unknown> | undefined;
 export declare function sleep(ms: number): Promise<void>;
 export declare function hasConfiguredSubagentSupport(binding: CompiledAgentBinding): boolean;
 export declare function hasConfiguredMiddlewareKind(binding: CompiledAgentBinding, kind: string): boolean;

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

@@ -1,22 +1,19 @@
-import { getBindingLangChainParams, getBindingMiddlewareConfigs, getBindingPrimaryTools } from "../support/compiled-binding.js";
+import { getBindingExecutionView } from "../support/compiled-binding.js";
 export function countConfiguredTools(binding) {
-    return getBindingPrimaryTools(binding).length;
-}
-export function asObject(value) {
-    return typeof value === "object" && value ? value : undefined;
+    return getBindingExecutionView(binding).primaryTools.length;
 }
 export function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
 export function hasConfiguredSubagentSupport(binding) {
-    const params = getBindingLangChainParams(binding);
+    const params = getBindingExecutionView(binding).langchainParams;
     if (!params) {
         return false;
     }
     return (params.subagents?.length ?? 0) > 0 || params.generalPurposeAgent === true || Boolean(params.taskDescription?.trim());
 }
 export function hasConfiguredMiddlewareKind(binding, kind) {
-    return getBindingMiddlewareConfigs(binding)?.some((entry) => entry.kind === kind) ?? false;
+    return getBindingExecutionView(binding).middlewareConfigs?.some((entry) => entry.kind === kind) ?? false;
 }
 export function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -34,7 +31,7 @@ export function truncateLines(lines, maxChars = 12_000) {
 export function summarizeBuiltinWriteTodosArgs(args) {
     const todos = Array.isArray(args.todos) ? args.todos : [];
     const items = todos.flatMap((todo) => {
-        if (!isObject(todo)) {
+        if (!isRecord(todo)) {
             return [];
         }
         const content = typeof todo.content === "string" && todo.content.trim().length > 0

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

@@ -8,8 +8,7 @@ import { buildToolNameMapping, } from "./adapter/tool/tool-name-mapping.js";
 import { finalizeInvocationResult } from "./adapter/invocation-result.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 { buildDeepAgentRunnableConfig, buildLangChainRunnableConfig } from "./adapter/runnable-config.js";
 import { applyStrictToolJsonInstruction as applyStrictToolJsonInstructionHelper, callRuntimeWithToolParseRecovery as callRuntimeWithToolParseRecoveryHelper, createModelFallbackRunnable as createModelFallbackRunnableHelper, invokeWithProviderRetry as invokeWithProviderRetryHelper, iterateWithTimeout as iterateWithTimeoutHelper, materializeModelStream as materializeModelStreamHelper, RuntimeOperationTimeoutError, withRuntimeTimeout, } from "./adapter/runtime-shell.js";
 import { invokeBuiltinTaskTool as invokeBuiltinTaskToolHelper, resolveAutomaticSummarizationMiddleware as resolveAutomaticSummarizationMiddlewareHelper, resolveBuiltinMiddlewareBackend as resolveBuiltinMiddlewareBackendHelper, resolveBuiltinMiddlewareTools as resolveBuiltinMiddlewareToolsHelper, resolveLangChainAutomaticMiddleware as resolveLangChainAutomaticMiddlewareHelper, resolveMiddleware as resolveMiddlewareHelper, resolveSubagents as resolveSubagentsHelper, } from "./adapter/middleware-assembly.js";
 import { computeRemainingTimeoutMs, resolveBindingTimeout, resolveStreamIdleTimeout, } from "./adapter/resilience.js";
@@ -17,12 +16,13 @@ import { createResolvedModel } from "./adapter/model/model-providers.js";
 import { buildInvocationRequest, } from "./adapter/model/invocation-request.js";
 import { compileInterruptOn } from "./adapter/tool/interrupt-policy.js";
 import { countConfiguredTools, } from "./adapter/runtime-adapter-support.js";
-import { buildExecutableToolMap, resolveAdapterTools } from "./adapter/tool-resolution.js";
+import { resolveAdapterTools } from "./adapter/tool-resolution.js";
+import { buildBindingToolCatalog, buildBindingToolExecutionContext, resolveLangChainStreamContext, } from "./adapter/execution-context.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";
 export { computeRemainingTimeoutMs, isRetryableProviderError, resolveBindingTimeout, resolveProviderRetryPolicy, resolveStreamIdleTimeout, resolveTimeoutMs, } from "./adapter/resilience.js";
-import { getBindingAdapterKind, getBindingDeepAgentParams, getBindingInterruptCompatibilityRules, getBindingLangChainParams, getBindingPrimaryModel, getBindingPrimaryTools, getBindingSystemPrompt, isDeepAgentBinding, isLangChainBinding, } from "./support/compiled-binding.js";
+import { getBindingAdapterKind, getBindingDeepAgentParams, getBindingInterruptCompatibilityRules, getBindingLangChainParams, getBindingPrimaryTools, getBindingSystemPrompt, isDeepAgentBinding, isLangChainBinding, } from "./support/compiled-binding.js";
 const AGENT_INTERRUPT_SENTINEL_PREFIX = "__agent_harness_interrupt__:";
 const UPSTREAM_BUILTIN_MIDDLEWARE_TOOL_NAMES = Object.freeze([
     "write_todos",
@@ -35,6 +35,12 @@ const UPSTREAM_BUILTIN_MIDDLEWARE_TOOL_NAMES = Object.freeze([
     "execute",
     "task",
 ]);
+function resolveBindingCheckpointer(options, binding) {
+    return options.checkpointerResolver ? options.checkpointerResolver(binding) : new MemorySaver();
+}
+function resolveBindingInterruptOn(binding) {
+    return compileInterruptOn(getBindingPrimaryTools(binding), getBindingInterruptCompatibilityRules(binding));
+}
 export class AgentRuntimeAdapter {
     options;
     modelCache = new Map();
@@ -198,7 +204,7 @@ export class AgentRuntimeAdapter {
     }
     async createLangChainRunnable(binding, options = {}) {
         const params = getBindingLangChainParams(binding);
-        const interruptOn = compileInterruptOn(getBindingPrimaryTools(binding), getBindingInterruptCompatibilityRules(binding));
+        const interruptOn = resolveBindingInterruptOn(binding);
         const model = (await this.resolveModel(params.model));
         const tools = this.resolveTools(params.tools, binding);
         if (tools.length > 0 && typeof model.bindTools !== "function") {
@@ -209,7 +215,7 @@ export class AgentRuntimeAdapter {
             resolvedModel: model,
             resolvedTools: tools,
             resolvedMiddleware: await this.resolveMiddleware(binding, interruptOn),
-            resolvedCheckpointer: this.options.checkpointerResolver ? this.options.checkpointerResolver(binding) : new MemorySaver(),
+            resolvedCheckpointer: resolveBindingCheckpointer(this.options, binding),
             resolvedStore: this.options.storeResolver?.(binding),
             passthroughOverride: options.passthroughOverride,
             systemPromptOverride: options.systemPromptOverride,
@@ -236,10 +242,10 @@ export class AgentRuntimeAdapter {
             resolvedTools: this.resolveTools(compatibleParams.tools, binding),
             resolvedMiddleware: await this.resolveMiddleware(binding),
             resolvedSubagents: await this.resolveSubagents(compatibleParams.subagents, binding),
-            resolvedCheckpointer: this.options.checkpointerResolver ? this.options.checkpointerResolver(binding) : new MemorySaver(),
+            resolvedCheckpointer: resolveBindingCheckpointer(this.options, binding),
             resolvedStore: this.options.storeResolver?.(binding),
             resolvedBackend: this.options.backendResolver?.(binding),
-            resolvedInterruptOn: compileInterruptOn(getBindingPrimaryTools(binding), getBindingInterruptCompatibilityRules(binding)),
+            resolvedInterruptOn: resolveBindingInterruptOn(binding),
             resolvedSkills: (await materializeDeepAgentSkillSourcePaths({
                 workspaceRoot: binding.harnessRuntime.workspaceRoot,
                 runRoot: binding.harnessRuntime.runRoot,
@@ -282,13 +288,10 @@ export class AgentRuntimeAdapter {
                 callRuntime,
             });
         };
-        const primaryTools = getBindingPrimaryTools(binding);
-        const resolvedTools = this.resolveTools(primaryTools, binding);
-        const toolNameMapping = this.getToolNameMapping(binding);
-        const executableTools = buildExecutableToolMap({
-            primaryTools,
-            resolvedTools,
-            toolNameMapping,
+        const { primaryTools, toolNameMapping, executableTools, defersToUpstreamHitlExecution, } = buildBindingToolExecutionContext({
+            binding,
+            resolveTools: (tools, currentBinding) => this.resolveTools(tools, currentBinding),
+            getToolNameMapping: (currentBinding) => this.getToolNameMapping(currentBinding),
             context: options.context,
         });
         const builtinExecutableTools = await this.resolveBuiltinMiddlewareTools(binding, options);
@@ -297,7 +300,7 @@ export class AgentRuntimeAdapter {
             request,
             resumePayload,
             primaryTools,
-            defersToUpstreamHitlExecution: primaryTools.some((tool) => tool.hitl?.enabled === true),
+            defersToUpstreamHitlExecution,
             toolNameMapping,
             executableTools,
             builtinExecutableTools: builtinExecutableTools,
@@ -320,24 +323,15 @@ export class AgentRuntimeAdapter {
         const invokeTimeoutMs = resolveBindingTimeout(binding);
         const streamIdleTimeoutMs = resolveStreamIdleTimeout(binding);
         const streamDeadlineAt = invokeTimeoutMs ? Date.now() + invokeTimeoutMs : undefined;
-        const primaryTools = getBindingPrimaryTools(binding);
-        const toolNameMapping = this.getToolNameMapping(binding);
-        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;
+        const { primaryTools, toolNameMapping } = buildBindingToolCatalog({
+            binding,
+            getToolNameMapping: (currentBinding) => this.getToolNameMapping(currentBinding),
+        });
+        const { forceInvokeFallback, canUseDirectModelStream, langChainStreamModel, } = await resolveLangChainStreamContext({
+            binding,
+            resolveModel: (model) => this.resolveModel(model),
+            resolveTools: (tools, currentBinding) => this.resolveTools(tools, currentBinding),
+        });
         yield* streamRuntimeExecution({
             binding,
             input,

package/dist/runtime/harness/background-runtime.d.ts

@@ -0,0 +1,13 @@
+import type { HarnessEvent } from "../../contracts/types.js";
+import type { RuntimePersistence } from "../../persistence/types.js";
+export declare function createBackgroundEventRuntime(input: {
+    persistence: RuntimePersistence;
+    publishEvent: (event: HarnessEvent) => void;
+    trackBackgroundTask: (task: Promise<void>) => void;
+    backgroundEventTypes: ReadonlySet<HarnessEvent["eventType"]>;
+}): {
+    persistence: RuntimePersistence;
+    publishEvent: (event: HarnessEvent) => void;
+    trackBackgroundTask: (task: Promise<void>) => void;
+    backgroundEventTypes: ReadonlySet<import("../../contracts/runtime.js").HarnessEventType>;
+};

package/dist/runtime/harness/background-runtime.js

@@ -0,0 +1,8 @@
+export function createBackgroundEventRuntime(input) {
+    return {
+        persistence: input.persistence,
+        publishEvent: input.publishEvent,
+        trackBackgroundTask: input.trackBackgroundTask,
+        backgroundEventTypes: input.backgroundEventTypes,
+    };
+}

package/dist/runtime/harness/bindings.d.ts

@@ -0,0 +1,14 @@
+import type { CompiledTool, RuntimeAdapterOptions, WorkspaceBundle } from "../../contracts/types.js";
+type Binding = WorkspaceBundle["bindings"] extends Map<any, infer T> ? T : never;
+export declare function getWorkspaceBinding(workspace: WorkspaceBundle, agentId: string): Binding | undefined;
+export declare function getRequiredWorkspaceBinding(workspace: WorkspaceBundle, agentId: string): Binding;
+export declare function resolveWorkspaceAgentTools(input: {
+    workspace: WorkspaceBundle;
+    agentId: string;
+    toolResolver?: RuntimeAdapterOptions["toolResolver"];
+}): Array<{
+    compiledTool: CompiledTool;
+    resolvedTool: unknown;
+}>;
+export declare function bindingSupportsRunningReplay(binding: Binding): boolean;
+export {};

package/dist/runtime/harness/bindings.js

@@ -0,0 +1,23 @@
+import { getBindingPrimaryTools } from "../support/compiled-binding.js";
+export function getWorkspaceBinding(workspace, agentId) {
+    return workspace.bindings.get(agentId);
+}
+export function getRequiredWorkspaceBinding(workspace, agentId) {
+    const binding = getWorkspaceBinding(workspace, agentId);
+    if (!binding) {
+        throw new Error(`Unknown agent ${agentId}`);
+    }
+    return binding;
+}
+export function resolveWorkspaceAgentTools(input) {
+    const binding = getRequiredWorkspaceBinding(input.workspace, input.agentId);
+    const compiledTools = getBindingPrimaryTools(binding);
+    const resolvedTools = input.toolResolver ? input.toolResolver(compiledTools.map((tool) => tool.id), binding) : [];
+    return compiledTools.map((compiledTool, index) => ({
+        compiledTool,
+        resolvedTool: resolvedTools[index],
+    }));
+}
+export function bindingSupportsRunningReplay(binding) {
+    return getBindingPrimaryTools(binding).every((tool) => tool.retryable === true);
+}

package/dist/runtime/harness/events/listener-runtime.d.ts

@@ -0,0 +1,18 @@
+import type { HarnessStreamItem, RunListeners, RunResult } from "../../../contracts/types.js";
+export declare function createListenerDispatchRuntime(input: {
+    notifyListener: <T>(listener: ((value: T) => void | Promise<void>) | undefined, value: T) => Promise<void>;
+    getThread: (threadId: string) => Promise<{
+        currentState: RunResult["state"];
+        latestRunId: string;
+        entryAgentId: string;
+        runs: Array<{
+            agentId: string;
+        }>;
+        pendingDecision?: {
+            approvalId?: string;
+            pendingActionId?: string;
+        };
+    } | null>;
+}): {
+    dispatchRunListeners: (stream: AsyncGenerator<HarnessStreamItem>, listeners: RunListeners) => Promise<RunResult>;
+};

package/dist/runtime/harness/events/listener-runtime.js

@@ -0,0 +1,9 @@
+import { dispatchRunListeners as dispatchStreamingRunListeners } from "./streaming.js";
+export function createListenerDispatchRuntime(input) {
+    return {
+        dispatchRunListeners: (stream, listeners) => dispatchStreamingRunListeners(stream, listeners, {
+            notifyListener: (listener, value) => input.notifyListener(listener, value),
+            getThread: (threadId) => input.getThread(threadId),
+        }),
+    };
+}

package/dist/runtime/harness/events/runtime-event-operations.d.ts

@@ -0,0 +1,17 @@
+import type { HarnessEvent, MessageContent, RunResult } from "../../../contracts/types.js";
+import { emitRunCreatedEvent } from "./events.js";
+type EventRuntime = Parameters<typeof emitRunCreatedEvent>[0];
+export declare function createRuntimeEventOperations(runtime: EventRuntime): {
+    emitRunCreated: (threadId: string, runId: 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: import("../../../contracts/runtime.js").InternalApprovalRecord;
+        event: HarnessEvent;
+    }>;
+    emitSyntheticFallback: (threadId: string, runId: string, selectedAgentId: string, error: unknown, sequence?: number) => Promise<void>;
+};
+export {};

package/dist/runtime/harness/events/runtime-event-operations.js

@@ -0,0 +1,9 @@
+import { emitRunCreatedEvent, emitSyntheticFallbackEvent, requestApprovalAndEmitEvent, setRunStateAndEmitEvent } from "./events.js";
+export function createRuntimeEventOperations(runtime) {
+    return {
+        emitRunCreated: (threadId, runId, payload) => emitRunCreatedEvent(runtime, threadId, runId, payload),
+        setRunStateAndEmit: (threadId, runId, sequence, state, options) => setRunStateAndEmitEvent(runtime, threadId, runId, sequence, state, options),
+        requestApprovalAndEmit: (threadId, runId, input, interruptContent, checkpointRef, sequence) => requestApprovalAndEmitEvent(runtime, threadId, runId, input, interruptContent, checkpointRef, sequence),
+        emitSyntheticFallback: (threadId, runId, selectedAgentId, error, sequence) => emitSyntheticFallbackEvent(runtime, threadId, runId, selectedAgentId, error, sequence),
+    };
+}

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

@@ -3,7 +3,7 @@ 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 = {
+export type StartupRecoveryContext = {
     persistence: RuntimePersistence;
     workspace: WorkspaceBundle;
     runtimeAdapter: AgentRuntimeAdapter;