@botbotgo/agent-harness 0.0.340 → 0.0.342

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

@@ -1,6 +1,6 @@
 import type { CompiledAgentBinding, MessageContent, RequestResult, RuntimeAdapterOptions, TranscriptMessage } from "../contracts/types.js";
 import { type RuntimeStreamChunk } from "./parsing/stream-event-parsing.js";
-import { AGENT_INTERRUPT_SENTINEL_PREFIX, buildDeepAgentCreateParams, buildLangChainCreateParams, materializeModelExposedBuiltinMiddlewareTools, resolveLangChainInvocationConfig, resolveRunnableCheckpointer, resolveRunnableInterruptOn } from "./agent-runtime-assembly.js";
+import { AGENT_INTERRUPT_SENTINEL_PREFIX, buildDeepAgentCreateParams, buildLangChainCreateParams, DEFAULT_DEEPAGENT_RECURSION_LIMIT, materializeModelExposedBuiltinMiddlewareTools, resolveLangChainInvocationConfig, resolveRunnableCheckpointer, resolveRunnableInterruptOn } from "./agent-runtime-assembly.js";
 import { RuntimeOperationTimeoutError } from "./adapter/runtime-shell.js";
 export { materializeDeepAgentSkillSourcePaths, resolveDeepAgentSkillSourcePaths, relativizeDeepAgentSkillSourcePaths, } from "./adapter/compat/deepagent-compat.js";
 export { buildAuthOmittingFetch, normalizeOpenAICompatibleInit } from "./adapter/compat/openai-compatible.js";
