@botbotgo/agent-harness 0.0.48 → 0.0.50

package/dist/extensions.js

@@ -198,6 +198,44 @@ registerToolKind({
         ];
     },
 });
+registerToolKind({
+    type: "provider",
+    validate(tool) {
+        if (!tool.name || !tool.description) {
+            throw new Error(`Tool ${tool.id} provider tool requires name and description`);
+        }
+        const providerTool = typeof tool.config?.providerTool === "object" && tool.config.providerTool
+            ? tool.config.providerTool
+            : undefined;
+        if (typeof providerTool?.provider !== "string" || !providerTool.provider.trim()) {
+            throw new Error(`Tool ${tool.id} provider tool must define providerTool.provider`);
+        }
+        if (typeof providerTool?.tool !== "string" || !providerTool.tool.trim()) {
+            throw new Error(`Tool ${tool.id} provider tool must define providerTool.tool`);
+        }
+    },
+    compile(tool) {
+        return [
+            {
+                id: tool.id,
+                type: "provider",
+                name: tool.name,
+                description: tool.description,
+                config: tool.config,
+                inputSchemaRef: tool.inputSchemaRef,
+                bundleRefs: [],
+                hitl: tool.hitl
+                    ? {
+                        enabled: tool.hitl.enabled,
+                        allow: tool.hitl.allow ?? ["approve", "edit", "reject"],
+                    }
+                    : undefined,
+                retryable: tool.retryable,
+                runtimeValue: { name: tool.name, description: tool.description, type: "provider" },
+            },
+        ];
+    },
+});
 registerToolKind({
     type: "bundle",
     validate(tool, tools) {

package/dist/package-version.d.ts

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

package/dist/package-version.js

@@ -1 +1 @@
-export const AGENT_HARNESS_VERSION = "0.0.47";
+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/resource/resource-impl.js

@@ -20,12 +20,6 @@ function installedResourceProviderEntry() {
     try {
         return require.resolve("@botbotgo/agent-harness-resource");
     }
-    catch {
-        // Fall through to the legacy package name for backward compatibility only.
-    }
-    try {
-        return require.resolve("@botbotgo/agent-harness-builtin");
-    }
     catch {
         return null;
     }

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

@@ -33,6 +33,8 @@ export declare class AgentRuntimeAdapter {
     private normalizeInterruptPolicy;
     private compileInterruptOn;
     private resolveInterruptOn;
+    private resolveFilesystemBackend;
+    private resolveLangChainAutomaticMiddleware;
     private resolveMiddleware;
     private resolveCheckpointer;
     private buildRouteSystemPrompt;

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

@@ -1,13 +1,15 @@
 import { Command, MemorySaver } from "@langchain/langgraph";
 import { tool as createLangChainTool } from "@langchain/core/tools";
-import { createDeepAgent } from "deepagents";
+import { createDeepAgent, createMemoryMiddleware, createSkillsMiddleware, createSubAgentMiddleware, FilesystemBackend, } from "deepagents";
 import { ChatAnthropic } from "@langchain/anthropic";
+import { tools as anthropicProviderTools } from "@langchain/anthropic";
 import { ChatGoogle } from "@langchain/google";
 import { ChatOllama } from "@langchain/ollama";
 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";
@@ -112,6 +114,35 @@ function buildToolNameMapping(tools) {
     }
     return { originalToModelFacing, modelFacingToOriginal };
 }
+function hasConfiguredSubagentSupport(binding) {
+    const params = getBindingLangChainParams(binding);
+    if (!params) {
+        return false;
+    }
+    return (params.subagents?.length ?? 0) > 0 || params.generalPurposeAgent === true || Boolean(params.taskDescription?.trim());
+}
+function instantiateProviderTool(compiledTool) {
+    const providerTool = asRecord(compiledTool.config?.providerTool);
+    const provider = typeof providerTool?.provider === "string" ? providerTool.provider.trim().toLowerCase() : "";
+    const toolName = typeof providerTool?.tool === "string" ? providerTool.tool.trim() : "";
+    const args = asRecord(providerTool?.args) ?? {};
+    if (!provider || !toolName) {
+        throw new Error(`Provider tool ${compiledTool.id} must define providerTool.provider and providerTool.tool`);
+    }
+    const registry = provider === "openai"
+        ? openAIProviderTools
+        : provider === "anthropic"
+            ? anthropicProviderTools
+            : undefined;
+    if (!registry) {
+        throw new Error(`Provider tool ${compiledTool.id} uses unsupported provider ${provider}`);
+    }
+    const factory = registry[toolName];
+    if (typeof factory !== "function") {
+        throw new Error(`Provider tool ${compiledTool.id} references unknown ${provider} tool ${toolName}`);
+    }
+    return factory(args);
+}
 function wrapResolvedToolWithModelFacingName(resolvedTool, modelFacingName) {
     if (typeof resolvedTool !== "object" || resolvedTool === null) {
         return resolvedTool;
@@ -393,10 +424,10 @@ export class AgentRuntimeAdapter {
     resolveTools(tools, binding) {
         const resolved = this.options.toolResolver ? this.options.toolResolver(tools.map((tool) => tool.id), binding) : [];
         const toolNameMapping = this.buildToolNameMapping(tools);
-        return resolved.map((resolvedTool, index) => {
-            const compiledTool = tools[index];
-            if (!compiledTool) {
-                return resolvedTool;
+        return tools.flatMap((compiledTool, index) => {
+            const resolvedTool = resolved[index] ?? (compiledTool.type === "provider" ? instantiateProviderTool(compiledTool) : undefined);
+            if (resolvedTool === undefined) {
+                return [];
             }
             const wrappedTool = wrapToolForExecution(resolvedTool, compiledTool, binding);
             const modelFacingName = toolNameMapping.originalToModelFacing.get(compiledTool.name) ?? compiledTool.name;
@@ -443,14 +474,55 @@ export class AgentRuntimeAdapter {
     resolveInterruptOn(binding) {
         return this.compileInterruptOn(getBindingPrimaryTools(binding), getBindingInterruptCompatibilityRules(binding));
     }
+    resolveFilesystemBackend(binding) {
+        return new FilesystemBackend({
+            rootDir: "/",
+            virtualMode: false,
+            maxFileSizeMb: 10,
+        });
+    }
+    async resolveLangChainAutomaticMiddleware(binding) {
+        const params = getBindingLangChainParams(binding);
+        if (!params) {
+            return [];
+        }
+        const automaticMiddleware = [];
+        if ((params.skills?.length ?? 0) > 0) {
+            automaticMiddleware.push(createSkillsMiddleware({
+                backend: this.resolveFilesystemBackend(binding),
+                sources: params.skills,
+            }));
+        }
+        if ((params.memory?.length ?? 0) > 0) {
+            automaticMiddleware.push(createMemoryMiddleware({
+                backend: this.resolveFilesystemBackend(binding),
+                sources: params.memory,
+            }));
+        }
+        if (hasConfiguredSubagentSupport(binding)) {
+            automaticMiddleware.push(createSubAgentMiddleware({
+                defaultModel: (await this.resolveModel(params.model)),
+                defaultTools: this.resolveTools(params.tools, binding),
+                defaultInterruptOn: getBindingInterruptCompatibilityRules(binding),
+                subagents: (await this.resolveSubagents(params.subagents ?? [], binding)),
+                generalPurposeAgent: params.generalPurposeAgent,
+                taskDescription: params.taskDescription ?? null,
+            }));
+        }
+        return automaticMiddleware;
+    }
     async resolveMiddleware(binding, interruptOn) {
         const declarativeMiddleware = await resolveDeclaredMiddleware(getBindingMiddlewareConfigs(binding), {
             resolveModel: (model) => this.resolveModel(model),
             resolveCustom: this.options.declaredMiddlewareResolver,
             binding,
         });
+        const automaticMiddleware = isLangChainBinding(binding)
+            ? await this.resolveLangChainAutomaticMiddleware(binding)
+            : [];
         const middleware = [
             ...declarativeMiddleware,
+            ...automaticMiddleware,
             ...(this.options.middlewareResolver ? this.options.middlewareResolver(binding) : []),
         ];
         if (interruptOn && Object.keys(interruptOn).length > 0) {
@@ -484,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),
@@ -506,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,
@@ -526,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,
@@ -600,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,
@@ -608,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, 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,9 +77,21 @@ 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;
+            case "pii": {
+                const piiType = typeof runtimeConfig.piiType === "string" ? runtimeConfig.piiType : undefined;
+                if (!piiType) {
+                    throw new Error("pii middleware requires piiType");
+                }
+                const { piiType: _piiType, ...piiOptions } = runtimeConfig;
+                resolved.push(piiMiddleware(piiType, piiOptions));
+                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

@@ -47,9 +47,9 @@ export class AgentHarnessRuntime {
     normalizeInvocationEnvelope(options) {
         const invocation = options.invocation;
         return {
-            context: invocation?.context ?? options.context,
-            state: invocation?.inputs ?? options.state,
-            files: invocation?.attachments ?? options.files,
+            context: invocation?.context,
+            state: invocation?.inputs,
+            files: invocation?.attachments,
             invocation,
         };
     }
@@ -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,22 @@ 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) {
+                    throw new Error(`Missing subagent ${ref} for agent ${agent.id}`);
+                }
+                return buildSubagent(subagent, workspaceRoot, models, tools, compiledAgentSkills, compiledAgentModel, compiledAgentMemory);
+            }),
+            memory: compiledAgentMemory,
+            skills: compiledAgentSkills,
+            generalPurposeAgent: typeof agent.langchainAgentConfig?.generalPurposeAgent === "boolean" ? agent.langchainAgentConfig.generalPurposeAgent : undefined,
+            taskDescription: typeof agent.langchainAgentConfig?.taskDescription === "string" && agent.langchainAgentConfig.taskDescription.trim()
+                ? agent.langchainAgentConfig.taskDescription
+                : undefined,
             includeAgentName: agent.langchainAgentConfig?.includeAgentName === "inline" ? "inline" : undefined,
             version: agent.langchainAgentConfig?.version === "v1" || agent.langchainAgentConfig?.version === "v2"
                 ? agent.langchainAgentConfig.version
@@ -269,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));