@botbotgo/agent-harness 0.0.327 → 0.0.329

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

@@ -37,7 +37,6 @@ export function summarizeBuiltinWriteTodosArgs(args) {
         completed: items.filter((item) => item.status === "completed").length,
         failed: items.filter((item) => item.status === "failed").length,
         cancelled: items.filter((item) => item.status === "cancelled").length,
-        blocked: items.filter((item) => item.status === "blocked").length,
     };
     return {
         items,
@@ -56,7 +55,7 @@ export function formatBuiltinTodoSnapshot(snapshot) {
         return "No todos tracked.";
     }
     const lines = [
-        `Tracked ${snapshot.summary.total} todo item(s): ${snapshot.summary.pending + snapshot.summary.inProgress + snapshot.summary.blocked} pending, ${snapshot.summary.completed} completed.`,
+        `Tracked ${snapshot.summary.total} todo item(s): ${snapshot.summary.pending + snapshot.summary.inProgress} pending, ${snapshot.summary.completed} completed.`,
         ...snapshot.items.map((item, index) => `${index + 1}. [${item.status}] ${item.content}`),
     ];
     return truncateLines(lines);

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

@@ -5,6 +5,21 @@ export type StreamEventProjectionState = {
     emittedOutput: string;
     emittedToolError: boolean;
     emittedToolResult: boolean;
+    emittedSuccessfulToolResult: boolean;
+    emittedSuccessfulTaskResult: boolean;
+    emittedPlaceholderTaskResult: boolean;
+    hasFailedTaskDelegation: boolean;
+    emittedNonTodoToolResult: boolean;
+    emittedSuccessfulNonTodoToolResult: boolean;
+    sawDelegatedAgentWithConfiguredTools: boolean;
+    emittedDelegatedExecutionToolResult: boolean;
+    emittedSuccessfulDelegatedExecutionToolResult: boolean;
+    emittedDelegatedTerminalOutput: boolean;
+    sawPlanState: boolean;
+    hasIncompletePlanState: boolean;
+    openTaskDelegations: number;
+    openToolCapableTaskDelegations: number;
+    taskDelegationHasToolsStack: boolean[];
     seenTerminalOutputs: Set<string>;
 };
 export declare function createStreamEventProjectionState(): StreamEventProjectionState;
@@ -12,6 +27,8 @@ export declare function projectRuntimeStreamEvent(params: {
     event: unknown;
     allowVisibleStreamDeltas: boolean;
     includeStateStreamOutput: boolean;
+    rootAgentId?: string;
+    countConfiguredToolsForAgentId?: (agentId: string) => number;
     toolNameMapping: ToolNameMapping;
     primaryTools: CompiledTool[];
     state: StreamEventProjectionState;

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

@@ -6,15 +6,190 @@ export function createStreamEventProjectionState() {
         emittedOutput: "",
         emittedToolError: false,
         emittedToolResult: false,
+        emittedSuccessfulToolResult: false,
+        emittedSuccessfulTaskResult: false,
+        emittedPlaceholderTaskResult: false,
+        hasFailedTaskDelegation: false,
+        emittedNonTodoToolResult: false,
+        emittedSuccessfulNonTodoToolResult: false,
+        sawDelegatedAgentWithConfiguredTools: false,
+        emittedDelegatedExecutionToolResult: false,
+        emittedSuccessfulDelegatedExecutionToolResult: false,
+        emittedDelegatedTerminalOutput: false,
+        sawPlanState: false,
+        hasIncompletePlanState: false,
+        openTaskDelegations: 0,
+        openToolCapableTaskDelegations: 0,
+        taskDelegationHasToolsStack: [],
         seenTerminalOutputs: new Set(),
     };
 }
+function readSummaryCounts(summary) {
+    if (typeof summary !== "object" || summary === null) {
+        return null;
+    }
+    const typed = summary;
+    const hasAnyCountField = typeof typed.pending === "number"
+        || typeof typed.inProgress === "number";
+    if (!hasAnyCountField) {
+        return null;
+    }
+    return {
+        pending: typeof typed.pending === "number" ? typed.pending : 0,
+        inProgress: typeof typed.inProgress === "number" ? typed.inProgress : 0,
+    };
+}
+function hasIncompleteTodosArray(value) {
+    if (!Array.isArray(value)) {
+        return null;
+    }
+    return value.some((item) => {
+        if (typeof item !== "object" || item === null) {
+            return false;
+        }
+        const status = item.status;
+        return status === "pending" || status === "in_progress";
+    });
+}
+function getPlanStateCompleteness(value) {
+    if (typeof value !== "object" || value === null) {
+        return null;
+    }
+    const typed = value;
+    const summaryCounts = readSummaryCounts(typed.summary);
+    if (summaryCounts) {
+        return summaryCounts.pending > 0 || summaryCounts.inProgress > 0;
+    }
+    if (typeof typed.summary === "object" && typed.summary !== null) {
+        const nestedSummary = getPlanStateCompleteness(typed.summary);
+        if (nestedSummary !== null) {
+            return nestedSummary;
+        }
+    }
+    const directTodos = hasIncompleteTodosArray(typed.todos);
+    if (directTodos !== null) {
+        return directTodos;
+    }
+    if (typeof typed.update === "object" && typed.update !== null) {
+        const nestedTodos = hasIncompleteTodosArray(typed.update.todos);
+        if (nestedTodos !== null) {
+            return nestedTodos;
+        }
+    }
+    if (typeof typed.output === "object" && typed.output !== null) {
+        const nestedOutput = getPlanStateCompleteness(typed.output);
+        if (nestedOutput !== null) {
+            return nestedOutput;
+        }
+    }
+    if (typeof typed.data === "object" && typed.data !== null) {
+        const nestedData = getPlanStateCompleteness(typed.data);
+        if (nestedData !== null) {
+            return nestedData;
+        }
+    }
+    return null;
+}
+function parseMaybeJsonString(value) {
+    const trimmed = value.trim();
+    if (!trimmed || (!trimmed.startsWith("{") && !trimmed.startsWith("["))) {
+        return value;
+    }
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        return value;
+    }
+}
+function unwrapPossibleToolInput(value) {
+    if (typeof value === "string") {
+        return parseMaybeJsonString(value);
+    }
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return value;
+    }
+    const typed = value;
+    if (typed.args !== undefined) {
+        return unwrapPossibleToolInput(typed.args);
+    }
+    if (typed.input !== undefined) {
+        return unwrapPossibleToolInput(typed.input);
+    }
+    return value;
+}
+function readTaskSubagentType(value) {
+    const unwrapped = unwrapPossibleToolInput(value);
+    if (typeof unwrapped !== "object" || unwrapped === null || Array.isArray(unwrapped)) {
+        return null;
+    }
+    const typed = unwrapped;
+    return typeof typed.subagent_type === "string" && typed.subagent_type.trim().length > 0
+        ? typed.subagent_type.trim()
+        : null;
+}
+function isUpstreamPlaceholderTaskResult(value) {
+    if (typeof value === "string") {
+        return value.trim() === "Task completed";
+    }
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return false;
+    }
+    const typed = value;
+    const messages = Array.isArray(typed.update?.messages) ? typed.update.messages : [];
+    if (messages.length !== 1) {
+        return false;
+    }
+    const message = messages[0];
+    return typed.lg_name === "Command"
+        && typed.lc_direct_tool_output === true
+        && message?.name === "task"
+        && message?.type === "tool"
+        && typeof message?.tool_call_id === "string"
+        && message?.content === "Task completed";
+}
+function updateDelegationState(state, event, countConfiguredToolsForAgentId) {
+    if (typeof event !== "object" || event === null) {
+        return;
+    }
+    const typed = event;
+    const eventName = typeof typed.event === "string" ? typed.event : "";
+    const toolName = typeof typed.name === "string" ? typed.name : "";
+    const runType = typeof typed.run_type === "string" ? typed.run_type : "";
+    const isTaskStart = toolName === "task" && (eventName === "on_tool_start" || (eventName === "on_chain_start" && runType === "tool"));
+    const isTaskEnd = toolName === "task" && (eventName === "on_tool_end" || (eventName === "on_chain_end" && runType === "tool"));
+    const isTaskError = toolName === "task" && (eventName === "on_tool_error" || (eventName === "on_chain_error" && runType === "tool"));
+    if (isTaskStart) {
+        state.openTaskDelegations += 1;
+        const delegatedSubagentType = readTaskSubagentType(typed.data?.input);
+        const delegatedTaskHasTools = !!delegatedSubagentType
+            && !!countConfiguredToolsForAgentId
+            && countConfiguredToolsForAgentId(delegatedSubagentType) > 0;
+        state.taskDelegationHasToolsStack.push(delegatedTaskHasTools);
+        if (delegatedTaskHasTools) {
+            state.sawDelegatedAgentWithConfiguredTools = true;
+            state.openToolCapableTaskDelegations += 1;
+        }
+        return;
+    }
+    if (isTaskEnd || isTaskError) {
+        state.openTaskDelegations = Math.max(0, state.openTaskDelegations - 1);
+        const delegatedTaskHadTools = state.taskDelegationHasToolsStack.pop() === true;
+        if (delegatedTaskHadTools) {
+            state.openToolCapableTaskDelegations = Math.max(0, state.openToolCapableTaskDelegations - 1);
+        }
+        if (isTaskError) {
+            state.hasFailedTaskDelegation = true;
+        }
+    }
+}
 export function projectRuntimeStreamEvent(params) {
-    const { event, allowVisibleStreamDeltas, includeStateStreamOutput, toolNameMapping, primaryTools, state, } = params;
+    const { event, allowVisibleStreamDeltas, includeStateStreamOutput, rootAgentId, countConfiguredToolsForAgentId, toolNameMapping, primaryTools, state, } = params;
     const chunks = [{
             kind: "upstream-event",
             event: sanitizeRetainedUpstreamEvent(event),
         }];
+    updateDelegationState(state, event, countConfiguredToolsForAgentId);
     const interruptPayload = extractInterruptPayload(event);
     if (interruptPayload) {
         chunks.push({ kind: "interrupt", content: interruptPayload });
@@ -24,7 +199,24 @@ export function projectRuntimeStreamEvent(params) {
     if (reasoning) {
         chunks.push({ kind: "reasoning", content: reasoning });
     }
-    if (allowVisibleStreamDeltas) {
+    const planStateCompleteness = getPlanStateCompleteness(event);
+    if (planStateCompleteness !== null) {
+        state.sawPlanState = true;
+        state.hasIncompletePlanState = planStateCompleteness;
+    }
+    const eventAgentId = typeof event === "object" && event !== null && typeof event.agentId === "string"
+        ? event.agentId.trim()
+        : "";
+    const isDelegatedAgentEvent = !!rootAgentId && !!eventAgentId && eventAgentId !== rootAgentId;
+    if (isDelegatedAgentEvent
+        && countConfiguredToolsForAgentId
+        && countConfiguredToolsForAgentId(eventAgentId) > 0) {
+        state.sawDelegatedAgentWithConfiguredTools = true;
+    }
+    const isRootVisibleEvent = !rootAgentId || !eventAgentId || eventAgentId === rootAgentId;
+    const allowVisibleContent = isRootVisibleEvent && state.openTaskDelegations === 0;
+    const allowStreamedVisibleContent = allowVisibleContent && !state.emittedToolResult && !state.emittedToolError;
+    if (allowVisibleStreamDeltas && allowStreamedVisibleContent) {
         const visibleStreamOutput = extractVisibleStreamOutput(event);
         if (visibleStreamOutput) {
             const nextOutput = computeIncrementalOutput(state.emittedOutput, visibleStreamOutput);
@@ -34,7 +226,7 @@ export function projectRuntimeStreamEvent(params) {
             }
         }
     }
-    if (includeStateStreamOutput) {
+    if (includeStateStreamOutput && allowVisibleContent) {
         const stateStreamOutput = extractStateStreamOutput(event);
         if (stateStreamOutput) {
             const nextOutput = computeIncrementalOutput(state.emittedOutput, sanitizeVisibleText(stateStreamOutput));
@@ -46,8 +238,23 @@ export function projectRuntimeStreamEvent(params) {
     }
     const toolResult = extractToolResult(event);
     if (toolResult) {
+        const isTodoTool = toolResult.toolName === "write_todos" || toolResult.toolName === "read_todos";
+        const isSuccessfulTaskResult = toolResult.toolName === "task" && toolResult.isError !== true;
+        const isPlaceholderTaskResult = isSuccessfulTaskResult && isUpstreamPlaceholderTaskResult(toolResult.output);
+        const isDelegatedExecutionTool = (isDelegatedAgentEvent || state.openToolCapableTaskDelegations > 0)
+            && toolResult.toolName !== "write_todos"
+            && toolResult.toolName !== "read_todos"
+            && toolResult.toolName !== "task";
         state.emittedToolResult = true;
         state.emittedToolError = state.emittedToolError || toolResult.isError === true;
+        state.emittedSuccessfulToolResult = state.emittedSuccessfulToolResult || toolResult.isError !== true;
+        state.emittedSuccessfulTaskResult = state.emittedSuccessfulTaskResult || isSuccessfulTaskResult;
+        state.emittedPlaceholderTaskResult = state.emittedPlaceholderTaskResult || isPlaceholderTaskResult;
+        state.emittedNonTodoToolResult = state.emittedNonTodoToolResult || !isTodoTool;
+        state.emittedSuccessfulNonTodoToolResult = state.emittedSuccessfulNonTodoToolResult || (!isTodoTool && toolResult.isError !== true);
+        state.emittedDelegatedExecutionToolResult = state.emittedDelegatedExecutionToolResult || isDelegatedExecutionTool;
+        state.emittedSuccessfulDelegatedExecutionToolResult =
+            state.emittedSuccessfulDelegatedExecutionToolResult || (isDelegatedExecutionTool && toolResult.isError !== true);
         chunks.push({
             kind: "tool-result",
             toolName: resolveModelFacingToolName(toolResult.toolName, toolNameMapping, primaryTools),
@@ -55,7 +262,13 @@ export function projectRuntimeStreamEvent(params) {
             isError: toolResult.isError,
         });
     }
-    const output = extractTerminalStreamOutput(event);
+    const output = allowVisibleContent ? extractTerminalStreamOutput(event) : "";
+    if (!allowVisibleContent) {
+        const delegatedTerminalOutput = extractTerminalStreamOutput(event);
+        if (delegatedTerminalOutput) {
+            state.emittedDelegatedTerminalOutput = true;
+        }
+    }
     if (output) {
         const outputKey = normalizeTerminalOutputKey(output);
         if (!outputKey || !state.seenTerminalOutputs.has(outputKey)) {

package/dist/runtime/adapter/tool/builtin-middleware-tools.d.ts

@@ -242,9 +242,6 @@ export declare const BUILTIN_MIDDLEWARE_TOOL_DESCRIPTORS: readonly [{
 }, {
     readonly name: "task";
     readonly description: "Delegate a bounded task to a subagent.";
-}, {
-    readonly name: "delegate_task";
-    readonly description: "Delegate a bounded task to a subagent.";
 }];
 export declare function createBuiltinMiddlewareTools(backend: BuiltinMiddlewareBackend, options: {
     includeTaskTool: boolean;

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

@@ -4,6 +4,28 @@ import { isSandboxBackend } from "deepagents";
 import { isRecord } from "../../../utils/object.js";
 import { formatBuiltinTodoSnapshot, isLowSignalTodoContent, summarizeBuiltinWriteTodosArgs, truncateLines } from "../runtime-adapter-support.js";
 import { maybePersistLargeToolOutput, resolveToolRuntimeContext } from "./tool-output-artifacts.js";
+const taskToolSchema = z.preprocess((value) => {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return value;
+    }
+    return normalizeTaskToolInput(value);
+}, z.object({
+    description: z.string(),
+    subagent_type: z.string(),
+}).passthrough());
+function normalizeTaskToolInput(typed) {
+    const description = typeof typed.description === "string" && typed.description.trim().length > 0
+        ? typed.description
+        : undefined;
+    const subagentType = typeof typed.subagent_type === "string" && typed.subagent_type.trim().length > 0
+        ? typed.subagent_type
+        : undefined;
+    return {
+        ...typed,
+        ...(description !== undefined ? { description } : {}),
+        ...(subagentType !== undefined ? { subagent_type: subagentType } : {}),
+    };
+}
 export const BUILTIN_MIDDLEWARE_TOOL_DESCRIPTORS = [
     { name: "write_todos", description: "Create and update the runtime todo board for multi-step work." },
     { name: "read_todos", description: "Read the current runtime todo board." },
@@ -23,7 +45,6 @@ export const BUILTIN_MIDDLEWARE_TOOL_DESCRIPTORS = [
     { name: "request_approval", description: "Request an approval decision from the runtime." },
     { name: "schedule_task", description: "Create, inspect, update, list, and delete system-level scheduled tasks." },
     { name: "task", description: "Delegate a bounded task to a subagent." },
-    { name: "delegate_task", description: "Delegate a bounded task to a subagent." },
 ];
 function toDisplayContent(content) {
     if (typeof content === "string") {
@@ -181,7 +202,6 @@ export async function createBuiltinMiddlewareTools(backend, options) {
             completed: 0,
             failed: 0,
             cancelled: 0,
-            blocked: 0,
         },
     };
     const finalizeOutput = async (toolName, output, toolConfig) => maybePersistLargeToolOutput({
@@ -193,7 +213,17 @@ export async function createBuiltinMiddlewareTools(backend, options) {
         name: "write_todos",
         description: "Create and update the runtime todo board for multi-step work.",
         schema: z.object({
-            todos: z.array(z.object({}).passthrough()).optional(),
+            todos: z.array(z.object({
+                id: z.string().optional(),
+                content: z.string().optional(),
+                description: z.string().optional(),
+                status: z.enum(["pending", "in_progress", "completed", "failed", "cancelled"]).optional(),
+                ownerAgentId: z.string().optional(),
+                startedAt: z.string().optional(),
+                endedAt: z.string().optional(),
+                result: z.unknown().optional(),
+                metadata: z.record(z.string(), z.unknown()).optional(),
+            }).passthrough()).optional(),
         }).passthrough(),
         invoke: async (input) => {
             const args = isRecord(input) ? input : {};
@@ -584,20 +614,10 @@ export async function createBuiltinMiddlewareTools(backend, options) {
         tools.set("task", {
             name: "task",
             description: "Delegate a bounded task to a subagent.",
-            schema: z.object({
-                description: z.string(),
-                subagent_type: z.string(),
-            }).passthrough(),
-            invoke: options.invokeTaskTool,
-        });
-        tools.set("delegate_task", {
-            name: "delegate_task",
-            description: "Delegate a bounded task to a subagent.",
-            schema: z.object({
-                description: z.string(),
-                subagent_type: z.string(),
-            }).passthrough(),
-            invoke: async (input) => tools.get("task").invoke(input),
+            schema: taskToolSchema,
+            invoke: async (input, config) => options.invokeTaskTool(typeof input === "object" && input !== null && !Array.isArray(input)
+                ? normalizeTaskToolInput(input)
+                : {}),
         });
     }
     return tools;

package/dist/runtime/adapter/tool/resolved-tool.js

@@ -19,6 +19,9 @@ function getZodLikeTypeName(value) {
         return undefined;
     }
     const typed = value;
+    if (typeof typed.def?.type === "string") {
+        return typed.def.type;
+    }
     if (typeof typed._zod?.def?.type === "string") {
         return typed._zod.def.type;
     }
@@ -32,7 +35,21 @@ function getZodLikeInnerSchema(value) {
         return undefined;
     }
     const typed = value;
-    return typed._zod?.def?.innerType ?? typed._zod?.def?.element ?? typed._zod?.def?.valueType ?? typed._def?.innerType ?? typed._def?.type ?? typed._def?.valueType;
+    return typed.def?.innerType
+        ?? typed.def?.element
+        ?? typed.def?.valueType
+        ?? typed.def?.schema
+        ?? typed.def?.out
+        ?? typed.def?.in
+        ?? typed._zod?.def?.innerType
+        ?? typed._zod?.def?.element
+        ?? typed._zod?.def?.valueType
+        ?? typed._def?.innerType
+        ?? typed._def?.schema
+        ?? typed._def?.type
+        ?? typed._def?.valueType
+        ?? typed._def?.in
+        ?? typed._def?.out;
 }
 function getZodLikeObjectShape(value) {
     if (typeof value !== "object" || value === null || Array.isArray(value)) {
@@ -58,7 +75,13 @@ function isZodLikeOptional(value) {
     if (!typeName) {
         return false;
     }
-    return typeName === "optional" || typeName === "default" || typeName === "catch";
+    if (typeName === "optional" || typeName === "default" || typeName === "catch") {
+        return true;
+    }
+    if (typeName === "effects" || typeName === "pipeline" || typeName === "pipe" || typeName === "transform") {
+        return isZodLikeOptional(getZodLikeInnerSchema(value));
+    }
+    return false;
 }
 function buildBestEffortJsonSchema(value) {
     const shape = isZodRawShape(value) ? value : getZodLikeObjectShape(value);
@@ -70,7 +93,7 @@ function buildBestEffortJsonSchema(value) {
         return {
             type: "object",
             properties,
-            ...(required.length > 0 ? { required } : {}),
+            required,
         };
     }
     const typeName = getZodLikeTypeName(value);
@@ -101,6 +124,9 @@ function buildBestEffortJsonSchema(value) {
             additionalProperties: buildBestEffortJsonSchema(getZodLikeInnerSchema(value)) ?? {},
         };
     }
+    if (typeName === "effects" || typeName === "pipeline" || typeName === "pipe" || typeName === "transform") {
+        return buildBestEffortJsonSchema(getZodLikeInnerSchema(value)) ?? {};
+    }
     return {};
 }
 function jsonSchemaPreservesShape(schema, expectedKeys) {

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

@@ -1,8 +1,8 @@
 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, buildMinimalDeepAgentCreateParams, materializeModelExposedBuiltinMiddlewareTools, resolveLangChainInvocationConfig, resolveRunnableCheckpointer, resolveRunnableInterruptOn, shouldUseMinimalDeepAgentAssembly } from "./agent-runtime-assembly.js";
+import { AGENT_INTERRUPT_SENTINEL_PREFIX, buildDeepAgentCreateParams, buildLangChainCreateParams, materializeModelExposedBuiltinMiddlewareTools, resolveLangChainInvocationConfig, resolveRunnableCheckpointer, resolveRunnableInterruptOn } from "./agent-runtime-assembly.js";
 import { RuntimeOperationTimeoutError } from "./adapter/runtime-shell.js";
-export { applyDeepAgentDelegationPromptCompatibility, materializeDeepAgentSkillSourcePaths, resolveDeepAgentSkillSourcePaths, relativizeDeepAgentSkillSourcePaths, shouldRelaxDeepAgentDelegationPrompt, } from "./adapter/compat/deepagent-compat.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";
@@ -66,4 +66,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, buildMinimalDeepAgentCreateParams, materializeModelExposedBuiltinMiddlewareTools, resolveLangChainInvocationConfig, resolveRunnableCheckpointer, resolveRunnableInterruptOn, shouldUseMinimalDeepAgentAssembly, RuntimeOperationTimeoutError, };
+export { AgentRuntimeAdapter as RuntimeAdapter, AGENT_INTERRUPT_SENTINEL_PREFIX, AGENT_INTERRUPT_SENTINEL_PREFIX as INTERRUPT_SENTINEL_PREFIX, buildDeepAgentCreateParams, buildLangChainCreateParams, materializeModelExposedBuiltinMiddlewareTools, resolveLangChainInvocationConfig, resolveRunnableCheckpointer, resolveRunnableInterruptOn, RuntimeOperationTimeoutError, };

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

@@ -2,7 +2,7 @@ import path from "node:path";
 import { createDeepAgent, FilesystemBackend, } from "deepagents";
 import { createAgent } from "langchain";
 import { wrapResolvedModel, } from "./parsing/output-parsing.js";
-import { AGENT_INTERRUPT_SENTINEL_PREFIX, buildDeepAgentCreateParams, buildLangChainCreateParams, buildMinimalDeepAgentCreateParams, materializeModelExposedBuiltinMiddlewareTools, resolveLangChainInvocationConfig, resolveRunnableCheckpointer, resolveRunnableInterruptOn, shouldAttachMinimalDeepAgentBackend, shouldAttachMinimalDeepAgentCheckpointer, shouldAttachMinimalDeepAgentStore, shouldUseMinimalDeepAgentAssembly, } from "./agent-runtime-assembly.js";
+import { AGENT_INTERRUPT_SENTINEL_PREFIX, buildDeepAgentCreateParams, buildLangChainCreateParams, 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";
@@ -15,7 +15,7 @@ import { renderDirectWorkspaceListing, shouldDirectlyListWorkspaceFiles } from "
 import { resolveAdapterTools } from "./adapter/tool-resolution.js";
 import { resolveRuntimeStreamExecutionContext, } from "./adapter/flow/execution-context.js";
 import { isRetryableProviderError } from "./adapter/resilience.js";
-export { applyDeepAgentDelegationPromptCompatibility, materializeDeepAgentSkillSourcePaths, resolveDeepAgentSkillSourcePaths, relativizeDeepAgentSkillSourcePaths, shouldRelaxDeepAgentDelegationPrompt, } from "./adapter/compat/deepagent-compat.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";
@@ -354,18 +354,11 @@ export class AgentRuntimeAdapter {
         const resolvedMiddleware = await this.resolveMiddleware(binding);
         const resolvedSubagents = await this.resolveDeepAgentSubagents(getBindingDeepAgentSubagents(binding), binding);
         const resolvedInterruptOn = resolveRunnableInterruptOn(binding);
-        const substrateMode = this.options.deepAgentUpstreamSubstrateMode ?? "minimal";
-        const resolvedCheckpointer = substrateMode === "minimal"
-            ? (shouldAttachMinimalDeepAgentCheckpointer(binding, resolvedInterruptOn)
-                ? resolveRunnableCheckpointer(this.options, binding)
-                : undefined)
-            : resolveRunnableCheckpointer(this.options, binding);
-        const resolvedStore = substrateMode === "minimal"
-            ? (shouldAttachMinimalDeepAgentStore(binding) ? this.options.storeResolver?.(binding) : undefined)
-            : this.options.storeResolver?.(binding);
-        const resolvedBackend = substrateMode === "minimal"
-            ? (shouldAttachMinimalDeepAgentBackend(binding) ? this.options.backendResolver?.(binding) : undefined)
-            : this.options.backendResolver?.(binding);
+        const resolvedCheckpointer = shouldAttachDeepAgentCheckpointer(binding, resolvedInterruptOn)
+            ? resolveRunnableCheckpointer(this.options, binding)
+            : undefined;
+        const resolvedStore = shouldAttachDeepAgentStore(binding) ? this.options.storeResolver?.(binding) : undefined;
+        const resolvedBackend = shouldAttachDeepAgentBackend(binding) ? this.options.backendResolver?.(binding) : undefined;
         const resolvedSkills = resolveDeepAgentSkillSourcePaths({
             workspaceRoot: binding.harnessRuntime.workspaceRoot,
             runtimeRoot: binding.harnessRuntime.runtimeRoot,
@@ -384,24 +377,6 @@ export class AgentRuntimeAdapter {
             resolvedInterruptOn,
             resolvedSkills,
         });
-        if (shouldUseMinimalDeepAgentAssembly({
-            binding,
-            resolvedMiddleware,
-            resolvedSubagents,
-            resolvedInterruptOn,
-            resolvedSkills,
-            resolvedBackend,
-        })) {
-            const minimalDeepAgentConfig = buildMinimalDeepAgentCreateParams({
-                binding,
-                resolvedModel,
-                resolvedTools: [...resolvedTools, ...builtinMiddlewareTools],
-                resolvedCheckpointer,
-                resolvedStore,
-                resolvedBackend,
-            });
-            return createAgent(minimalDeepAgentConfig);
-        }
         return createDeepAgent(deepAgentConfig);
     }
     buildRunnableCacheKey(binding, sessionId) {
@@ -559,7 +534,11 @@ export class AgentRuntimeAdapter {
             isLangChainBinding,
             isDeepAgentBinding,
             countConfiguredTools: getBindingToolCount,
+            countConfiguredToolsForAgentId: (agentId) => {
+                const resolved = this.options.bindingResolver?.(agentId);
+                return resolved ? getBindingToolCount(resolved) : 0;
+            },
         });
     }
 }
-export { AgentRuntimeAdapter as RuntimeAdapter, AGENT_INTERRUPT_SENTINEL_PREFIX, AGENT_INTERRUPT_SENTINEL_PREFIX as INTERRUPT_SENTINEL_PREFIX, buildDeepAgentCreateParams, buildLangChainCreateParams, buildMinimalDeepAgentCreateParams, materializeModelExposedBuiltinMiddlewareTools, resolveLangChainInvocationConfig, resolveRunnableCheckpointer, resolveRunnableInterruptOn, shouldUseMinimalDeepAgentAssembly, RuntimeOperationTimeoutError, };
+export { AgentRuntimeAdapter as RuntimeAdapter, AGENT_INTERRUPT_SENTINEL_PREFIX, AGENT_INTERRUPT_SENTINEL_PREFIX as INTERRUPT_SENTINEL_PREFIX, buildDeepAgentCreateParams, buildLangChainCreateParams, materializeModelExposedBuiltinMiddlewareTools, resolveLangChainInvocationConfig, resolveRunnableCheckpointer, resolveRunnableInterruptOn, RuntimeOperationTimeoutError, };

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

@@ -42,26 +42,8 @@ export declare function buildDeepAgentCreateParams(input: {
     }>;
     resolvedSkills: string[];
 }): Record<string, unknown>;
-export declare function shouldUseMinimalDeepAgentAssembly(input: {
-    binding: CompiledAgentBinding;
-    resolvedMiddleware: unknown[];
-    resolvedSubagents: Array<UpstreamSubagentConfig | CompiledAsyncSubAgent>;
-    resolvedInterruptOn?: Record<string, {
-        allowedDecisions: Array<"approve" | "edit" | "reject">;
-    }>;
-    resolvedSkills: string[];
-    resolvedBackend?: unknown;
-}): boolean;
-export declare function buildMinimalDeepAgentCreateParams(input: {
-    binding: CompiledAgentBinding;
-    resolvedModel: unknown;
-    resolvedTools: unknown[];
-    resolvedCheckpointer?: unknown;
-    resolvedStore?: unknown;
-    resolvedBackend: unknown;
-}): Record<string, unknown>;
-export declare function shouldAttachMinimalDeepAgentCheckpointer(binding: CompiledAgentBinding, resolvedInterruptOn?: Record<string, {
+export declare function shouldAttachDeepAgentCheckpointer(binding: CompiledAgentBinding, resolvedInterruptOn?: Record<string, {
     allowedDecisions: Array<"approve" | "edit" | "reject">;
 }>): boolean;
-export declare function shouldAttachMinimalDeepAgentStore(binding: CompiledAgentBinding): boolean;
-export declare function shouldAttachMinimalDeepAgentBackend(binding: CompiledAgentBinding): boolean;
+export declare function shouldAttachDeepAgentStore(binding: CompiledAgentBinding): boolean;
+export declare function shouldAttachDeepAgentBackend(binding: CompiledAgentBinding): boolean;