@@ -45,6 +45,7 @@ export declare class AgentRuntimeAdapter {
     private createLangChainRunnable;
     private createRunnable;
     private createDeepAgentRunnable;
+    private createConfigurableDeepAgentRunnable;
     private buildRunnableCacheKey;
     create(binding: CompiledAgentBinding, options?: {
         sessionId?: string;
@@ -66,4 +67,4 @@ export declare class AgentRuntimeAdapter {
         toolRuntimeContext?: Record<string, unknown>;
     }): AsyncGenerator<RuntimeStreamChunk | string>;
 }
-export { AgentRuntimeAdapter as RuntimeAdapter, AGENT_INTERRUPT_SENTINEL_PREFIX, AGENT_INTERRUPT_SENTINEL_PREFIX as INTERRUPT_SENTINEL_PREFIX, buildDeepAgentCreateParams, buildLangChainCreateParams, materializeModelExposedBuiltinMiddlewareTools, resolveLangChainInvocationConfig, resolveRunnableCheckpointer, resolveRunnableInterruptOn, RuntimeOperationTimeoutError, };
+export { AgentRuntimeAdapter as RuntimeAdapter, AGENT_INTERRUPT_SENTINEL_PREFIX, AGENT_INTERRUPT_SENTINEL_PREFIX as INTERRUPT_SENTINEL_PREFIX, buildDeepAgentCreateParams, buildLangChainCreateParams, DEFAULT_DEEPAGENT_RECURSION_LIMIT, materializeModelExposedBuiltinMiddlewareTools, resolveLangChainInvocationConfig, resolveRunnableCheckpointer, resolveRunnableInterruptOn, RuntimeOperationTimeoutError, };

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

@@ -1,25 +1,29 @@
 import path from "node:path";
-import { createDeepAgent, FilesystemBackend, } from "deepagents";
-import { createAgent } from "langchain";
+import { GENERAL_PURPOSE_SUBAGENT, createAsyncSubAgentMiddleware, createDeepAgent, createFilesystemMiddleware, createMemoryMiddleware, createPatchToolCallsMiddleware, createSkillsMiddleware, createSummarizationMiddleware, createSubAgentMiddleware, FilesystemBackend, StateBackend, } from "deepagents";
+import { createAgent, humanInTheLoopMiddleware, todoListMiddleware } from "langchain";
 import { wrapResolvedModel, } from "./parsing/output-parsing.js";
-import { AGENT_INTERRUPT_SENTINEL_PREFIX, buildDeepAgentCreateParams, buildLangChainCreateParams, materializeModelExposedBuiltinMiddlewareTools, resolveLangChainInvocationConfig, resolveRunnableCheckpointer, resolveRunnableInterruptOn, shouldAttachDeepAgentBackend, shouldAttachDeepAgentCheckpointer, shouldAttachDeepAgentStore, } from "./agent-runtime-assembly.js";
+import { AGENT_INTERRUPT_SENTINEL_PREFIX, buildDeepAgentCreateParams, buildLangChainCreateParams, DEFAULT_DEEPAGENT_RECURSION_LIMIT, materializeModelExposedBuiltinMiddlewareTools, resolveLangChainInvocationConfig, resolveRunnableCheckpointer, resolveRunnableInterruptOn, shouldAttachDeepAgentBackend, shouldAttachDeepAgentCheckpointer, shouldAttachDeepAgentStore, } from "./agent-runtime-assembly.js";
 import { resolveDeepAgentSkillSourcePaths, } from "./adapter/compat/deepagent-compat.js";
 import { buildToolNameMapping, } from "./adapter/tool/tool-name-mapping.js";
 import { executeRequestInvocation } from "./adapter/flow/invocation-flow.js";
 import { streamRuntimeExecution } from "./adapter/flow/stream-runtime.js";
 import { applyToolRecoveryInstruction as applyToolRecoveryInstructionHelper, 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, materializeAutomaticSummarizationMiddleware as materializeAutomaticSummarizationMiddlewareHelper, resolveBuiltinMiddlewareBackend as resolveBuiltinMiddlewareBackendHelper, resolveBuiltinMiddlewareTools as resolveBuiltinMiddlewareToolsHelper, resolveLangChainRuntimeExtensionMiddleware as resolveLangChainRuntimeExtensionMiddlewareHelper, resolveMiddleware as resolveMiddlewareHelper, resolveSubagents as resolveSubagentsHelper, } from "./adapter/middleware-assembly.js";
+import { extractSubagentRequestText, invokeBuiltinTaskTool as invokeBuiltinTaskToolHelper, materializeAutomaticSummarizationMiddleware as materializeAutomaticSummarizationMiddlewareHelper, resolveBuiltinMiddlewareBackend as resolveBuiltinMiddlewareBackendHelper, resolveBuiltinMiddlewareTools as resolveBuiltinMiddlewareToolsHelper, resolveLangChainRuntimeExtensionMiddleware as resolveLangChainRuntimeExtensionMiddlewareHelper, resolveMiddleware as resolveMiddlewareHelper, resolveSubagents as resolveSubagentsHelper, wrapRequestResultAsSubagentResponse, } from "./adapter/middleware-assembly.js";
 import { resolveBindingTimeout, resolveStreamIdleTimeout, } from "./adapter/resilience.js";
 import { createResolvedModel } from "./adapter/model/model-providers.js";
 import { renderDirectWorkspaceListing, shouldDirectlyListWorkspaceFiles } from "./adapter/direct-builtin-utility.js";
 import { resolveAdapterTools } from "./adapter/tool-resolution.js";
 import { resolveRuntimeStreamExecutionContext, } from "./adapter/flow/execution-context.js";
 import { isRetryableProviderError } from "./adapter/resilience.js";
+import { UPSTREAM_REQUEST_CONFIG_KEY, UPSTREAM_SESSION_CONFIG_KEY } from "./adapter/upstream-configurable-keys.js";
 export { materializeDeepAgentSkillSourcePaths, resolveDeepAgentSkillSourcePaths, relativizeDeepAgentSkillSourcePaths, } 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, getBindingDeepAgentSubagents, getBindingExecutionKind, getBindingFilesystemConfig, getBindingPrimaryModel, getBindingSkills, getBindingToolCount, getBindingPrimaryTools, getBindingSystemPrompt, isDeepAgentBinding, isLangChainBinding, } from "./support/compiled-binding.js";
