@botbotgo/agent-harness 0.0.42 → 0.0.43

package/README.md

@@ -15,7 +15,7 @@ What it provides:
 
 - a small runtime API centered on `createAgentHarness(...)`, `run(...)`, `subscribe(...)`, inspection methods, and `stop(...)`
 - YAML-defined runtime assembly for hosts, models, routing, recovery, concurrency, MCP, and maintenance policy
-- DeepAgents-first execution with LangChain v1 compatibility
+- backend-adapted execution with current DeepAgents-first defaults and LangChain v1 compatibility
 - local `resources/tools/` and `resources/skills/` loading
 - persisted runs, threads, approvals, events, and resumable checkpoints
 
@@ -66,7 +66,7 @@ try {
 ## Feature List
 
 - Workspace runtime for multi-agent applications
-- DeepAgents-first execution with LangChain v1 compatibility
+- Generic runtime contract with backend-adapted execution
 - YAML-defined host routing
 - Auto-discovered local tools and SKILL packages
 - MCP bridge support for agent-declared MCP servers
@@ -107,13 +107,15 @@ const result = await run(runtime, {
 });
 ```
 
-Each run creates or continues a persisted thread and returns `threadId`, `runId`, `state`, and `output`.
+Each run creates or continues a persisted thread and returns `threadId`, `runId`, `state`, and the final user-facing output text.
 
-When the upstream LangChain v1 or DeepAgents graph expects extra invocation data, the runtime passes it through directly instead of inventing a parallel harness abstraction:
+The preferred runtime-facing way to pass execution metadata is `invocation`:
 
-- `context` is forwarded as runtime context
-- `state` is merged into the invocation input
-- `files` is merged into the invocation input for state-backed DeepAgents files, memories, and skills
+- `invocation.context` for request-scoped context
+- `invocation.inputs` for additional structured runtime inputs
+- `invocation.attachments` for attachment-like payloads that the active backend can interpret
+
+For compatibility, `context`, `state`, and `files` are still accepted as existing aliases and are normalized into the same runtime invocation envelope.
 
 ### Let The Runtime Route
 
@@ -161,7 +163,7 @@ const approvals = await listApprovals(runtime, { status: "pending" });
 const approval = approvals[0] ? await getApproval(runtime, approvals[0].approvalId) : null;
 ```
 
-These methods return runtime-facing records, not raw persistence or backend objects.
+These methods return runtime-facing records, not raw persistence or backend checkpoint objects.
 
 ### Bridge MCP Servers Into Agents
 
@@ -233,9 +235,26 @@ Put stable project context here. Do not use it as mutable long-term memory.
 
 ### `config/agents/*.yaml`
 
-Use agent YAML for upstream-facing agent assembly. Common fields include:
+Prefer the generic agent form and declare the current execution backend explicitly:
+
+```yaml
+apiVersion: agent-harness/v1alpha1
+kind: Agent
+metadata:
+  name: orchestra
+spec:
+  modelRef: model/default
+  execution:
+    backend: deepagent
+  systemPrompt: Coordinate the request.
+```
+
+`kind: DeepAgent` and `kind: LangChainAgent` remain supported as compatibility forms, but `kind: Agent` is the recommended product-facing entry point.
+
+Common fields include:
 
 - `modelRef`
+- `execution.backend`
 - `systemPrompt`
 - `tools`
 - `skills`
@@ -262,7 +281,7 @@ Keep runtime extension source under `resources/`. Keep tests outside the publish
 
 ## Design Notes
 
-- `agent-harness` should express LangChain v1 and DeepAgents concepts as directly as possible
+- `agent-harness` should keep the public runtime contract generic while mapping cleanly onto current backend capabilities
 - agent-level execution behavior stays upstream
 - application-level orchestration and lifecycle management stays in the harness
 - checkpoint resume is treated as a system-managed runtime behavior, not a primary public abstraction

package/dist/config/agents/direct.yaml

@@ -1,19 +1,20 @@
 # agent-harness feature: schema version for this declarative config object.
 apiVersion: agent-harness/v1alpha1
 # agent-harness feature: object type discriminator.
-# Available options today: `DeepAgent`, `LangChainAgent`.
-# `LangChainAgent` means this file compiles to the lightweight LangChain v1 execution path
-# rather than the upstream `createDeepAgent(...)` runtime.
-kind: LangChainAgent
+# Prefer the generic `Agent` form and select the concrete execution backend under `spec.execution`.
+kind: Agent
 metadata:
   # agent-harness feature: stable object id used for refs and host-agent selection.
   name: direct
   # 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:
-  # ======================
-  # LangChainAgent Features
-  # ======================
+  execution:
+    # Current backend adapter for this host profile.
+    backend: langchain-v1
+  # =====================
+  # Runtime Agent Features
+  # =====================
   # Shared LangChain v1 / DeepAgents 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.

package/dist/config/agents/orchestra.yaml

@@ -1,18 +1,20 @@
 # agent-harness feature: schema version for this declarative config object.
 apiVersion: agent-harness/v1alpha1
 # agent-harness feature: object type discriminator.
-# Available options today: `DeepAgent`, `LangChainAgent`.
-# `DeepAgent` means this file compiles to `createDeepAgent(...)` rather than the LangChain v1 agent path.
-kind: DeepAgent
+# Prefer the generic `Agent` form and select the concrete execution backend under `spec.execution`.
+kind: Agent
 metadata:
   # agent-harness feature: stable object id used for refs and default DeepAgents name inference.
   name: orchestra
   # 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:
-  # ===================
-  # DeepAgents Features
-  # ===================
+  execution:
+    # Current backend adapter for this host profile.
+    backend: deepagent
+  # =====================
+  # Runtime Agent Features
+  # =====================
   # DeepAgents aligned feature: model ref for the underlying LLM used by `createDeepAgent(...)`.
   modelRef: model/default
   # Shared LangChain v1 / DeepAgents feature: checkpointer config passed into the upstream runtime.

package/dist/contracts/types.d.ts

@@ -1,9 +1,14 @@
 export type ExecutionMode = "deepagent" | "langchain-v1";
 export declare const AUTO_AGENT_ID = "auto";
+export type RuntimeCapabilities = {
+    delegation?: boolean;
+    memory?: boolean;
+};
 export type RunState = "running" | "waiting_for_approval" | "resuming" | "completed" | "failed";
 export type ParsedAgentObject = {
     id: string;
     executionMode: ExecutionMode;
+    capabilities?: RuntimeCapabilities;
     description: string;
     modelRef: string;
     runRoot?: string;
@@ -175,6 +180,10 @@ export type CompiledTool = {
 };
 export type CompiledAgentBinding = {
     agent: ParsedAgentObject;
+    adapter?: {
+        kind: string;
+        config: Record<string, unknown>;
+    };
     langchainAgentParams?: LangChainAgentParams;
     directAgentParams?: LangChainAgentParams;
     deepAgentParams?: DeepAgentParams;
@@ -182,6 +191,7 @@ export type CompiledAgentBinding = {
         runRoot: string;
         workspaceRoot?: string;
         hostFacing: boolean;
+        capabilities?: RuntimeCapabilities;
         checkpointer?: Record<string, unknown> | boolean;
         store?: Record<string, unknown>;
     };
@@ -239,11 +249,14 @@ export type RunResult = {
     runId: string;
     state: RunState;
     output: string;
+    finalMessageText?: string;
     interruptContent?: string;
     agentId?: string;
     approvalId?: string;
     pendingActionId?: string;
     delegationId?: string;
+    artifacts?: ArtifactRecord[];
+    metadata?: Record<string, unknown>;
 };
 export type RunListeners = {
     onChunk?: (chunk: string) => void | Promise<void>;
@@ -264,10 +277,17 @@ export type MessageContentPart = {
     image_url: string;
 };
 export type MessageContent = string | MessageContentPart[];
+export type InvocationEnvelope = {
+    context?: Record<string, unknown>;
+    inputs?: Record<string, unknown>;
+    attachments?: Record<string, unknown>;
+    capabilities?: Record<string, unknown>;
+};
 export type RunStartOptions = {
     agentId?: string;
     input: MessageContent;
     threadId?: string;
+    invocation?: InvocationEnvelope;
     context?: Record<string, unknown>;
     state?: Record<string, unknown>;
     files?: Record<string, unknown>;
@@ -285,6 +305,9 @@ export type RunOptions = RunStartOptions | RunDecisionOptions;
 export type HarnessStreamItem = {
     type: "event";
     event: HarnessEvent;
+} | {
+    type: "result";
+    result: RunResult;
 } | {
     type: "content";
     threadId: string;
@@ -322,6 +345,7 @@ export type ThreadRunRecord = {
     runId: string;
     agentId: string;
     executionMode: string;
+    adapterKind?: string;
     createdAt: string;
     updatedAt: string;
     state: RunState;
@@ -362,13 +386,15 @@ export type ApprovalRecord = {
     pendingActionId: string;
     threadId: string;
     runId: string;
-    toolCallId: string;
     toolName: string;
     status: "pending" | "approved" | "edited" | "rejected" | "expired";
     requestedAt: string;
     resolvedAt: string | null;
     allowedDecisions: Array<"approve" | "edit" | "reject">;
     inputPreview: Record<string, unknown>;
+};
+export type InternalApprovalRecord = ApprovalRecord & {
+    toolCallId: string;
     checkpointRef: string;
     eventRefs: string[];
 };

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.41";
+export declare const AGENT_HARNESS_VERSION = "0.0.42";

package/dist/package-version.js

@@ -1 +1 @@
-export const AGENT_HARNESS_VERSION = "0.0.41";
+export const AGENT_HARNESS_VERSION = "0.0.42";

package/dist/persistence/file-store.d.ts

@@ -1,4 +1,4 @@
-import type { ApprovalRecord, ArtifactListing, ArtifactRecord, DelegationRecord, HarnessEvent, RunState, ThreadSummary, ThreadRunRecord, TranscriptMessage } from "../contracts/types.js";
+import type { ArtifactListing, ArtifactRecord, DelegationRecord, HarnessEvent, InternalApprovalRecord, RunState, ThreadSummary, ThreadRunRecord, TranscriptMessage } from "../contracts/types.js";
 type ThreadMeta = {
     threadId: string;
     workspaceId: string;
@@ -13,6 +13,7 @@ type RunMeta = {
     threadId: string;
     agentId: string;
     executionMode: string;
+    adapterKind?: string;
     createdAt: string;
     updatedAt: string;
 };
@@ -56,6 +57,7 @@ export declare class FilePersistence {
         runId: string;
         agentId: string;
         executionMode: string;
+        adapterKind?: string;
         createdAt: string;
     }): Promise<void>;
     setRunState(threadId: string, runId: string, state: RunState, checkpointRef?: string | null): Promise<void>;
@@ -66,14 +68,14 @@ export declare class FilePersistence {
     getThreadMeta(threadId: string): Promise<ThreadMeta | null>;
     listThreadRuns(threadId: string): Promise<ThreadRunRecord[]>;
     listRunEvents(threadId: string, runId: string): Promise<HarnessEvent[]>;
-    listApprovals(): Promise<ApprovalRecord[]>;
-    getApproval(approvalId: string): Promise<ApprovalRecord | null>;
-    getRunApprovals(threadId: string, runId: string): Promise<ApprovalRecord[]>;
+    listApprovals(): Promise<InternalApprovalRecord[]>;
+    getApproval(approvalId: string): Promise<InternalApprovalRecord | null>;
+    getRunApprovals(threadId: string, runId: string): Promise<InternalApprovalRecord[]>;
     getRunMeta(threadId: string, runId: string): Promise<RunMeta>;
     getRunLifecycle(threadId: string, runId: string): Promise<Lifecycle>;
     listDelegations(): Promise<DelegationRecord[]>;
-    createApproval(record: ApprovalRecord): Promise<void>;
-    resolveApproval(threadId: string, runId: string, approvalId: string, status: ApprovalRecord["status"]): Promise<ApprovalRecord>;
+    createApproval(record: InternalApprovalRecord): Promise<void>;
+    resolveApproval(threadId: string, runId: string, approvalId: string, status: InternalApprovalRecord["status"]): Promise<InternalApprovalRecord>;
     createDelegation(record: DelegationRecord): Promise<void>;
     updateDelegation(threadId: string, runId: string, delegationId: string, patch: Partial<DelegationRecord>): Promise<DelegationRecord>;
     createArtifact(threadId: string, runId: string, artifact: ArtifactRecord, content: unknown): Promise<ArtifactRecord>;

package/dist/persistence/file-store.js

@@ -54,6 +54,7 @@ export class FilePersistence {
             threadId: input.threadId,
             agentId: input.agentId,
             executionMode: input.executionMode,
+            adapterKind: input.adapterKind ?? input.executionMode,
             createdAt: input.createdAt,
             updatedAt: input.createdAt,
         };
@@ -218,6 +219,7 @@ export class FilePersistence {
                 runId: meta.runId,
                 agentId: meta.agentId,
                 executionMode: meta.executionMode,
+                adapterKind: meta.adapterKind ?? meta.executionMode,
                 createdAt: meta.createdAt,
                 updatedAt: meta.updatedAt,
                 state: lifecycle.state,

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

@@ -27,6 +27,7 @@ export declare class AgentRuntimeAdapter {
     private buildToolNameMapping;
     private buildAgentMessages;
     private buildInvocationRequest;
+    private buildStateSnapshot;
     private buildRawModelMessages;
     private resolveTools;
     private normalizeInterruptPolicy;

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

@@ -12,8 +12,9 @@ import { computeIncrementalOutput, extractAgentStep, extractInterruptPayload, ex
 import { wrapToolForExecution } from "./tool-hitl.js";
 import { resolveDeclaredMiddleware } from "./declared-middleware.js";
 import { extractMessageText, normalizeMessageContent } from "../utils/message-content.js";
+import { getBindingDeepAgentParams, getBindingInterruptCompatibilityRules, getBindingLangChainParams, getBindingMiddlewareConfigs, getBindingModelInit, getBindingPrimaryModel, getBindingPrimaryTools, getBindingSystemPrompt, isDeepAgentBinding, isLangChainBinding, } from "./support/compiled-binding.js";
 function countConfiguredTools(binding) {
-    return binding.langchainAgentParams?.tools.length ?? binding.deepAgentParams?.tools.length ?? 0;
+    return getBindingPrimaryTools(binding).length;
 }
 const AGENT_INTERRUPT_SENTINEL_PREFIX = "__agent_harness_interrupt__:";
 const MODEL_SAFE_TOOL_NAME_PATTERN = /^[a-zA-Z0-9_-]+$/;
@@ -142,6 +143,11 @@ function hasCallableToolHandler(value) {
     const typed = value;
     return typeof typed.invoke === "function" || typeof typed.call === "function" || typeof typed.func === "function";
 }
+function asRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? { ...value }
+        : undefined;
+}
 function normalizeResolvedToolSchema(resolvedTool) {
     const schema = resolvedTool.schema;
     if (schema && typeof schema.parse === "function" && "_def" in schema) {
@@ -172,10 +178,10 @@ export class AgentRuntimeAdapter {
         this.options = options;
     }
     resolveBindingTimeout(binding) {
-        return resolveTimeoutMs(binding.langchainAgentParams?.model.init.timeout ?? binding.deepAgentParams?.model.init.timeout);
+        return resolveTimeoutMs(getBindingModelInit(binding)?.timeout);
     }
     resolveStreamIdleTimeout(binding) {
-        const configuredIdleTimeout = resolveTimeoutMs(binding.langchainAgentParams?.model.init.streamIdleTimeout ?? binding.deepAgentParams?.model.init.streamIdleTimeout);
+        const configuredIdleTimeout = resolveTimeoutMs(getBindingModelInit(binding)?.streamIdleTimeout);
         if (configuredIdleTimeout) {
             return configuredIdleTimeout;
         }
@@ -284,35 +290,38 @@ export class AgentRuntimeAdapter {
         };
     }
     applyStrictToolJsonInstruction(binding) {
-        if (binding.langchainAgentParams) {
+        if (isLangChainBinding(binding)) {
+            const params = getBindingLangChainParams(binding);
             return {
                 ...binding,
                 langchainAgentParams: {
-                    ...binding.langchainAgentParams,
-                    systemPrompt: [binding.langchainAgentParams.systemPrompt, STRICT_TOOL_JSON_INSTRUCTION].filter(Boolean).join("\n\n"),
+                    ...params,
+                    systemPrompt: [params.systemPrompt, STRICT_TOOL_JSON_INSTRUCTION].filter(Boolean).join("\n\n"),
                 },
             };
         }
-        if (binding.deepAgentParams) {
+        if (isDeepAgentBinding(binding)) {
+            const params = getBindingDeepAgentParams(binding);
             return {
                 ...binding,
                 deepAgentParams: {
-                    ...binding.deepAgentParams,
-                    systemPrompt: [binding.deepAgentParams.systemPrompt, STRICT_TOOL_JSON_INSTRUCTION].filter(Boolean).join("\n\n"),
+                    ...params,
+                    systemPrompt: [params.systemPrompt, STRICT_TOOL_JSON_INSTRUCTION].filter(Boolean).join("\n\n"),
                 },
             };
         }
         return binding;
     }
     async synthesizeDeepAgentAnswer(binding, input, result) {
-        if (!binding.deepAgentParams) {
+        const params = getBindingDeepAgentParams(binding);
+        if (!params) {
             return "";
         }
         const toolContext = extractToolFallbackContext(result);
         if (!toolContext) {
             return "";
         }
-        const model = (await this.resolveModel(binding.deepAgentParams.model));
+        const model = (await this.resolveModel(params.model));
         if (!model?.invoke) {
             return "";
         }
@@ -365,6 +374,14 @@ export class AgentRuntimeAdapter {
             messages: this.buildAgentMessages(history, input),
         };
     }
+    buildStateSnapshot(result) {
+        const snapshot = { ...result };
+        delete snapshot.messages;
+        delete snapshot.__interrupt__;
+        delete snapshot.structuredResponse;
+        delete snapshot.files;
+        return Object.keys(snapshot).length > 0 ? snapshot : undefined;
+    }
     buildRawModelMessages(systemPrompt, history, input) {
         const messages = [];
         if (systemPrompt) {
@@ -424,14 +441,10 @@ export class AgentRuntimeAdapter {
         return compiled.size > 0 ? Object.fromEntries(compiled.entries()) : undefined;
     }
     resolveInterruptOn(binding) {
-        if (binding.deepAgentParams) {
-            return this.compileInterruptOn(binding.deepAgentParams.tools, binding.deepAgentParams.interruptOn);
-        }
-        return this.compileInterruptOn(binding.langchainAgentParams?.tools ?? [], binding.agent.langchainAgentConfig?.interruptOn);
+        return this.compileInterruptOn(getBindingPrimaryTools(binding), getBindingInterruptCompatibilityRules(binding));
     }
     async resolveMiddleware(binding, interruptOn) {
-        const declarativeMiddleware = await resolveDeclaredMiddleware(binding.langchainAgentParams?.middleware ??
-            binding.deepAgentParams?.middleware, {
+        const declarativeMiddleware = await resolveDeclaredMiddleware(getBindingMiddlewareConfigs(binding), {
             resolveModel: (model) => this.resolveModel(model),
             resolveCustom: this.options.declaredMiddlewareResolver,
             binding,
@@ -484,30 +497,31 @@ export class AgentRuntimeAdapter {
         })));
     }
     async create(binding) {
-        if (binding.langchainAgentParams) {
+        if (isLangChainBinding(binding)) {
+            const params = getBindingLangChainParams(binding);
             const interruptOn = this.resolveInterruptOn(binding);
-            const model = (await this.resolveModel(binding.langchainAgentParams.model));
-            const tools = this.resolveTools(binding.langchainAgentParams.tools, binding);
+            const model = (await this.resolveModel(params.model));
+            const tools = this.resolveTools(params.tools, binding);
             if (tools.length > 0 && typeof model.bindTools !== "function") {
-                throw new Error(`Agent ${binding.agent.id} configures ${tools.length} tool(s), but resolved model ${binding.langchainAgentParams.model.id} does not support tool binding.`);
+                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({
                 model: model,
                 tools: tools,
-                systemPrompt: binding.langchainAgentParams.systemPrompt,
-                stateSchema: binding.langchainAgentParams.stateSchema,
-                responseFormat: binding.langchainAgentParams.responseFormat,
-                contextSchema: binding.langchainAgentParams.contextSchema,
+                systemPrompt: params.systemPrompt,
+                stateSchema: params.stateSchema,
+                responseFormat: params.responseFormat,
+                contextSchema: params.contextSchema,
                 middleware: (await this.resolveMiddleware(binding, interruptOn)),
                 checkpointer: this.resolveCheckpointer(binding),
                 store: this.options.storeResolver?.(binding),
-                includeAgentName: binding.langchainAgentParams.includeAgentName,
-                version: binding.langchainAgentParams.version,
-                name: binding.langchainAgentParams.name,
-                description: binding.langchainAgentParams.description,
+                includeAgentName: params.includeAgentName,
+                version: params.version,
+                name: params.name,
+                description: params.description,
             });
         }
-        const params = binding.deepAgentParams;
+        const params = getBindingDeepAgentParams(binding);
         if (!params) {
             throw new Error(`Agent ${binding.agent.id} has no runnable params`);
         }
@@ -532,10 +546,8 @@ export class AgentRuntimeAdapter {
         return createDeepAgent(deepAgentConfig);
     }
     async route(input, primaryBinding, secondaryBinding, options = {}) {
-        const routeModelConfig = primaryBinding.langchainAgentParams?.model ??
-            primaryBinding.deepAgentParams?.model ??
-            secondaryBinding.langchainAgentParams?.model ??
-            secondaryBinding.deepAgentParams?.model;
+        const routeModelConfig = getBindingPrimaryModel(primaryBinding) ??
+            getBindingPrimaryModel(secondaryBinding);
         if (!routeModelConfig) {
             throw new Error("No router model configuration available");
         }
@@ -587,13 +599,21 @@ export class AgentRuntimeAdapter {
             throw new Error(emptyAssistantMessageFailure);
         }
         const output = visibleOutput || synthesizedOutput || toolFallback || JSON.stringify(result, null, 2);
+        const finalMessageText = sanitizeVisibleText(output);
         return {
             threadId,
             runId,
             agentId: binding.agent.id,
             state: Array.isArray(result.__interrupt__) && result.__interrupt__.length > 0 ? "waiting_for_approval" : "completed",
             interruptContent,
-            output: sanitizeVisibleText(output),
+            output: finalMessageText,
+            finalMessageText,
+            metadata: {
+                ...(result.structuredResponse !== undefined ? { structuredResponse: result.structuredResponse } : {}),
+                ...(asRecord(result.files) ? { files: asRecord(result.files) } : {}),
+                ...(this.buildStateSnapshot(result) ? { stateSnapshot: this.buildStateSnapshot(result) } : {}),
+                upstreamResult: result,
+            },
         };
     }
     async *stream(binding, input, threadId, history = [], options = {}) {
@@ -601,9 +621,9 @@ export class AgentRuntimeAdapter {
             const invokeTimeoutMs = this.resolveBindingTimeout(binding);
             const streamIdleTimeoutMs = this.resolveStreamIdleTimeout(binding);
             const streamDeadlineAt = invokeTimeoutMs ? Date.now() + invokeTimeoutMs : undefined;
-            if (binding.langchainAgentParams) {
-                const langchainParams = binding.langchainAgentParams;
-                const resolvedModel = (await this.resolveModel(binding.langchainAgentParams.model));
+            if (isLangChainBinding(binding)) {
+                const langchainParams = getBindingLangChainParams(binding);
+                const resolvedModel = (await this.resolveModel(langchainParams.model));
                 const tools = this.resolveTools(langchainParams.tools, binding);
                 const canUseDirectModelStream = tools.length === 0 || typeof resolvedModel.bindTools !== "function";
                 const model = canUseDirectModelStream
@@ -615,7 +635,7 @@ export class AgentRuntimeAdapter {
                 // agent loop and only adds an extra model round-trip before the runnable path.
                 if (canUseDirectModelStream && typeof model.stream === "function") {
                     let emitted = false;
-                    const stream = await this.withTimeout(() => model.stream(this.buildRawModelMessages(langchainParams.systemPrompt, history, input)), computeRemainingTimeoutMs(streamDeadlineAt, invokeTimeoutMs), "model stream start", "stream");
+                    const stream = await this.withTimeout(() => model.stream(this.buildRawModelMessages(getBindingSystemPrompt(binding), history, input)), computeRemainingTimeoutMs(streamDeadlineAt, invokeTimeoutMs), "model stream start", "stream");
                     for await (const chunk of this.iterateWithTimeout(stream, streamIdleTimeoutMs, "model stream", streamDeadlineAt, invokeTimeoutMs)) {
                         const delta = readStreamDelta(chunk);
                         if (delta) {
@@ -637,7 +657,7 @@ export class AgentRuntimeAdapter {
             const request = this.buildInvocationRequest(history, input, options);
             if (typeof runnable.streamEvents === "function") {
                 const events = await this.withTimeout(() => runnable.streamEvents(request, { configurable: { thread_id: threadId }, version: "v2", ...(options.context ? { context: options.context } : {}) }), computeRemainingTimeoutMs(streamDeadlineAt, invokeTimeoutMs), "agent streamEvents start", "stream");
-                const allowVisibleStreamDeltas = Boolean(binding.langchainAgentParams);
+                const allowVisibleStreamDeltas = isLangChainBinding(binding);
                 let emittedOutput = "";
                 let emittedToolError = false;
                 const seenTerminalOutputs = new Set();
@@ -662,7 +682,7 @@ export class AgentRuntimeAdapter {
                             }
                         }
                     }
-                    if (binding.deepAgentParams) {
+                    if (isDeepAgentBinding(binding)) {
                         const stateStreamOutput = extractStateStreamOutput(event);
                         if (stateStreamOutput) {
                             const nextOutput = computeIncrementalOutput(emittedOutput, sanitizeVisibleText(stateStreamOutput));
@@ -702,7 +722,7 @@ export class AgentRuntimeAdapter {
                     return;
                 }
             }
-            if (binding.langchainAgentParams && typeof runnable.stream === "function") {
+            if (isLangChainBinding(binding) && typeof runnable.stream === "function") {
                 const stream = await this.withTimeout(() => runnable.stream(request, { configurable: { thread_id: threadId } }), computeRemainingTimeoutMs(streamDeadlineAt, invokeTimeoutMs), "agent stream start", "stream");
                 let emitted = false;
                 for await (const chunk of this.iterateWithTimeout(stream, streamIdleTimeoutMs, "agent stream", streamDeadlineAt, invokeTimeoutMs)) {

package/dist/runtime/harness.d.ts

@@ -24,6 +24,8 @@ export declare class AgentHarnessRuntime {
     private readonly concurrencyConfig;
     private activeRunSlots;
     private readonly pendingRunSlots;
+    private toPublicApprovalRecord;
+    private normalizeInvocationEnvelope;
     private listHostBindings;
     private defaultRunRoot;
     private heuristicRoute;

package/dist/runtime/harness.js

@@ -15,6 +15,7 @@ import { FileBackedStore } from "./store.js";
 import { CheckpointMaintenanceLoop, discoverCheckpointMaintenanceTargets, readCheckpointMaintenanceConfig, } from "./checkpoint-maintenance.js";
 import { extractMessageText, normalizeMessageContent } from "../utils/message-content.js";
 import { createToolMcpServerFromTools, serveToolsOverStdioFromHarness } from "../mcp.js";
+import { getBindingAdapterKind, getBindingPrimaryTools, getBindingStoreConfig } from "./support/compiled-binding.js";
 export class AgentHarnessRuntime {
     workspace;
     runtimeAdapterOptions;
@@ -39,6 +40,19 @@ export class AgentHarnessRuntime {
     concurrencyConfig;
     activeRunSlots = 0;
     pendingRunSlots = [];
+    toPublicApprovalRecord(approval) {
+        const { toolCallId: _toolCallId, checkpointRef: _checkpointRef, eventRefs: _eventRefs, ...publicApproval } = approval;
+        return publicApproval;
+    }
+    normalizeInvocationEnvelope(options) {
+        const invocation = options.invocation;
+        return {
+            context: invocation?.context ?? options.context,
+            state: invocation?.inputs ?? options.state,
+            files: invocation?.attachments ?? options.files,
+            invocation,
+        };
+    }
     listHostBindings() {
         return inferRoutingBindings(this.workspace).hostBindings;
     }
@@ -79,7 +93,7 @@ export class AgentHarnessRuntime {
         return requestedAgentId;
     }
     resolveStore(binding) {
-        const storeConfig = binding?.deepAgentParams?.store ?? binding?.harnessRuntime.store;
+        const storeConfig = binding ? getBindingStoreConfig(binding) : undefined;
         const cacheKey = storeConfig ? JSON.stringify(storeConfig) : undefined;
         if (!storeConfig) {
             return this.defaultStore;
@@ -184,7 +198,7 @@ export class AgentHarnessRuntime {
         if (!binding) {
             throw new Error(`Unknown agent ${agentId}`);
         }
-        return binding.langchainAgentParams?.tools ?? binding.deepAgentParams?.tools ?? [];
+        return getBindingPrimaryTools(binding);
     }
     resolveAgentTools(agentId) {
         const binding = this.getBinding(agentId);
@@ -259,10 +273,11 @@ export class AgentHarnessRuntime {
                 return false;
             }
             return true;
-        });
+        }).map((approval) => this.toPublicApprovalRecord(approval));
     }
     async getApproval(approvalId) {
-        return this.persistence.getApproval(approvalId);
+        const approval = await this.persistence.getApproval(approvalId);
+        return approval ? this.toPublicApprovalRecord(approval) : null;
     }
     async createToolMcpServer(options) {
         const tools = this.resolveAgentTools(options.agentId).map(({ compiledTool, resolvedTool }) => ({
@@ -340,7 +355,8 @@ export class AgentHarnessRuntime {
             threadId,
             runId,
             agentId: binding.agent.id,
-            executionMode: binding.agent.executionMode,
+            executionMode: getBindingAdapterKind(binding),
+            adapterKind: getBindingAdapterKind(binding),
             createdAt,
         });
         return { threadId, runId, createdAt };
@@ -500,6 +516,7 @@ export class AgentHarnessRuntime {
     }
     async dispatchRunListeners(stream, listeners) {
         let latestEvent;
+        let latestResult;
         let output = "";
         for await (const item of stream) {
             if (item.type === "event") {
@@ -507,6 +524,10 @@ export class AgentHarnessRuntime {
                 await this.notifyListener(listeners.onEvent, item.event);
                 continue;
             }
+            if (item.type === "result") {
+                latestResult = item.result;
+                continue;
+            }
             if (item.type === "content") {
                 output += item.content;
                 await this.notifyListener(listeners.onChunk, item.content);
@@ -531,6 +552,13 @@ export class AgentHarnessRuntime {
         if (!latestEvent) {
             throw new Error("run did not emit any events");
         }
+        if (latestResult) {
+            return {
+                ...latestResult,
+                output: latestResult.output || output,
+                finalMessageText: latestResult.finalMessageText ?? latestResult.output ?? output,
+            };
+        }
         const thread = await this.getThread(latestEvent.threadId);
         if (!thread) {
             throw new Error(`Unknown thread ${latestEvent.threadId}`);
@@ -561,6 +589,7 @@ export class AgentHarnessRuntime {
         }
         const releaseRunSlot = await this.acquireRunSlot();
         try {
+            const invocation = this.normalizeInvocationEnvelope(options);
             const selectedAgentId = await this.resolveSelectedAgentId(options.input, options.agentId, options.threadId);
             const binding = this.workspace.bindings.get(selectedAgentId);
             if (!binding) {
@@ -575,13 +604,13 @@ export class AgentHarnessRuntime {
                 agentId: binding.agent.id,
                 requestedAgentId: options.agentId ?? AUTO_AGENT_ID,
                 selectedAgentId,
-                executionMode: binding.agent.executionMode,
+                executionMode: getBindingAdapterKind(binding),
             });
             try {
                 const actual = await this.invokeWithHistory(binding, options.input, threadId, runId, undefined, {
-                    context: options.context,
-                    state: options.state,
-                    files: options.files,
+                    context: invocation.context,
+                    state: invocation.state,
+                    files: invocation.files,
                 });
                 const finalized = await this.finalizeContinuedRun(threadId, runId, options.input, actual, {
                     previousState: null,
@@ -615,6 +644,7 @@ export class AgentHarnessRuntime {
     async *streamEvents(options) {
         const releaseRunSlot = await this.acquireRunSlot();
         try {
+            const invocation = this.normalizeInvocationEnvelope(options);
             const selectedAgentId = await this.resolveSelectedAgentId(options.input, options.agentId, options.threadId);
             const binding = this.workspace.bindings.get(selectedAgentId);
             if (!binding) {
@@ -644,9 +674,9 @@ export class AgentHarnessRuntime {
                 let assistantOutput = "";
                 const toolErrors = [];
                 for await (const chunk of this.runtimeAdapter.stream(binding, options.input, threadId, priorHistory, {
-                    context: options.context,
-                    state: options.state,
-                    files: options.files,
+                    context: invocation.context,
+                    state: invocation.state,
+                    files: invocation.files,
                 })) {
                     if (chunk) {
                         const normalizedChunk = typeof chunk === "string"
@@ -669,6 +699,20 @@ export class AgentHarnessRuntime {
                                 type: "event",
                                 event: approvalRequest.event,
                             };
+                            yield {
+                                type: "result",
+                                result: {
+                                    threadId,
+                                    runId,
+                                    agentId: selectedAgentId,
+                                    state: "waiting_for_approval",
+                                    output: assistantOutput,
+                                    finalMessageText: assistantOutput,
+                                    interruptContent: normalizedChunk.content,
+                                    approvalId: approvalRequest.approval.approvalId,
+                                    pendingActionId: approvalRequest.approval.pendingActionId,
+                                },
+                            };
                             return;
                         }
                         if (normalizedChunk.kind === "reasoning") {
@@ -728,6 +772,17 @@ export class AgentHarnessRuntime {
                     }
                 }
                 await this.appendAssistantMessage(threadId, runId, assistantOutput);
+                yield {
+                    type: "result",
+                    result: {
+                        threadId,
+                        runId,
+                        agentId: selectedAgentId,
+                        state: "completed",
+                        output: assistantOutput,
+                        finalMessageText: assistantOutput,
+                    },
+                };
                 yield { type: "event", event: await this.setRunStateAndEmit(threadId, runId, 4, "completed", {
                         previousState: null,
                     }) };
@@ -753,6 +808,17 @@ export class AgentHarnessRuntime {
                         agentId: selectedAgentId,
                         content: renderRuntimeFailure(error),
                     };
+                    yield {
+                        type: "result",
+                        result: {
+                            threadId,
+                            runId,
+                            agentId: selectedAgentId,
+                            state: "failed",
+                            output: renderRuntimeFailure(error),
+                            finalMessageText: renderRuntimeFailure(error),
+                        },
+                    };
                     return;
                 }
                 try {
@@ -761,6 +827,15 @@ export class AgentHarnessRuntime {
                     if (actual.output) {
                         yield await this.emitOutputDeltaAndCreateItem(threadId, runId, selectedAgentId, actual.output);
                     }
+                    yield {
+                        type: "result",
+                        result: {
+                            ...actual,
+                            threadId,
+                            runId,
+                            agentId: selectedAgentId,
+                        },
+                    };
                     yield { type: "event", event: await this.setRunStateAndEmit(threadId, runId, 4, actual.state, {
                             previousState: null,
                         }) };
@@ -779,6 +854,17 @@ export class AgentHarnessRuntime {
                         agentId: selectedAgentId,
                         content: renderRuntimeFailure(invokeError),
                     };
+                    yield {
+                        type: "result",
+                        result: {
+                            threadId,
+                            runId,
+                            agentId: selectedAgentId,
+                            state: "failed",
+                            output: renderRuntimeFailure(invokeError),
+                            finalMessageText: renderRuntimeFailure(invokeError),
+                        },
+                    };
                     return;
                 }
             }

package/dist/runtime/inventory.js

@@ -1,4 +1,5 @@
 import { readSkillMetadata } from "./support/skill-metadata.js";
+import { getBindingPrimaryTools } from "./support/compiled-binding.js";
 function listHostBindings(workspace) {
     return Array.from(workspace.bindings.values()).filter((binding) => binding.harnessRuntime.hostFacing);
 }
@@ -31,7 +32,7 @@ export function listAgentTools(workspace, agentId) {
     if (!binding) {
         return [];
     }
-    return dedupeTools(binding.langchainAgentParams?.tools ?? binding.deepAgentParams?.tools ?? []);
+    return dedupeTools(getBindingPrimaryTools(binding));
 }
 export function listAgentSkills(workspace, agentId) {
     const binding = findAgentBinding(workspace, agentId);

package/dist/runtime/support/compiled-binding.d.ts

@@ -0,0 +1,15 @@
+import type { CompiledAgentBinding, CompiledModel, CompiledTool, DeepAgentParams, LangChainAgentParams } from "../../contracts/types.js";
+export declare function getBindingAdapterKind(binding: CompiledAgentBinding): string;
+export declare function getBindingAdapterConfig(binding: CompiledAgentBinding): Record<string, unknown>;
+export declare function getBindingLangChainParams(binding: CompiledAgentBinding): LangChainAgentParams | undefined;
+export declare function getBindingDeepAgentParams(binding: CompiledAgentBinding): DeepAgentParams | undefined;
+export declare function isLangChainBinding(binding: CompiledAgentBinding): boolean;
+export declare function isDeepAgentBinding(binding: CompiledAgentBinding): boolean;
+export declare function getBindingPrimaryTools(binding: CompiledAgentBinding): CompiledTool[];
+export declare function getBindingPrimaryModel(binding: CompiledAgentBinding): CompiledModel | undefined;
+export declare function getBindingSystemPrompt(binding: CompiledAgentBinding): string | undefined;
+export declare function getBindingMiddlewareConfigs(binding: CompiledAgentBinding): Array<Record<string, unknown>> | undefined;
+export declare function getBindingInterruptCompatibilityRules(binding: CompiledAgentBinding): Record<string, boolean | object> | undefined;
+export declare function getBindingModelInit(binding: CompiledAgentBinding): Record<string, unknown> | undefined;
+export declare function getBindingStoreConfig(binding: CompiledAgentBinding): Record<string, unknown> | undefined;
+export declare function bindingHasSubagents(binding: CompiledAgentBinding): boolean;

package/dist/runtime/support/compiled-binding.js

@@ -0,0 +1,56 @@
+function asRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+export function getBindingAdapterKind(binding) {
+    return binding.adapter?.kind ?? binding.agent.executionMode;
+}
+export function getBindingAdapterConfig(binding) {
+    return binding.adapter?.config ?? {};
+}
+export function getBindingLangChainParams(binding) {
+    const adapterParams = asRecord(getBindingAdapterConfig(binding).params);
+    if (getBindingAdapterKind(binding) === "langchain-v1" && adapterParams) {
+        return adapterParams;
+    }
+    return binding.langchainAgentParams;
+}
+export function getBindingDeepAgentParams(binding) {
+    const adapterParams = asRecord(getBindingAdapterConfig(binding).params);
+    if (getBindingAdapterKind(binding) === "deepagent" && adapterParams) {
+        return adapterParams;
+    }
+    return binding.deepAgentParams;
+}
+export function isLangChainBinding(binding) {
+    return getBindingAdapterKind(binding) === "langchain-v1" || Boolean(binding.langchainAgentParams);
+}
+export function isDeepAgentBinding(binding) {
+    return getBindingAdapterKind(binding) === "deepagent" || Boolean(binding.deepAgentParams);
+}
+export function getBindingPrimaryTools(binding) {
+    return binding.langchainAgentParams?.tools ?? binding.deepAgentParams?.tools ?? [];
+}
+export function getBindingPrimaryModel(binding) {
+    return binding.langchainAgentParams?.model ?? binding.deepAgentParams?.model;
+}
+export function getBindingSystemPrompt(binding) {
+    return binding.langchainAgentParams?.systemPrompt ?? binding.deepAgentParams?.systemPrompt;
+}
+export function getBindingMiddlewareConfigs(binding) {
+    return binding.langchainAgentParams?.middleware ?? binding.deepAgentParams?.middleware;
+}
+export function getBindingInterruptCompatibilityRules(binding) {
+    return binding.deepAgentParams?.interruptOn ??
+        binding.agent.langchainAgentConfig?.interruptOn;
+}
+export function getBindingModelInit(binding) {
+    return getBindingPrimaryModel(binding)?.init;
+}
+export function getBindingStoreConfig(binding) {
+    return binding.deepAgentParams?.store ?? binding.harnessRuntime.store;
+}
+export function bindingHasSubagents(binding) {
+    return (binding.deepAgentParams?.subagents.length ?? 0) > 0;
+}

package/dist/runtime/support/harness-support.d.ts

@@ -1,4 +1,4 @@
-import type { ApprovalRecord, HarnessEvent, WorkspaceBundle } from "../../contracts/types.js";
+import type { HarnessEvent, InternalApprovalRecord, WorkspaceBundle } from "../../contracts/types.js";
 export declare function renderRuntimeFailure(error: unknown): string;
 export declare function renderToolFailure(toolName: string, output: unknown): string;
 export declare function parseInterruptContent(content: string): {
@@ -19,7 +19,7 @@ export declare function heuristicRoute(input: string, primaryBinding?: {
     };
 }): string;
 export declare function createHarnessEvent(threadId: string, runId: string, sequence: number, eventType: string, payload: Record<string, unknown>, source?: HarnessEvent["source"]): HarnessEvent;
-export declare function createPendingApproval(threadId: string, runId: string, checkpointRef: string, input: string, interruptContent?: string): ApprovalRecord;
+export declare function createPendingApproval(threadId: string, runId: string, checkpointRef: string, input: string, interruptContent?: string): InternalApprovalRecord;
 export declare function inferRoutingBindings(workspace: WorkspaceBundle): {
     primaryBinding: import("../../contracts/types.js").CompiledAgentBinding;
     secondaryBinding: import("../../contracts/types.js").CompiledAgentBinding | undefined;

package/dist/runtime/support/harness-support.js

@@ -1,4 +1,5 @@
 import { createPersistentId } from "../../utils/id.js";
+import { isDelegationCapableBinding } from "../../workspace/support/agent-capabilities.js";
 export function renderRuntimeFailure(error) {
     const message = error instanceof Error ? error.message : String(error);
     return `runtime_error=${message}`.trim();
@@ -131,20 +132,21 @@ export function inferRoutingBindings(workspace) {
     const hostBindings = Array.from(workspace.bindings.values()).filter((binding) => binding.harnessRuntime.hostFacing);
     const researchBinding = hostBindings.find((binding) => binding.agent.id === "research-lite" || binding.agent.id === "research");
     const directBinding = hostBindings.find((binding) => binding.agent.id === "direct");
-    const langchainHost = hostBindings.find((binding) => binding.agent.executionMode === "langchain-v1" && binding.agent.id !== researchBinding?.agent.id);
-    const deepagentHosts = hostBindings.filter((binding) => binding.agent.executionMode === "deepagent");
-    const defaultDeepagentHost = deepagentHosts.find((binding) => binding.agent.id === "orchestra") ??
-        deepagentHosts.find((binding) => (binding.deepAgentParams?.subagents.length ?? 0) > 0) ??
-        deepagentHosts[0];
-    const deepagentWithSubagents = deepagentHosts.find((binding) => (binding.deepAgentParams?.subagents.length ?? 0) > 0) ??
-        deepagentHosts[0];
-    const primaryBinding = defaultDeepagentHost ?? directBinding ?? langchainHost ?? hostBindings[0];
-    const secondaryBinding = langchainHost && langchainHost.agent.id !== primaryBinding?.agent.id
-        ? langchainHost
+    const delegationHosts = hostBindings.filter((binding) => isDelegationCapableBinding(binding));
+    const lightweightHosts = hostBindings.filter((binding) => !isDelegationCapableBinding(binding));
+    const defaultOrchestratingHost = hostBindings.find((binding) => binding.agent.id === "orchestra") ??
+        delegationHosts.find((binding) => (binding.deepAgentParams?.subagents.length ?? 0) > 0) ??
+        delegationHosts[0];
+    const delegationPreferredSecondary = delegationHosts.find((binding) => (binding.deepAgentParams?.subagents.length ?? 0) > 0) ??
+        delegationHosts[0];
+    const genericLightweightHost = lightweightHosts.find((binding) => binding.agent.id !== researchBinding?.agent.id);
+    const primaryBinding = defaultOrchestratingHost ?? directBinding ?? genericLightweightHost ?? hostBindings[0];
+    const secondaryBinding = genericLightweightHost && genericLightweightHost.agent.id !== primaryBinding?.agent.id
+        ? genericLightweightHost
         : directBinding && directBinding.agent.id !== primaryBinding?.agent.id
             ? directBinding
-            : deepagentWithSubagents && deepagentWithSubagents.agent.id !== primaryBinding?.agent.id
-                ? deepagentWithSubagents
+            : delegationPreferredSecondary && delegationPreferredSecondary.agent.id !== primaryBinding?.agent.id
+                ? delegationPreferredSecondary
                 : hostBindings.find((binding) => binding.agent.id !== primaryBinding?.agent.id);
     return { primaryBinding, secondaryBinding, researchBinding, hostBindings };
 }

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

@@ -1,6 +1,7 @@
 import path from "node:path";
 import { getSkillInheritancePolicy, resolveToolTargets } from "../extensions.js";
 import { compileModel, compileTool } from "./resource-compilers.js";
+import { inferAgentCapabilities } from "./support/agent-capabilities.js";
 import { discoverSkillPaths } from "./support/discovery.js";
 import { compileAgentMemories, getRuntimeDefaults, resolvePromptValue, resolveRefId } from "./support/workspace-ref-utils.js";
 const WORKSPACE_BOUNDARY_GUIDANCE = "Keep repository and file exploration bounded to the current workspace root unless the user explicitly asks for broader host or filesystem access. " +
@@ -168,10 +169,21 @@ export function compileBinding(workspaceRoot, agent, agents, referencedSubagentI
             : path.join(workspaceRoot, "run-data");
     const base = {
         agent,
+        adapter: {
+            kind: agent.executionMode,
+            config: agent.executionMode === "deepagent"
+                ? {
+                    deepAgent: true,
+                }
+                : {
+                    langchainV1: true,
+                },
+        },
         harnessRuntime: {
             runRoot,
             workspaceRoot,
             hostFacing: !internalSubagent,
+            capabilities: inferAgentCapabilities(agent),
             ...(checkpointer ? { checkpointer: checkpointer.config } : {}),
             ...(store ? { store: store.config } : {}),
         },
@@ -194,37 +206,50 @@ export function compileBinding(workspaceRoot, agent, agents, referencedSubagentI
         };
         return {
             ...base,
+            adapter: {
+                kind: "langchain-v1",
+                config: {
+                    params: langchainAgentParams,
+                },
+            },
             langchainAgentParams,
             directAgentParams: langchainAgentParams,
         };
     }
+    const deepAgentParams = {
+        model: compiledAgentModel,
+        tools: requireTools(tools, agent.toolRefs, agent.id),
+        systemPrompt: resolveSystemPrompt(agent),
+        responseFormat: agent.deepAgentConfig?.responseFormat,
+        contextSchema: agent.deepAgentConfig?.contextSchema,
+        middleware: compileMiddlewareConfigs(agent.deepAgentConfig?.middleware, models, agent.id),
+        description: agent.description,
+        subagents: agent.subagentRefs.map((ref) => {
+            const subagent = agents.get(resolveRefId(ref));
+            if (!subagent) {
+                throw new Error(`Missing subagent ${ref} for agent ${agent.id}`);
+            }
+            return buildSubagent(subagent, workspaceRoot, models, tools, compiledAgentSkills, compiledAgentModel, compiledAgentMemory);
+        }),
+        interruptOn: resolveInterruptOn(agent),
+        ...(backend ? { backend: backend.config } : {}),
+        ...(store ? { store: store.config } : {}),
+        name: resolveAgentRuntimeName(agent),
+        memory: compiledAgentMemory,
+        skills: compiledAgentSkills,
+        generalPurposeAgent: typeof agent.deepAgentConfig?.generalPurposeAgent === "boolean" ? agent.deepAgentConfig.generalPurposeAgent : undefined,
+        taskDescription: typeof agent.deepAgentConfig?.taskDescription === "string" && agent.deepAgentConfig.taskDescription.trim()
+            ? agent.deepAgentConfig.taskDescription
+            : undefined,
+    };
     return {
         ...base,
-        deepAgentParams: {
-            model: compiledAgentModel,
-            tools: requireTools(tools, agent.toolRefs, agent.id),
-            systemPrompt: resolveSystemPrompt(agent),
-            responseFormat: agent.deepAgentConfig?.responseFormat,
-            contextSchema: agent.deepAgentConfig?.contextSchema,
-            middleware: compileMiddlewareConfigs(agent.deepAgentConfig?.middleware, models, agent.id),
-            description: agent.description,
-            subagents: agent.subagentRefs.map((ref) => {
-                const subagent = agents.get(resolveRefId(ref));
-                if (!subagent) {
-                    throw new Error(`Missing subagent ${ref} for agent ${agent.id}`);
-                }
-                return buildSubagent(subagent, workspaceRoot, models, tools, compiledAgentSkills, compiledAgentModel, compiledAgentMemory);
-            }),
-            interruptOn: resolveInterruptOn(agent),
-            ...(backend ? { backend: backend.config } : {}),
-            ...(store ? { store: store.config } : {}),
-            name: resolveAgentRuntimeName(agent),
-            memory: compiledAgentMemory,
-            skills: compiledAgentSkills,
-            generalPurposeAgent: typeof agent.deepAgentConfig?.generalPurposeAgent === "boolean" ? agent.deepAgentConfig.generalPurposeAgent : undefined,
-            taskDescription: typeof agent.deepAgentConfig?.taskDescription === "string" && agent.deepAgentConfig.taskDescription.trim()
-                ? agent.deepAgentConfig.taskDescription
-                : undefined,
+        adapter: {
+            kind: "deepagent",
+            config: {
+                params: deepAgentParams,
+            },
         },
+        deepAgentParams,
     };
 }

package/dist/workspace/object-loader.js

@@ -88,6 +88,8 @@ function normalizeNamedResourceSpec(document, kind) {
 }
 function normalizeKind(kind) {
     switch (kind) {
+        case "Agent":
+            return "agent";
         case "LangChainAgent":
             return "langchain-agent";
         case "DeepAgent":
@@ -209,6 +211,37 @@ function readObjectArray(items) {
         .map((item) => ({ ...item }));
     return records.length > 0 ? records : undefined;
 }
+function readCapabilities(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return undefined;
+    }
+    const typed = value;
+    const capabilities = {
+        ...(typeof typed.delegation === "boolean" ? { delegation: typed.delegation } : {}),
+        ...(typeof typed.memory === "boolean" ? { memory: typed.memory } : {}),
+    };
+    return Object.keys(capabilities).length > 0 ? capabilities : undefined;
+}
+function readExecutionConfig(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? { ...value }
+        : undefined;
+}
+function resolveExecutionBackend(item, current) {
+    const execution = readExecutionConfig(item.execution) ?? readExecutionConfig(current?.execution);
+    const backend = typeof execution?.backend === "string"
+        ? execution.backend.trim().toLowerCase()
+        : typeof execution?.mode === "string"
+            ? execution.mode.trim().toLowerCase()
+            : undefined;
+    if (backend === "langchain-v1" || backend === "langchain" || backend === "langchain-agent") {
+        return "langchain-v1";
+    }
+    if (backend === "deepagent" || backend === "deepagents") {
+        return "deepagent";
+    }
+    return undefined;
+}
 function readSharedAgentConfig(item) {
     const middleware = readMiddlewareArray(item.middleware);
     return {
@@ -244,12 +277,16 @@ export function parseAgentItem(item, sourcePath) {
     const subagentRefs = readRefArray(item.subagents);
     const subagentPathRefs = readPathArray(item.subagents);
     const kind = typeof item.kind === "string" ? item.kind : "agent";
-    const executionMode = String((kind === "langchain-agent" ? "langchain-v1" : undefined) ??
+    const executionMode = String(resolveExecutionBackend(item) ??
+        (kind === "langchain-agent" ? "langchain-v1" : undefined) ??
         (kind === "deepagent" ? "deepagent" : undefined) ??
         "deepagent");
     return {
         id: String(item.id),
         executionMode: executionMode,
+        capabilities: readCapabilities(item.capabilities) ?? (executionMode === "deepagent"
+            ? { delegation: true, memory: true }
+            : { delegation: false, memory: false }),
         description: String(item.description ?? ""),
         modelRef: readSingleRef(item.modelRef) ?? "",
         runRoot: typeof item.runRoot === "string" ? item.runRoot : undefined,
@@ -469,7 +506,7 @@ async function readNamedModelItems(root) {
     return records;
 }
 function isAgentKind(kind) {
-    return kind === "deepagent" || kind === "langchain-agent";
+    return kind === "deepagent" || kind === "langchain-agent" || kind === "agent";
 }
 async function readConfigAgentItems(configRoot) {
     const records = await readYamlItems(configRoot, "agents", { recursive: true });
@@ -517,6 +554,10 @@ export async function readToolModuleItems(root) {
     return records;
 }
 function inferExecutionMode(item, current) {
+    const explicitExecution = resolveExecutionBackend(item, current);
+    if (explicitExecution) {
+        return explicitExecution;
+    }
     const kind = typeof item.kind === "string" ? item.kind : typeof current?.kind === "string" ? current.kind : undefined;
     if (kind === "langchain-agent") {
         return "langchain-v1";

package/dist/workspace/support/agent-capabilities.d.ts

@@ -0,0 +1,7 @@
+import type { CompiledAgentBinding, ParsedAgentObject, RuntimeCapabilities } from "../../contracts/types.js";
+export declare function inferAgentCapabilities(agent: ParsedAgentObject): RuntimeCapabilities;
+export declare function inferBindingCapabilities(binding: CompiledAgentBinding): RuntimeCapabilities;
+export declare function isDelegationCapableAgent(agent: ParsedAgentObject): boolean;
+export declare function isMemoryCapableAgent(agent: ParsedAgentObject): boolean;
+export declare function isDelegationCapableBinding(binding: CompiledAgentBinding): boolean;
+export declare function isMemoryCapableBinding(binding: CompiledAgentBinding): boolean;

package/dist/workspace/support/agent-capabilities.js

@@ -0,0 +1,30 @@
+function normalizeCapabilities(capabilities) {
+    return {
+        delegation: capabilities?.delegation === true,
+        memory: capabilities?.memory === true,
+    };
+}
+export function inferAgentCapabilities(agent) {
+    if (agent.capabilities) {
+        return normalizeCapabilities(agent.capabilities);
+    }
+    return {
+        delegation: agent.executionMode === "deepagent",
+        memory: agent.executionMode === "deepagent",
+    };
+}
+export function inferBindingCapabilities(binding) {
+    return normalizeCapabilities(binding.harnessRuntime.capabilities ?? binding.agent.capabilities ?? inferAgentCapabilities(binding.agent));
+}
+export function isDelegationCapableAgent(agent) {
+    return inferAgentCapabilities(agent).delegation === true;
+}
+export function isMemoryCapableAgent(agent) {
+    return inferAgentCapabilities(agent).memory === true;
+}
+export function isDelegationCapableBinding(binding) {
+    return inferBindingCapabilities(binding).delegation === true;
+}
+export function isMemoryCapableBinding(binding) {
+    return inferBindingCapabilities(binding).memory === true;
+}

package/dist/workspace/validate.js

@@ -1,3 +1,4 @@
+import { isDelegationCapableAgent, isMemoryCapableAgent } from "./support/agent-capabilities.js";
 const allowedExecutionModes = new Set(["deepagent", "langchain-v1"]);
 function hasPromptContent(value) {
     return typeof value === "string" && value.trim().length > 0;
@@ -52,14 +53,14 @@ export function validateAgent(agent) {
     if (!agent.description.trim()) {
         throw new Error(`Agent ${agent.id} description must not be empty`);
     }
-    if (agent.executionMode === "langchain-v1" && (agent.subagentRefs.length > 0 || agent.subagentPathRefs.length > 0)) {
-        throw new Error(`Agent ${agent.id} cannot define subagents unless execution.mode is deepagent`);
+    if (!isDelegationCapableAgent(agent) && (agent.subagentRefs.length > 0 || agent.subagentPathRefs.length > 0)) {
+        throw new Error(`Agent ${agent.id} cannot define subagents unless it uses a delegation-capable backend`);
     }
-    if (agent.executionMode === "langchain-v1" && agent.memorySources.length > 0) {
-        throw new Error(`Agent ${agent.id} cannot define memory unless execution.mode is deepagent`);
+    if (!isMemoryCapableAgent(agent) && agent.memorySources.length > 0) {
+        throw new Error(`Agent ${agent.id} cannot define memory unless it uses a memory-capable backend`);
     }
-    if ((agent.subagentRefs.length > 0 || agent.subagentPathRefs.length > 0) && agent.executionMode !== "deepagent") {
-        throw new Error(`Agent ${agent.id} must use deepagent execution when subagents are defined`);
+    if ((agent.subagentRefs.length > 0 || agent.subagentPathRefs.length > 0) && !isDelegationCapableAgent(agent)) {
+        throw new Error(`Agent ${agent.id} must use a delegation-capable backend when subagents are defined`);
     }
     validateCheckpointerConfig(agent);
     validateMiddlewareConfig(agent);
@@ -83,8 +84,8 @@ export function validateTopology(agents) {
         if (!referencedSubagentIds.has(agent.id)) {
             continue;
         }
-        if (agent.executionMode !== "deepagent") {
-            throw new Error(`Subagent ${agent.id} must use deepagent execution`);
+        if (!isDelegationCapableAgent(agent)) {
+            throw new Error(`Subagent ${agent.id} must use a delegation-capable backend`);
         }
         if (!hasPromptContent(agent.deepAgentConfig?.systemPrompt)) {
             throw new Error(`Subagent ${agent.id} requires deepagent.systemPrompt`);

package/package.json

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