@botbotgo/agent-harness 0.0.49 → 0.0.51

package/README.md

@@ -6,16 +6,16 @@
 
 It is not a new agent framework. It is the runtime layer around LangChain v1 and DeepAgents that turns one workspace into one operable application runtime.
 
-The product boundary is:
+The product boundary is simple:
 
 - LangChain v1 and DeepAgents own agent execution semantics
-- `agent-harness` owns application runtime semantics
+- `agent-harness` owns application-level orchestration and lifecycle management
 
 That means:
 
 - public API stays small
-- complex assembly and policy live in YAML
-- runtime lifecycle stays stable even if the backend implementation changes
+- complex setup and operating policy live in YAML
+- runtime lifecycle stays stable even if backend implementations change
 
 What the runtime provides:
 
@@ -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);
     },
@@ -196,11 +201,11 @@ metadata:
 spec:
   execution:
     backend: deepagent
-  modelRef: model/default
-  mcpServers:
-    - name: browser
-      command: node
-      args: ["./mcp-browser-server.mjs"]
+    modelRef: model/default
+    mcpServers:
+      - name: browser
+        command: node
+        args: ["./mcp-browser-server.mjs"]
 ```
 
 The runtime discovers MCP tools, filters them through agent configuration, and exposes them like other tools.
@@ -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`
@@ -344,6 +347,13 @@ Use this file for named MCP server presets.
 
 Agents are always declared with `kind: Agent` and `spec.execution.backend`.
 
+Use two nested sections inside each agent:
+
+- `spec.runtime` for harness-owned runtime placement such as `spec.runtime.runRoot`
+- `spec.execution` for upstream execution semantics and adapter-facing config
+
+This keeps the public product model small while letting LangChain v1 and DeepAgents concepts pass through with minimal translation.
+
 Example lightweight host:
 
 ```yaml
@@ -354,10 +364,11 @@ metadata:
 spec:
   execution:
     backend: langchain-v1
-  modelRef: model/default
-  checkpointer:
-    ref: checkpointer/default
-  systemPrompt: Answer simple requests directly.
+    modelRef: model/default
+    config:
+      checkpointer:
+        ref: checkpointer/default
+      systemPrompt: Answer simple requests directly.
 ```
 
 Example main execution host:
@@ -370,21 +381,22 @@ metadata:
 spec:
   execution:
     backend: deepagent