+import { getBindingAdapterKind, getBindingBuiltinToolsConfig, getBindingDeepAgentSubagents, getBindingExecutionParams, getBindingExecutionKind, getBindingFilesystemConfig, getBindingMemorySources, getBindingPrimaryModel, getBindingSkills, getBindingToolCount, getBindingPrimaryTools, getBindingSystemPrompt, isDeepAgentBinding, isLangChainBinding, } from "./support/compiled-binding.js";
+function shouldUseConfigurableDeepAgentAssembly(binding) {
+    return getBindingBuiltinToolsConfig(binding) !== undefined;
+}
 export class AgentRuntimeAdapter {
     options;
     modelCache = new Map();
@@ -279,13 +283,64 @@ export class AgentRuntimeAdapter {
             resolveModel: assembly.resolveModel,
             resolveTools: assembly.resolveTools,
             createDeclaredMiddlewareResolverOptions: assembly.createDeclaredMiddlewareResolverOptions,
+            resolveBackend: (currentBinding) => {
+                const targetBinding = currentBinding ?? binding;
+                return targetBinding ? this.options.backendResolver?.(targetBinding) : undefined;
+            },
         });
     }
-    async resolveDeepAgentSubagents(subagents, binding) {
+    async resolveDeepAgentSubagents(subagents, binding, options = {}) {
         const syncSubagents = subagents.filter((subagent) => !("graphId" in subagent));
         const asyncSubagents = subagents.filter((subagent) => "graphId" in subagent);
         const resolvedSyncSubagents = await this.resolveSubagents(syncSubagents, binding);
-        return [...resolvedSyncSubagents, ...asyncSubagents];
+        const wrappedSyncSubagents = await Promise.all(resolvedSyncSubagents.map(async (resolvedSubagent, index) => {
+            const compiledSubagent = syncSubagents[index];
+            const targetAgentId = compiledSubagent?.agentId;
+            const targetBinding = targetAgentId ? this.options.bindingResolver?.(targetAgentId) : undefined;
+            if (!targetBinding) {
+                return resolvedSubagent;
+            }
+            const wrapper = {
+                name: resolvedSubagent.name,
+                description: resolvedSubagent.description,
+                systemPrompt: resolvedSubagent.systemPrompt,
+                runnable: {
+                    invoke: async (state, config) => {
+                        const requestText = extractSubagentRequestText(state);
+                        const configurable = typeof config?.configurable === "object" && config.configurable
+                            ? config.configurable
+                            : {};
+                        const sessionId = typeof configurable[UPSTREAM_SESSION_CONFIG_KEY] === "string"
+                            ? configurable[UPSTREAM_SESSION_CONFIG_KEY]
+                            : options.sessionId ?? `${binding?.agent.id ?? "agent"}:${resolvedSubagent.name}`;
+                        const requestId = typeof configurable[UPSTREAM_REQUEST_CONFIG_KEY] === "string"
+                            ? configurable[UPSTREAM_REQUEST_CONFIG_KEY]
+                            : sessionId;
+                        const childSessionId = `${sessionId}:delegated:${resolvedSubagent.name}`;
+                        const childRequestId = `${requestId}:delegated:${resolvedSubagent.name}:${Date.now().toString(36)}`;
+                        try {
+                            const result = await this.invoke(targetBinding, requestText, childSessionId, childRequestId, undefined, [], {
+                                ...(typeof config?.context === "object" && config.context ? { context: config.context } : {}),
+                            });
+                            return wrapRequestResultAsSubagentResponse({
+                                output: result.output,
+                                structuredResponse: result.structuredResponse,
+                            });
+                        }
+                        catch (error) {
+                            const message = error instanceof Error && error.message.trim().length > 0
+                                ? error.message.trim()
+                                : "delegated execution failed";
+                            return wrapRequestResultAsSubagentResponse({
+                                output: `Blocked: ${message}`,
+                            });
+                        }
+                    },
+                },
+            };
+            return wrapper;
+        }));
+        return [...wrappedSyncSubagents, ...asyncSubagents];
     }
     async createLangChainRunnable(binding, options = {}) {
         const executionKind = getBindingExecutionKind(binding);
@@ -352,7 +407,7 @@ export class AgentRuntimeAdapter {
             explicitToolNames: primaryTools.map((tool) => tool.name),
         });
         const resolvedMiddleware = await this.resolveMiddleware(binding);
-        const resolvedSubagents = await this.resolveDeepAgentSubagents(getBindingDeepAgentSubagents(binding), binding);
+        const resolvedSubagents = await this.resolveDeepAgentSubagents(getBindingDeepAgentSubagents(binding), binding, { sessionId: options.sessionId ?? options.legacySessionId });
         const resolvedInterruptOn = resolveRunnableInterruptOn(binding);
         const resolvedCheckpointer = shouldAttachDeepAgentCheckpointer(binding, resolvedInterruptOn)
             ? resolveRunnableCheckpointer(this.options, binding)
@@ -377,8 +432,66 @@ export class AgentRuntimeAdapter {
             resolvedInterruptOn,
             resolvedSkills,
         });
