@botbotgo/agent-harness 0.0.49 → 0.0.50

package/README.md

@@ -81,10 +81,12 @@ try {
 - YAML-defined host routing and runtime policy
 - LangChain v1 and DeepAgents backend adaptation
 - Auto-discovered local tools and SKILL packages
+- provider-native tools, MCP tools, and workspace-local tool modules
+- persisted threads, runs, approvals, lifecycle events, and queued runs
+- runtime-managed recovery and checkpoint maintenance
+- structured output and multimodal content preservation in run results
 - MCP bridge support for agent-declared MCP servers
 - MCP server support for exposing harness tools outward
-- Persisted threads, runs, approvals, lifecycle events, and queued runs
-- Runtime-managed recovery and checkpoint maintenance
 
 ## How To Use
 
@@ -120,7 +122,7 @@ const result = await run(runtime, {
 });
 ```
 
-Each run creates or continues a persisted thread and returns `threadId`, `runId`, `state`, and the final user-facing output text.
+`run(runtime, { ... })` creates or continues a persisted thread and returns `threadId`, `runId`, `state`, and a simple text `output`. When upstream returns richer output, the runtime also preserves `outputContent`, `contentBlocks`, and `structuredResponse` without making the basic API larger.
 
 Use `invocation` as the runtime-facing request envelope:
 
@@ -149,6 +151,9 @@ const result = await run(runtime, {
     onChunk(chunk) {
       process.stdout.write(chunk);
     },
+    onContentBlocks(blocks) {
+      console.log(blocks);
+    },
     onEvent(event) {
       console.log(event.eventType, event.payload);
     },
@@ -244,8 +249,6 @@ Core workspace files:
 - `resources/tools/`
 - `resources/skills/`
 
-### Client-Configurable YAML Reference
-
 There are three configuration layers:
 
 - runtime policy in `config/workspace.yaml`
@@ -406,6 +409,8 @@ Client-configurable agent fields include:
 - `spec.responseFormat`
 - `spec.contextSchema`
 
+For backend-specific agent options, prefer passing the upstream concept directly in YAML. The loader keeps a small stable product shape, but it also preserves agent-level passthrough fields so new LangChain v1 or DeepAgents parameters can flow into adapters without expanding the public API surface.
+
 ### `resources/`
 
 Use `resources/` for executable local extensions:
@@ -426,6 +431,7 @@ SKILL packages are discovered from `resources/skills/` and attached to agents th
 - upstream LangChain v1 and DeepAgents concepts should be expressed as directly as possible in YAML
 - recovery, approvals, threads, runs, and events are runtime concepts, not backend-specific escape hatches
 - backend implementation details should stay internal unless product requirements force exposure
+- application-level orchestration and lifecycle management stays in the harness
 
 In short: `agent-harness` is a public runtime contract generic enough to survive backend changes, while the deep execution semantics stay upstream.
 

package/dist/contracts/types.d.ts

@@ -96,6 +96,7 @@ export type LangChainAgentParams = {
     responseFormat?: unknown;
     contextSchema?: unknown;
     middleware?: Array<Record<string, unknown>>;
+    passthrough?: Record<string, unknown>;
     subagents?: CompiledSubAgent[];
     memory?: string[];
     skills?: string[];
@@ -118,6 +119,7 @@ export type CompiledSubAgent = {
     responseFormat?: unknown;
     contextSchema?: unknown;
     middleware?: Array<Record<string, unknown>>;
+    passthrough?: Record<string, unknown>;
 };
 export type DeepAgentParams = {
     model: CompiledModel;
@@ -126,6 +128,7 @@ export type DeepAgentParams = {
     responseFormat?: unknown;
     contextSchema?: unknown;
     middleware?: Array<Record<string, unknown>>;
+    passthrough?: Record<string, unknown>;
     description: string;
     subagents: CompiledSubAgent[];
     interruptOn?: Record<string, boolean | object>;
@@ -257,6 +260,9 @@ export type RunResult = {
     state: RunState;
     output: string;
     finalMessageText?: string;
+    outputContent?: unknown;
+    contentBlocks?: unknown[];
+    structuredResponse?: unknown;
     interruptContent?: string;
     agentId?: string;
     approvalId?: string;
@@ -267,6 +273,7 @@ export type RunResult = {
 };
 export type RunListeners = {
     onChunk?: (chunk: string) => void | Promise<void>;
+    onContentBlocks?: (blocks: unknown[]) => void | Promise<void>;
     onEvent?: (event: HarnessEvent) => void | Promise<void>;
     onReasoning?: (chunk: string) => void | Promise<void>;
     onStep?: (step: string) => void | Promise<void>;
@@ -318,6 +325,12 @@ export type HarnessStreamItem = {
     runId: string;
     agentId: string;
     content: string;
+} | {
+    type: "content-blocks";
+    threadId: string;
+    runId: string;
+    agentId: string;
+    contentBlocks: unknown[];
 } | {
     type: "reasoning";
     threadId: string;

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.48";
+export declare const AGENT_HARNESS_VERSION = "0.0.49";

package/dist/package-version.js

@@ -1 +1 @@
-export const AGENT_HARNESS_VERSION = "0.0.48";
+export const AGENT_HARNESS_VERSION = "0.0.49";

package/dist/presentation.d.ts

@@ -1,18 +1,4 @@
 export declare function escapeHtml(value: string): string;
-/** CSS class for anchors that should open in the host app embedded browser (Wallee). */
-export declare const WALLEE_OUTPUT_LINK_CLASS = "wallee-output-link";
-/** `data-wallee-url` — target URL for the embedded browser (http/https only). */
-export declare const WALLEE_BROWSER_URL_ATTR = "data-wallee-url";
-export declare function isAllowedWalleeBrowserUrl(url: string): boolean;
-/**
- * Escape plain text and wrap http(s) URLs in Wallee output anchors (open in host embedded browser).
- */
-export declare function linkifyPlainTextForWalleeBrowser(text: string): string;
-/**
- * Like {@link markdownToHtml} but inline http(s) URLs and markdown links `[label](https://…)` render as
- * Wallee embedded-browser anchors (`wallee-output-link` + `data-wallee-url`).
- */
-export declare function markdownToWalleeOutputHtml(markdown: string): string;
 export declare function markdownToHtml(markdown: string): string;
 export declare function markdownToConsole(markdown: string): string;
 export declare function renderTemplate(data: Record<string, unknown>, template: string): string;

package/dist/presentation.js

@@ -8,152 +8,6 @@ export function escapeHtml(value) {
         .replaceAll('"', """)
         .replaceAll("'", "'");
 }
-/** CSS class for anchors that should open in the host app embedded browser (Wallee). */
-export const WALLEE_OUTPUT_LINK_CLASS = "wallee-output-link";
-/** `data-wallee-url` — target URL for the embedded browser (http/https only). */
-export const WALLEE_BROWSER_URL_ATTR = "data-wallee-url";
-export function isAllowedWalleeBrowserUrl(url) {
-    try {
-        const u = new URL(url);
-        return u.protocol === "http:" || u.protocol === "https:";
-    }
-    catch {
-        return false;
-    }
-}
-function walleeOutputAnchor(url, labelEscaped) {
-    return `<a class="${WALLEE_OUTPUT_LINK_CLASS}" ${WALLEE_BROWSER_URL_ATTR}="${escapeHtml(url)}" href="#">${labelEscaped}</a>`;
-}
-/**
- * Escape plain text and wrap http(s) URLs in Wallee output anchors (open in host embedded browser).
- */
-export function linkifyPlainTextForWalleeBrowser(text) {
-    const urlRe = /\bhttps?:\/\/[^\s<>"']+/g;
-    const parts = [];
-    let last = 0;
-    let m;
-    while ((m = urlRe.exec(text)) !== null) {
-        parts.push(escapeHtml(text.slice(last, m.index)));
-        const raw = m[0];
-        const trimmed = raw.replace(/[.,;:!?)\]]+$/u, "");
-        const rest = raw.slice(trimmed.length);
-        if (isAllowedWalleeBrowserUrl(trimmed)) {
-            parts.push(walleeOutputAnchor(trimmed, escapeHtml(trimmed)));
-            if (rest) {
-                parts.push(escapeHtml(rest));
-            }
-        }
-        else {
-            parts.push(escapeHtml(raw));
-        }
-        last = m.index + raw.length;
-    }
-    parts.push(escapeHtml(text.slice(last)));
-    return parts.join("");
-}
-function applyBasicInlineMarkdown(escaped) {
-    return escaped
-        .replace(/\*\*(.+?)\*\*/g, "<strong>$1</strong>")
-        .replace(/\*(.+?)\*/g, "<em>$1</em>")
-        .replace(/`([^`]+)`/g, "<code>$1</code>");
-}
-function linkifyPlainTextSegmentWithWalleeMarkdown(text) {
-    const mdLinkPattern = /\[([^\]]*)\]\((https?:\/\/[^)\s]+)\)/g;
-    const segments = [];
-    let lastIndex = 0;
-    let m;
-    while ((m = mdLinkPattern.exec(text)) !== null) {
-        if (m.index > lastIndex) {
-            segments.push({ type: "text", text: text.slice(lastIndex, m.index) });
-        }
-        segments.push({ type: "mdlink", label: m[1], url: m[2] });
-        lastIndex = m.index + m[0].length;
-    }
-    if (lastIndex < text.length) {
-        segments.push({ type: "text", text: text.slice(lastIndex) });
-    }
-    if (segments.length === 0) {
-        segments.push({ type: "text", text });
-    }
-    return segments
-        .map((seg) => {
-        if (seg.type === "mdlink") {
-            if (!isAllowedWalleeBrowserUrl(seg.url)) {
-                return `${escapeHtml(seg.label)} (${escapeHtml(seg.url)})`;
-            }
-            return walleeOutputAnchor(seg.url, escapeHtml(seg.label));
-        }
-        return linkifyBareUrlsWithInlineMarkdown(seg.text);
-    })
-        .join("");
-}
-function linkifyBareUrlsWithInlineMarkdown(text) {
-    const urlRe = /\bhttps?:\/\/[^\s<>"']+/g;
-    const parts = [];
-    let last = 0;
-    let m;
-    while ((m = urlRe.exec(text)) !== null) {
-        parts.push(applyBasicInlineMarkdown(escapeHtml(text.slice(last, m.index))));
-        const raw = m[0];
-        const trimmed = raw.replace(/[.,;:!?)\]]+$/u, "");
-        const rest = raw.slice(trimmed.length);
-        if (isAllowedWalleeBrowserUrl(trimmed)) {
-            parts.push(walleeOutputAnchor(trimmed, escapeHtml(trimmed)));
-            if (rest) {
-                parts.push(applyBasicInlineMarkdown(escapeHtml(rest)));
-            }
-        }
-        else {
-            parts.push(applyBasicInlineMarkdown(escapeHtml(raw)));
-        }
-        last = m.index + raw.length;
-    }
-    parts.push(applyBasicInlineMarkdown(escapeHtml(text.slice(last))));
-    return parts.join("");
-}
-/**
- * Like {@link markdownToHtml} but inline http(s) URLs and markdown links `[label](https://…)` render as
- * Wallee embedded-browser anchors (`wallee-output-link` + `data-wallee-url`).
- */
-export function markdownToWalleeOutputHtml(markdown) {
-    const normalized = markdown.replace(/\r\n/g, "\n");
-    const blocks = normalized.split(/\n\n+/);
-    const html = [];
-    for (const block of blocks) {
-        const trimmed = block.trim();
-        if (!trimmed) {
-            continue;
-        }
-        if (trimmed.startsWith("```") && trimmed.endsWith("```")) {
-            const lines = trimmed.split("\n");
-            const language = lines[0]?.slice(3).trim();
-            const code = lines.slice(1, -1).join("\n");
-            html.push(`<pre class="ah-code"><code${language ? ` data-language="${escapeHtml(language)}"` : ""}>${escapeHtml(code)}</code></pre>`);
-            continue;
-        }
-        if (/^#{1,6}\s/.test(trimmed)) {
-            const match = trimmed.match(/^(#{1,6})\s+(.*)$/);
-            const level = match?.[1].length ?? 1;
-            const content = linkifyPlainTextSegmentWithWalleeMarkdown(match?.[2] ?? trimmed);
-            html.push(`<h${level}>${content}</h${level}>`);
-            continue;
-        }
-        if (trimmed.split("\n").every((line) => /^[-*]\s+/.test(line))) {
-            const items = trimmed
-                .split("\n")
-                .map((line) => line.replace(/^[-*]\s+/, ""))
-                .map((line) => `<li>${linkifyPlainTextSegmentWithWalleeMarkdown(line)}</li>`)
-                .join("");
-            html.push(`<ul>${items}</ul>`);
-            continue;
-        }
-        html.push(`<p>${trimmed
-            .split("\n")
-            .map((line) => linkifyPlainTextSegmentWithWalleeMarkdown(line))
-            .join("<br />")}</p>`);
-    }
-    return html.join("");
-}
 function renderInlineMarkdown(text) {
     const escaped = escapeHtml(text);
     return escaped

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

@@ -9,7 +9,7 @@ import { ChatOpenAI } from "@langchain/openai";
 import { tools as openAIProviderTools } from "@langchain/openai";
 import { createAgent, humanInTheLoopMiddleware, initChatModel } from "langchain";
 import { z } from "zod";
-import { extractEmptyAssistantMessageFailure, extractReasoningText, extractToolFallbackContext, extractVisibleOutput, isLikelyToolArgsObject, isToolCallParseFailure, STRICT_TOOL_JSON_INSTRUCTION, sanitizeVisibleText, tryParseJson, wrapResolvedModel, } from "./parsing/output-parsing.js";
+import { extractEmptyAssistantMessageFailure, extractContentBlocks, extractOutputContent, extractReasoningText, extractToolFallbackContext, extractVisibleOutput, isLikelyToolArgsObject, isToolCallParseFailure, STRICT_TOOL_JSON_INSTRUCTION, sanitizeVisibleText, tryParseJson, wrapResolvedModel, } from "./parsing/output-parsing.js";
 import { computeIncrementalOutput, extractAgentStep, extractInterruptPayload, extractReasoningStreamOutput, extractStateStreamOutput, extractVisibleStreamOutput, extractTerminalStreamOutput, extractToolResult, normalizeTerminalOutputKey, readStreamDelta, } from "./parsing/stream-event-parsing.js";
 import { wrapToolForExecution } from "./tool-hitl.js";
 import { resolveDeclaredMiddleware } from "./declared-middleware.js";
@@ -556,6 +556,7 @@ export class AgentRuntimeAdapter {
     async resolveSubagents(subagents, binding) {
         return Promise.all(subagents.map(async (subagent) => ({
             ...subagent,
+            ...(subagent.passthrough ?? {}),
             model: subagent.model ? (await this.resolveModel(subagent.model)) : undefined,
             tools: subagent.tools ? this.resolveTools(subagent.tools) : undefined,
             interruptOn: this.compileInterruptOn(subagent.tools ?? [], subagent.interruptOn),
@@ -578,6 +579,7 @@ export class AgentRuntimeAdapter {
                 throw new Error(`Agent ${binding.agent.id} configures ${tools.length} tool(s), but resolved model ${params.model.id} does not support tool binding.`);
             }
             return createAgent({
+                ...(params.passthrough ?? {}),
                 model: model,
                 tools: tools,
                 systemPrompt: params.systemPrompt,
@@ -598,6 +600,7 @@ export class AgentRuntimeAdapter {
             throw new Error(`Agent ${binding.agent.id} has no runnable params`);
         }
         const deepAgentConfig = {
+            ...(params.passthrough ?? {}),
             model: (await this.resolveModel(params.model)),
             tools: this.resolveTools(params.tools, binding),
             systemPrompt: params.systemPrompt,
@@ -672,6 +675,9 @@ export class AgentRuntimeAdapter {
         }
         const output = visibleOutput || synthesizedOutput || toolFallback || JSON.stringify(result, null, 2);
         const finalMessageText = sanitizeVisibleText(output);
+        const outputContent = extractOutputContent(result);
+        const contentBlocks = extractContentBlocks(result);
+        const structuredResponse = result.structuredResponse;
         return {
             threadId,
             runId,
@@ -680,8 +686,13 @@ export class AgentRuntimeAdapter {
             interruptContent,
             output: finalMessageText,
             finalMessageText,
+            ...(outputContent !== undefined ? { outputContent } : {}),
+            ...(contentBlocks.length > 0 ? { contentBlocks } : {}),
+            ...(structuredResponse !== undefined ? { structuredResponse } : {}),
             metadata: {
-                ...(result.structuredResponse !== undefined ? { structuredResponse: result.structuredResponse } : {}),
+                ...(structuredResponse !== undefined ? { structuredResponse } : {}),
+                ...(outputContent !== undefined ? { outputContent } : {}),
+                ...(contentBlocks.length > 0 ? { contentBlocks } : {}),
                 ...(asRecord(result.files) ? { files: asRecord(result.files) } : {}),
                 ...(this.buildStateSnapshot(result) ? { stateSnapshot: this.buildStateSnapshot(result) } : {}),
                 upstreamResult: result,

package/dist/runtime/declared-middleware.js

@@ -1,4 +1,4 @@
-import { anthropicPromptCachingMiddleware, contextEditingMiddleware, llmToolSelectorMiddleware, modelCallLimitMiddleware, modelFallbackMiddleware, modelRetryMiddleware, openAIModerationMiddleware, piiMiddleware, piiRedactionMiddleware, summarizationMiddleware, todoListMiddleware, toolCallLimitMiddleware, toolEmulatorMiddleware, toolRetryMiddleware, } from "langchain";
+import { anthropicPromptCachingMiddleware, contextEditingMiddleware, humanInTheLoopMiddleware, llmToolSelectorMiddleware, modelCallLimitMiddleware, modelFallbackMiddleware, modelRetryMiddleware, openAIModerationMiddleware, piiMiddleware, summarizationMiddleware, todoListMiddleware, toolCallLimitMiddleware, toolEmulatorMiddleware, toolRetryMiddleware, } from "langchain";
 function asMiddlewareConfig(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value) ? { ...value } : null;
 }
@@ -77,6 +77,9 @@ export async function resolveDeclaredMiddleware(middlewareConfigs, options) {
             case "toolEmulator":
                 resolved.push(toolEmulatorMiddleware(runtimeConfig));
                 break;
+            case "humanInTheLoop":
+                resolved.push(humanInTheLoopMiddleware(runtimeConfig));
+                break;
             case "openAIModeration":
                 resolved.push(openAIModerationMiddleware(runtimeConfig));
                 break;
@@ -89,9 +92,6 @@ export async function resolveDeclaredMiddleware(middlewareConfigs, options) {
                 resolved.push(piiMiddleware(piiType, piiOptions));
                 break;
             }
-            case "piiRedaction":
-                resolved.push(piiRedactionMiddleware(runtimeConfig));
-                break;
             case "anthropicPromptCaching":
                 resolved.push(anthropicPromptCachingMiddleware(runtimeConfig));
                 break;

package/dist/runtime/harness.d.ts

@@ -71,6 +71,7 @@ export declare class AgentHarnessRuntime {
     private checkpointRefForState;
     private finalizeContinuedRun;
     private emitOutputDeltaAndCreateItem;
+    private createContentBlocksItem;
     private emitRunCreated;
     private setRunStateAndEmit;
     private requestApprovalAndEmit;

package/dist/runtime/harness.js

@@ -525,6 +525,15 @@ export class AgentHarnessRuntime {
             content,
         };
     }
+    createContentBlocksItem(threadId, runId, agentId, contentBlocks) {
+        return {
+            type: "content-blocks",
+            threadId,
+            runId,
+            agentId,
+            contentBlocks,
+        };
+    }
     async emitRunCreated(threadId, runId, payload) {
         return this.emit(threadId, runId, 1, "run.created", payload);
     }
@@ -678,6 +687,10 @@ export class AgentHarnessRuntime {
                 await this.notifyListener(listeners.onChunk, item.content);
                 continue;
             }
+            if (item.type === "content-blocks") {
+                await this.notifyListener(listeners.onContentBlocks, item.contentBlocks);
+                continue;
+            }
             if (item.type === "reasoning") {
                 await this.notifyListener(listeners.onReasoning, item.content);
                 continue;
@@ -890,6 +903,9 @@ export class AgentHarnessRuntime {
                 }
                 if (!assistantOutput) {
                     const actual = await this.invokeWithHistory(binding, options.input, threadId, runId);
+                    if (Array.isArray(actual.contentBlocks) && actual.contentBlocks.length > 0) {
+                        yield this.createContentBlocksItem(threadId, runId, selectedAgentId, actual.contentBlocks);
+                    }
                     if (actual.output) {
                         assistantOutput = actual.output;
                         emitted = true;
@@ -949,6 +965,9 @@ export class AgentHarnessRuntime {
                 try {
                     const actual = await this.invokeWithHistory(binding, options.input, threadId, runId);
                     await this.appendAssistantMessage(threadId, runId, actual.output);
+                    if (Array.isArray(actual.contentBlocks) && actual.contentBlocks.length > 0) {
+                        yield this.createContentBlocksItem(threadId, runId, selectedAgentId, actual.contentBlocks);
+                    }
                     if (actual.output) {
                         yield await this.emitOutputDeltaAndCreateItem(threadId, runId, selectedAgentId, actual.output);
                     }

package/dist/runtime/parsing/output-parsing.d.ts

@@ -6,6 +6,8 @@ export declare function readTextContent(value: unknown): string;
 export declare function hasToolCalls(value: unknown): boolean;
 export declare function extractToolFallbackContext(value: unknown): string;
 export declare function extractVisibleOutput(value: unknown): string;
+export declare function extractOutputContent(value: unknown): unknown;
+export declare function extractContentBlocks(value: unknown): unknown[];
 export declare function extractEmptyAssistantMessageFailure(value: unknown): string;
 export declare function isToolCallParseFailure(error: unknown): boolean;
 export declare const STRICT_TOOL_JSON_INSTRUCTION = "When calling tools, return only the tool call itself. The arguments must be a pure JSON object with no explanatory text before or after it.";

package/dist/runtime/parsing/output-parsing.js

@@ -166,8 +166,8 @@ function extractMessageContent(message) {
     if (typeof message !== "object" || !message)
         return "";
     const typed = message;
-    if (typeof typed.content === "string")
-        return typed.content;
+    if (typed.content !== undefined)
+        return readTextContent(typed.content);
     if (typeof typed.kwargs === "object" && typed.kwargs) {
         return readTextContent(typed.kwargs.content);
     }
@@ -341,6 +341,79 @@ export function extractVisibleOutput(value) {
     }
     return "";
 }
+function isContentBlock(value) {
+    return typeof value === "object" && value !== null && typeof value.type === "string";
+}
+function normalizeContentBlocks(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.filter(isContentBlock).map((block) => ({ ...block }));
+}
+function extractStructuredOutputContent(value) {
+    if (typeof value !== "object" || !value)
+        return undefined;
+    const typed = value;
+    if (typed.output && typeof typed.output === "object") {
+        const nested = extractStructuredOutputContent(typed.output);
+        if (nested !== undefined)
+            return nested;
+    }
+    if (typed.content !== undefined) {
+        return typed.content;
+    }
+    if (!Array.isArray(typed.messages)) {
+        return undefined;
+    }
+    for (let index = typed.messages.length - 1; index >= 0; index -= 1) {
+        const message = typed.messages[index];
+        if (typeof message !== "object" || !message)
+            continue;
+        const ids = Array.isArray(message.id)
+            ? (message.id.filter((item) => typeof item === "string"))
+            : [];
+        const typeName = ids.at(-1);
+        const runtimeType = typeof message._getType === "function"
+            ? message._getType()
+            : typeof message.getType === "function"
+                ? message.getType()
+                : undefined;
+        if (!(typeName === "AIMessage" || runtimeType === "ai")) {
+            continue;
+        }
+        if (hasToolCalls(message)) {
+            continue;
+        }
+        const directContent = message.content;
+        if (directContent !== undefined) {
+            return directContent;
+        }
+        const kwargs = typeof message.kwargs === "object" && message.kwargs
+            ? (message.kwargs)
+            : undefined;
+        if (kwargs?.content !== undefined) {
+            return kwargs.content;
+        }
+    }
+    return undefined;
+}
+export function extractOutputContent(value) {
+    const content = extractStructuredOutputContent(value);
+    if (content !== undefined) {
+        return content;
+    }
+    return undefined;
+}
+export function extractContentBlocks(value) {
+    const outputContent = extractOutputContent(value);
+    if (outputContent === undefined) {
+        return [];
+    }
+    if (typeof outputContent === "string") {
+        return outputContent.trim() ? [{ type: "text", text: outputContent }] : [];
+    }
+    return normalizeContentBlocks(outputContent);
+}
 export function extractEmptyAssistantMessageFailure(value) {
     if (typeof value !== "object" || !value)
         return "";

package/dist/workspace/agent-binding-compiler.js

@@ -105,6 +105,9 @@ function buildSubagent(agent, workspaceRoot, models, tools, parentSkills, parent
         responseFormat: agent.deepAgentConfig?.responseFormat,
         contextSchema: agent.deepAgentConfig?.contextSchema,
         middleware: compileMiddlewareConfigs(agent.deepAgentConfig?.middleware, models, agent.id),
+        passthrough: typeof agent.deepAgentConfig?.passthrough === "object" && agent.deepAgentConfig.passthrough
+            ? { ...agent.deepAgentConfig.passthrough }
+            : undefined,
     };
 }
 function resolveDirectPrompt(agent) {
@@ -243,6 +246,9 @@ export function compileBinding(workspaceRoot, agent, agents, referencedSubagentI
             responseFormat: agent.langchainAgentConfig?.responseFormat,
             contextSchema: agent.langchainAgentConfig?.contextSchema,
             middleware: compileMiddlewareConfigs(agent.langchainAgentConfig?.middleware, models, agent.id),
+            passthrough: typeof agent.langchainAgentConfig?.passthrough === "object" && agent.langchainAgentConfig.passthrough
+                ? { ...agent.langchainAgentConfig.passthrough }
+                : undefined,
             subagents: agent.subagentRefs.map((ref) => {
                 const subagent = agents.get(resolveRefId(ref));
                 if (!subagent) {
@@ -282,6 +288,9 @@ export function compileBinding(workspaceRoot, agent, agents, referencedSubagentI
         responseFormat: agent.deepAgentConfig?.responseFormat,
         contextSchema: agent.deepAgentConfig?.contextSchema,
         middleware: compileMiddlewareConfigs(agent.deepAgentConfig?.middleware, models, agent.id),
+        passthrough: typeof agent.deepAgentConfig?.passthrough === "object" && agent.deepAgentConfig.passthrough
+            ? { ...agent.deepAgentConfig.passthrough }
+            : undefined,
         description: agent.description,
         subagents: agent.subagentRefs.map((ref) => {
             const subagent = agents.get(resolveRefId(ref));

package/dist/workspace/object-loader.js

@@ -215,6 +215,21 @@ function readExecutionConfig(value) {
         ? { ...value }
         : undefined;
 }
+function cloneConfigValue(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => cloneConfigValue(item));
+    }
+    if (typeof value === "object" && value !== null) {
+        return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, cloneConfigValue(entry)]));
+    }
+    return value;
+}
+function readPassthroughConfig(item, consumedKeys) {
+    const passthrough = Object.fromEntries(Object.entries(item)
+        .filter(([key]) => !consumedKeys.includes(key))
+        .map(([key, value]) => [key, cloneConfigValue(value)]));
+    return Object.keys(passthrough).length > 0 ? passthrough : undefined;
+}
 function resolveExecutionBackend(item, current) {
     const execution = readExecutionConfig(item.execution) ?? readExecutionConfig(current?.execution);
     const backend = typeof execution?.backend === "string"
@@ -232,6 +247,33 @@ function resolveExecutionBackend(item, current) {
 }
 function readSharedAgentConfig(item) {
     const middleware = readMiddlewareArray(item.middleware);
+    const passthrough = readPassthroughConfig(item, [
+        "id",
+        "kind",
+        "description",
+        "modelRef",
+        "runRoot",
+        "tools",
+        "mcpServers",
+        "skills",
+        "memory",
+        "subagents",
+        "execution",
+        "capabilities",
+        "systemPrompt",
+        "checkpointer",
+        "interruptOn",
+        "stateSchema",
+        "responseFormat",
+        "contextSchema",
+        "includeAgentName",
+        "version",
+        "middleware",
+        "backend",
+        "store",
+        "taskDescription",
+        "generalPurposeAgent",
+    ]);
     return {
         ...(typeof item.systemPrompt === "string" ? { systemPrompt: item.systemPrompt } : {}),
         ...((typeof item.checkpointer === "object" && item.checkpointer) || typeof item.checkpointer === "boolean"
@@ -244,6 +286,7 @@ function readSharedAgentConfig(item) {
         ...(item.includeAgentName === "inline" ? { includeAgentName: "inline" } : {}),
         ...(item.version === "v1" || item.version === "v2" ? { version: item.version } : {}),
         ...(middleware ? { middleware } : {}),
+        ...(passthrough ? { passthrough } : {}),
     };
 }
 function readLangchainAgentConfig(item) {

package/dist/workspace/validate.js

@@ -38,6 +38,9 @@ function validateMiddlewareConfig(agent) {
         if (kind === "modelFallback" && !Array.isArray(typed.fallbackModels) && !Array.isArray(typed.models)) {
             throw new Error(`Agent ${agent.id} modelFallback middleware requires fallbackModels or models`);
         }
+        if (kind === "humanInTheLoop" && typeof typed.interruptOn !== "object") {
+            throw new Error(`Agent ${agent.id} humanInTheLoop middleware requires interruptOn`);
+        }
         if (kind === "pii" && typeof typed.piiType !== "string") {
             throw new Error(`Agent ${agent.id} pii middleware requires piiType`);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botbotgo/agent-harness",
-  "version": "0.0.49",
+  "version": "0.0.50",
   "description": "Workspace runtime for multi-agent applications",
   "type": "module",
   "packageManager": "npm@10.9.2",
@@ -26,11 +26,6 @@
       "types": "./dist/tools.d.ts",
       "import": "./dist/tools.js",
       "default": "./dist/tools.js"
-    },
-    "./presentation": {
-      "types": "./dist/presentation.d.ts",
-      "import": "./dist/presentation.js",
-      "default": "./dist/presentation.js"
     }
   },
   "dependencies": {
@@ -38,7 +33,7 @@
     "@langchain/community": "^1.1.24",
     "@langchain/core": "^1.1.33",
     "@langchain/google": "^0.1.7",
-    "@langchain/langgraph": "^1.2.3",
+    "@langchain/langgraph": "^1.2.5",
     "@langchain/langgraph-checkpoint-sqlite": "^1.0.1",
     "@langchain/ollama": "^1.2.6",
     "@langchain/openai": "^1.1.0",
@@ -46,7 +41,7 @@
     "@llamaindex/ollama": "^0.1.23",
     "@modelcontextprotocol/sdk": "^1.12.0",
     "deepagents": "1.8.4",
-    "langchain": "1.2.34",
+    "langchain": "^1.2.36",
     "llamaindex": "^0.12.1",
     "mustache": "^4.2.0",
     "yaml": "^2.8.1",
@@ -55,9 +50,8 @@
   "scripts": {
     "build": "rm -rf dist tsconfig.tsbuildinfo && tsc -p tsconfig.json && cp -R config dist/",
     "check": "tsc -p tsconfig.json --noEmit",
-    "test": "vitest run test/public-api.test.ts test/resource-optional-provider.test.ts test/resource-isolation.test.ts test/stock-research-app-load-harness.test.ts test/stock-research-app-run.test.ts test/release-workflow.test.ts test/release-version.test.ts test/gitignore.test.ts test/package-lock.test.ts test/readme.test.ts test/runtime-adapter-regressions.test.ts test/runtime-recovery.test.ts test/tool-extension-gaps.test.ts test/checkpoint-maintenance.test.ts test/llamaindex-dependency-compat.test.ts test/skill-standard.test.ts test/routing-config.test.ts test/workspace-compat-regressions.test.ts test/upstream-compat-regressions.test.ts test/embedded-browser-bookmarks.test.ts test/presentation-wallee.test.ts",
+    "test": "vitest run test/public-api.test.ts test/resource-optional-provider.test.ts test/resource-isolation.test.ts test/stock-research-app-load-harness.test.ts test/stock-research-app-run.test.ts test/release-workflow.test.ts test/release-version.test.ts test/gitignore.test.ts test/package-lock.test.ts test/readme.test.ts test/runtime-adapter-regressions.test.ts test/runtime-capabilities.test.ts test/runtime-recovery.test.ts test/tool-extension-gaps.test.ts test/checkpoint-maintenance.test.ts test/llamaindex-dependency-compat.test.ts test/skill-standard.test.ts test/routing-config.test.ts test/workspace-compat-regressions.test.ts test/upstream-compat-regressions.test.ts test/yaml-format.test.ts",
     "test:real-providers": "vitest run test/real-provider-harness.test.ts",
-    "test:integration": "npm run build && node scripts/integration-wallee-browser.mjs",
     "release:prepare": "npm version patch --no-git-tag-version && node ./scripts/sync-example-version.mjs",
     "release:pack": "npm pack --dry-run",
     "release:publish": "npm publish --access public --registry https://registry.npmjs.org/"