@botbotgo/agent-harness 0.0.52 → 0.0.54

package/README.md

@@ -6,21 +6,21 @@
 
 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 boundary is strict:
+The product boundary is strict:
 
 - LangChain v1 and DeepAgents own agent execution semantics
-- `agent-harness` owns application-level orchestration and lifecycle management
+- `agent-harness` owns application-level orchestration and lifecycle management stays in the harness
 
 That means:
 
 - public API stays small
 - complex setup and operating policy live in YAML
-- application-level orchestration and lifecycle management stays in the harness
 - runtime lifecycle stays stable even if backend implementations change
+- backend internals stay behind adapters
 
 What the runtime provides:
 
-- `createAgentHarness(...)`, `run(...)`, `subscribe(...)`, inspection methods, and `stop(...)`
+- `createAgentHarness(workspaceRoot)`, `run(...)`, `resolveApproval(...)`, `subscribe(...)`, inspection methods, and `stop(...)`
 - YAML-defined workspace assembly for routing, models, tools, stores, backends, MCP, recovery, and maintenance
 - backend-adapted execution with current LangChain v1 and DeepAgents adapters
 - local `resources/tools/` and `resources/skills/` discovery
@@ -124,12 +124,12 @@ const result = await run(runtime, {
 });
 ```
 
-`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.
+`run(runtime, { ... })` creates or continues a persisted thread and returns `threadId`, `runId`, `state`, and a compact text `output`. Richer upstream results remain available through `outputContent`, `contentBlocks`, and `structuredResponse` without expanding the main facade.
 
 Use `invocation` as the runtime-facing request envelope:
 
 - `invocation.context` for request-scoped execution context
-- `invocation.inputs` for additional structured runtime inputs
+- `invocation.inputs` for structured runtime inputs
 - `invocation.attachments` for attachment-like payloads that the active backend can interpret
 
 ### Let The Runtime Route
@@ -141,7 +141,7 @@ const result = await run(runtime, {
 });
 ```
 
-`agentId: "auto"` evaluates ordered `routing.rules`, then `routing.defaultAgentId`, and only falls back to model routing when `routing.modelRouting: true`.
+`agentId: "auto"` evaluates ordered routing rules in `config/workspace.yaml`, then `routing.defaultAgentId`, and only falls back to model routing when `routing.modelRouting: true`.
 
 ### Stream Output And Events
 
@@ -183,12 +183,20 @@ import {
   getThread,
   listApprovals,
   listThreads,
+  resolveApproval,
 } from "@botbotgo/agent-harness";
 
 const threads = await listThreads(runtime);
 const thread = await getThread(runtime, threads[0]!.threadId);
 const approvals = await listApprovals(runtime, { status: "pending" });
 const approval = approvals[0] ? await getApproval(runtime, approvals[0].approvalId) : null;
+
+if (approval) {
+  await resolveApproval(runtime, {
+    approvalId: approval.approvalId,
+    decision: "approve",
+  });
+}
 ```
 
 These methods return runtime-facing records, not raw persistence or backend checkpoint objects.
@@ -258,6 +266,8 @@ There are three configuration layers:
 - reusable object catalogs in `config/*.yaml`
 - agent assembly in `config/agents/*.yaml`
 
+The repository-owned default config layer is intentionally full-shaped. The shipped YAML keeps explicit default values for the main runtime knobs so teams can start from concrete config instead of reconstructing adapter defaults from code.
+
 ### `config/workspace.yaml`
 
 Use this file for runtime-level policy shared by the whole workspace.
@@ -277,8 +287,6 @@ Primary fields:
 
 If `runRoot` is omitted, the runtime defaults to `<workspace-root>/run-data`.
 
-Queued runs are persisted under `runRoot` and continue after process restart. `running` runs are only replayed on startup when the bound tools are retryable.
-
 ### `config/agent-context.md`
 
 Use this file for shared bootstrap context loaded into agents at construction time.
