@botbotgo/agent-harness 0.0.110 → 0.0.112

package/dist/workspace/object-loader.js

@@ -151,9 +151,75 @@ const CONSUMED_AGENT_CONFIG_KEYS = [
     "generalPurposeAgent",
     "filesystem",
 ];
+const RESERVED_EXECUTION_KEYS = [
+    "backend",
+    "modelRef",
+    "tools",
+    "skills",
+    "memory",
+    "subagents",
+    "mcpServers",
+    "config",
+];
+const MIGRATED_EXECUTION_CONFIG_KEYS = [
+    "systemPrompt",
+    "checkpointer",
+    "interruptOn",
+    "stateSchema",
+    "responseFormat",
+    "contextSchema",
+    "includeAgentName",
+    "version",
+    "middleware",
+    "store",
+    "taskDescription",
+    "generalPurposeAgent",
+    "filesystem",
+];
 function readExecutionConfig(value) {
     return asMutableObject(value);
 }
+function normalizeAgentItemForMerge(item) {
+    const normalized = { ...item };
+    const execution = readExecutionConfig(normalized.execution);
+    if (!execution) {
+        return normalized;
+    }
+    const config = asMutableObject(execution.config);
+    const runtime = readRuntimeConfig(normalized);
+    if (config) {
+        for (const key of MIGRATED_EXECUTION_CONFIG_KEYS) {
+            if (!(key in config) || execution[key] !== undefined) {
+                continue;
+            }
+            execution[key] = cloneConfigValue(config[key]);
+            delete config[key];
+        }
+        if (config.runtimeMemory !== undefined && runtime?.runtimeMemory === undefined) {
+            const nextRuntime = runtime ?? {};
+            nextRuntime.runtimeMemory = cloneConfigValue(config.runtimeMemory);
+            normalized.runtime = nextRuntime;
+            delete config.runtimeMemory;
+        }
+    }
+    if (config && Object.keys(config).length > 0) {
+        execution.config = config;
+    }
+    else {
+        delete execution.config;
+    }
+    normalized.execution = execution;
+    return normalized;
+}
+function readExecutionAgentConfig(item) {
+    const execution = readExecutionConfig(item.execution) ?? {};
+    const config = asMutableObject(execution.config) ?? {};
+    const directExecutionConfig = Object.fromEntries(Object.entries(execution).filter(([key]) => !RESERVED_EXECUTION_KEYS.includes(key)));
+    return {
+        ...config,
+        ...directExecutionConfig,
+    };
+}
 function readExecutionValue(item, key, reader) {
     const execution = readExecutionConfig(item.execution);
     return reader(execution?.[key]);
@@ -161,19 +227,17 @@ function readExecutionValue(item, key, reader) {
 function readRuntimeConfig(item) {
     return asMutableObject(item.runtime);
 }
-function readRuntimeModelRefs(runtime) {
-    if (!runtime) {
-        return undefined;
+function readRuntimeMemoryConfig(item, runtime) {
+    if (typeof runtime?.runtimeMemory === "object" && runtime.runtimeMemory && !Array.isArray(runtime.runtimeMemory)) {
+        return cloneConfigValue(runtime.runtimeMemory);
     }
-    const modelRefs = {
-        ...(typeof runtime.planningModelRef === "string" && runtime.planningModelRef.trim()
-            ? { planning: runtime.planningModelRef.trim() }
-            : {}),
-        ...(typeof runtime.executionModelRef === "string" && runtime.executionModelRef.trim()
-            ? { execution: runtime.executionModelRef.trim() }
-            : {}),
-    };
-    return Object.keys(modelRefs).length > 0 ? modelRefs : undefined;
+    const legacyExecutionConfig = readExecutionAgentConfig(item);
+    if (typeof legacyExecutionConfig.runtimeMemory === "object" &&
+        legacyExecutionConfig.runtimeMemory &&
+        !Array.isArray(legacyExecutionConfig.runtimeMemory)) {
+        return cloneConfigValue(legacyExecutionConfig.runtimeMemory);
+    }
+    return undefined;
 }
 function cloneConfigValue(value) {
     if (Array.isArray(value)) {
@@ -239,12 +303,15 @@ function resolveExecutionBackend(item, current) {
     }
     return undefined;
 }
-function readSharedAgentConfigFields(config) {
+function readSharedAgentConfigFields(config, options = {}) {
     return {
         ...(typeof config.store === "object" && config.store ? { store: config.store } : {}),
-        ...(typeof config.runtimeMemory === "object" && config.runtimeMemory ? { runtimeMemory: config.runtimeMemory } : {}),
-        ...(typeof config.taskDescription === "string" && config.taskDescription.trim() ? { taskDescription: config.taskDescription } : {}),
-        ...(typeof config.generalPurposeAgent === "boolean" ? { generalPurposeAgent: config.generalPurposeAgent } : {}),
+        ...(options.includeDelegationControls && typeof config.taskDescription === "string" && config.taskDescription.trim()
+            ? { taskDescription: config.taskDescription }
+            : {}),
+        ...(options.includeDelegationControls && typeof config.generalPurposeAgent === "boolean"
+            ? { generalPurposeAgent: config.generalPurposeAgent }
+            : {}),
     };
 }
 function readSharedAgentConfig(config) {
@@ -268,11 +335,11 @@ function readSharedAgentConfig(config) {
     };
 }
 function readAgentConfig(item, options = {}) {
-    const config = readExecutionValue(item, "config", asMutableObject) ?? {};
+    const config = readExecutionAgentConfig(item);
     const passthrough = readPassthroughConfig(config, [...CONSUMED_AGENT_CONFIG_KEYS]);
     return {
         ...readSharedAgentConfig(config),
-        ...readSharedAgentConfigFields(config),
+        ...readSharedAgentConfigFields(config, { includeDelegationControls: options.includeDelegationControls }),
         ...(options.includeObjectBackend && typeof config.backend === "object" && config.backend ? { backend: config.backend } : {}),
         ...(passthrough ? { passthrough } : {}),
     };
@@ -286,7 +353,7 @@ export function parseAgentItem(item, sourcePath) {
     return {
         id: String(item.id),
         executionMode: executionMode,
-        runtimeModelRefs: readRuntimeModelRefs(runtime),
+        runtimeMemory: readRuntimeMemoryConfig(item, runtime),
         capabilities: readCapabilities(item.capabilities) ?? (executionMode === "deepagent"
             ? { delegation: true, memory: true }
             : { delegation: true, memory: true }),
@@ -299,8 +366,11 @@ export function parseAgentItem(item, sourcePath) {
         memorySources: readExecutionValue(item, "memory", readPathArray).map((entry) => resolveModuleRelativePath(entry, moduleRoot)),
         subagentRefs,
         subagentPathRefs,
-        langchainAgentConfig: normalizeModuleAgentConfig(readAgentConfig(item), moduleRoot),
-        deepAgentConfig: normalizeModuleAgentConfig(readAgentConfig(item, { includeObjectBackend: true }), moduleRoot),
+        langchainAgentConfig: normalizeModuleAgentConfig(readAgentConfig(item, { includeDelegationControls: true }), moduleRoot),
+        deepAgentConfig: normalizeModuleAgentConfig(readAgentConfig(item, {
+            includeObjectBackend: true,
+            includeDelegationControls: false,
+        }), moduleRoot),
         sourcePath,
     };
 }
@@ -347,11 +417,12 @@ function mergeRawItemRecord(records, key, item, sourcePath) {
     return mergedRecord;
 }
 function mergeAgentRecord(records, item, sourcePath) {
-    const id = typeof item.id === "string" ? item.id : undefined;
+    const normalizedItem = normalizeAgentItemForMerge(item);
+    const id = typeof normalizedItem.id === "string" ? normalizedItem.id : undefined;
     if (!id) {
         return null;
     }
-    return mergeRawItemRecord(records, id, item, sourcePath);
+    return mergeRawItemRecord(records, id, normalizedItem, sourcePath);
 }
 function mergeWorkspaceObjectRecord(records, workspaceObject, item, sourcePath) {
     mergeRawItemRecord(records, `${workspaceObject.kind}/${workspaceObject.id}`, item, sourcePath);

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

@@ -1,12 +1,21 @@
-function asRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value)
-        ? value
-        : undefined;
+import { asRecord } from "../../utils/object.js";
+const agentExecutionViewsCache = new WeakMap();
+function deriveAgentExecutionViews(agent) {
+    const cached = agentExecutionViewsCache.get(agent);
+    if (cached) {
+        return cached;
+    }
+    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),
+    };
+    agentExecutionViewsCache.set(agent, views);
+    return views;
 }
 function getConfigsForMode(agent, executionMode = agent.executionMode) {
-    const primary = executionMode === "deepagent" ? asRecord(agent.deepAgentConfig) : asRecord(agent.langchainAgentConfig);
-    const fallback = executionMode === "deepagent" ? asRecord(agent.langchainAgentConfig) : asRecord(agent.deepAgentConfig);
-    return [primary, fallback].filter((config) => config !== undefined);
+    return deriveAgentExecutionViews(agent)[executionMode];
 }
 export function getAgentExecutionConfigs(agent, executionMode = agent.executionMode) {
     return getConfigsForMode(agent, executionMode);

package/dist/workspace/support/workspace-ref-utils.d.ts

@@ -1,4 +1,4 @@
-import type { ParsedAgentObject, RuntimeModelRefMap, WorkspaceObject } from "../../contracts/types.js";
+import type { ParsedAgentObject, WorkspaceObject } from "../../contracts/types.js";
 export type RoutingRule = {
     agentId: string;
     equals?: string[];
@@ -34,7 +34,6 @@ export type ResilienceConfig = {
 export declare function getWorkspaceObject(refs: Map<string, WorkspaceObject | ParsedAgentObject>, ref: string | undefined): WorkspaceObject | undefined;
 export declare function getRuntimeDefaults(refs: Map<string, WorkspaceObject | ParsedAgentObject>): Record<string, unknown> | undefined;
 export declare function getRuntimeMemoryDefaults(refs: Map<string, WorkspaceObject | ParsedAgentObject>): Record<string, unknown> | undefined;
-export declare function getRuntimeModelDefaults(refs: Map<string, WorkspaceObject | ParsedAgentObject>): RuntimeModelRefMap | undefined;
 export declare function getRecoveryConfig(refs: Map<string, WorkspaceObject | ParsedAgentObject>): RecoveryConfig;
 export declare function getConcurrencyConfig(refs: Map<string, WorkspaceObject | ParsedAgentObject>): ConcurrencyConfig;
 export declare function getResilienceConfig(refs: Map<string, WorkspaceObject | ParsedAgentObject>): ResilienceConfig;

package/dist/workspace/support/workspace-ref-utils.js

@@ -36,18 +36,6 @@ export function getRuntimeMemoryDefaults(refs) {
     }
     return runtimeMemories[0].value;
 }
-export function getRuntimeModelDefaults(refs) {
-    const runtimeDefaults = getRuntimeDefaults(refs);
-    const modelRefs = {
-        ...(typeof runtimeDefaults?.planningModelRef === "string" && runtimeDefaults.planningModelRef.trim()
-            ? { planning: runtimeDefaults.planningModelRef.trim() }
-            : {}),
-        ...(typeof runtimeDefaults?.executionModelRef === "string" && runtimeDefaults.executionModelRef.trim()
-            ? { execution: runtimeDefaults.executionModelRef.trim() }
-            : {}),
-    };
-    return Object.keys(modelRefs).length > 0 ? modelRefs : undefined;
-}
 export function getRecoveryConfig(refs) {
     const runtimeDefaults = getRuntimeDefaults(refs);
     const recovery = typeof runtimeDefaults?.recovery === "object" && runtimeDefaults.recovery

package/package.json

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