-  modelRef: model/default
-  memory:
-    - path: config/agent-context.md
-  store:
-    ref: store/default
-  checkpointer:
-    ref: checkpointer/default
-  backend:
-    kind: CompositeBackend
-    state:
-      kind: VfsSandbox
-      timeout: 600
-    routes:
-      /memories/:
-        kind: StoreBackend
+    modelRef: model/default
+    memory:
+      - path: config/agent-context.md
+    config:
+      store:
+        ref: store/default
+      checkpointer:
+        ref: checkpointer/default
+      backend:
+        kind: CompositeBackend
+        state:
+          kind: VfsSandbox
+          timeout: 600
+        routes:
+          /memories/:
+            kind: StoreBackend
 ```
 
 Client-configurable agent fields include:
@@ -392,19 +404,29 @@ Client-configurable agent fields include:
 - `metadata.name`
 - `metadata.description`
 - `spec.execution.backend`
-- `spec.modelRef`
-- `spec.systemPrompt`
-- `spec.tools`
-- `spec.skills`
-- `spec.memory`
-- `spec.checkpointer`
-- `spec.store`
-- `spec.backend`
-- `spec.middleware`
-- `spec.subagents`
-- `spec.mcpServers`
-- `spec.responseFormat`
-- `spec.contextSchema`
+- `spec.runtime.runRoot`
+- `spec.execution.modelRef`
+- `spec.execution.tools`
+- `spec.execution.skills`
+- `spec.execution.memory`
+- `spec.execution.subagents`
+- `spec.execution.mcpServers`
+- `spec.execution.config.systemPrompt`
+- `spec.execution.config.checkpointer`
+- `spec.execution.config.store`
+- `spec.execution.config.backend`
+- `spec.execution.config.middleware`
+- `spec.execution.config.responseFormat`
+- `spec.execution.config.contextSchema`
+- `spec.execution.config.stateSchema`
+- `spec.execution.config.interruptOn`
+- `spec.execution.config.filesystem`
+- `spec.execution.config.taskDescription`
+- `spec.execution.config.generalPurposeAgent`
+- `spec.execution.config.includeAgentName`
+- `spec.execution.config.version`
+
+For backend-specific agent options, prefer passing the upstream concept directly inside `spec.execution.config`. The loader keeps a small stable product shape, but it also preserves adapter-facing passthrough fields so new LangChain v1 or DeepAgents parameters can flow into adapters without expanding the public API surface.
 
 ### `resources/`
 

package/dist/config/agents/direct.yaml

@@ -9,41 +9,43 @@ metadata:
   # agent-harness feature: human-readable summary for inventory and UI.
   description: Manual low-latency host for direct answers and lightweight inventory lookup. Do not use it as the default executor for tool-heavy or specialist-shaped tasks.
 spec:
-  execution:
-    # Current backend adapter for this host profile.
-    backend: langchain-v1
+  runtime: {}
   # =====================
   # Runtime Agent Features
   # =====================
-  # Upstream execution feature: model ref for the underlying LLM used by the direct-response agent.
-  # This should point at a cheap, fast, general-purpose chat model, because `direct` is intended
-  # to be the low-latency path for simple requests.
-  modelRef: model/default
-  # Runtime execution feature: checkpointer config passed into the selected backend adapter.
-  # Even the lightweight direct path can benefit from resumable state during interactive use.
-  # Available `kind` options in this harness: `FileCheckpointer`, `MemorySaver`, `SqliteSaver`.
-  # `path` is only used by `FileCheckpointer` and `SqliteSaver`; omit it for `MemorySaver`.
-  checkpointer:
-    ref: checkpointer/default
-  # Upstream execution feature: system prompt for the lightweight direct-response host.
-  # This prompt should keep the agent focused on:
-  # - answering simple requests in one turn
-  # - staying lightweight instead of planning or orchestrating
-  # - avoiding specialist-style decomposition unless the caller explicitly switches agents
-  #
-  # The direct host is intentionally narrower than the orchestra host:
-  # - `direct` is optimized for latency and straightforward completion
-  # - `orchestra` is optimized for multi-step work, tools, delegation, and specialist use
-  #
-  # Keep this prompt biased toward concise, self-contained answers. If richer routing policy is
-  # needed for choosing between host agents, configure that separately via `Runtime.spec.routing`
-  # rather than overloading the direct host prompt with classifier behavior.
-  systemPrompt: |-
-    You are the direct agent.
+  execution:
+    # Current backend adapter for this host profile.
+    backend: langchain-v1
+    # Upstream execution feature: model ref for the underlying LLM used by the direct-response agent.
+    # This should point at a cheap, fast, general-purpose chat model, because `direct` is intended
+    # to be the low-latency path for simple requests.
+    modelRef: model/default
+    config:
+      # Runtime execution feature: checkpointer config passed into the selected backend adapter.
+      # Even the lightweight direct path can benefit from resumable state during interactive use.
+      # Available `kind` options in this harness: `FileCheckpointer`, `MemorySaver`, `SqliteSaver`.
+      # `path` is only used by `FileCheckpointer` and `SqliteSaver`; omit it for `MemorySaver`.
+      checkpointer:
+        ref: checkpointer/default
+      # Upstream execution feature: system prompt for the lightweight direct-response host.
+      # This prompt should keep the agent focused on:
+      # - answering simple requests in one turn
+      # - staying lightweight instead of planning or orchestrating
+      # - avoiding specialist-style decomposition unless the caller explicitly switches agents
+      #
+      # The direct host is intentionally narrower than the orchestra host:
+      # - `direct` is optimized for latency and straightforward completion
+      # - `orchestra` is optimized for multi-step work, tools, delegation, and specialist use
+      #
+      # Keep this prompt biased toward concise, self-contained answers. If richer routing policy is
+      # needed for choosing between host agents, configure that separately via `Runtime.spec.routing`
+      # rather than overloading the direct host prompt with classifier behavior.
+      systemPrompt: |-
+        You are the direct agent.
 
-    This is a manual low-latency host.
-    Answer simple requests directly.
-    Keep the path lightweight.
-    Do not delegate.
-    Do not perform broad multi-step execution.
-    Do not behave like the default execution host.
+        This is a manual low-latency host.
+        Answer simple requests directly.
+        Keep the path lightweight.
+        Do not delegate.
+        Do not perform broad multi-step execution.
+        Do not behave like the default execution host.

package/dist/config/agents/orchestra.yaml

@@ -9,86 +9,88 @@ metadata:
   # agent-harness feature: human-readable summary for inventory and UI.
   description: Default execution host. Answer directly when possible, use local tools and skills first, and delegate only when a specialist is a better fit. Not a reflex delegation-only planner.
 spec:
-  execution:
-    # Current backend adapter for this host profile.
-    backend: deepagent
+  runtime: {}
   # =====================
   # Runtime Agent Features
   # =====================
-  # Upstream execution feature: model ref for the underlying LLM used by this execution host.
-  modelRef: model/default
-  # Runtime execution feature: checkpointer config passed into the selected backend adapter.
-  # This persists resumable graph state for this agent.
-  # Available `kind` options in this harness: `FileCheckpointer`, `MemorySaver`, `SqliteSaver`.
-  # `path` is only used by `FileCheckpointer` and `SqliteSaver`; omit it for `MemorySaver`.
-  checkpointer:
-    # ref: checkpointer/sqlite
-    ref: checkpointer/default
-  memory:
-    # Upstream execution feature: bootstrap memory sources supplied to the selected backend at construction time.
-    # These paths resolve relative to the workspace root unless they are already absolute.
-    # Treat this as agent-owned startup context, not as a dynamic long-term memory sink:
-    # - keep `systemPrompt` for stable role, boundaries, and hard behavioral rules
-    # - use `memory:` for stable project knowledge, operating conventions, and shared or agent-specific context files
-    # - use `/memories/*` via the backend/store below for durable knowledge learned from prior runs
-    # - use the harness checkpointer for resumable graph state for an in-flight run
-    # Updating these files changes future agent constructions, but they are still bootstrap inputs rather than
-    # self-updating runtime memory.
-    - path: config/agent-context.md
-  # Upstream execution feature: store config passed into the selected backend adapter.
-  # In the default deepagent adapter this is the LangGraph store used by `StoreBackend` routes.
-  # Available `kind` options in this harness: `FileStore`, `InMemoryStore`, `RedisStore`, `PostgresStore`.
-  store:
-    ref: store/default
-  # Upstream execution feature: backend config passed into the selected backend adapter.
-  # This directly defines the backend topology for this agent:
-  # - workspace execution uses a lightweight VFS sandbox
-  # - long-term memory under `/memories/*` uses `StoreBackend`
-  # - `CompositeBackend` composes those backend instances together
-  # The harness also injects a persistent file-backed store and a file-backed checkpointer so that
-  # `/memories/*` and resumable run state survive restarts in the default setup.
-  # Available top-level `kind` options in this harness: `CompositeBackend`, `StateBackend`, `StoreBackend`.
-  backend:
-    kind: CompositeBackend
-    state:
-      # Available state backend `kind` options today: `StateBackend`, `LocalShellBackend`, `VfsSandbox`.
-      kind: VfsSandbox
-      timeout: 600
-    routes:
-      /memories/:
-        # Available route backend `kind` options today: `StoreBackend`.
-        kind: StoreBackend
-  # Upstream execution feature: system prompt for the orchestration host.
-  # This becomes the top-level instruction block for the selected execution backend and should hold the
-  # agent's durable role, priorities, and behavioral guardrails rather than bulky project facts.
-  systemPrompt: |-
-    You are the orchestra agent.
+  execution:
+    # Current backend adapter for this host profile.
+    backend: deepagent
+    # Upstream execution feature: model ref for the underlying LLM used by this execution host.
+    modelRef: model/default
+    memory:
+      # Upstream execution feature: bootstrap memory sources supplied to the selected backend at construction time.
+      # These paths resolve relative to the workspace root unless they are already absolute.
+      # Treat this as agent-owned startup context, not as a dynamic long-term memory sink:
+      # - keep `systemPrompt` for stable role, boundaries, and hard behavioral rules
+      # - use `memory:` for stable project knowledge, operating conventions, and shared or agent-specific context files
+      # - use `/memories/*` via the backend/store below for durable knowledge learned from prior runs
+      # - use the harness checkpointer for resumable graph state for an in-flight run
+      # Updating these files changes future agent constructions, but they are still bootstrap inputs rather than
+      # self-updating runtime memory.
+      - path: config/agent-context.md
+    config:
+      # Runtime execution feature: checkpointer config passed into the selected backend adapter.
+      # This persists resumable graph state for this agent.
+      # Available `kind` options in this harness: `FileCheckpointer`, `MemorySaver`, `SqliteSaver`.
+      # `path` is only used by `FileCheckpointer` and `SqliteSaver`; omit it for `MemorySaver`.
+      checkpointer:
+        # ref: checkpointer/sqlite
+        ref: checkpointer/default
+      # Upstream execution feature: store config passed into the selected backend adapter.
+      # In the default deepagent adapter this is the LangGraph store used by `StoreBackend` routes.
+      # Available `kind` options in this harness: `FileStore`, `InMemoryStore`, `RedisStore`, `PostgresStore`.
+      store:
+        ref: store/default
+      # Upstream execution feature: backend config passed into the selected backend adapter.
+      # This directly defines the backend topology for this agent:
+      # - workspace execution uses a lightweight VFS sandbox
+      # - long-term memory under `/memories/*` uses `StoreBackend`
+      # - `CompositeBackend` composes those backend instances together
+      # The harness also injects a persistent file-backed store and a file-backed checkpointer so that
+      # `/memories/*` and resumable run state survive restarts in the default setup.
+      # Available top-level `kind` options in this harness: `CompositeBackend`, `StateBackend`, `StoreBackend`.
+      backend:
+        kind: CompositeBackend
+        state:
+          # Available state backend `kind` options today: `StateBackend`, `LocalShellBackend`, `VfsSandbox`.
+          kind: VfsSandbox
+          timeout: 600
+        routes:
+          /memories/:
+            # Available route backend `kind` options today: `StoreBackend`.
+            kind: StoreBackend
+      # Upstream execution feature: system prompt for the orchestration host.
+      # This becomes the top-level instruction block for the selected execution backend and should hold the
+      # agent's durable role, priorities, and behavioral guardrails rather than bulky project facts.
+      systemPrompt: |-
+        You are the orchestra agent.
 
-    You are the default execution host.
-    Try to finish the request yourself before delegating.
-    Use your own tools first when they are sufficient.
-    Use your own skills first when they are sufficient.
-    Delegate only when a specialist is a clearly better fit or when your own tools and skills are not enough.
-    If neither you nor any suitable specialist can do the work, say so plainly.
+        You are the default execution host.
+        Try to finish the request yourself before delegating.
+        Use your own tools first when they are sufficient.
+        Use your own skills first when they are sufficient.
+        Delegate only when a specialist is a clearly better fit or when your own tools and skills are not enough.
+        If neither you nor any suitable specialist can do the work, say so plainly.
 
-    Do not delegate by reflex.
-    Do not delegate just because a task has multiple steps.
-    Do not delegate when a direct answer or a short local tool pass is enough.
-    Keep the critical path local when immediate progress depends on it; otherwise delegate bounded sidecar work to
-    the most appropriate specialist.
+        Do not delegate by reflex.
+        Do not delegate just because a task has multiple steps.
+        Do not delegate when a direct answer or a short local tool pass is enough.
+        Keep the critical path local when immediate progress depends on it; otherwise delegate bounded sidecar work to
+        the most appropriate specialist.
 
-    Use your own tools for lightweight discovery, inventory, and context gathering.
-    Prefer the structured checkout, indexing, retrieval, and inventory tools that are already attached to you over
-    ad hoc shell work when those tools are sufficient.
-    Use the attached specialist descriptions as the source of truth for what each specialist is for.
-    Do not delegate to a specialist whose description does not clearly match the task.
-    Integrate specialist results into one coherent answer and do not claim checks or evidence you did not obtain.
+        Use your own tools for lightweight discovery, inventory, and context gathering.
+        Prefer the structured checkout, indexing, retrieval, and inventory tools that are already attached to you over
+        ad hoc shell work when those tools are sufficient.
+        Use the attached specialist descriptions as the source of truth for what each specialist is for.
+        Do not delegate to a specialist whose description does not clearly match the task.
+        Integrate specialist results into one coherent answer and do not claim checks or evidence you did not obtain.
 
-    When the user asks about available tools, skills, or agents, use the attached inventory tools instead of
-    inferring from memory.
+        When the user asks about available tools, skills, or agents, use the attached inventory tools instead of
+        inferring from memory.
 
-    Write to `/memories/*` only when the information is durable, reusable across future runs or threads, and likely
-    to matter again: user preferences, project conventions, confirmed decisions, reusable summaries, and stable
-    ownership facts are good candidates.
-    Do not store transient reasoning, temporary plans, scratch work, one-off search results, or intermediate
-    outputs that can be cheaply recomputed.
+        Write to `/memories/*` only when the information is durable, reusable across future runs or threads, and likely
+        to matter again: user preferences, project conventions, confirmed decisions, reusable summaries, and stable
+        ownership facts are good candidates.
+        Do not store transient reasoning, temporary plans, scratch work, one-off search results, or intermediate
+        outputs that can be cheaply recomputed.

package/dist/contracts/types.d.ts

@@ -95,7 +95,9 @@ export type LangChainAgentParams = {
     stateSchema?: unknown;
     responseFormat?: unknown;
     contextSchema?: unknown;
+    filesystem?: Record<string, unknown>;
     middleware?: Array<Record<string, unknown>>;
+    passthrough?: Record<string, unknown>;
     subagents?: CompiledSubAgent[];
     memory?: string[];
     skills?: string[];
@@ -118,6 +120,7 @@ export type CompiledSubAgent = {
     responseFormat?: unknown;
     contextSchema?: unknown;
     middleware?: Array<Record<string, unknown>>;
+    passthrough?: Record<string, unknown>;
 };
 export type DeepAgentParams = {
     model: CompiledModel;
@@ -126,6 +129,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 +261,9 @@ export type RunResult = {
     state: RunState;
     output: string;
     finalMessageText?: string;
+    outputContent?: unknown;
+    contentBlocks?: unknown[];
+    structuredResponse?: unknown;
     interruptContent?: string;
     agentId?: string;
     approvalId?: string;
@@ -267,6 +274,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 +326,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.50";

package/dist/package-version.js

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

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

@@ -1,3 +1,4 @@
+import path from "node:path";
 import { Command, MemorySaver } from "@langchain/langgraph";
 import { tool as createLangChainTool } from "@langchain/core/tools";
 import { createDeepAgent, createMemoryMiddleware, createSkillsMiddleware, createSubAgentMiddleware, FilesystemBackend, } from "deepagents";
@@ -9,7 +10,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";
@@ -475,10 +476,20 @@ export class AgentRuntimeAdapter {
         return this.compileInterruptOn(getBindingPrimaryTools(binding), getBindingInterruptCompatibilityRules(binding));
     }
     resolveFilesystemBackend(binding) {
+        const filesystemConfig = getBindingLangChainParams(binding)?.filesystem;
+        const configuredRootDir = typeof filesystemConfig?.rootDir === "string" && filesystemConfig.rootDir.trim().length > 0
+            ? filesystemConfig.rootDir
+            : undefined;
+        const workspaceRoot = binding.harnessRuntime.workspaceRoot;
+        const rootDir = configuredRootDir
+            ? (path.isAbsolute(configuredRootDir) ? configuredRootDir : path.resolve(workspaceRoot ?? process.cwd(), configuredRootDir))
+            : workspaceRoot ?? process.cwd();
         return new FilesystemBackend({
-            rootDir: "/",
-            virtualMode: false,
-            maxFileSizeMb: 10,
+            rootDir,
+            virtualMode: filesystemConfig?.virtualMode === true,
+            maxFileSizeMb: typeof filesystemConfig?.maxFileSizeMb === "number" && Number.isFinite(filesystemConfig.maxFileSizeMb)
+                ? filesystemConfig.maxFileSizeMb
+                : 10,
         });
     }
     async resolveLangChainAutomaticMiddleware(binding) {
@@ -556,6 +567,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 +590,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 +611,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 +686,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 +697,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) {
@@ -242,7 +245,13 @@ export function compileBinding(workspaceRoot, agent, agents, referencedSubagentI
             stateSchema: agent.langchainAgentConfig?.stateSchema,
             responseFormat: agent.langchainAgentConfig?.responseFormat,
             contextSchema: agent.langchainAgentConfig?.contextSchema,
+            filesystem: typeof agent.langchainAgentConfig?.filesystem === "object" && agent.langchainAgentConfig.filesystem
+                ? { ...agent.langchainAgentConfig.filesystem }
+                : undefined,
             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 +291,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

@@ -61,6 +61,11 @@ function toArray(value) {
 function asObject(value) {
     return typeof value === "object" && value ? value : undefined;
 }
+function asMutableObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? { ...value }
+        : undefined;
+}
 function normalizeCatalogSpec(document, options = {}) {
     const typed = asObject(document);
     const spec = typed?.spec;
@@ -211,9 +216,29 @@ function readCapabilities(value) {
     return Object.keys(capabilities).length > 0 ? capabilities : undefined;
 }
 function readExecutionConfig(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value)
-        ? { ...value }
-        : undefined;
+    return asMutableObject(value);
+}
+function readExecutionAgentConfig(item) {
+    const execution = readExecutionConfig(item.execution);
+    return asMutableObject(execution?.config) ?? {};
+}
+function readRuntimeConfig(item) {
+    return asMutableObject(item.runtime);
+}
+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);
@@ -230,43 +255,97 @@ function resolveExecutionBackend(item, current) {
     }
     return undefined;
 }
-function readSharedAgentConfig(item) {
-    const middleware = readMiddlewareArray(item.middleware);
+function readExecutionSingleRef(item, key) {
+    const execution = readExecutionConfig(item.execution);
+    return readSingleRef(execution?.[key]);
+}
+function readExecutionRefArray(item, key) {
+    const execution = readExecutionConfig(item.execution);
+    return readRefArray(execution?.[key]);
+}
+function readExecutionPathArray(item, key) {
+    const execution = readExecutionConfig(item.execution);
+    return readPathArray(execution?.[key]);
+}
+function readExecutionObjectArray(item, key) {
+    const execution = readExecutionConfig(item.execution);
+    return readObjectArray(execution?.[key]);
+}
+function readSharedAgentConfig(config) {
+    const middleware = readMiddlewareArray(config.middleware);
     return {
-        ...(typeof item.systemPrompt === "string" ? { systemPrompt: item.systemPrompt } : {}),
-        ...((typeof item.checkpointer === "object" && item.checkpointer) || typeof item.checkpointer === "boolean"
-            ? { checkpointer: item.checkpointer }
+        ...(typeof config.systemPrompt === "string" ? { systemPrompt: config.systemPrompt } : {}),
+        ...((typeof config.checkpointer === "object" && config.checkpointer) || typeof config.checkpointer === "boolean"
+            ? { checkpointer: config.checkpointer }
             : {}),
-        ...(typeof item.interruptOn === "object" && item.interruptOn ? { interruptOn: item.interruptOn } : {}),
-        ...(item.stateSchema !== undefined ? { stateSchema: item.stateSchema } : {}),
-        ...(item.responseFormat !== undefined ? { responseFormat: item.responseFormat } : {}),
-        ...(item.contextSchema !== undefined ? { contextSchema: item.contextSchema } : {}),
-        ...(item.includeAgentName === "inline" ? { includeAgentName: "inline" } : {}),
-        ...(item.version === "v1" || item.version === "v2" ? { version: item.version } : {}),
+        ...(typeof config.interruptOn === "object" && config.interruptOn ? { interruptOn: config.interruptOn } : {}),
+        ...(config.stateSchema !== undefined ? { stateSchema: config.stateSchema } : {}),
+        ...(config.responseFormat !== undefined ? { responseFormat: config.responseFormat } : {}),
+        ...(config.contextSchema !== undefined ? { contextSchema: config.contextSchema } : {}),
+        ...(config.includeAgentName === "inline" ? { includeAgentName: "inline" } : {}),
+        ...(config.version === "v1" || config.version === "v2" ? { version: config.version } : {}),
+        ...(typeof config.filesystem === "object" && config.filesystem ? { filesystem: config.filesystem } : {}),
         ...(middleware ? { middleware } : {}),
     };
 }
 function readLangchainAgentConfig(item) {
+    const config = readExecutionAgentConfig(item);
+    const passthrough = readPassthroughConfig(config, [
+        "systemPrompt",
+        "checkpointer",
+        "interruptOn",
+        "stateSchema",
+        "responseFormat",
+        "contextSchema",
+        "includeAgentName",
+        "version",
+        "middleware",
+        "backend",
+        "store",
+        "taskDescription",
+        "generalPurposeAgent",
+        "filesystem",
+    ]);
     return {
-        ...readSharedAgentConfig(item),
-        ...(typeof item.store === "object" && item.store ? { store: item.store } : {}),
-        ...(typeof item.taskDescription === "string" && item.taskDescription.trim() ? { taskDescription: item.taskDescription } : {}),
-        ...(typeof item.generalPurposeAgent === "boolean" ? { generalPurposeAgent: item.generalPurposeAgent } : {}),
+        ...readSharedAgentConfig(config),
+        ...(typeof config.store === "object" && config.store ? { store: config.store } : {}),
+        ...(typeof config.taskDescription === "string" && config.taskDescription.trim() ? { taskDescription: config.taskDescription } : {}),
+        ...(typeof config.generalPurposeAgent === "boolean" ? { generalPurposeAgent: config.generalPurposeAgent } : {}),
+        ...(passthrough ? { passthrough } : {}),
     };
 }
 function readDeepAgentConfig(item) {
+    const config = readExecutionAgentConfig(item);
+    const passthrough = readPassthroughConfig(config, [
+        "systemPrompt",
+        "checkpointer",
+        "interruptOn",
+        "stateSchema",
+        "responseFormat",
+        "contextSchema",
+        "includeAgentName",
+        "version",
+        "middleware",
+        "backend",
+        "store",
+        "taskDescription",
+        "generalPurposeAgent",
+        "filesystem",
+    ]);
     return {
-        ...readSharedAgentConfig(item),
-        ...(typeof item.backend === "object" && item.backend ? { backend: item.backend } : {}),
-        ...(typeof item.store === "object" && item.store ? { store: item.store } : {}),
-        ...(typeof item.taskDescription === "string" && item.taskDescription.trim() ? { taskDescription: item.taskDescription } : {}),
-        ...(typeof item.generalPurposeAgent === "boolean" ? { generalPurposeAgent: item.generalPurposeAgent } : {}),
+        ...readSharedAgentConfig(config),
+        ...(typeof config.backend === "object" && config.backend ? { backend: config.backend } : {}),
+        ...(typeof config.store === "object" && config.store ? { store: config.store } : {}),
+        ...(typeof config.taskDescription === "string" && config.taskDescription.trim() ? { taskDescription: config.taskDescription } : {}),
+        ...(typeof config.generalPurposeAgent === "boolean" ? { generalPurposeAgent: config.generalPurposeAgent } : {}),
+        ...(passthrough ? { passthrough } : {}),
     };
 }
 export function parseAgentItem(item, sourcePath) {
-    const subagentRefs = readRefArray(item.subagents);
-    const subagentPathRefs = readPathArray(item.subagents);
+    const subagentRefs = readExecutionRefArray(item, "subagents");
+    const subagentPathRefs = readExecutionPathArray(item, "subagents");
     const executionMode = String(resolveExecutionBackend(item) ?? "deepagent");
+    const runtime = readRuntimeConfig(item);
     return {
         id: String(item.id),
         executionMode: executionMode,
@@ -274,12 +353,12 @@ export function parseAgentItem(item, sourcePath) {
             ? { delegation: true, memory: true }
             : { delegation: true, memory: true }),
         description: String(item.description ?? ""),
-        modelRef: readSingleRef(item.modelRef) ?? "",
-        runRoot: typeof item.runRoot === "string" ? item.runRoot : undefined,
-        toolRefs: readRefArray(item.tools),
-        mcpServers: readObjectArray(item.mcpServers),
-        skillPathRefs: readPathArray(item.skills),
-        memorySources: readPathArray(item.memory),
+        modelRef: readExecutionSingleRef(item, "modelRef") ?? "",
+        runRoot: typeof runtime?.runRoot === "string" ? runtime.runRoot : undefined,
+        toolRefs: readExecutionRefArray(item, "tools"),
+        mcpServers: readExecutionObjectArray(item, "mcpServers"),
+        skillPathRefs: readExecutionPathArray(item, "skills"),
+        memorySources: readExecutionPathArray(item, "memory"),
         subagentRefs,
         subagentPathRefs,
         langchainAgentConfig: 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.51",
   "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/"