@@ -299,7 +307,7 @@ spec:
     temperature: 0.2
 ```
 
-These load as `model/<name>`.
+These load as `model/default`.
 
 ### `config/embedding-models.yaml`
 
@@ -324,21 +332,12 @@ spec:
   - kind: Checkpointer
     name: default
     checkpointerKind: MemorySaver
+  - kind: Checkpointer
+    name: sqlite
+    checkpointerKind: SqliteSaver
+    path: checkpoints.sqlite
 ```
 
-Built-in store kinds today:
-
-- `FileStore`
-- `InMemoryStore`
-
-Built-in checkpointer kinds today:
-
-- `MemorySaver`
-- `FileCheckpointer`
-- `SqliteSaver`
-
-If you need other store or checkpointer implementations, inject them through runtime resolvers instead of treating them as built-in harness features.
-
 ### `config/backends.yaml`
 
 Use reusable DeepAgent backend presets so filesystem and long-term memory topology stays in YAML instead of application code:
@@ -352,6 +351,8 @@ spec:
     backendKind: CompositeBackend
     state:
       kind: VfsSandbox
+      rootDir: .
+      virtualMode: true
       timeout: 600
     routes:
       /memories/:
@@ -362,17 +363,9 @@ spec:
 
 Use this file for reusable tool objects.
 
-Supported tool families in the built-in runtime include:
-
-- function tools
-- backend tools
-- MCP tools
-- provider-native tools
-- bundles
+Supported tool families in the built-in runtime include function tools, backend tools, MCP tools, provider-native tools, and bundles.
 
-Provider-native tools are declared in YAML and resolved directly to upstream provider tool factories such as OpenAI and Anthropic tool objects.
-
-Use `retryable` carefully. Mark a tool retryable only when repeated execution is safe or intentionally idempotent.
+Provider-native tools are declared in YAML and resolved directly to upstream provider tool factories.
 
 ### `config/mcp.yaml`
 
@@ -397,12 +390,23 @@ kind: Agent
 metadata:
   name: direct
 spec:
+  runtime:
+    runRoot: ./.agent
   execution:
     backend: langchain-v1
     modelRef: model/default
+    tools: []
+    skills: []
+    memory: []
+    subagents: []
+    mcpServers: []
     config:
       checkpointer:
         ref: checkpointer/default
+      store:
+        ref: store/default
+      interruptOn: {}
+      middleware: []
       systemPrompt: Answer simple requests directly.
 ```
 
@@ -414,11 +418,17 @@ kind: Agent
 metadata:
   name: orchestra
 spec:
+  runtime:
+    runRoot: ./.agent
   execution:
     backend: deepagent
     modelRef: model/default
     memory:
       - path: config/agent-context.md
+    tools: []
+    skills: []
+    subagents: []
+    mcpServers: []
     config:
       store:
         ref: store/default
@@ -426,36 +436,13 @@ spec:
         ref: checkpointer/default
       backend:
         ref: backend/default
+      interruptOn: {}
+      middleware: []
+      generalPurposeAgent: true
+      taskDescription: Complete delegated sidecar work and return concise results.
 ```
 