+        if (shouldUseConfigurableDeepAgentAssembly(binding)) {
+            return this.createConfigurableDeepAgentRunnable(binding, {
+                resolvedModel,
+                resolvedTools: [...resolvedTools, ...builtinMiddlewareTools],
+                resolvedMiddleware,
+                resolvedSubagents,
+                resolvedInterruptOn,
+                resolvedBackend,
+                resolvedSkills,
+            });
+        }
         return createDeepAgent(deepAgentConfig);
     }
+    createConfigurableDeepAgentRunnable(binding, input) {
+        const builtinTools = getBindingBuiltinToolsConfig(binding) ?? {};
+        const backend = (input.resolvedBackend ?? new StateBackend({}));
+        const inlineSubagents = input.resolvedSubagents.filter((subagent) => !("graphId" in subagent));
+        const asyncSubagents = input.resolvedSubagents.filter((subagent) => "graphId" in subagent);
+        const subagents = inlineSubagents.some((subagent) => subagent.name === GENERAL_PURPOSE_SUBAGENT.name)
+            ? inlineSubagents
+            : [{
+                    ...GENERAL_PURPOSE_SUBAGENT,
+                    model: input.resolvedModel,
+                    tools: input.resolvedTools,
+                    skills: input.resolvedSkills,
+                }, ...inlineSubagents];
+        const middleware = [
+            ...(builtinTools.todos === false ? [] : [todoListMiddleware()]),
+            ...(input.resolvedSkills.length > 0 ? [createSkillsMiddleware({ backend, sources: input.resolvedSkills })] : []),
+            ...(builtinTools.filesystem === false ? [] : [createFilesystemMiddleware({ backend })]),
+            createSubAgentMiddleware({
+                defaultModel: input.resolvedModel,
+                defaultTools: input.resolvedTools,
+                defaultInterruptOn: input.resolvedInterruptOn,
+                subagents: subagents,
+                generalPurposeAgent: false,
+            }),
+            createSummarizationMiddleware({
+                model: input.resolvedModel,
+                backend,
+            }),
+            createPatchToolCallsMiddleware(),
+            ...(asyncSubagents.length > 0 ? [createAsyncSubAgentMiddleware({ asyncSubAgents: asyncSubagents })] : []),
+            ...input.resolvedMiddleware,
+            ...(getBindingMemorySources(binding).length > 0 ? [createMemoryMiddleware({ backend, sources: getBindingMemorySources(binding) })] : []),
+            ...(input.resolvedInterruptOn ? [humanInTheLoopMiddleware({ interruptOn: input.resolvedInterruptOn })] : []),
+        ];
+        const executionParams = getBindingExecutionParams(binding);
+        const responseFormat = getBindingExecutionKind(binding) === "deepagent"
+            ? (executionParams && "responseFormat" in executionParams ? executionParams.responseFormat : undefined)
+            : undefined;
+        return createAgent({
+            model: input.resolvedModel,
+            systemPrompt: getBindingSystemPrompt(binding),
+            tools: input.resolvedTools,
+            middleware: middleware,
+            name: binding.agent.id,
+            ...(responseFormat !== undefined ? { responseFormat: responseFormat } : {}),
+        });
+    }
     buildRunnableCacheKey(binding, sessionId) {
         const filesystemConfig = getBindingFilesystemConfig(binding);
         const sessionStorage = typeof filesystemConfig?.sessionStorage === "object" && filesystemConfig.sessionStorage
@@ -522,6 +635,12 @@ export class AgentRuntimeAdapter {
             canUseDirectModelStream,
             langChainStreamModel,
             createRunnable: () => this.create(binding, { sessionId }),
+            resolveInvocationConfig: (activeBinding, configOptions) => resolveLangChainInvocationConfig(activeBinding, {
+                sessionId: configOptions.sessionId,
+                requestId: configOptions.requestId,
+                ...(configOptions.context ? { context: configOptions.context } : {}),
+                ...(configOptions.toolRuntimeContext ? { toolRuntimeContext: configOptions.toolRuntimeContext } : {}),
+            }),
             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,
@@ -541,4 +660,4 @@ export class AgentRuntimeAdapter {
         });
     }
 }
