@botbotgo/agent-harness 0.0.448 → 0.0.450

package/dist/package-version.d.ts

@@ -1,2 +1,2 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.448";
+export declare const AGENT_HARNESS_VERSION = "0.0.450";
 export declare const AGENT_HARNESS_RELEASE_DATE = "2026-05-04";

package/dist/package-version.js

@@ -1,2 +1,2 @@
-export const AGENT_HARNESS_VERSION = "0.0.448";
+export const AGENT_HARNESS_VERSION = "0.0.450";
 export const AGENT_HARNESS_RELEASE_DATE = "2026-05-04";

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

@@ -47,6 +47,7 @@ export declare class AgentRuntimeAdapter {
     private createLangChainRunnable;
     private createRunnable;
     private createDeepAgentRunnable;
+    private createUpstreamDeepAgentRunnable;
     private createConfigurableDeepAgentRunnable;
     private buildRunnableCacheKey;
     create(binding: CompiledAgentBinding, options?: {

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

@@ -1,6 +1,6 @@
 import path from "node:path";
 import { createHash } from "node:crypto";
-import { createAsyncSubAgentMiddleware, createFilesystemMiddleware, createMemoryMiddleware, createPatchToolCallsMiddleware, createSkillsMiddleware, createSummarizationMiddleware, createSubAgentMiddleware, FilesystemBackend, StateBackend, } from "deepagents";
+import { createAsyncSubAgentMiddleware, createDeepAgent, createFilesystemMiddleware, createMemoryMiddleware, createPatchToolCallsMiddleware, createSkillsMiddleware, createSummarizationMiddleware, createSubAgentMiddleware, FilesystemBackend, StateBackend, } from "deepagents";
 import { createAgent, humanInTheLoopMiddleware, todoListMiddleware } from "langchain";
 import { sanitizeVisibleText, tryParseJson, wrapResolvedModel, } from "./parsing/output-parsing.js";
 import { salvageJsonToolCalls } from "./parsing/output-tool-args.js";
@@ -154,6 +154,10 @@ function readConfiguredToolName(value) {
 function shouldUseConfigurableDeepAgentAssembly(binding) {
     return getBindingExecutionKind(binding) === "deepagent";
 }
+function canUseUpstreamCreateDeepAgentAssembly(binding) {
+    const builtinTools = getBindingBuiltinToolsConfig(binding);
+    return builtinTools?.todos !== false && builtinTools?.filesystem !== false;
+}
 function readModelText(value) {
     if (typeof value === "string") {
         return value.trim();
@@ -890,7 +894,7 @@ export class AgentRuntimeAdapter {
             }) : undefined))
             : undefined;
         if (shouldUseConfigurableDeepAgentAssembly(binding)) {
-            return this.createConfigurableDeepAgentRunnable(binding, {
+            const assemblyInput = {
                 resolvedModel,
                 resolvedTools: modelTools,
                 resolvedMiddleware,
@@ -900,10 +904,43 @@ export class AgentRuntimeAdapter {
                 resolvedStore,
                 resolvedBackend,
                 resolvedSkills,
-            });
+            };
+            return canUseUpstreamCreateDeepAgentAssembly(binding)
+                ? this.createUpstreamDeepAgentRunnable(binding, assemblyInput)
+                : this.createConfigurableDeepAgentRunnable(binding, assemblyInput);
         }
         throw new Error(`Agent ${binding.agent.id} has no supported deepagent assembly path`);
     }
+    createUpstreamDeepAgentRunnable(binding, input) {
+        const executionParams = getBindingExecutionParams(binding);
+        const responseFormat = getBindingExecutionKind(binding) === "deepagent"
+            ? (executionParams && "responseFormat" in executionParams ? executionParams.responseFormat : undefined)
+            : undefined;
+        const contextSchema = getBindingExecutionKind(binding) === "deepagent"
+            ? (executionParams && "contextSchema" in executionParams ? executionParams.contextSchema : undefined)
+            : undefined;
+        return createDeepAgent({
+            model: input.resolvedModel,
+            systemPrompt: buildDeepAgentSystemPromptWithCapabilityHierarchy({
+                systemPrompt: getBindingSystemPrompt(binding),
+                subagents: input.resolvedSubagents,
+                skills: input.resolvedSkills,
+                tools: getBindingPrimaryTools(binding),
+            }),
+            tools: input.resolvedTools,
+            middleware: input.resolvedMiddleware,
+            subagents: input.resolvedSubagents,
+            ...(responseFormat !== undefined ? { responseFormat: responseFormat } : {}),
+            ...(contextSchema !== undefined ? { contextSchema: contextSchema } : {}),
+            ...(input.resolvedCheckpointer !== undefined ? { checkpointer: input.resolvedCheckpointer } : {}),
+            ...(input.resolvedStore !== undefined ? { store: input.resolvedStore } : {}),
+            ...(input.resolvedBackend !== undefined ? { backend: input.resolvedBackend } : {}),
+            ...(input.resolvedInterruptOn !== undefined ? { interruptOn: input.resolvedInterruptOn } : {}),
+            name: binding.agent.id,
+            memory: getBindingMemorySources(binding),
+            skills: input.resolvedSkills,
+        });
+    }
     createConfigurableDeepAgentRunnable(binding, input) {
         const builtinTools = getBindingBuiltinToolsConfig(binding) ?? {};
         const backend = (input.resolvedBackend ?? new StateBackend({}));

package/dist/workspace/framework-contract-validation.js

@@ -2,7 +2,7 @@ import path from "node:path";
 import { validateSkillMetadata } from "../runtime/skills/skill-metadata.js";
 import { getAgentExecutionConfigValue } from "./support/agent-execution-config.js";
 import { getRuntimeAgentDefaults, getWorkspaceObject, resolvePromptValue } from "./support/workspace-ref-utils.js";
-const FORBIDDEN_GENERAL_PURPOSE_SUBAGENT_NAME = "general-purpose";
+const UPSTREAM_GENERAL_PURPOSE_SUBAGENT_NAME = "general-purpose";
 const FRAMEWORK_AGENT_TOOL_NAMES = new Set(["task"]);
 const FRAMEWORK_EXECUTION_TOOL_NAMES = new Set(["write_todos", "read_todos"]);
 const TERMINAL_STATUS_VALUES = new Set(["completed", "blocked", "failed", "refused"]);
@@ -188,17 +188,17 @@ function validateAgentContract(agent, referencedSubagentIds, tools, refs, issues
         ...agent.subagentRefs.map(resolveRefId),
         ...(agent.asyncSubagents ?? []).map((subagent) => subagent.name),
     ];
-    if (agent.id === FORBIDDEN_GENERAL_PURPOSE_SUBAGENT_NAME) {
-        addIssue(issues, "agent.general_purpose.forbidden", `Agent ${agent.id} uses the reserved general-purpose subagent name. Define explicit specialists with narrow responsibilities instead.`);
+    const isDeepAgentsGeneralPurposeSubagentOverride = agent.executionMode === "deepagent"
+        && isSubagent
+        && agent.id === UPSTREAM_GENERAL_PURPOSE_SUBAGENT_NAME;
+    if (agent.id === UPSTREAM_GENERAL_PURPOSE_SUBAGENT_NAME && !isDeepAgentsGeneralPurposeSubagentOverride) {
+        addIssue(issues, "agent.general_purpose.forbidden", `Agent ${agent.id} uses the upstream DeepAgents general-purpose subagent name outside a DeepAgents subagent override. Define a product agent with a narrow runtime boundary instead.`);
     }
     for (const asyncSubagent of agent.asyncSubagents ?? []) {
-        if (asyncSubagent.name === FORBIDDEN_GENERAL_PURPOSE_SUBAGENT_NAME) {
-            addIssue(issues, "agent.general_purpose.forbidden", `Agent ${agent.id} defines async subagent ${asyncSubagent.name}. Define explicit specialists with narrow responsibilities instead.`);
+        if (asyncSubagent.name === UPSTREAM_GENERAL_PURPOSE_SUBAGENT_NAME) {
+            addIssue(issues, "agent.general_purpose.forbidden", `Agent ${agent.id} defines async subagent ${asyncSubagent.name}. DeepAgents reserves that name for its inline general-purpose subagent surface.`);
         }
     }
-    if (localSubagentNames.includes(FORBIDDEN_GENERAL_PURPOSE_SUBAGENT_NAME)) {
-        addIssue(issues, "agent.general_purpose.forbidden", `Agent ${agent.id} references reserved subagent name ${FORBIDDEN_GENERAL_PURPOSE_SUBAGENT_NAME}. Define explicit specialists with narrow responsibilities instead.`);
-    }
     if (hasDuplicateValues(localSubagentNames)) {
         addIssue(issues, "agent.subagent.duplicate_name", `Agent ${agent.id} exposes duplicate subagent names. Each delegated capability must have one stable owner.`);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botbotgo/agent-harness",
-  "version": "0.0.448",
+  "version": "0.0.450",
   "description": "Workspace runtime for multi-agent applications",
   "license": "MIT",
   "type": "module",