@botbotgo/agent-harness 0.0.366 → 0.0.368

package/dist/cli/chat-stream.js

@@ -371,6 +371,16 @@ export async function streamChatMessage(input) {
                 renderContentBlocks(delta.contentBlocks, delta.agentId);
                 return;
             }
+            if (delta.type === "plan.step") {
+                latestAgentId = delta.agentId || latestAgentId;
+                const item = delta.item;
+                const status = typeof item?.status === "string" ? item.status : "unknown";
+                const content = typeof item?.content === "string" ? item.content : "";
+                if ((input.showToolResults ?? true) && !input.requestEvents && content.trim().length > 0) {
+                    writeChatStderr(`\n[${formatPerfClock(Date.now())} +${formatElapsed(Date.now())}]${formatAgentProgressLabel(delta.agentId)} [todo:${status}] ${content}\n`);
+                }
+                return;
+            }
             if (delta.type === "tool.result") {
                 latestAgentId = delta.agentId || latestAgentId;
                 if ((input.showToolResults ?? true) && !input.requestEvents) {

package/dist/package-version.d.ts

@@ -1,2 +1,2 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.366";
-export declare const AGENT_HARNESS_RELEASE_DATE = "2026-04-28";
+export declare const AGENT_HARNESS_VERSION = "0.0.368";
+export declare const AGENT_HARNESS_RELEASE_DATE = "2026-04-30";

package/dist/package-version.js

@@ -1,2 +1,2 @@
-export const AGENT_HARNESS_VERSION = "0.0.366";
-export const AGENT_HARNESS_RELEASE_DATE = "2026-04-28";
+export const AGENT_HARNESS_VERSION = "0.0.368";
+export const AGENT_HARNESS_RELEASE_DATE = "2026-04-30";

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

@@ -8,6 +8,19 @@ import { appendToolRecoveryInstruction, extractVisibleOutput, tryParseJson } fro
 import { salvageJsonToolCalls } from "../../parsing/output-tool-args.js";
 import { isEmptyFinalAiMessageError } from "../resilience.js";
 import { AUTONOMOUS_INVESTIGATION_RECOVERY_INSTRUCTION, EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION, } from "../../prompts/runtime-prompts.js";
+const CLOSE_REQUIRED_PLAN_RECOVERY_INSTRUCTION = [
+    "The current required todo board still has unfinished work.",
+    "Do not broaden the investigation, restart planning, or ask the user what to do next.",
+    "Use the existing tool evidence already available in this run.",
+    "Your next action must be write_todos: update every remaining pending or in_progress item to completed if evidence was gathered, or failed if it cannot be completed with the available tools.",
+    "After that write_todos call, provide the final answer required by the agent response format.",
+].join("\n");
+const INITIAL_REQUIRED_PLAN_INSTRUCTION = [
+    "This agent has a required visible planning contract.",
+    "Your first action for this request must be write_todos with concrete task steps and statuses.",
+    "Do not call any domain/evidence tool and do not provide a final answer before the initial write_todos call succeeds.",
+    "After each evidence step, update the todo board. Before the final answer, close every todo as completed or failed.",
+].join("\n");
 function readBindingExecutionParams(binding) {
     const params = binding.execution?.params ?? binding.deepAgentParams ?? binding.langchainAgentParams;
     return {
@@ -280,9 +293,13 @@ function appendUserRecoveryInstruction(input, instruction) {
 export async function executeRequestInvocation(options) {
     const history = options.history ?? [];
     const invokeOptions = options.invokeOptions ?? {};
-    const request = options.resumePayload === undefined
+    let request = options.resumePayload === undefined
         ? buildInvocationRequest(options.binding, history, options.input, invokeOptions)
         : new Command({ resume: options.resumePayload });
+    if (options.resumePayload === undefined
+        && options.binding.harnessRuntime.executionContract?.requiresPlan === true) {
+        request = appendToolRecoveryInstruction(request, INITIAL_REQUIRED_PLAN_INSTRUCTION);
+    }
     const { primaryTools, toolNameMapping, executableTools, defersToUpstreamHitlExecution, } = buildBindingToolExecutionContext({
         binding: options.binding,
         resolveTools: options.resolveTools,
@@ -335,7 +352,7 @@ export async function executeRequestInvocation(options) {
             ? result.messages
             : undefined;
         const recoveryBase = messages ? { messages } : request;
-        const recoveredRequest = appendToolRecoveryInstruction(recoveryBase, AUTONOMOUS_INVESTIGATION_RECOVERY_INSTRUCTION);
+        const recoveredRequest = appendToolRecoveryInstruction(recoveryBase, CLOSE_REQUIRED_PLAN_RECOVERY_INSTRUCTION);
         const recoveredInvocation = await invokeOnce(recoveredRequest);
         localOrUpstreamInvocation = recoveredInvocation;
         result = recoveredInvocation.result;
@@ -343,8 +360,7 @@ export async function executeRequestInvocation(options) {
     }
     if (options.resumePayload === undefined
         && options.binding.harnessRuntime.executionContract?.requiresPlan === true
-        && hasIncompleteUpstreamPlan(result)
-        && !extractVisibleOutput(result).trim()) {
+        && hasIncompleteUpstreamPlan(result)) {
         const messages = Array.isArray(result.messages)
             ? result.messages
             : undefined;

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

@@ -59,6 +59,7 @@ export declare class AgentRuntimeAdapter {
     }): Promise<RequestResult>;
     private tryDelegateWithCompactRouter;
     private buildCompactDelegationReport;
+    private streamDelegateWithCompactRouter;
     stream(binding: CompiledAgentBinding, input: MessageContent, sessionId: string, history?: TranscriptMessage[], options?: {
         context?: Record<string, unknown>;
         state?: Record<string, unknown>;

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

@@ -164,6 +164,11 @@ function hasDelegatedPlanEvidence(result) {
     return Array.isArray(toolResults)
         && toolResults.some((item) => item.toolName === "write_todos" || item.toolName === "read_todos");
 }
+const DELEGATED_PLAN_EVIDENCE_RETRY_INSTRUCTION = [
+    "The delegated task requires visible TODO planning evidence.",
+    "Before any other tool call or final answer, call write_todos with concrete task steps and statuses.",
+    "Then continue the task to completion, update TODO statuses after evidence steps, and close every TODO as completed or failed before the final answer.",
+].join("\n");
 function resolveDelegatedResultOutput(result) {
     const executedToolResults = Array.isArray(result.metadata?.executedToolResults)
         ? result.metadata.executedToolResults
@@ -936,21 +941,62 @@ export class AgentRuntimeAdapter {
             delegatedResult = await runDelegatedRequest(requestText);
         }
         catch (error) {
-            const output = error instanceof Error ? error.message : String(error);
-            return {
-                toolOutput: output,
-                delegatedSubagentType: subagentType,
-                delegatedResult: {
-                    sessionId,
-                    requestId,
-                    agentId: selectedBinding.agent.id,
-                    state: "failed",
-                    output,
-                    finalMessageText: output,
-                },
-            };
+            if (selectedBinding.harnessRuntime.executionContract?.requiresPlan === true) {
+                try {
+                    delegatedResult = await runDelegatedRequest([requestText, DELEGATED_PLAN_EVIDENCE_RETRY_INSTRUCTION].filter(Boolean).join("\n\n"), ":plan-evidence-retry");
+                }
+                catch (recoveryError) {
+                    const output = recoveryError instanceof Error ? recoveryError.message : String(recoveryError);
+                    return {
+                        toolOutput: output,
+                        delegatedSubagentType: subagentType,
+                        delegatedResult: {
+                            sessionId,
+                            requestId,
+                            agentId: selectedBinding.agent.id,
+                            state: "failed",
+                            output,
+                            finalMessageText: output,
+                        },
+                    };
+                }
+            }
+            else {
+                const output = error instanceof Error ? error.message : String(error);
+                return {
+                    toolOutput: output,
+                    delegatedSubagentType: subagentType,
+                    delegatedResult: {
+                        sessionId,
+                        requestId,
+                        agentId: selectedBinding.agent.id,
+                        state: "failed",
+                        output,
+                        finalMessageText: output,
+                    },
+                };
+            }
         }
         const targetRequiresExecutionToolEvidence = getBindingPrimaryTools(selectedBinding).length > 0;
+        if (selectedBinding.harnessRuntime.executionContract?.requiresPlan === true
+            && !hasDelegatedPlanEvidence(delegatedResult)) {
+            try {
+                delegatedResult = await runDelegatedRequest([requestText, DELEGATED_PLAN_EVIDENCE_RETRY_INSTRUCTION].filter(Boolean).join("\n\n"), ":plan-evidence-retry");
+            }
+            catch (error) {
+                const output = error instanceof Error ? error.message : String(error);
+                return {
+                    toolOutput: output,
+                    delegatedSubagentType: subagentType,
+                    delegatedResult: {
+                        ...delegatedResult,
+                        state: "failed",
+                        output,
+                        finalMessageText: output,
+                    },
+                };
+            }
+        }
         if (targetRequiresExecutionToolEvidence && !hasDelegatedExecutionToolEvidence(delegatedResult)) {
             try {
                 delegatedResult = await runDelegatedRequest([requestText, EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION].filter(Boolean).join("\n\n"), ":tool-evidence-retry");
@@ -969,8 +1015,9 @@ export class AgentRuntimeAdapter {
                 };
             }
         }
-        if (targetRequiresExecutionToolEvidence && !hasDelegatedExecutionToolEvidence(delegatedResult)) {
-            const output = `runtime_error=Delegated agent ${selectedBinding.agent.id} completed without tool execution evidence.`;
+        if (selectedBinding.harnessRuntime.executionContract?.requiresPlan === true
+            && !hasDelegatedPlanEvidence(delegatedResult)) {
+            const output = "runtime_error=Delegated agent ended before producing required plan evidence.";
             return {
                 toolOutput: output,
                 delegatedSubagentType: subagentType,
@@ -982,10 +1029,8 @@ export class AgentRuntimeAdapter {
                 },
             };
         }
-        if (selectedBinding.harnessRuntime.executionContract?.requiresPlan === true
-            && !hasDelegatedPlanEvidence(delegatedResult)
-            && !hasDelegatedExecutionToolEvidence(delegatedResult)) {
-            const output = "runtime_error=Delegated agent ended before producing required plan evidence.";
+        if (targetRequiresExecutionToolEvidence && !hasDelegatedExecutionToolEvidence(delegatedResult)) {
+            const output = `runtime_error=Delegated agent ${selectedBinding.agent.id} completed without tool execution evidence.`;
             return {
                 toolOutput: output,
                 delegatedSubagentType: subagentType,
@@ -1094,6 +1139,176 @@ export class AgentRuntimeAdapter {
             report,
         };
     }
+    async *streamDelegateWithCompactRouter(binding, input, sessionId, requestId, options = {}) {
+        if (!isDelegationOnlyDeepAgentBinding(binding) || !this.options.bindingResolver) {
+            return null;
+        }
+        const primaryModel = getBindingPrimaryModel(binding);
+        if (!primaryModel) {
+            return null;
+        }
+        const requestText = extractMessageText(input).trim();
+        if (!requestText) {
+            return null;
+        }
+        const subagents = getBindingSubagents(binding);
+        const subagentNames = new Set(subagents.map((subagent) => subagent.name));
+        const subagentCatalog = subagents
+            .map((subagent) => `- ${subagent.name}: ${subagent.description}`)
+            .join("\n");
+        const routingPolicy = getBindingSystemPrompt(binding);
+        const prompt = [
+            primaryModel.init?.think === false ? "/no_think" : "",
+            "You are selecting a subagent for a delegation-only agent.",
+            "Choose exactly one listed subagent when it can responsibly handle the request.",
+            routingPolicy ? "Agent routing policy:" : "",
+            routingPolicy ?? "",
+            "Return only JSON with this shape:",
+            "{\"subagent_type\":\"<listed subagent name>\"}",
+            "If no listed subagent can handle the request, return only:",
+            "{\"status\":\"refused\",\"reason\":\"No configured subagent can handle the request.\"}",
+            "Available subagents:",
+            subagentCatalog,
+            "User request:",
+            requestText,
+        ].filter(Boolean).join("\n\n");
+        const model = await this.resolveModel(primaryModel);
+        if (typeof model.invoke !== "function") {
+            return null;
+        }
+        const invokeRouter = async (activePrompt, operationName) => this.invokeWithProviderRetry(binding, () => this.withTimeout(() => model.invoke(activePrompt, resolveLangChainInvocationConfig(binding, {
+            sessionId,
+            requestId,
+            context: options.context,
+            toolRuntimeContext: this.buildFunctionToolRuntimeContext(binding, {
+                ...options,
+                sessionId,
+                requestId,
+            }),
+        })), resolveBindingTimeout(binding), operationName, "invoke"));
+        const routerPrompts = [
+            prompt,
+            [
+                prompt,
+                "Your previous router output was invalid.",
+                "Return only one JSON object now. Do not include prose, markdown, labels, or tool-call wrappers.",
+            ].join("\n\n"),
+            [
+                primaryModel.init?.think === false ? "/no_think" : "",
+                "Select one subagent from this exact list:",
+                Array.from(subagentNames).join(", "),
+                "Return JSON only:",
+                "{\"subagent_type\":\"<one exact listed name>\"}",
+                "User request:",
+                requestText,
+            ].filter(Boolean).join("\n\n"),
+            [
+                primaryModel.init?.think === false ? "/no_think" : "",
+                "JSON only. Pick a listed subagent or refuse.",
+                "Listed subagents:",
+                Array.from(subagentNames).join(", "),
+                "Allowed outputs:",
+                "{\"subagent_type\":\"<listed name>\"}",
+                "{\"status\":\"refused\",\"reason\":\"No configured subagent can handle the request.\"}",
+                "Request:",
+                requestText,
+            ].filter(Boolean).join("\n\n"),
+        ];
+        let selection = null;
+        let previousRawText = "";
+        for (let index = 0; index < routerPrompts.length && !selection; index += 1) {
+            const activePrompt = index <= 1 || !previousRawText
+                ? routerPrompts[index]
+                : [routerPrompts[index], "Previous output:", previousRawText].join("\n\n");
+            const raw = await invokeRouter(activePrompt, index === 0 ? "delegation router invoke" : `delegation router retry invoke ${index}`);
+            previousRawText = readModelText(raw);
+            selection = parseCompactRouterSelection(previousRawText, subagentNames);
+        }
+        if (selection?.refusedReason) {
+            return {
+                toolOutput: selection.refusedReason,
+                delegatedSubagentType: null,
+                delegatedResult: {
+                    sessionId,
+                    requestId,
+                    agentId: binding.agent.id,
+                    state: "failed",
+                    output: selection.refusedReason,
+                    finalMessageText: selection.refusedReason,
+                },
+            };
+        }
+        let subagentType = selection?.subagentType ?? "";
+        if (!subagentNames.has(subagentType)) {
+            const fallbackSubagent = subagentNames.values().next().value;
+            if (typeof fallbackSubagent === "string" && fallbackSubagent) {
+                subagentType = fallbackSubagent;
+            }
+            else {
+                return null;
+            }
+        }
+        const selectedBinding = this.options.bindingResolver(subagentType);
+        if (!selectedBinding) {
+            return null;
+        }
+        yield {
+            kind: "commentary",
+            content: `Delegating to ${subagentType}.`,
+            agentId: binding.agent.id,
+        };
+        yield {
+            kind: "commentary",
+            content: "Starting delegated execution.",
+            agentId: selectedBinding.agent.id,
+        };
+        const childRequestId = `${requestId}:${subagentType}`;
+        let delegatedResult;
+        const runDelegatedRequest = (text, requestSuffix = "") => this.invoke(selectedBinding, text, sessionId, `${childRequestId}${requestSuffix}`, undefined, [], {
+            context: options.context,
+            state: options.state,
+            files: options.files,
+            memoryContext: options.memoryContext,
+        });
+        try {
+            delegatedResult = await runDelegatedRequest(requestText);
+        }
+        catch (error) {
+            const output = error instanceof Error ? error.message : String(error);
+            return {
+                toolOutput: output,
+                delegatedSubagentType: subagentType,
+                delegatedResult: {
+                    sessionId,
+                    requestId: childRequestId,
+                    agentId: selectedBinding.agent.id,
+                    state: "failed",
+                    output,
+                    finalMessageText: output,
+                },
+            };
+        }
+        const delegatedToolResults = Array.isArray(delegatedResult.metadata?.executedToolResults)
+            ? delegatedResult.metadata.executedToolResults
+            : [];
+        for (const toolResult of delegatedToolResults) {
+            if (!toolResult?.toolName) {
+                continue;
+            }
+            yield {
+                kind: "tool-result",
+                toolName: toolResult.toolName,
+                output: toolResult.output,
+                ...(toolResult.isError !== undefined ? { isError: toolResult.isError } : {}),
+                agentId: selectedBinding.agent.id,
+            };
+        }
+        return {
+            toolOutput: resolveDelegatedResultOutput(delegatedResult),
+            delegatedSubagentType: subagentType,
+            delegatedResult,
+        };
+    }
     async *stream(binding, input, sessionId, history = [], options = {}) {
         const directListing = await this.tryHandleDirectWorkspaceListing(binding, input, {
             ...options,
@@ -1118,11 +1333,7 @@ export class AgentRuntimeAdapter {
                 content: "Selecting a specialist for delegated execution.",
             };
         }
-        const compactDelegation = await this.tryDelegateWithCompactRouter(binding, input, sessionId, options.requestId ?? sessionId, {
-            ...options,
-            sessionId,
-            requestId: options.requestId,
-        });
+        const compactDelegation = yield* this.streamDelegateWithCompactRouter(binding, input, sessionId, options.requestId ?? sessionId, options);
         if (compactDelegation) {
             const compactReport = this.buildCompactDelegationReport(compactDelegation);
             yield {

package/dist/runtime/harness/run/stream-run.d.ts

@@ -3,6 +3,7 @@ import { type InternalHarnessStreamItem } from "../events/streaming.js";
 type RuntimeStreamChunk = {
     kind: "commentary";
     content: string;
+    agentId?: string;
 } | string | {
     kind: "content" | "interrupt" | "reasoning" | "tool-result" | "upstream-event";
     content?: string;
@@ -10,9 +11,11 @@ type RuntimeStreamChunk = {
     output?: unknown;
     isError?: boolean;
     event?: unknown;
+    agentId?: string;
 } | {
     kind: "profile";
     step: RequestExecutionStep;
+    agentId?: string;
 };
 type StreamRunOptions = {
     binding: CompiledAgentBinding;

package/dist/runtime/harness/run/stream-run.js

@@ -284,16 +284,16 @@ function normalizeStreamChunk(chunk) {
         return { kind: "content", content: chunk };
     }
     if (chunk.kind === "commentary") {
-        return { kind: "commentary", content: chunk.content ?? "" };
+        return { kind: "commentary", content: chunk.content ?? "", agentId: chunk.agentId };
     }
     if (chunk.kind === "upstream-event") {
-        return { kind: "upstream-event", event: (chunk.event ?? {}) };
+        return { kind: "upstream-event", event: (chunk.event ?? {}), agentId: chunk.agentId };
     }
     if (chunk.kind === "interrupt") {
-        return { kind: "interrupt", content: chunk.content };
+        return { kind: "interrupt", content: chunk.content, agentId: chunk.agentId };
     }
     if (chunk.kind === "reasoning") {
-        return { kind: "reasoning", content: chunk.content ?? "" };
+        return { kind: "reasoning", content: chunk.content ?? "", agentId: chunk.agentId };
     }
     if (chunk.kind === "tool-result") {
         return {
@@ -301,15 +301,17 @@ function normalizeStreamChunk(chunk) {
             toolName: chunk.toolName ?? "unknown_tool",
             output: chunk.output,
             isError: chunk.isError,
+            agentId: chunk.agentId,
         };
     }
     if (chunk.kind === "profile") {
         return {
             kind: "profile",
             step: chunk.step,
+            agentId: chunk.agentId,
         };
     }
-    return { kind: "content", content: chunk.content ?? "" };
+    return { kind: "content", content: chunk.content ?? "", agentId: chunk.agentId };
 }
 function normalizeCommentaryText(value) {
     return value
@@ -645,7 +647,7 @@ export async function* streamHarnessRun(options) {
     let lastToolResultKey = null;
     const executedToolResults = [];
     const emittedCommentary = new Set();
-    const emitCommentary = function* (content) {
+    const emitCommentary = function* (content, agentIdOverride) {
         const normalized = normalizeCommentaryText(content);
         if (!normalized || emittedCommentary.has(normalized)) {
             return;
@@ -655,7 +657,7 @@ export async function* streamHarnessRun(options) {
             type: "commentary",
             sessionId: options.sessionId,
             requestId: options.requestId,
-            agentId: currentAgentId,
+            agentId: agentIdOverride ?? currentAgentId,
             content: normalized,
         };
     };
@@ -804,7 +806,7 @@ export async function* streamHarnessRun(options) {
                 return;
             }
             if (normalizedChunk.kind === "commentary") {
-                yield* emitCommentary(normalizedChunk.content);
+                yield* emitCommentary(normalizedChunk.content, normalizedChunk.agentId);
                 continue;
             }
             if (normalizedChunk.kind === "reasoning") {
@@ -824,6 +826,7 @@ export async function* streamHarnessRun(options) {
                 continue;
             }
             if (normalizedChunk.kind === "tool-result") {
+                const chunkAgentId = normalizedChunk.agentId ?? currentAgentId;
                 const toolResultKey = createToolResultKey(normalizedChunk.toolName, normalizedChunk.output, normalizedChunk.isError);
                 if (toolResultKey === lastToolResultKey) {
                     continue;
@@ -844,7 +847,7 @@ export async function* streamHarnessRun(options) {
                     type: "tool-result",
                     sessionId: options.sessionId,
                     requestId: options.requestId,
-                    agentId: currentAgentId,
+                    agentId: chunkAgentId,
                     toolName: normalizedChunk.toolName,
                     output: normalizedChunk.output,
                     isError: normalizedChunk.isError,
@@ -873,16 +876,16 @@ export async function* streamHarnessRun(options) {
                         currentPlanState = mergedPlanState;
                         const progression = buildPlanStateProgression(previousPlanState, currentPlanState);
                         for (const progressionStep of progression) {
-                            for (const item of await emitPlanStateUpdate(options, currentAgentId, progressionStep.planState)) {
+                            for (const item of await emitPlanStateUpdate(options, chunkAgentId, progressionStep.planState)) {
                                 yield item;
                             }
                             if (progressionStep.commentary) {
-                                yield* emitCommentary(progressionStep.commentary);
+                                yield* emitCommentary(progressionStep.commentary, chunkAgentId);
                             }
                         }
                         const commentary = summarizePlanState(currentPlanState);
                         if (commentary) {
-                            yield* emitCommentary(commentary);
+                            yield* emitCommentary(commentary, chunkAgentId);
                         }
                     }
                 }
@@ -899,16 +902,16 @@ export async function* streamHarnessRun(options) {
                         currentPlanState = reconciledPlanState;
                         const progression = buildPlanStateProgression(previousPlanState, currentPlanState);
                         for (const progressionStep of progression) {
-                            for (const item of await emitPlanStateUpdate(options, currentAgentId, progressionStep.planState)) {
+                            for (const item of await emitPlanStateUpdate(options, chunkAgentId, progressionStep.planState)) {
                                 yield item;
                             }
                             if (progressionStep.commentary) {
-                                yield* emitCommentary(progressionStep.commentary);
+                                yield* emitCommentary(progressionStep.commentary, chunkAgentId);
                             }
                         }
                         const commentary = summarizePlanState(currentPlanState);
                         if (commentary) {
-                            yield* emitCommentary(commentary);
+                            yield* emitCommentary(commentary, chunkAgentId);
                         }
                     }
                 }

package/dist/runtime/parsing/stream-event-parsing.d.ts

@@ -2,26 +2,33 @@ import type { RequestExecutionStep } from "../../contracts/types.js";
 export type RuntimeStreamChunk = {
     kind: "upstream-event";
     event: unknown;
+    agentId?: string;
 } | {
     kind: "commentary";
     content: string;
+    agentId?: string;
 } | {
     kind: "content";
     content: string;
+    agentId?: string;
 } | {
     kind: "reasoning";
     content: string;
+    agentId?: string;
 } | {
     kind: "interrupt";
     content: string;
+    agentId?: string;
 } | {
     kind: "tool-result";
     toolName: string;
     output: unknown;
     isError?: boolean;
+    agentId?: string;
 } | {
     kind: "profile";
     step: RequestExecutionStep;
+    agentId?: string;
 };
 export declare function sanitizeStreamPayload(value: unknown): unknown;
 export declare function sanitizeRetainedUpstreamEvent(event: unknown): unknown;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botbotgo/agent-harness",
-  "version": "0.0.366",
+  "version": "0.0.368",
   "description": "Workspace runtime for multi-agent applications",
   "license": "MIT",
   "type": "module",