@botbotgo/agent-harness 0.0.51 → 0.0.53

package/README.md

@@ -6,7 +6,7 @@
 
 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 simple:
+The boundary is strict:
 
 - LangChain v1 and DeepAgents own agent execution semantics
 - `agent-harness` owns application-level orchestration and lifecycle management
@@ -15,12 +15,13 @@ 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
 
 What the runtime provides:
 
 - `createAgentHarness(...)`, `run(...)`, `subscribe(...)`, inspection methods, and `stop(...)`
-- YAML-defined workspace assembly for routing, models, tools, stores, MCP, recovery, and maintenance
+- 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
 - persisted threads, runs, approvals, events, queue state, and recovery metadata
@@ -44,6 +45,7 @@ your-workspace/
     embedding-models.yaml
     vector-stores.yaml
     stores.yaml
+    backends.yaml
     tools.yaml
     mcp.yaml
     agents/
@@ -242,6 +244,7 @@ Core workspace files:
 - `config/embedding-models.yaml`
 - `config/vector-stores.yaml`
 - `config/stores.yaml`
+- `config/backends.yaml`
 - `config/tools.yaml`
 - `config/mcp.yaml`
 - `config/agents/direct.yaml`
@@ -255,6 +258,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.
@@ -321,6 +326,44 @@ 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:
+
+```yaml
+apiVersion: agent-harness/v1alpha1
+kind: Backends
+spec:
+  - kind: Backend
+    name: default
+    backendKind: CompositeBackend
+    state:
+      kind: VfsSandbox
+      rootDir: .
+      virtualMode: true
+      timeout: 600
+    routes:
+      /memories/:
+        kind: StoreBackend
 ```
 
 ### `config/tools.yaml`
@@ -362,12 +405,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.
 ```
 
@@ -379,24 +433,28 @@ 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
       checkpointer:
         ref: checkpointer/default
       backend:
-        kind: CompositeBackend
-        state:
-          kind: VfsSandbox
-          timeout: 600
-        routes:
-          /memories/:
-            kind: StoreBackend
+        ref: backend/default
+      interruptOn: {}
+      middleware: []
+      generalPurposeAgent: true
+      taskDescription: Complete delegated sidecar work and return concise results.
 ```
 
 Client-configurable agent fields include:
@@ -428,6 +486,8 @@ Client-configurable agent fields include:
 
 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.
 
+Upstream feature coverage is tracked in [docs/upstream-feature-matrix.md](docs/upstream-feature-matrix.md).
+
 ### `resources/`
 
 Use `resources/` for executable local extensions:
@@ -448,6 +508,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.
 
@@ -466,5 +527,3 @@ Primary exports:
 - `createToolMcpServer`
 - `serveToolsOverStdio`
 - `stop`
-
-`AgentHarnessRuntime` is the concrete runtime class behind the public facade.

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.
@@ -39,27 +50,27 @@ spec:
         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`.
+      # Built-in kinds in this harness today: `FileStore`, `InMemoryStore`.
+      # Other store kinds should flow through a custom runtime resolver instead of being claimed as built in.
       store:
         ref: store/default
       # Upstream execution feature: backend config passed into the selected backend adapter.
-      # This directly defines the backend topology for this agent:
+      # Prefer a reusable backend preset via `ref` so backend topology stays declarative and reusable in YAML.
+      # The default preset keeps DeepAgent execution semantics upstream-owned:
       # - 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`.
+      # The harness injects the resolved store/checkpointer instances, but the backend topology itself stays upstream-shaped.
       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
+        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

@@ -0,0 +1,18 @@
+# agent-harness feature: schema version for reusable backend presets.
+apiVersion: agent-harness/v1alpha1
+# agent-harness feature: object type for named DeepAgent backend presets.
+kind: Backends
+spec:
+  # upstream deepagents feature: default hybrid backend for workspace execution plus durable /memories storage.
+  - kind: Backend
+    name: default
+    description: Default DeepAgent backend preset with a virtual workspace sandbox and durable /memories storage.
+    backendKind: CompositeBackend
+    state:
+      kind: VfsSandbox
+      rootDir: .
+      virtualMode: true
+      timeout: 600
+    routes:
+      /memories/:
+        kind: StoreBackend

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/package-version.d.ts

