@botbotgo/agent-harness 0.0.111 → 0.0.113

package/dist/runtime/adapter/{execution-context.js → flow/execution-context.js}

@@ -1,5 +1,5 @@
-import { buildExecutableToolMap } from "./tool-resolution.js";
-import { getBindingLangChainParams, getBindingPrimaryModel, getBindingPrimaryTools, isLangChainBinding } from "../support/compiled-binding.js";
+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);
@@ -50,3 +50,21 @@ export async function resolveLangChainStreamContext(input) {
         langChainStreamModel,
     };
 }
+export async function resolveRuntimeStreamExecutionContext(input) {
+    const { primaryTools, toolNameMapping } = buildBindingToolCatalog({
+        binding: input.binding,
+        getToolNameMapping: input.getToolNameMapping,
+    });
+    const { forceInvokeFallback, canUseDirectModelStream, langChainStreamModel, } = await resolveLangChainStreamContext({
+        binding: input.binding,
+        resolveModel: input.resolveModel,
+        resolveTools: input.resolveTools,
+    });
+    return {
+        primaryTools,
+        toolNameMapping,
+        forceInvokeFallback,
+        canUseDirectModelStream,
+        langChainStreamModel,
+    };
+}

package/dist/runtime/adapter/flow/invocation-flow.d.ts

@@ -0,0 +1,24 @@
+import type { CompiledAgentBinding, CompiledTool, MessageContent, RunResult, TranscriptMessage } from "../../../contracts/types.js";
+import { type ExecutableTool } from "./invoke-runtime.js";
+import type { ToolNameMapping } from "../tool/tool-name-mapping.js";
+export declare function executeRuntimeInvocation(options: {
+    binding: CompiledAgentBinding;
+    input: MessageContent;
+    threadId: string;
+    runId: string;
+    resumePayload?: unknown;
+    history?: TranscriptMessage[];
+    invokeOptions?: {
+        context?: Record<string, unknown>;
+        state?: Record<string, unknown>;
+        files?: Record<string, unknown>;
+    };
+    resolveTools: (tools: CompiledTool[], binding?: CompiledAgentBinding) => unknown[];
+    getToolNameMapping: (binding: CompiledAgentBinding) => ToolNameMapping;
+    resolveBuiltinMiddlewareTools: (binding: CompiledAgentBinding, options?: {
+        context?: Record<string, unknown>;
+        state?: Record<string, unknown>;
+        files?: Record<string, unknown>;
+    }) => Promise<Map<string, ExecutableTool>>;
+    callRuntimeWithToolParseRecovery: (request: unknown) => Promise<Record<string, unknown>>;
+}): Promise<RunResult>;

package/dist/runtime/adapter/flow/invocation-flow.js

@@ -0,0 +1,42 @@
+import { Command } from "@langchain/langgraph";
+import { buildBindingToolExecutionContext } from "./execution-context.js";
+import { finalizeInvocationResult } from "../invocation-result.js";
+import { invokeRuntimeWithLocalTools } from "./invoke-runtime.js";
+import { buildInvocationRequest } from "../model/invocation-request.js";
+export async function executeRuntimeInvocation(options) {
+    const history = options.history ?? [];
+    const invokeOptions = options.invokeOptions ?? {};
+    const request = options.resumePayload === undefined
+        ? buildInvocationRequest(options.binding, history, options.input, invokeOptions)
+        : new Command({ resume: options.resumePayload });
+    const { primaryTools, toolNameMapping, executableTools, defersToUpstreamHitlExecution, } = buildBindingToolExecutionContext({
+        binding: options.binding,
+        resolveTools: options.resolveTools,
+        getToolNameMapping: options.getToolNameMapping,
+        context: invokeOptions.context,
+    });
+    const builtinExecutableTools = await options.resolveBuiltinMiddlewareTools(options.binding, invokeOptions);
+    const localOrUpstreamInvocation = await invokeRuntimeWithLocalTools({
+        binding: options.binding,
+        request,
+        resumePayload: options.resumePayload,
+        primaryTools,
+        defersToUpstreamHitlExecution,
+        toolNameMapping,
+        executableTools,
+        builtinExecutableTools: builtinExecutableTools,
+        callRuntimeWithToolParseRecovery: options.callRuntimeWithToolParseRecovery,
+    });
+    const result = localOrUpstreamInvocation.result;
+    const executedToolResults = [...localOrUpstreamInvocation.executedToolResults];
+    if (!result) {
+        throw new Error("Agent invocation returned no result");
+    }
+    return finalizeInvocationResult({
+        bindingAgentId: options.binding.agent.id,
+        threadId: options.threadId,
+        runId: options.runId,
+        result,
+        executedToolResults,
+    });
+}