-export { AgentRuntimeAdapter as RuntimeAdapter, AGENT_INTERRUPT_SENTINEL_PREFIX, AGENT_INTERRUPT_SENTINEL_PREFIX as INTERRUPT_SENTINEL_PREFIX, buildDeepAgentCreateParams, buildLangChainCreateParams, materializeModelExposedBuiltinMiddlewareTools, resolveLangChainInvocationConfig, resolveRunnableCheckpointer, resolveRunnableInterruptOn, RuntimeOperationTimeoutError, };
+export { AgentRuntimeAdapter as RuntimeAdapter, AGENT_INTERRUPT_SENTINEL_PREFIX, AGENT_INTERRUPT_SENTINEL_PREFIX as INTERRUPT_SENTINEL_PREFIX, buildDeepAgentCreateParams, buildLangChainCreateParams, DEFAULT_DEEPAGENT_RECURSION_LIMIT, materializeModelExposedBuiltinMiddlewareTools, resolveLangChainInvocationConfig, resolveRunnableCheckpointer, resolveRunnableInterruptOn, RuntimeOperationTimeoutError, };

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

@@ -2,6 +2,7 @@ import type { CompiledAgentBinding, CompiledAsyncSubAgent, RuntimeAdapterOptions
 import type { ExecutableTool } from "./adapter/flow/invoke-runtime.js";
 import type { UpstreamSubagentConfig } from "./adapter/middleware-assembly.js";
 export declare const AGENT_INTERRUPT_SENTINEL_PREFIX = "__agent_harness_interrupt__:";
+export declare const DEFAULT_DEEPAGENT_RECURSION_LIMIT = 100;
 export declare function materializeModelExposedBuiltinMiddlewareTools(input: {
     builtinTools: Map<string, ExecutableTool>;
     explicitToolNames?: string[];

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

@@ -4,6 +4,7 @@ import { asStructuredExecutableTool } from "./adapter/tool/resolved-tool.js";
 import { compileInterruptOn } from "./adapter/tool/interrupt-policy.js";
 import { getBindingBackendConfig, getBindingExecutionKind, getBindingExecutionParams, getBindingInterruptCompatibilityRules, getBindingMemorySources, getBindingMiddlewareConfigs, getBindingPrimaryTools, getBindingSkills, getBindingStoreConfig, } from "./support/compiled-binding.js";
 export const AGENT_INTERRUPT_SENTINEL_PREFIX = "__agent_harness_interrupt__:";
+export const DEFAULT_DEEPAGENT_RECURSION_LIMIT = 100;
 const BUILTIN_MIDDLEWARE_ALIAS_TOOL_NAMES = new Set([
     "list_files",
     "search_files",
@@ -88,8 +89,12 @@ export function buildLangChainCreateParams(input) {
     };
 }
 export function resolveLangChainInvocationConfig(binding, options) {
-    const langchainPassthrough = typeof binding.harnessRuntime.langchain?.passthrough === "object" && binding.harnessRuntime.langchain?.passthrough
-        ? binding.harnessRuntime.langchain.passthrough
+    const executionKind = getBindingExecutionKind(binding) ?? binding.agent.executionMode;
+    const runtimePassthrough = executionKind === "deepagent"
+        ? binding.harnessRuntime.deepagent?.passthrough
+        : binding.harnessRuntime.langchain?.passthrough;
+    const langchainPassthrough = typeof runtimePassthrough === "object" && runtimePassthrough
+        ? runtimePassthrough
         : undefined;
     const config = {
         configurable: {
@@ -100,6 +105,9 @@ export function resolveLangChainInvocationConfig(binding, options) {
     if (typeof langchainPassthrough?.recursionLimit === "number") {
         config.recursionLimit = langchainPassthrough.recursionLimit;
     }
+    else if (executionKind === "deepagent") {
+        config.recursionLimit = DEFAULT_DEEPAGENT_RECURSION_LIMIT;
+    }
     if (options.context) {
         config.context = options.context;
     }

package/dist/runtime/harness/run/inspection.js

@@ -1,9 +1,9 @@
 import { readSkillMetadata } from "../../skills/skill-metadata.js";
 import { createUpstreamTimelineReducer } from "../../../projections/upstream-events.js";
 import { formatAgentName } from "../../../utils/agent-display.js";
-import { getBindingMemorySources, getBindingPrimaryModel, getBindingPrimaryTools, getBindingSkills, getBindingSubagents, isDeepAgentBinding, } from "../../support/compiled-binding.js";
+import { getBindingBuiltinToolsConfig, getBindingMemorySources, getBindingPrimaryModel, getBindingPrimaryTools, getBindingSkills, getBindingSubagents, isDeepAgentBinding, } from "../../support/compiled-binding.js";
 import { buildRuntimeGovernanceBundles } from "./governance.js";
-import { BUILTIN_MIDDLEWARE_TOOL_DESCRIPTORS } from "../../adapter/tool/builtin-middleware-tools.js";
+import { filterBuiltinMiddlewareToolDescriptors } from "../../adapter/tool/builtin-middleware-tools.js";
 import { buildSurfaceId, resolveSurfaceAction, resolveSurfaceDisplayName, } from "./surface-semantics.js";
 function asObject(value) {
     return typeof value === "object" && value !== null ? value : null;
@@ -109,9 +109,8 @@ export function buildRequestRuntimeSnapshot(binding, options) {
     const tools = isDeepAgentBinding(binding)
         ? [
             ...declaredTools,
-            ...BUILTIN_MIDDLEWARE_TOOL_DESCRIPTORS
-                .filter((descriptor) => !declaredTools.some((tool) => tool.name === descriptor.name))
-                .map((descriptor) => ({ ...descriptor })),
+            ...filterBuiltinMiddlewareToolDescriptors(getBindingBuiltinToolsConfig(binding))
+                .filter((descriptor) => !declaredTools.some((tool) => tool.name === descriptor.name)),
         ]
         : declaredTools;
     return {