@@ -1 +1 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.50";
+export declare const AGENT_HARNESS_VERSION = "0.0.52";

package/dist/package-version.js

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

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

@@ -127,14 +127,22 @@ function resolveInterruptOn(agent) {
     return (agent.deepAgentConfig?.interruptOn ??
         agent.langchainAgentConfig?.interruptOn);
 }
-function resolveBackendConfig(agent) {
+function resolveBackendConfig(agent, refs) {
     if (agent.executionMode !== "deepagent") {
         return undefined;
     }
     const backendConfig = typeof agent.deepAgentConfig?.backend === "object" && agent.deepAgentConfig.backend
         ? agent.deepAgentConfig.backend
         : undefined;
-    return backendConfig ? { config: backendConfig } : undefined;
+    if (!backendConfig) {
+        return undefined;
+    }
+    if (isRefConfig(backendConfig)) {
+        return {
+            config: materializeWorkspaceObjectConfig(refs, backendConfig.ref, ["backend"], `Agent ${agent.id} backend`),
+        };
+    }
+    return { config: backendConfig };
 }
 function isRefConfig(value) {
     if (typeof value?.ref !== "string" || value.ref.trim().length === 0) {
@@ -161,6 +169,11 @@ function materializeWorkspaceObjectConfig(refs, ref, allowedKinds, ownerLabel) {
         const { checkpointerKind: _checkpointerKind, ...rest } = config;
         return checkpointerKind ? { kind: checkpointerKind, ...rest } : config;
     }
+    if (object.kind === "backend") {
+        const backendKind = typeof config.backendKind === "string" ? config.backendKind : undefined;
+        const { backendKind: _backendKind, ...rest } = config;
+        return backendKind ? { kind: backendKind, ...rest } : config;
+    }
     return config;
 }
 function resolveStoreConfig(agent, refs) {
@@ -208,7 +221,7 @@ export function compileBinding(workspaceRoot, agent, agents, referencedSubagentI
     const compiledAgentSkills = compileAgentSkills(workspaceRoot, agent);
     const compiledAgentMemory = compileAgentMemories(workspaceRoot, agent.memorySources);
     const compiledAgentModel = requireModel(models, agent.modelRef || (internalSubagent ? "model/default" : ""), agent.id);
-    const backend = resolveBackendConfig(agent);
+    const backend = resolveBackendConfig(agent, refs);
     const store = resolveStoreConfig(agent, refs);
     const checkpointer = resolveCheckpointerConfig(agent, refs);
     const runRoot = typeof agent.runRoot === "string" && agent.runRoot.trim().length > 0
@@ -281,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";
     }
@@ -377,11 +378,13 @@ async function objectItemsFromDocument(document, sourcePath) {
         ? normalizeCatalogSpec(document, { defaultKind: "Model" })
         : catalogKind === "Stores"
             ? normalizeCatalogSpec(document)
-            : catalogKind === "Tools"
-                ? normalizeCatalogSpec(document, { defaultKind: "Tool" })
-                : catalogKind === "McpServers"
-                    ? normalizeCatalogSpec(document)
-                    : [];
+            : catalogKind === "Backends"
+                ? normalizeCatalogSpec(document, { defaultKind: "Backend" })
+                : catalogKind === "Tools"
+                    ? normalizeCatalogSpec(document, { defaultKind: "Tool" })
+                    : catalogKind === "McpServers"
+                        ? normalizeCatalogSpec(document)
+                        : [];
     if (catalogItems.length > 0) {
         return catalogItems;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botbotgo/agent-harness",
-  "version": "0.0.51",
+  "version": "0.0.53",
   "description": "Workspace runtime for multi-agent applications",
   "type": "module",
   "packageManager": "npm@10.9.2",
@@ -50,7 +50,7 @@
   "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-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": "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/stock-research-app-config.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",
     "release:prepare": "npm version patch --no-git-tag-version && node ./scripts/sync-example-version.mjs",
     "release:pack": "npm pack --dry-run",