@botbotgo/agent-harness 0.0.112 → 0.0.114

package/dist/contracts/workspace.d.ts

@@ -139,16 +139,14 @@ export type CompiledSubAgent = {
     model?: CompiledModel;
     interruptOn?: Record<string, boolean | object>;
     skills?: string[];
-    memory?: string[];
     responseFormat?: unknown;
-    contextSchema?: unknown;
     middleware?: Array<Record<string, unknown>>;
-    passthrough?: Record<string, unknown>;
 };
 export type LangChainAgentParams = {
     model: CompiledModel;
     tools: CompiledTool[];
     systemPrompt?: string;
+    interruptOn?: Record<string, boolean | object>;
     stateSchema?: unknown;
     responseFormat?: unknown;
     contextSchema?: unknown;
@@ -172,7 +170,6 @@ export type DeepAgentParams = {
     responseFormat?: unknown;
     contextSchema?: unknown;
     middleware?: Array<Record<string, unknown>>;
-    passthrough?: Record<string, unknown>;
     description: string;
     subagents: CompiledSubAgent[];
     interruptOn?: Record<string, boolean | object>;

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.111";
+export declare const AGENT_HARNESS_VERSION = "0.0.113";

package/dist/package-version.js

@@ -1 +1 @@
-export const AGENT_HARNESS_VERSION = "0.0.111";
+export const AGENT_HARNESS_VERSION = "0.0.113";

package/dist/runtime/adapter/middleware-assembly.d.ts

@@ -1,6 +1,17 @@
 import { FilesystemBackend } from "deepagents";
 import type { CompiledAgentBinding, CompiledModel, CompiledSubAgent, DeepAgentParams, RuntimeAdapterOptions } from "../../contracts/types.js";
 import type { ExecutableTool } from "./flow/invoke-runtime.js";
+export declare function buildBuiltinTaskSubagentRunnableConfig(input: {
+    selectedSubagent: CompiledSubAgent;
+    defaultModel: unknown;
+    defaultTools: unknown[];
+    middleware: unknown[];
+}): Record<string, unknown>;
+export declare function buildBuiltinTaskSubagentMiddleware(input: {
+    selectedSubagent: CompiledSubAgent;
+    builtinBackend: unknown;
+    summarizationModel: unknown;
+}): unknown[];
 export declare function resolveBuiltinMiddlewareBackend(input: {
     binding: CompiledAgentBinding;
     runtimeAdapterOptions: RuntimeAdapterOptions;

package/dist/runtime/adapter/middleware-assembly.js

@@ -8,6 +8,43 @@ import { isRecord } from "../../utils/object.js";
 import { resolveDeclaredMiddleware } from "./tool/declared-middleware.js";
 import { bindingHasLangChainSubagentSupport, bindingHasMiddlewareKind, getBindingDeepAgentParams, getBindingInterruptCompatibilityRules, getBindingLangChainParams, getBindingMiddlewareConfigs, getBindingPrimaryModel, isDeepAgentBinding, isLangChainBinding, } from "../support/compiled-binding.js";
 import { applyDeepAgentDelegationPromptCompatibility, materializeDeepAgentSkillSourcePaths } from "./compat/deepagent-compat.js";
+export function buildBuiltinTaskSubagentRunnableConfig(input) {
+    const { selectedSubagent, defaultModel, defaultTools, middleware } = input;
+    return {
+        model: (selectedSubagent.model ?? defaultModel),
+        tools: (selectedSubagent.tools ?? defaultTools),
+        systemPrompt: selectedSubagent.systemPrompt ?? DEFAULT_SUBAGENT_PROMPT,
+        middleware: middleware,
+        responseFormat: selectedSubagent.responseFormat,
+        name: selectedSubagent.name,
+        description: selectedSubagent.description,
+    };
+}
+export function buildBuiltinTaskSubagentMiddleware(input) {
+    const { selectedSubagent, builtinBackend, summarizationModel } = input;
+    const defaultSubagentMiddleware = [
+        createPatchToolCallsMiddleware(),
+        createSummarizationMiddleware({
+            model: summarizationModel,
+            backend: builtinBackend,
+        }),
+    ];
+    const subagentSkillsMiddleware = selectedSubagent.skills?.length
+        ? [createSkillsMiddleware({ backend: builtinBackend, sources: selectedSubagent.skills })]
+        : [];
+    const subagentMiddleware = selectedSubagent.middleware ?? [];
+    const interruptMiddleware = selectedSubagent.interruptOn
+        ? [humanInTheLoopMiddleware({
+                interruptOn: compileInterruptOn(selectedSubagent.tools ?? [], selectedSubagent.interruptOn),
+            })]
+        : [];
+    return [
+        ...defaultSubagentMiddleware,
+        ...subagentSkillsMiddleware,
+        ...subagentMiddleware,
+        ...interruptMiddleware,
+    ];
+}
 function buildLangChainContextMiddleware(params) {
     const middleware = [];
     const hasSkills = (params.compatibleParams.skills?.length ?? 0) > 0;
@@ -51,22 +88,26 @@ export function resolveBuiltinMiddlewareBackend(input) {
     return new StateBackend(runtimeLike);
 }
 export async function resolveSubagents(input) {
-    return Promise.all(input.subagents.map(async (subagent) => ({
-        ...subagent,
-        ...(subagent.passthrough ?? {}),
-        model: subagent.model ? (await input.resolveModel(subagent.model)) : undefined,
-        tools: subagent.tools ? input.resolveTools(subagent.tools, input.binding) : undefined,
-        skills: await materializeDeepAgentSkillSourcePaths({
-            workspaceRoot: input.binding?.harnessRuntime.workspaceRoot,
-            runRoot: input.binding?.harnessRuntime.runRoot,
-            ownerId: `${input.binding?.agent.id ?? "agent"}-${subagent.name}`,
-            skillPaths: subagent.skills,
-        }),
-        interruptOn: compileInterruptOn(subagent.tools ?? [], subagent.interruptOn),
-        responseFormat: subagent.responseFormat,
-        contextSchema: subagent.contextSchema,
-        middleware: (await resolveDeclaredMiddleware(subagent.middleware, input.createDeclaredMiddlewareResolverOptions(input.binding))),
-    })));
+    return Promise.all(input.subagents.map(async (subagent) => {
+        // Only pass DeepAgents-supported subagent fields through to upstream middleware.
+        // Harness-only extensions stay internal instead of becoming a second subagent dialect.
+        return {
+            name: subagent.name,
+            description: subagent.description,
+            systemPrompt: subagent.systemPrompt,
+            model: subagent.model ? (await input.resolveModel(subagent.model)) : undefined,
+            tools: subagent.tools ? input.resolveTools(subagent.tools, input.binding) : undefined,
+            skills: await materializeDeepAgentSkillSourcePaths({
+                workspaceRoot: input.binding?.harnessRuntime.workspaceRoot,
+                runRoot: input.binding?.harnessRuntime.runRoot,
+                ownerId: `${input.binding?.agent.id ?? "agent"}-${subagent.name}`,
+                skillPaths: subagent.skills,
+            }),
+            interruptOn: compileInterruptOn(subagent.tools ?? [], subagent.interruptOn),
+            responseFormat: subagent.responseFormat,
+            middleware: (await resolveDeclaredMiddleware(subagent.middleware, input.createDeclaredMiddlewareResolverOptions(input.binding))),
+        };
+    }));
 }
 export async function invokeBuiltinTaskTool(input) {
     if (!isDeepAgentBinding(input.binding)) {
@@ -89,37 +130,17 @@ export async function invokeBuiltinTaskTool(input) {
     const summarizationModel = selectedSubagent.model
         ? await input.resolveModel(selectedSubagent.model)
         : await input.resolveModel(params.model);
-    const middleware = [
-        ...(selectedSubagent.skills?.length
-            ? [createSkillsMiddleware({ backend: builtinBackend, sources: selectedSubagent.skills })]
-            : []),
-        ...(selectedSubagent.memory?.length
-            ? [createMemoryMiddleware({ backend: builtinBackend, sources: selectedSubagent.memory })]
-            : []),
-        ...(selectedSubagent.middleware ??
-            [
-                createPatchToolCallsMiddleware(),
-                createSummarizationMiddleware({
-                    model: summarizationModel,
-                    backend: builtinBackend,
-                }),
-            ]),
-        ...(selectedSubagent.interruptOn
-            ? [humanInTheLoopMiddleware({
-                    interruptOn: compileInterruptOn(selectedSubagent.tools ?? [], selectedSubagent.interruptOn),
-                })]
-            : []),
-    ];
-    const runnable = createAgent({
-        model: (selectedSubagent.model ?? (await input.resolveModel(params.model))),
-        tools: (selectedSubagent.tools ?? input.resolveTools(params.tools, input.binding)),
-        systemPrompt: selectedSubagent.systemPrompt ?? DEFAULT_SUBAGENT_PROMPT,
-        middleware: middleware,
-        responseFormat: selectedSubagent.responseFormat,
-        contextSchema: selectedSubagent.contextSchema,
-        name: selectedSubagent.name,
-        description: selectedSubagent.description,
+    const middleware = buildBuiltinTaskSubagentMiddleware({
+        selectedSubagent,
+        builtinBackend,
+        summarizationModel,
     });
+    const runnable = createAgent(buildBuiltinTaskSubagentRunnableConfig({
+        selectedSubagent,
+        defaultModel: await input.resolveModel(params.model),
+        defaultTools: input.resolveTools(params.tools, input.binding),
+        middleware,
+    }));
     const result = await runnable.invoke({ messages: [new HumanMessage({ content: description })] }, { configurable: { thread_id: `${input.binding.agent.id}:builtin-task` }, ...(input.options?.context ? { context: input.options.context } : {}) });
     const visibleOutput = extractVisibleOutput(result);
     const fallbackOutput = extractToolFallbackContext(result);

package/dist/runtime/adapter/runnable-config.d.ts

@@ -27,7 +27,6 @@ type LangChainRunnableConfigParams = {
 };
 type DeepAgentRunnableConfigParams = {
     compatibleParams: {
-        passthrough?: Record<string, unknown>;
         systemPrompt?: string;
         responseFormat?: unknown;
         contextSchema?: unknown;

package/dist/runtime/adapter/runnable-config.js

@@ -37,7 +37,6 @@ export function buildLangChainRunnableConfig(params) {
 export function buildDeepAgentRunnableConfig(params) {
     const { compatibleParams, resolvedModel, resolvedTools, resolvedMiddleware, resolvedSubagents, resolvedCheckpointer, resolvedStore, resolvedBackend, resolvedInterruptOn, resolvedSkills, } = params;
     return buildResolvedRunnableConfig({
-        passthrough: compatibleParams.passthrough ?? {},
         staticConfig: {
             systemPrompt: compatibleParams.systemPrompt,
             responseFormat: compatibleParams.responseFormat,

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

@@ -31,8 +31,8 @@ function deriveBindingExecutionView(binding) {
         systemPrompt: langchainParams?.systemPrompt ?? deepAgentParams?.systemPrompt,
         middlewareConfigs,
         middlewareKinds,
-        interruptCompatibilityRules: deepAgentParams?.interruptOn ??
-            binding.agent.langchainAgentConfig?.interruptOn,
+        interruptCompatibilityRules: langchainParams?.interruptOn ??
+            deepAgentParams?.interruptOn,
         storeConfig: deepAgentParams?.store ?? binding.harnessRuntime?.store,
         langChainSubagentSupport: (langchainParams?.subagents?.length ?? 0) > 0 ||
             langchainParams?.generalPurposeAgent === true ||

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

@@ -87,8 +87,7 @@ export function requireTools(tools, refs, ownerId) {
     }
     return Array.from(deduped.values());
 }
-function buildSubagent(agent, workspaceRoot, models, tools, parentSkills, parentModel, parentMemory) {
-    const ownMemory = compileAgentMemories(workspaceRoot, agent.memorySources);
+function buildSubagent(agent, workspaceRoot, models, tools, parentSkills, parentModel) {
     const execution = compileExecutionCore(agent, models, tools);
     return {
         name: resolveAgentRuntimeName(agent),
@@ -98,11 +97,8 @@ function buildSubagent(agent, workspaceRoot, models, tools, parentSkills, parent
         model: agent.modelRef ? execution.model : parentModel,
         interruptOn: resolveInterruptOn(agent),
         skills: compileAgentSkills(workspaceRoot, agent, parentSkills),
-        memory: ownMemory.length > 0 ? ownMemory : parentMemory,
         responseFormat: execution.responseFormat,
-        contextSchema: execution.contextSchema,
         middleware: execution.middleware,
-        passthrough: execution.passthrough,
     };
 }
 function resolveSystemPrompt(agent) {
@@ -129,13 +125,13 @@ function resolvePassthrough(agent) {
     const passthrough = getAgentExecutionObject(agent, "passthrough");
     return passthrough ? { ...passthrough } : undefined;
 }
-function compileSubagents(agent, agents, workspaceRoot, models, tools, compiledAgentSkills, compiledAgentModel, compiledAgentMemory) {
+function compileSubagents(agent, agents, workspaceRoot, models, tools, compiledAgentSkills, compiledAgentModel) {
     return 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);
+        return buildSubagent(subagent, workspaceRoot, models, tools, compiledAgentSkills, compiledAgentModel);
     });
 }
 function compileExecutionCore(agent, models, tools) {
@@ -293,13 +289,14 @@ export function compileBinding(workspaceRoot, agent, agents, referencedSubagentI
             model: execution.model,
             tools: execution.tools,
             systemPrompt: execution.systemPrompt,
+            interruptOn: resolveInterruptOn(agent),
             stateSchema: getAgentExecutionConfigValue(agent, "stateSchema", { executionMode: "langchain-v1" }),
             responseFormat: execution.responseFormat,
             contextSchema: execution.contextSchema,
             filesystem: getAgentExecutionObject(agent, "filesystem", { executionMode: "langchain-v1" }),
             middleware: execution.middleware,
             passthrough: execution.passthrough,
-            subagents: compileSubagents(agent, agents, workspaceRoot, models, tools, compiledAgentSkills, compiledAgentModel, compiledAgentMemory),
+            subagents: compileSubagents(agent, agents, workspaceRoot, models, tools, compiledAgentSkills, compiledAgentModel),
             memory: compiledAgentMemory,
             skills: compiledAgentSkills,
             generalPurposeAgent: getAgentExecutionConfigValue(agent, "generalPurposeAgent", { executionMode: "langchain-v1" }),
@@ -329,9 +326,8 @@ export function compileBinding(workspaceRoot, agent, agents, referencedSubagentI
         responseFormat: execution.responseFormat,
         contextSchema: execution.contextSchema,
         middleware: execution.middleware,
-        passthrough: execution.passthrough,
         description: agent.description,
-        subagents: compileSubagents(agent, agents, workspaceRoot, models, tools, compiledAgentSkills, compiledAgentModel, compiledAgentMemory),
+        subagents: compileSubagents(agent, agents, workspaceRoot, models, tools, compiledAgentSkills, compiledAgentModel),
         interruptOn: resolveInterruptOn(agent),
         ...(backend ? { backend: backend.config } : {}),
         ...(store ? { store: store.config } : {}),

package/dist/workspace/support/agent-execution-config.js

@@ -8,8 +8,8 @@ function deriveAgentExecutionViews(agent) {
     const langchainConfig = asRecord(agent.langchainAgentConfig);
     const deepAgentConfig = asRecord(agent.deepAgentConfig);
     const views = {
-        "langchain-v1": [langchainConfig, deepAgentConfig].filter((config) => config !== undefined),
-        deepagent: [deepAgentConfig, langchainConfig].filter((config) => config !== undefined),
+        "langchain-v1": [langchainConfig ?? {}],
+        deepagent: [deepAgentConfig ?? {}],
     };
     agentExecutionViewsCache.set(agent, views);
     return views;

package/dist/workspace/validate.js

@@ -1,4 +1,4 @@
-import { hasAgentSystemPrompt, isDelegationCapableAgent, isMemoryCapableAgent, } from "./support/agent-capabilities.js";
+import { isDelegationCapableAgent, isMemoryCapableAgent, } from "./support/agent-capabilities.js";
 import { getAgentExecutionConfigValue, getAgentExecutionConfigs } from "./support/agent-execution-config.js";
 const allowedExecutionModes = new Set(["deepagent", "langchain-v1"]);
 function validateCheckpointerConfig(agent) {
@@ -88,8 +88,5 @@ export function validateTopology(agents) {
         if (!isDelegationCapableAgent(agent)) {
             throw new Error(`Subagent ${agent.id} must use a delegation-capable backend`);
         }
-        if (!hasAgentSystemPrompt(agent)) {
-            throw new Error(`Subagent ${agent.id} requires systemPrompt`);
-        }
     }
 }

package/package.json

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