-Client-configurable agent fields include:
-
-- `metadata.name`
-- `metadata.description`
-- `spec.execution.backend`
-- `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.
+For backend-specific agent options, prefer the upstream concept directly inside `spec.execution.config`. Upstream feature coverage is tracked in [docs/upstream-feature-matrix.md](docs/upstream-feature-matrix.md).
 
 ### `resources/`
 
@@ -466,10 +453,6 @@ Use `resources/` for executable local extensions:
 
 Tool modules are discovered from `resources/tools/*.js`, `resources/tools/*.mjs`, and `resources/tools/*.cjs`.
 
-The preferred tool module format is exporting `tool({...})`.
-
-SKILL packages are discovered from `resources/skills/` and attached to agents through YAML.
-
 ## Design Notes
 
 - public runtime contract stays generic and small
@@ -477,6 +460,7 @@ SKILL packages are discovered from `resources/skills/` and attached to agents th
 - upstream LangChain v1 and DeepAgents concepts should be expressed as directly as possible in YAML
 - recovery, approvals, threads, runs, and events are runtime concepts, not backend-specific escape hatches
 - backend implementation details should stay internal unless product requirements force exposure
+- new LangChain v1 or DeepAgents public config should land in YAML passthrough and compatibility tests before adding new public runtime APIs
 
 In short: `agent-harness` is a public runtime contract generic enough to survive backend changes, while the deep execution semantics stay upstream.
 
@@ -486,6 +470,7 @@ Primary exports:
 
 - `createAgentHarness`
 - `run`
+- `resolveApproval`
 - `subscribe`
 - `listThreads`
 - `getThread`
@@ -495,5 +480,3 @@ Primary exports:
 - `createToolMcpServer`
 - `serveToolsOverStdio`
 - `stop`
-
-`AgentHarnessRuntime` is the concrete runtime class behind the public facade.

package/dist/api.d.ts

@@ -1,4 +1,4 @@
-import type { ApprovalRecord, RunOptions, RuntimeAdapterOptions, ThreadSummary, ThreadRecord, WorkspaceLoadOptions, WorkspaceBundle } from "./contracts/types.js";
+import type { ApprovalRecord, RunOptions, ResumeOptions, RuntimeAdapterOptions, ThreadSummary, ThreadRecord, WorkspaceLoadOptions } from "./contracts/types.js";
 import { AgentHarnessRuntime } from "./runtime/harness.js";
 import type { ToolMcpServerOptions } from "./mcp.js";
 export { AgentHarnessRuntime } from "./runtime/harness.js";
@@ -8,7 +8,6 @@ type CreateAgentHarnessOptions = {
 };
 export declare function createAgentHarness(): Promise<AgentHarnessRuntime>;
 export declare function createAgentHarness(workspaceRoot: string, options?: CreateAgentHarnessOptions): Promise<AgentHarnessRuntime>;
-export declare function createAgentHarness(workspace: WorkspaceBundle, options?: CreateAgentHarnessOptions): Promise<AgentHarnessRuntime>;
 export declare function run(runtime: AgentHarnessRuntime, options: RunOptions): Promise<import("./contracts/types.js").RunResult>;
 export declare function subscribe(runtime: AgentHarnessRuntime, listener: Parameters<AgentHarnessRuntime["subscribe"]>[0]): () => void;
 export declare function listThreads(runtime: AgentHarnessRuntime, filter?: Parameters<AgentHarnessRuntime["listThreads"]>[0]): Promise<ThreadSummary[]>;
@@ -16,6 +15,7 @@ export declare function getThread(runtime: AgentHarnessRuntime, threadId: string
 export declare function deleteThread(runtime: AgentHarnessRuntime, threadId: string): Promise<boolean>;
 export declare function listApprovals(runtime: AgentHarnessRuntime, filter?: Parameters<AgentHarnessRuntime["listApprovals"]>[0]): Promise<ApprovalRecord[]>;
 export declare function getApproval(runtime: AgentHarnessRuntime, approvalId: string): Promise<ApprovalRecord | null>;
+export declare function resolveApproval(runtime: AgentHarnessRuntime, options: ResumeOptions): Promise<import("./contracts/types.js").RunResult>;
 export declare function stop(runtime: AgentHarnessRuntime): Promise<void>;
 export declare function createToolMcpServer(runtime: AgentHarnessRuntime, options: ToolMcpServerOptions): Promise<import("@modelcontextprotocol/sdk/server/mcp.js").McpServer>;
 export declare function serveToolsOverStdio(runtime: AgentHarnessRuntime, options: ToolMcpServerOptions): Promise<import("@modelcontextprotocol/sdk/server/mcp.js").McpServer>;

package/dist/api.js

@@ -1,10 +1,8 @@
 import { AgentHarnessRuntime } from "./runtime/harness.js";
 import { loadWorkspace } from "./workspace/compile.js";
 export { AgentHarnessRuntime } from "./runtime/harness.js";
-export async function createAgentHarness(input = process.cwd(), options = {}) {
-    const workspace = typeof input === "string"
-        ? await loadWorkspace(input, options.load ?? {})
-        : input;
+export async function createAgentHarness(workspaceRoot = process.cwd(), options = {}) {
+    const workspace = await loadWorkspace(workspaceRoot, options.load ?? {});
     const harness = new AgentHarnessRuntime(workspace, options.adapter ?? {});
     await harness.initialize();
     return harness;
@@ -30,6 +28,9 @@ export async function listApprovals(runtime, filter) {
 export async function getApproval(runtime, approvalId) {
     return runtime.getApproval(approvalId);
 }
+export async function resolveApproval(runtime, options) {
+    return runtime.resume(options);
+}
 export async function stop(runtime) {
     return runtime.stop();
 }

package/dist/config/agents/direct.yaml

@@ -9,7 +9,10 @@ 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:
-  runtime: {}
+  runtime:
+    # agent-harness feature: host-level run data placement override.
+    # This matches the workspace default and keeps the default config shape explicit.
+    runRoot: ./.agent
   # =====================
   # Runtime Agent Features
   # =====================
@@ -20,6 +23,16 @@ spec:
     # 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
+    # Upstream execution feature: direct host starts with no attached explicit tools by default.
+    tools: []
+    # Upstream execution feature: direct host starts with no attached local skill packages by default.
+    skills: []
+    # Upstream execution feature: direct host does not bootstrap project memory by default.
+    memory: []
+    # Upstream execution feature: direct host does not predeclare specialist subagents by default.
+    subagents: []
+    # Upstream execution feature: direct host does not attach MCP servers by default.
+    mcpServers: []
     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.
@@ -27,6 +40,14 @@ spec:
       # `path` is only used by `FileCheckpointer` and `SqliteSaver`; omit it for `MemorySaver`.
       checkpointer:
         ref: checkpointer/default
+      # Upstream execution feature: LangGraph store available to middleware and runtime context hooks.
+      # The default direct host keeps this enabled so middleware can use the same durable store surface as other hosts.
+      store:
+        ref: store/default
+      # Upstream execution feature: no declarative HITL tool routing by default.
+      interruptOn: {}
+      # Upstream execution feature: no extra declarative middleware beyond the runtime's automatic injections.
+      middleware: []
       # 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

package/dist/config/agents/orchestra.yaml

@@ -9,7 +9,10 @@ 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:
-  runtime: {}
+  runtime:
+    # agent-harness feature: host-level run data placement override.
+    # This matches the workspace default and keeps the default config shape explicit.
+    runRoot: ./.agent
   # =====================
   # Runtime Agent Features
   # =====================
@@ -29,6 +32,14 @@ spec:
       # 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: top-level host starts with no extra direct tool refs beyond discovered workspace tools.
+    tools: []
+    # Upstream execution feature: top-level host starts with no explicit skill package refs in the default workspace.
+    skills: []
+    # Upstream execution feature: specialist topology is empty in the repository default and can be filled in YAML.
+    subagents: []
+    # Upstream execution feature: host-level MCP servers are opt-in and empty by default.
+    mcpServers: []
     config:
       # Runtime execution feature: checkpointer config passed into the selected backend adapter.
       # This persists resumable graph state for this agent.
@@ -52,6 +63,14 @@ spec:
       # The harness injects the resolved store/checkpointer instances, but the backend topology itself stays upstream-shaped.
       backend:
         ref: backend/default
+      # Upstream execution feature: no extra declarative HITL rules by default.
+      interruptOn: {}
+      # Upstream execution feature: no extra declarative middleware beyond upstream deepagents defaults by default.
+      middleware: []
+      # Upstream execution feature: keep the built-in general-purpose subagent enabled.
+      generalPurposeAgent: true
+      # Upstream execution feature: bias the general-purpose subagent toward bounded sidecar work and context isolation.
+      taskDescription: Complete delegated sidecar work and return concise results without bloating the parent context.
       # 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.

package/dist/config/backends.yaml

@@ -10,6 +10,8 @@ spec:
     backendKind: CompositeBackend
     state:
       kind: VfsSandbox
+      rootDir: .
+      virtualMode: true
       timeout: 600
     routes:
       /memories/:

package/dist/config/stores.yaml

@@ -15,3 +15,10 @@ spec:
     name: default
     description: Default in-memory checkpointer preset for lightweight local development.
     checkpointerKind: MemorySaver
+
+  # agent-harness feature: reusable sqlite checkpointer preset for longer-lived local runs.
+  - kind: Checkpointer
+    name: sqlite
+    description: Default sqlite-backed checkpointer preset for durable local graph state and maintenance sweeps.
+    checkpointerKind: SqliteSaver
+    path: checkpoints.sqlite

package/dist/contracts/types.d.ts

@@ -196,7 +196,6 @@ export type CompiledAgentBinding = {
         config: Record<string, unknown>;
     };
     langchainAgentParams?: LangChainAgentParams;
-    directAgentParams?: LangChainAgentParams;
     deepAgentParams?: DeepAgentParams;
     harnessRuntime: {
         runRoot: string;

package/dist/index.d.ts

@@ -1,3 +1,3 @@
-export { AgentHarnessRuntime, createAgentHarness, createToolMcpServer, deleteThread, getApproval, getThread, listApprovals, listThreads, run, serveToolsOverStdio, subscribe, stop, } from "./api.js";
+export { AgentHarnessRuntime, createAgentHarness, createToolMcpServer, deleteThread, getApproval, getThread, listApprovals, listThreads, resolveApproval, run, serveToolsOverStdio, subscribe, stop, } from "./api.js";
 export type { ToolMcpServerOptions } from "./mcp.js";
 export { tool } from "./tools.js";

package/dist/index.js

@@ -1,2 +1,2 @@
-export { AgentHarnessRuntime, createAgentHarness, createToolMcpServer, deleteThread, getApproval, getThread, listApprovals, listThreads, run, serveToolsOverStdio, subscribe, stop, } from "./api.js";
+export { AgentHarnessRuntime, createAgentHarness, createToolMcpServer, deleteThread, getApproval, getThread, listApprovals, listThreads, resolveApproval, run, serveToolsOverStdio, subscribe, stop, } from "./api.js";
 export { tool } from "./tools.js";

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.51";
+export declare const AGENT_HARNESS_VERSION = "0.0.53";

package/dist/package-version.js

@@ -1 +1 @@
-export const AGENT_HARNESS_VERSION = "0.0.51";
+export const AGENT_HARNESS_VERSION = "0.0.53";

package/dist/runtime/declared-middleware.d.ts

@@ -1,4 +1,12 @@
 import type { CompiledAgentBinding, CompiledModel } from "../contracts/types.js";
+type MiddlewareConfig = Record<string, unknown>;
+type MiddlewareFactoryContext = {
+    config: MiddlewareConfig;
+    resolveModel: (model: CompiledModel) => Promise<unknown>;
+};
+type MiddlewareFactory = (context: MiddlewareFactoryContext) => Promise<unknown | unknown[] | null | undefined>;
+export declare const DECLARATIVE_MIDDLEWARE_REGISTRY: Record<string, MiddlewareFactory>;
+export declare const SUPPORTED_DECLARATIVE_MIDDLEWARE_KINDS: readonly string[];
 export declare function resolveDeclaredMiddleware(middlewareConfigs: unknown[] | undefined, options: {
     resolveModel: (model: CompiledModel) => Promise<unknown>;
     resolveCustom?: (input: {
@@ -9,3 +17,4 @@ export declare function resolveDeclaredMiddleware(middlewareConfigs: unknown[] |
     }) => unknown | unknown[] | null | undefined | Promise<unknown | unknown[] | null | undefined>;
     binding?: CompiledAgentBinding;
 }): Promise<unknown[]>;
+export {};

package/dist/runtime/declared-middleware.js

@@ -25,6 +25,52 @@ async function resolveReferencedModelList(values, options) {
     }
     return Promise.all(values.map((value) => resolveReferencedModel(value, options)));
 }
+async function createSummarizationMiddleware({ config, resolveModel }) {
+    const runtimeConfig = { ...config };
+    runtimeConfig.model = await resolveReferencedModel(runtimeConfig.model, { resolveModel });
+    if (runtimeConfig.model === undefined) {
+        throw new Error("summarization middleware requires model or modelRef");
+    }
+    return summarizationMiddleware(runtimeConfig);
+}
+async function createLlmToolSelectorMiddleware({ config, resolveModel }) {
+    const runtimeConfig = { ...config };
+    runtimeConfig.model = await resolveReferencedModel(runtimeConfig.model, { resolveModel });
+    return llmToolSelectorMiddleware(runtimeConfig);
+}
+async function createModelFallbackDeclarativeMiddleware({ config, resolveModel }) {
+    const fallbackModels = (await resolveReferencedModelList(config.fallbackModels, { resolveModel })) ??
+        (await resolveReferencedModelList(config.models, { resolveModel }));
+    if (!fallbackModels || fallbackModels.length === 0) {
+        throw new Error("modelFallback middleware requires fallbackModels or models");
+    }
+    return modelFallbackMiddleware(...fallbackModels);
+}
+async function createPiiDeclarativeMiddleware({ config }) {
+    const piiType = typeof config.piiType === "string" ? config.piiType : undefined;
+    if (!piiType) {
+        throw new Error("pii middleware requires piiType");
+    }
+    const { piiType: _piiType, ...piiOptions } = config;
+    return piiMiddleware(piiType, piiOptions);
+}
+export const DECLARATIVE_MIDDLEWARE_REGISTRY = {
+    summarization: createSummarizationMiddleware,
+    llmToolSelector: createLlmToolSelectorMiddleware,
+    modelRetry: async ({ config }) => modelRetryMiddleware(config),
+    modelFallback: createModelFallbackDeclarativeMiddleware,
+    toolRetry: async ({ config }) => toolRetryMiddleware(config),
+    toolCallLimit: async ({ config }) => toolCallLimitMiddleware(config),
+    modelCallLimit: async ({ config }) => modelCallLimitMiddleware(config),
+    todoList: async ({ config }) => todoListMiddleware(config),
+    contextEditing: async ({ config }) => contextEditingMiddleware(config),
+    toolEmulator: async ({ config }) => toolEmulatorMiddleware(config),
+    humanInTheLoop: async ({ config }) => humanInTheLoopMiddleware(config),
+    openAIModeration: async ({ config }) => openAIModerationMiddleware(config),
+    pii: createPiiDeclarativeMiddleware,
+    anthropicPromptCaching: async ({ config }) => anthropicPromptCachingMiddleware(config),
+};
+export const SUPPORTED_DECLARATIVE_MIDDLEWARE_KINDS = Object.freeze(Object.keys(DECLARATIVE_MIDDLEWARE_REGISTRY).sort());
 export async function resolveDeclaredMiddleware(middlewareConfigs, options) {
     const resolved = [];
     for (const rawConfig of middlewareConfigs ?? []) {
@@ -34,87 +80,38 @@ export async function resolveDeclaredMiddleware(middlewareConfigs, options) {
         }
         const kind = requireKind(config);
         const runtimeConfig = omitKind(config);
-        switch (kind) {
-            case "summarization": {
-                runtimeConfig.model = await resolveReferencedModel(runtimeConfig.model, options);
-                if (runtimeConfig.model === undefined) {
-                    throw new Error("summarization middleware requires model or modelRef");
-                }
-                resolved.push(summarizationMiddleware(runtimeConfig));
-                break;
+        const registeredFactory = DECLARATIVE_MIDDLEWARE_REGISTRY[kind];
+        if (registeredFactory) {
+            const resolvedBuiltin = await registeredFactory({
+                config: runtimeConfig,
+                resolveModel: options.resolveModel,
+            });
+            if (Array.isArray(resolvedBuiltin)) {
+                resolved.push(...resolvedBuiltin);
+                continue;
             }
-            case "llmToolSelector":
-                runtimeConfig.model = await resolveReferencedModel(runtimeConfig.model, options);
-                resolved.push(llmToolSelectorMiddleware(runtimeConfig));
-                break;
-            case "modelRetry":
-                resolved.push(modelRetryMiddleware(runtimeConfig));
-                break;
-            case "modelFallback": {
-                const fallbackModels = (await resolveReferencedModelList(runtimeConfig.fallbackModels, options)) ??
-                    (await resolveReferencedModelList(runtimeConfig.models, options));
-                if (!fallbackModels || fallbackModels.length === 0) {
-                    throw new Error("modelFallback middleware requires fallbackModels or models");
-                }
-                resolved.push(modelFallbackMiddleware(...fallbackModels));
-                break;
-            }
-            case "toolRetry":
-                resolved.push(toolRetryMiddleware(runtimeConfig));
-                break;
-            case "toolCallLimit":
-                resolved.push(toolCallLimitMiddleware(runtimeConfig));
-                break;
-            case "modelCallLimit":
-                resolved.push(modelCallLimitMiddleware(runtimeConfig));
-                break;
-            case "todoList":
-                resolved.push(todoListMiddleware(runtimeConfig));
-                break;
-            case "contextEditing":
-                resolved.push(contextEditingMiddleware(runtimeConfig));
-                break;
-            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;
-            default: {
-                const customResolved = options.resolveCustom
-                    ? await options.resolveCustom({
-                        kind,
-                        config: runtimeConfig,
-                        binding: options.binding,
-                        resolveModel: options.resolveModel,
-                    })
-                    : undefined;
-                if (Array.isArray(customResolved)) {
-                    resolved.push(...customResolved);
-                    break;
-                }
-                if (customResolved) {
-                    resolved.push(customResolved);
-                    break;
-                }
-                throw new Error(`Unsupported declarative middleware kind ${kind}`);
+            if (resolvedBuiltin) {
+                resolved.push(resolvedBuiltin);
+                continue;
             }
         }
+        const customResolved = options.resolveCustom
+            ? await options.resolveCustom({
+                kind,
+                config: runtimeConfig,
+                binding: options.binding,
+                resolveModel: options.resolveModel,
+            })
+            : undefined;
+        if (Array.isArray(customResolved)) {
+            resolved.push(...customResolved);
+            continue;
+        }
+        if (customResolved) {
+            resolved.push(customResolved);
+            continue;
+        }
+        throw new Error(`Unsupported declarative middleware kind ${kind}`);
     }
     return resolved;
 }

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

@@ -294,7 +294,6 @@ export function compileBinding(workspaceRoot, agent, agents, referencedSubagentI
                 },
             },
             langchainAgentParams,
-            directAgentParams: langchainAgentParams,
         };
     }
     const deepAgentParams = {

package/dist/workspace/object-loader.js

@@ -242,11 +242,12 @@ function readPassthroughConfig(item, consumedKeys) {
 }
 function resolveExecutionBackend(item, current) {
     const execution = readExecutionConfig(item.execution) ?? readExecutionConfig(current?.execution);
+    if (typeof execution?.mode === "string" && execution.mode.trim().length > 0) {
+        throw new Error("Agent execution.mode is no longer supported; use execution.backend");
+    }
     const backend = typeof execution?.backend === "string"
         ? execution.backend.trim().toLowerCase()
-        : typeof execution?.mode === "string"
-            ? execution.mode.trim().toLowerCase()
-            : undefined;
+        : undefined;
     if (backend === "langchain-v1") {
         return "langchain-v1";
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botbotgo/agent-harness",
-  "version": "0.0.52",
+  "version": "0.0.54",
   "description": "Workspace runtime for multi-agent applications",
   "type": "module",
   "packageManager": "npm@10.9.2",