package/dist/runtime/adapter/{invoke-runtime.d.ts → flow/invoke-runtime.d.ts}

@@ -1,6 +1,6 @@
-import type { CompiledAgentBinding, CompiledTool } from "../../contracts/types.js";
-import type { ExecutedToolResult } from "./invocation-result.js";
-import type { ToolNameMapping } from "./tool/tool-name-mapping.js";
+import type { CompiledAgentBinding, CompiledTool } from "../../../contracts/types.js";
+import type { ExecutedToolResult } from "../invocation-result.js";
+import type { ToolNameMapping } from "../tool/tool-name-mapping.js";
 export type ExecutableTool = {
     name: string;
     schema: unknown;

package/dist/runtime/adapter/{invoke-runtime.js → flow/invoke-runtime.js}

@@ -1,4 +1,4 @@
-import { runLocalToolInvocationLoop } from "./local-tool-invocation.js";
+import { runLocalToolInvocationLoop } from "../local-tool-invocation.js";
 export async function invokeRuntimeWithLocalTools(options) {
     if (options.resumePayload !== undefined || options.defersToUpstreamHitlExecution) {
         return {

package/dist/runtime/adapter/flow/runnable-assembly.d.ts

@@ -0,0 +1,51 @@
+import type { CompiledAgentBinding, CompiledModel, CompiledSubAgent, CompiledTool, DeepAgentParams, LangChainAgentParams, RuntimeAdapterOptions } from "../../../contracts/types.js";
+export declare function resolveRunnableCheckpointer(options: RuntimeAdapterOptions, binding: CompiledAgentBinding): unknown;
+export declare function resolveRunnableInterruptOn(binding: CompiledAgentBinding): Record<string, {
+    allowedDecisions: import("../tool/interrupt-policy.js").InterruptDecision[];
+}> | undefined;
+export declare function assembleLangChainRunnable(input: {
+    binding: CompiledAgentBinding;
+    runtimeAdapterOptions: RuntimeAdapterOptions;
+    passthroughOverride?: Record<string, unknown>;
+    systemPromptOverride?: string;
+    resolveModel: (model: CompiledModel) => Promise<unknown>;
+    resolveTools: (tools: CompiledTool[], binding?: CompiledAgentBinding) => unknown[];
+    resolveMiddleware: (binding: CompiledAgentBinding, interruptOn?: Record<string, {
+        allowedDecisions: Array<"approve" | "edit" | "reject">;
+    }>) => Promise<unknown[]>;
+}): Promise<{
+    langchainParams: LangChainAgentParams;
+    interruptOn?: Record<string, {
+        allowedDecisions: Array<"approve" | "edit" | "reject">;
+    }>;
+    resolvedModel: unknown;
+    resolvedTools: unknown[];
+    resolvedMiddleware: unknown[];
+    resolvedCheckpointer: unknown;
+    resolvedStore: unknown;
+    passthroughOverride?: Record<string, unknown>;
+    systemPromptOverride?: string;
+}>;
+export declare function assembleDeepAgentRunnable(input: {
+    binding: CompiledAgentBinding;
+    runtimeAdapterOptions: RuntimeAdapterOptions;
+    resolveModel: (model: CompiledModel) => Promise<unknown>;
+    resolveTools: (tools: CompiledTool[], binding?: CompiledAgentBinding) => unknown[];
+    resolveMiddleware: (binding: CompiledAgentBinding, interruptOn?: Record<string, {
+        allowedDecisions: Array<"approve" | "edit" | "reject">;
+    }>) => Promise<unknown[]>;
+    resolveSubagents: (subagents: CompiledSubAgent[], binding?: CompiledAgentBinding) => Promise<CompiledSubAgent[]>;
+}): Promise<{
+    compatibleParams: DeepAgentParams;
+    resolvedModel: unknown;
+    resolvedTools: unknown[];
+    resolvedMiddleware: unknown[];
+    resolvedSubagents: CompiledSubAgent[];
+    resolvedCheckpointer: unknown;
+    resolvedStore: unknown;
+    resolvedBackend: unknown;
+    resolvedInterruptOn?: Record<string, {
+        allowedDecisions: Array<"approve" | "edit" | "reject">;
+    }>;
+    resolvedSkills: string[];
+}>;

package/dist/runtime/adapter/flow/runnable-assembly.js

@@ -0,0 +1,52 @@
+import { MemorySaver } from "@langchain/langgraph";
+import { applyDeepAgentDelegationPromptCompatibility, resolveDeepAgentSkillSourcePaths, } from "../compat/deepagent-compat.js";
+import { compileInterruptOn } from "../tool/interrupt-policy.js";
+import { getBindingDeepAgentParams, getBindingInterruptCompatibilityRules, getBindingLangChainParams, getBindingPrimaryTools, } from "../../support/compiled-binding.js";
+export function resolveRunnableCheckpointer(options, binding) {
+    return options.checkpointerResolver ? options.checkpointerResolver(binding) : new MemorySaver();
+}
+export function resolveRunnableInterruptOn(binding) {
+    return compileInterruptOn(getBindingPrimaryTools(binding), getBindingInterruptCompatibilityRules(binding));
+}
+export async function assembleLangChainRunnable(input) {
+    const langchainParams = getBindingLangChainParams(input.binding);
+    if (!langchainParams) {
+        throw new Error(`Agent ${input.binding.agent.id} has no langchain params`);
+    }
+    const interruptOn = resolveRunnableInterruptOn(input.binding);
+    return {
+        langchainParams,
+        interruptOn,
+        resolvedModel: await input.resolveModel(langchainParams.model),
+        resolvedTools: input.resolveTools(langchainParams.tools, input.binding),
+        resolvedMiddleware: await input.resolveMiddleware(input.binding, interruptOn),
+        resolvedCheckpointer: resolveRunnableCheckpointer(input.runtimeAdapterOptions, input.binding),
+        resolvedStore: input.runtimeAdapterOptions.storeResolver?.(input.binding),
+        passthroughOverride: input.passthroughOverride,
+        systemPromptOverride: input.systemPromptOverride,
+    };
+}
+export async function assembleDeepAgentRunnable(input) {
+    const deepAgentParams = getBindingDeepAgentParams(input.binding);
+    if (!deepAgentParams) {
+        throw new Error(`Agent ${input.binding.agent.id} has no runnable params`);
+    }
+    const compatibleParams = applyDeepAgentDelegationPromptCompatibility(deepAgentParams.model, deepAgentParams);
+    return {
+        compatibleParams,
+        resolvedModel: await input.resolveModel(compatibleParams.model),
+        resolvedTools: input.resolveTools(compatibleParams.tools, input.binding),
+        resolvedMiddleware: await input.resolveMiddleware(input.binding),
+        resolvedSubagents: await input.resolveSubagents(compatibleParams.subagents, input.binding),
+        resolvedCheckpointer: resolveRunnableCheckpointer(input.runtimeAdapterOptions, input.binding),
+        resolvedStore: input.runtimeAdapterOptions.storeResolver?.(input.binding),
+        resolvedBackend: input.runtimeAdapterOptions.backendResolver?.(input.binding),
+        resolvedInterruptOn: resolveRunnableInterruptOn(input.binding),
+        resolvedSkills: resolveDeepAgentSkillSourcePaths({
+            workspaceRoot: input.binding.harnessRuntime.workspaceRoot,
+            runRoot: input.binding.harnessRuntime.runRoot,
+            ownerId: input.binding.agent.id,
+            skillPaths: compatibleParams.skills,
+        }) ?? [],
+    };
+}

package/dist/runtime/adapter/{stream-runtime.d.ts → flow/stream-runtime.d.ts}

@@ -1,6 +1,6 @@
-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";
+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>>;

package/dist/runtime/adapter/{stream-runtime.js → flow/stream-runtime.js}

@@ -1,9 +1,9 @@
-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";
+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 {

package/dist/runtime/adapter/middleware-assembly.d.ts

@@ -1,6 +1,17 @@
 import { FilesystemBackend } from "deepagents";
 import type { CompiledAgentBinding, CompiledModel, CompiledSubAgent, DeepAgentParams, RuntimeAdapterOptions } from "../../contracts/types.js";
-import type { ExecutableTool } from "./invoke-runtime.js";
+import type { ExecutableTool } from "./flow/invoke-runtime.js";
+export declare function buildBuiltinTaskSubagentRunnableConfig(input: {
+    selectedSubagent: CompiledSubAgent;
+    defaultModel: unknown;
+    defaultTools: unknown[];
+    middleware: unknown[];
+}): Record<string, unknown>;
+export declare function buildBuiltinTaskSubagentMiddleware(input: {
+    selectedSubagent: CompiledSubAgent;
+    builtinBackend: unknown;
+    summarizationModel: unknown;
+}): unknown[];
 export declare function resolveBuiltinMiddlewareBackend(input: {
     binding: CompiledAgentBinding;
     runtimeAdapterOptions: RuntimeAdapterOptions;

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

@@ -4,10 +4,47 @@ 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, isRecord } from "./runtime-adapter-support.js";
+import { isRecord } from "../../utils/object.js";
 import { resolveDeclaredMiddleware } from "./tool/declared-middleware.js";
-import { getBindingDeepAgentParams, getBindingInterruptCompatibilityRules, getBindingLangChainParams, getBindingMiddlewareConfigs, getBindingPrimaryModel, isDeepAgentBinding, isLangChainBinding, } from "../support/compiled-binding.js";
+import { bindingHasLangChainSubagentSupport, bindingHasMiddlewareKind, getBindingDeepAgentParams, getBindingInterruptCompatibilityRules, getBindingLangChainParams, getBindingMiddlewareConfigs, getBindingPrimaryModel, isDeepAgentBinding, isLangChainBinding, } from "../support/compiled-binding.js";
 import { applyDeepAgentDelegationPromptCompatibility, materializeDeepAgentSkillSourcePaths } from "./compat/deepagent-compat.js";
+export function buildBuiltinTaskSubagentRunnableConfig(input) {
+    const { selectedSubagent, defaultModel, defaultTools, middleware } = input;
+    return {
+        model: (selectedSubagent.model ?? defaultModel),
+        tools: (selectedSubagent.tools ?? defaultTools),
+        systemPrompt: selectedSubagent.systemPrompt ?? DEFAULT_SUBAGENT_PROMPT,
+        middleware: middleware,
+        responseFormat: selectedSubagent.responseFormat,
+        name: selectedSubagent.name,
+        description: selectedSubagent.description,
+    };
+}
+export function buildBuiltinTaskSubagentMiddleware(input) {
+    const { selectedSubagent, builtinBackend, summarizationModel } = input;
+    const defaultSubagentMiddleware = [
+        createPatchToolCallsMiddleware(),
+        createSummarizationMiddleware({
+            model: summarizationModel,
+            backend: builtinBackend,
+        }),
+    ];
+    const subagentSkillsMiddleware = selectedSubagent.skills?.length
+        ? [createSkillsMiddleware({ backend: builtinBackend, sources: selectedSubagent.skills })]
+        : [];
+    const subagentMiddleware = selectedSubagent.middleware ?? [];
+    const interruptMiddleware = selectedSubagent.interruptOn
+        ? [humanInTheLoopMiddleware({
+                interruptOn: compileInterruptOn(selectedSubagent.tools ?? [], selectedSubagent.interruptOn),
+            })]
+        : [];
+    return [
+        ...defaultSubagentMiddleware,
+        ...subagentSkillsMiddleware,
+        ...subagentMiddleware,
+        ...interruptMiddleware,
+    ];
+}
 function buildLangChainContextMiddleware(params) {
     const middleware = [];
     const hasSkills = (params.compatibleParams.skills?.length ?? 0) > 0;
@@ -51,22 +88,26 @@ export function resolveBuiltinMiddlewareBackend(input) {
     return new StateBackend(runtimeLike);
 }
 export async function resolveSubagents(input) {
-    return Promise.all(input.subagents.map(async (subagent) => ({
-        ...subagent,
-        ...(subagent.passthrough ?? {}),
-        model: subagent.model ? (await input.resolveModel(subagent.model)) : undefined,
-        tools: subagent.tools ? input.resolveTools(subagent.tools, input.binding) : undefined,
-        skills: await materializeDeepAgentSkillSourcePaths({
-            workspaceRoot: input.binding?.harnessRuntime.workspaceRoot,
-            runRoot: input.binding?.harnessRuntime.runRoot,
-            ownerId: `${input.binding?.agent.id ?? "agent"}-${subagent.name}`,
-            skillPaths: subagent.skills,
-        }),
-        interruptOn: compileInterruptOn(subagent.tools ?? [], subagent.interruptOn),
-        responseFormat: subagent.responseFormat,
-        contextSchema: subagent.contextSchema,
-        middleware: (await resolveDeclaredMiddleware(subagent.middleware, input.createDeclaredMiddlewareResolverOptions(input.binding))),
-    })));
+    return Promise.all(input.subagents.map(async (subagent) => {
+        // Only pass DeepAgents-supported subagent fields through to upstream middleware.
+        // Harness-only extensions stay internal instead of becoming a second subagent dialect.
+        return {
+            name: subagent.name,
+            description: subagent.description,
+            systemPrompt: subagent.systemPrompt,
+            model: subagent.model ? (await input.resolveModel(subagent.model)) : undefined,
+            tools: subagent.tools ? input.resolveTools(subagent.tools, input.binding) : undefined,
+            skills: await materializeDeepAgentSkillSourcePaths({
+                workspaceRoot: input.binding?.harnessRuntime.workspaceRoot,
+                runRoot: input.binding?.harnessRuntime.runRoot,
+                ownerId: `${input.binding?.agent.id ?? "agent"}-${subagent.name}`,
+                skillPaths: subagent.skills,
+            }),
+            interruptOn: compileInterruptOn(subagent.tools ?? [], subagent.interruptOn),
+            responseFormat: subagent.responseFormat,
+            middleware: (await resolveDeclaredMiddleware(subagent.middleware, input.createDeclaredMiddlewareResolverOptions(input.binding))),
+        };
+    }));
 }
 export async function invokeBuiltinTaskTool(input) {
     if (!isDeepAgentBinding(input.binding)) {
@@ -83,46 +124,23 @@ export async function invokeBuiltinTaskTool(input) {
     const resolvedSubagents = await input.resolveSubagents(params.subagents, input.binding);
     const selectedSubagent = resolvedSubagents.find((subagent) => subagent.name === subagentType);
     if (!selectedSubagent) {
-        const allowed = [
-            ...resolvedSubagents.map((subagent) => subagent.name),
-            ...(params.generalPurposeAgent ? ["general-purpose"] : []),
-        ];
+        const allowed = resolvedSubagents.map((subagent) => subagent.name);
         throw new Error(`Error: invoked agent of type ${subagentType}, the only allowed types are ${allowed.map((name) => `\`${name}\``).join(", ")}`);
     }
     const summarizationModel = selectedSubagent.model
         ? await input.resolveModel(selectedSubagent.model)
         : await input.resolveModel(params.model);
-    const middleware = [
-        ...(selectedSubagent.skills?.length
-            ? [createSkillsMiddleware({ backend: builtinBackend, sources: selectedSubagent.skills })]
-            : []),
-        ...(selectedSubagent.memory?.length
-            ? [createMemoryMiddleware({ backend: builtinBackend, sources: selectedSubagent.memory })]
-            : []),
-        ...(selectedSubagent.middleware ??
-            [
-                createPatchToolCallsMiddleware(),
-                createSummarizationMiddleware({
-                    model: summarizationModel,
-                    backend: builtinBackend,
-                }),
-            ]),
-        ...(selectedSubagent.interruptOn
-            ? [humanInTheLoopMiddleware({
-                    interruptOn: compileInterruptOn(selectedSubagent.tools ?? [], selectedSubagent.interruptOn),
-                })]
-            : []),
-    ];
-    const runnable = createAgent({
-        model: (selectedSubagent.model ?? (await input.resolveModel(params.model))),
-        tools: (selectedSubagent.tools ?? input.resolveTools(params.tools, input.binding)),
-        systemPrompt: selectedSubagent.systemPrompt ?? DEFAULT_SUBAGENT_PROMPT,
-        middleware: middleware,
-        responseFormat: selectedSubagent.responseFormat,
-        contextSchema: selectedSubagent.contextSchema,
-        name: selectedSubagent.name,
-        description: selectedSubagent.description,
+    const middleware = buildBuiltinTaskSubagentMiddleware({
+        selectedSubagent,
+        builtinBackend,
+        summarizationModel,
     });
+    const runnable = createAgent(buildBuiltinTaskSubagentRunnableConfig({
+        selectedSubagent,
+        defaultModel: await input.resolveModel(params.model),
+        defaultTools: input.resolveTools(params.tools, input.binding),
+        middleware,
+    }));
     const result = await runnable.invoke({ messages: [new HumanMessage({ content: description })] }, { configurable: { thread_id: `${input.binding.agent.id}:builtin-task` }, ...(input.options?.context ? { context: input.options.context } : {}) });
     const visibleOutput = extractVisibleOutput(result);
     const fallbackOutput = extractToolFallbackContext(result);
@@ -138,7 +156,7 @@ export async function resolveBuiltinMiddlewareTools(input) {
     });
 }
 export async function resolveAutomaticSummarizationMiddleware(input) {
-    if (hasConfiguredMiddlewareKind(input.binding, "summarization")) {
+    if (bindingHasMiddlewareKind(input.binding, "summarization")) {
         return [];
     }
     const primaryModel = getBindingPrimaryModel(input.binding);
@@ -161,7 +179,7 @@ export async function resolveLangChainAutomaticMiddleware(input) {
         compatibleParams,
         resolveFilesystemBackend: input.resolveFilesystemBackend,
     }));
-    if (hasConfiguredSubagentSupport(input.binding)) {
+    if (bindingHasLangChainSubagentSupport(input.binding)) {
         automaticMiddleware.push(createSubAgentMiddleware({
             defaultModel: (await input.resolveModel(compatibleParams.model)),
             defaultTools: input.resolveTools(compatibleParams.tools, input.binding),

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

@@ -27,14 +27,11 @@ type LangChainRunnableConfigParams = {
 };
 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[];

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

@@ -37,7 +37,6 @@ export function buildLangChainRunnableConfig(params) {
 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,
@@ -45,8 +44,6 @@ export function buildDeepAgentRunnableConfig(params) {
             name: compatibleParams.name,
             memory: compatibleParams.memory,
             skills: resolvedSkills,
-            generalPurposeAgent: compatibleParams.generalPurposeAgent,
-            taskDescription: compatibleParams.taskDescription,
         },
         resolved: {
             resolvedModel,

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

@@ -1,10 +1,3 @@
-import type { CompiledAgentBinding } from "../../contracts/types.js";
-export declare function countConfiguredTools(binding: CompiledAgentBinding): number;
-export declare function sleep(ms: number): Promise<void>;
-export declare function hasConfiguredSubagentSupport(binding: CompiledAgentBinding): boolean;
-export declare function hasConfiguredMiddlewareKind(binding: CompiledAgentBinding, kind: string): boolean;
-export declare function isRecord(value: unknown): value is Record<string, unknown>;
-export declare function isObject(value: unknown): value is Record<string, unknown>;
 export declare function truncateLines(lines: string[], maxChars?: number): string;
 export declare function summarizeBuiltinWriteTodosArgs(args: Record<string, unknown>): {
     total: number;

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

@@ -1,23 +1,4 @@
-import { bindingHasLangChainSubagentSupport, bindingHasMiddlewareKind, getBindingToolCount, } from "../support/compiled-binding.js";
-import { isRecord as isRecordValue } from "../../utils/object.js";
-export function countConfiguredTools(binding) {
-    return getBindingToolCount(binding);
-}
-export function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-export function hasConfiguredSubagentSupport(binding) {
-    return bindingHasLangChainSubagentSupport(binding);
-}
-export function hasConfiguredMiddlewareKind(binding, kind) {
-    return bindingHasMiddlewareKind(binding, kind);
-}
-export function isRecord(value) {
-    return isRecordValue(value);
-}
-export function isObject(value) {
-    return isRecord(value);
-}
+import { isRecord } from "../../utils/object.js";
 export function truncateLines(lines, maxChars = 12_000) {
     const joined = lines.join("\n");
     if (joined.length <= maxChars) {

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

@@ -1,7 +1,7 @@
+import { setTimeout as sleep } from "node:timers/promises";
 import { extractVisibleOutput, isToolCallParseFailure, STRICT_TOOL_JSON_INSTRUCTION } from "../parsing/output-parsing.js";
 import { readStreamDelta } from "../parsing/stream-event-parsing.js";
 import { computeRemainingTimeoutMs, isRetryableProviderError, resolveProviderRetryPolicy } from "./resilience.js";
-import { sleep } from "./runtime-adapter-support.js";
 import { getBindingDeepAgentParams, getBindingLangChainParams, isDeepAgentBinding, isLangChainBinding, } from "../support/compiled-binding.js";
 export class RuntimeOperationTimeoutError extends Error {
     operation;

package/dist/runtime/adapter/tool/builtin-middleware-tools.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { isSandboxBackend } from "deepagents";
-import { summarizeBuiltinWriteTodosArgs, truncateLines, isObject } from "../runtime-adapter-support.js";
+import { isRecord } from "../../../utils/object.js";
+import { summarizeBuiltinWriteTodosArgs, truncateLines } from "../runtime-adapter-support.js";
 export async function createBuiltinMiddlewareTools(backend, options) {
     const tools = new Map();
     tools.set("write_todos", {
@@ -9,7 +10,7 @@ export async function createBuiltinMiddlewareTools(backend, options) {
             todos: z.array(z.object({}).passthrough()).optional(),
         }).passthrough(),
         invoke: async (input) => {
-            const args = isObject(input) ? input : {};
+            const args = isRecord(input) ? input : {};
             const summary = summarizeBuiltinWriteTodosArgs(args);
             return {
                 ok: true,
@@ -23,7 +24,7 @@ export async function createBuiltinMiddlewareTools(backend, options) {
         name: "ls",
         schema: z.object({ path: z.string().optional().default("/") }).passthrough(),
         invoke: async (input) => {
-            const targetPath = isObject(input) && typeof input.path === "string" ? input.path : "/";
+            const targetPath = isRecord(input) && typeof input.path === "string" ? input.path : "/";
             const infos = (await Promise.resolve(backend.lsInfo?.(targetPath))) ?? [];
             if (infos.length === 0) {
                 return `No files found in ${targetPath}`;
@@ -39,7 +40,7 @@ export async function createBuiltinMiddlewareTools(backend, options) {
             limit: z.number().optional(),
         }).passthrough(),
         invoke: async (input) => {
-            const typed = isObject(input) ? input : {};
+            const typed = isRecord(input) ? input : {};
             const filePath = typeof typed.file_path === "string" ? typed.file_path : "";
             const offset = typeof typed.offset === "number" ? typed.offset : 0;
             const limit = typeof typed.limit === "number" ? typed.limit : 500;
@@ -50,7 +51,7 @@ export async function createBuiltinMiddlewareTools(backend, options) {
         name: "write_file",
         schema: z.object({ file_path: z.string(), content: z.string().optional() }).passthrough(),
         invoke: async (input) => {
-            const typed = isObject(input) ? input : {};
+            const typed = isRecord(input) ? input : {};
             const result = await Promise.resolve(backend.write?.(typeof typed.file_path === "string" ? typed.file_path : "", typeof typed.content === "string" ? typed.content : ""));
             return result?.error ?? `Successfully wrote to '${result?.path ?? (typed.file_path ?? "")}'`;
         },
@@ -64,7 +65,7 @@ export async function createBuiltinMiddlewareTools(backend, options) {
             replace_all: z.boolean().optional(),
         }).passthrough(),
         invoke: async (input) => {
-            const typed = isObject(input) ? input : {};
+            const typed = isRecord(input) ? input : {};
             const result = await Promise.resolve(backend.edit?.(typeof typed.file_path === "string" ? typed.file_path : "", typeof typed.old_string === "string" ? typed.old_string : "", typeof typed.new_string === "string" ? typed.new_string : "", typed.replace_all === true));
             return result?.error ?? `Successfully replaced ${result?.occurrences ?? 0} occurrence(s) in '${result?.path ?? (typed.file_path ?? "")}'`;
         },
@@ -73,7 +74,7 @@ export async function createBuiltinMiddlewareTools(backend, options) {
         name: "glob",
         schema: z.object({ pattern: z.string(), path: z.string().optional().default("/") }).passthrough(),
         invoke: async (input) => {
-            const typed = isObject(input) ? input : {};
+            const typed = isRecord(input) ? input : {};
             const pattern = typeof typed.pattern === "string" ? typed.pattern : "";
             const targetPath = typeof typed.path === "string" ? typed.path : "/";
             const infos = (await Promise.resolve(backend.globInfo?.(pattern, targetPath))) ?? [];
@@ -91,7 +92,7 @@ export async function createBuiltinMiddlewareTools(backend, options) {
             glob: z.string().nullable().optional(),
         }).passthrough(),
         invoke: async (input) => {
-            const typed = isObject(input) ? input : {};
+            const typed = isRecord(input) ? input : {};
             const result = await Promise.resolve(backend.grepRaw?.(typeof typed.pattern === "string" ? typed.pattern : "", typeof typed.path === "string" ? typed.path : "/", typeof typed.glob === "string" ? typed.glob : null));
             if (typeof result === "string") {
                 return result;
@@ -118,7 +119,7 @@ export async function createBuiltinMiddlewareTools(backend, options) {
             if (!isSandboxBackend(backend) || typeof backend.execute !== "function") {
                 return "Error: Execution not available. This agent's backend does not support command execution (SandboxBackendProtocol).";
             }
-            const typed = isObject(input) ? input : {};
+            const typed = isRecord(input) ? input : {};
             const result = await Promise.resolve(backend.execute(typeof typed.command === "string" ? typed.command : ""));
             const parts = [result.output];
             if (result.exitCode !== null) {

package/dist/runtime/adapter/tool-resolution.d.ts

@@ -1,6 +1,6 @@
 import type { CompiledAgentBinding, CompiledTool } from "../../contracts/types.js";
 import { type ToolNameMapping } from "./tool/tool-name-mapping.js";
-import type { ExecutableTool } from "./invoke-runtime.js";
+import type { ExecutableTool } from "./flow/invoke-runtime.js";
 export declare function resolveAdapterTools(input: {
     tools: Array<CompiledTool>;
     binding?: CompiledAgentBinding;

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

@@ -1,7 +1,7 @@
 import type { CompiledAgentBinding, MessageContent, RunResult, RuntimeAdapterOptions, TranscriptMessage } from "../contracts/types.js";
 import { type RuntimeStreamChunk } from "./parsing/stream-event-parsing.js";
 import { RuntimeOperationTimeoutError } from "./adapter/runtime-shell.js";
-export { applyDeepAgentDelegationPromptCompatibility, materializeDeepAgentSkillSourcePaths, relativizeDeepAgentSkillSourcePaths, shouldRelaxDeepAgentDelegationPrompt, } from "./adapter/compat/deepagent-compat.js";
+export { applyDeepAgentDelegationPromptCompatibility, materializeDeepAgentSkillSourcePaths, resolveDeepAgentSkillSourcePaths, 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";