@botbotgo/agent-harness 0.0.92 → 0.0.94

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

@@ -1,3 +1,3 @@
 export function isRuntimeEntryBinding(binding) {
-    return binding.harnessRuntime.runtimeEntry;
+    return Boolean(binding);
 }

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

@@ -3,7 +3,7 @@ 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, getResilienceConfig, getRuntimeDefaults, getRuntimeMemoryDefaults, getWorkspaceObject, resolvePromptValue, resolveRefId } from "./support/workspace-ref-utils.js";
+import { compileAgentMemories, getResilienceConfig, getRuntimeDefaults, getRuntimeMemoryDefaults, getRuntimeModelDefaults, getWorkspaceObject, 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. " +
     "Do not inspect absolute paths outside the workspace, system directories, or unrelated repos by default. " +
     "Prefer workspace-local tools, relative paths, and the current repository checkout when analyzing code.";
@@ -150,6 +150,15 @@ function isRefConfig(value) {
     }
     return Object.keys(value).every((key) => key === "ref");
 }
+function mergeOpaqueConfig(base, extra) {
+    if (!base && !extra) {
+        return undefined;
+    }
+    return {
+        ...(base ?? {}),
+        ...(extra ?? {}),
+    };
+}
 function materializeWorkspaceObjectConfig(refs, ref, allowedKinds, ownerLabel) {
     const object = getWorkspaceObject(refs, ref);
     if (!object) {
@@ -232,6 +241,81 @@ function resolveRuntimeMemoryConfig(agent, refs) {
     const runtimeMemoryDefaults = getRuntimeMemoryDefaults(refs);
     return runtimeMemoryDefaults ? { config: runtimeMemoryDefaults } : undefined;
 }
+function resolveLangGraphWorkflowConfig(agent, refs) {
+    if (agent.executionMode !== "langgraph") {
+        return undefined;
+    }
+    const profile = typeof agent.langchainAgentConfig?.profile === "string" && agent.langchainAgentConfig.profile.trim()
+        ? agent.langchainAgentConfig.profile.trim()
+        : typeof agent.langchainAgentConfig?.passthrough === "object" &&
+            agent.langchainAgentConfig.passthrough &&
+            typeof agent.langchainAgentConfig.passthrough.profile === "string" &&
+            agent.langchainAgentConfig.passthrough.profile.trim()
+            ? agent.langchainAgentConfig.passthrough.profile.trim()
+            : undefined;
+    const profileWith = typeof agent.langchainAgentConfig?.with === "object" && agent.langchainAgentConfig.with
+        ? { ...agent.langchainAgentConfig.with }
+        : typeof agent.langchainAgentConfig?.passthrough === "object" &&
+            agent.langchainAgentConfig.passthrough &&
+            typeof agent.langchainAgentConfig.passthrough.with === "object" &&
+            agent.langchainAgentConfig.passthrough.with
+            ? { ...agent.langchainAgentConfig.passthrough.with }
+            : undefined;
+    const preset = typeof agent.langchainAgentConfig?.preset === "string" && agent.langchainAgentConfig.preset.trim()
+        ? agent.langchainAgentConfig.preset.trim()
+        : typeof agent.langchainAgentConfig?.passthrough === "object" &&
+            agent.langchainAgentConfig.passthrough &&
+            typeof agent.langchainAgentConfig.passthrough.preset === "string" &&
+            agent.langchainAgentConfig.passthrough.preset.trim()
+            ? agent.langchainAgentConfig.passthrough.preset.trim()
+            : undefined;
+    const workflowConfig = typeof agent.langchainAgentConfig?.workflow === "object" && agent.langchainAgentConfig.workflow
+        ? agent.langchainAgentConfig.workflow
+        : typeof agent.langchainAgentConfig?.langgraph === "object" && agent.langchainAgentConfig.langgraph
+            ? agent.langchainAgentConfig.langgraph
+            : typeof agent.langchainAgentConfig?.passthrough === "object" &&
+                agent.langchainAgentConfig.passthrough &&
+                typeof agent.langchainAgentConfig.passthrough.workflow === "object" &&
+                agent.langchainAgentConfig.passthrough.workflow
+                ? agent.langchainAgentConfig.passthrough.workflow
+                : typeof agent.langchainAgentConfig?.passthrough === "object" &&
+                    agent.langchainAgentConfig.passthrough &&
+                    typeof agent.langchainAgentConfig.passthrough.langgraph === "object" &&
+                    agent.langchainAgentConfig.passthrough.langgraph
+                    ? agent.langchainAgentConfig.passthrough.langgraph
+                    : undefined;
+    if (!workflowConfig) {
+        return profile || preset ? { ...(profile ? { profile } : {}), ...(profileWith ? { with: profileWith } : {}), ...(preset ? { preset } : {}) } : undefined;
+    }
+    if (isRefConfig(workflowConfig)) {
+        return {
+            config: materializeWorkspaceObjectConfig(refs, workflowConfig.ref, ["langgraph-workflow"], `Agent ${agent.id} workflow`),
+            ...(profile ? { profile } : {}),
+            ...(profileWith ? { with: profileWith } : {}),
+            ...(preset ? { preset } : {}),
+        };
+    }
+    return {
+        config: workflowConfig,
+        ...(profile ? { profile } : {}),
+        ...(profileWith ? { with: profileWith } : {}),
+        ...(preset ? { preset } : {}),
+    };
+}
+function resolveRuntimeModelRefs(agent, refs) {
+    const merged = {
+        ...(getRuntimeModelDefaults(refs) ?? {}),
+        ...(agent.runtimeModelRefs ?? {}),
+    };
+    return Object.keys(merged).length > 0 ? merged : undefined;
+}
+function compileRuntimeModels(modelRefs, models, ownerId) {
+    if (!modelRefs) {
+        return undefined;
+    }
+    const compiled = Object.fromEntries(Object.entries(modelRefs).map(([slot, modelRef]) => [slot, requireModel(models, modelRef, ownerId)]));
+    return Object.keys(compiled).length > 0 ? compiled : undefined;
+}
 export function compileBinding(workspaceRoot, agent, agents, referencedSubagentIds, refs, models, tools) {
     const internalSubagent = referencedSubagentIds.has(agent.id);
     const runtimeDefaults = getRuntimeDefaults(refs);
@@ -243,6 +327,9 @@ export function compileBinding(workspaceRoot, agent, agents, referencedSubagentI
     const store = resolveStoreConfig(agent, refs);
     const checkpointer = resolveCheckpointerConfig(agent, refs);
     const runtimeMemory = resolveRuntimeMemoryConfig(agent, refs);
+    const langGraphWorkflow = resolveLangGraphWorkflowConfig(agent, refs);
+    const runtimeModelRefs = resolveRuntimeModelRefs(agent, refs);
+    const runtimeModels = compileRuntimeModels(runtimeModelRefs, models, agent.id);
     const runRoot = typeof agent.runRoot === "string" && agent.runRoot.trim().length > 0
         ? path.resolve(workspaceRoot, agent.runRoot)
         : typeof runtimeDefaults?.runRoot === "string" && runtimeDefaults.runRoot.trim().length > 0
@@ -256,14 +343,19 @@ export function compileBinding(workspaceRoot, agent, agents, referencedSubagentI
                 ? {
                     deepAgent: true,
                 }
-                : {
-                    langchainV1: true,
-                },
+                : agent.executionMode === "langgraph"
+                    ? {
+                        langGraph: true,
+                    }
+                    : {
+                        langchainV1: true,
+                    },
         },
         harnessRuntime: {
             runRoot,
             workspaceRoot,
-            runtimeEntry: !internalSubagent,
+            ...(runtimeModelRefs ? { modelRefs: runtimeModelRefs } : {}),
+            ...(runtimeModels ? { models: runtimeModels } : {}),
             capabilities: inferAgentCapabilities(agent),
             resilience,
             ...(checkpointer ? { checkpointer: checkpointer.config } : {}),
@@ -272,6 +364,13 @@ export function compileBinding(workspaceRoot, agent, agents, referencedSubagentI
         },
     };
     if (agent.executionMode !== "deepagent") {
+        const langGraphPassthrough = agent.executionMode === "langgraph"
+            ? {
+                ...(langGraphWorkflow?.profile ? { profile: langGraphWorkflow.profile } : {}),
+                ...(langGraphWorkflow?.with ? { with: langGraphWorkflow.with } : {}),
+                ...(langGraphWorkflow?.config ? { workflow: langGraphWorkflow.config } : {}),
+            }
+            : undefined;
         const langchainAgentParams = {
             model: compiledAgentModel,
             tools: requireTools(tools, agent.toolRefs, agent.id),
@@ -283,9 +382,9 @@ export function compileBinding(workspaceRoot, agent, agents, referencedSubagentI
                 ? { ...agent.langchainAgentConfig.filesystem }
                 : undefined,
             middleware: compileMiddlewareConfigs(agent.langchainAgentConfig?.middleware, models, agent.id),
-            passthrough: typeof agent.langchainAgentConfig?.passthrough === "object" && agent.langchainAgentConfig.passthrough
+            passthrough: mergeOpaqueConfig(typeof agent.langchainAgentConfig?.passthrough === "object" && agent.langchainAgentConfig.passthrough
                 ? { ...agent.langchainAgentConfig.passthrough }
-                : undefined,
+                : undefined, langGraphPassthrough),
             subagents: agent.subagentRefs.map((ref) => {
                 const subagent = agents.get(resolveRefId(ref));
                 if (!subagent) {
@@ -309,8 +408,12 @@ export function compileBinding(workspaceRoot, agent, agents, referencedSubagentI
         return {
             ...base,
             adapter: {
-                kind: "langchain-v1",
+                kind: agent.executionMode === "langgraph" ? "langgraph" : "langchain-v1",
                 config: {
+                    ...(agent.executionMode === "langgraph" && langGraphWorkflow?.profile ? { profile: langGraphWorkflow.profile } : {}),
+                    ...(agent.executionMode === "langgraph" && langGraphWorkflow?.with ? { with: langGraphWorkflow.with } : {}),
+                    ...(agent.executionMode === "langgraph" && langGraphWorkflow?.preset ? { preset: langGraphWorkflow.preset } : {}),
+                    ...(agent.executionMode === "langgraph" && langGraphWorkflow?.config ? { workflow: langGraphWorkflow.config } : {}),
                     params: langchainAgentParams,
                 },
             },

package/dist/workspace/compile.js

@@ -71,9 +71,7 @@ function compileBindings(workspaceRoot, refs, agentsList, models, tools) {
     return bindings;
 }
 function validateRoutingTargets(refs, agentsList) {
-    const runtimeEntryAgentIds = new Set(agentsList
-        .filter((agent) => !agentsList.some((owner) => owner.subagentRefs.some((ref) => resolveRefId(ref) === agent.id)))
-        .map((agent) => agent.id));
+    const runtimeEntryAgentIds = new Set(agentsList.map((agent) => agent.id));
     const defaultAgentId = getRoutingDefaultAgentId(refs);
     if (defaultAgentId && !runtimeEntryAgentIds.has(defaultAgentId)) {
         throw new Error(`Runtime routing.defaultAgentId references unknown runtime entry agent ${defaultAgentId}`);

package/dist/workspace/object-loader.js

@@ -150,6 +150,8 @@ function normalizeKind(kind) {
             return "runtime";
         case "RuntimeMemory":
             return "runtime-memory";
+        case "LangGraphWorkflow":
+            return "langgraph-workflow";
         case "Prompt":
             return "prompt";
         case "McpServer":
@@ -245,6 +247,29 @@ function readExecutionAgentConfig(item) {
 function readRuntimeConfig(item) {
     return asMutableObject(item.runtime);
 }
+function readRuntimeModelRefs(runtime) {
+    if (!runtime) {
+        return undefined;
+    }
+    const modelRefs = {
+        ...(typeof runtime.routingModelRef === "string" && runtime.routingModelRef.trim()
+            ? { routing: runtime.routingModelRef.trim() }
+            : {}),
+        ...(typeof runtime.planningModelRef === "string" && runtime.planningModelRef.trim()
+            ? { planning: runtime.planningModelRef.trim() }
+            : {}),
+        ...(typeof runtime.executionModelRef === "string" && runtime.executionModelRef.trim()
+            ? { execution: runtime.executionModelRef.trim() }
+            : {}),
+        ...(typeof runtime.reviewModelRef === "string" && runtime.reviewModelRef.trim()
+            ? { review: runtime.reviewModelRef.trim() }
+            : {}),
+        ...(typeof runtime.finalModelRef === "string" && runtime.finalModelRef.trim()
+            ? { final: runtime.finalModelRef.trim() }
+            : {}),
+    };
+    return Object.keys(modelRefs).length > 0 ? modelRefs : undefined;
+}
 function cloneConfigValue(value) {
     if (Array.isArray(value)) {
         return value.map((item) => cloneConfigValue(item));
@@ -301,6 +326,9 @@ function resolveExecutionBackend(item, current) {
     if (backend === "langchain-v1") {
         return "langchain-v1";
     }
+    if (backend === "langgraph") {
+        return "langgraph";
+    }
     if (backend === "deepagent") {
         return "deepagent";
     }
@@ -408,6 +436,7 @@ export function parseAgentItem(item, sourcePath) {
     return {
         id: String(item.id),
         executionMode: executionMode,
+        runtimeModelRefs: readRuntimeModelRefs(runtime),
         capabilities: readCapabilities(item.capabilities) ?? (executionMode === "deepagent"
             ? { delegation: true, memory: true }
             : { delegation: true, memory: true }),
@@ -442,7 +471,9 @@ async function objectItemsFromDocument(document, sourcePath) {
                     ? normalizeCatalogSpec(document, { defaultKind: "Tool" })
                     : catalogKind === "McpServers"
                         ? normalizeCatalogSpec(document, { defaultKind: "McpServer" })
-                        : [];
+                        : catalogKind === "LangGraphWorkflows"
+                            ? normalizeCatalogSpec(document, { defaultKind: "LangGraphWorkflow" })
+                            : [];
     if (catalogItems.length > 0) {
         return catalogItems;
     }
@@ -678,12 +709,22 @@ async function readNamedYamlItems(root, filenames) {
     return records;
 }
 async function readNamedModelItems(root) {
-    const records = [];
+    const filePaths = new Set();
     for (const filename of MODEL_FILENAMES) {
-        const filePath = path.join(root, filename);
-        if (!(await fileExists(filePath))) {
-            continue;
+        const directPath = path.join(root, filename);
+        if (await fileExists(directPath)) {
+            filePaths.add(directPath);
         }
+    }
+    for (const extension of [".yaml", ".yml"]) {
+        for (const filePath of await listFilesRecursive(root, extension)) {
+            if (MODEL_FILENAMES.includes(path.basename(filePath))) {
+                filePaths.add(filePath);
+            }
+        }
+    }
+    const records = [];
+    for (const filePath of [...filePaths].sort()) {
         const parsedDocuments = parseAllDocuments(await readYamlOrJson(filePath));
         for (const parsedDocument of parsedDocuments) {
             for (const item of await objectItemsFromDocument(parsedDocument.toJSON(), filePath)) {

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

@@ -9,8 +9,8 @@ export function inferAgentCapabilities(agent) {
         return normalizeCapabilities(agent.capabilities);
     }
     return {
-        delegation: agent.executionMode === "deepagent" || agent.executionMode === "langchain-v1",
-        memory: agent.executionMode === "deepagent" || agent.executionMode === "langchain-v1",
+        delegation: agent.executionMode === "deepagent" || agent.executionMode === "langchain-v1" || agent.executionMode === "langgraph",
+        memory: agent.executionMode === "deepagent" || agent.executionMode === "langchain-v1" || agent.executionMode === "langgraph",
     };
 }
 export function inferBindingCapabilities(binding) {

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

@@ -1,4 +1,4 @@
-import type { ParsedAgentObject, WorkspaceObject } from "../../contracts/types.js";
+import type { ParsedAgentObject, RuntimeModelRefMap, WorkspaceObject } from "../../contracts/types.js";
 export type RoutingRule = {
     agentId: string;
     equals?: string[];
@@ -34,6 +34,7 @@ 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,6 +36,27 @@ export function getRuntimeMemoryDefaults(refs) {
     }
     return runtimeMemories[0].value;
 }
+export function getRuntimeModelDefaults(refs) {
+    const runtimeDefaults = getRuntimeDefaults(refs);
+    const modelRefs = {
+        ...(typeof runtimeDefaults?.routingModelRef === "string" && runtimeDefaults.routingModelRef.trim()
+            ? { routing: runtimeDefaults.routingModelRef.trim() }
+            : {}),
+        ...(typeof runtimeDefaults?.planningModelRef === "string" && runtimeDefaults.planningModelRef.trim()
+            ? { planning: runtimeDefaults.planningModelRef.trim() }
+            : {}),
+        ...(typeof runtimeDefaults?.executionModelRef === "string" && runtimeDefaults.executionModelRef.trim()
+            ? { execution: runtimeDefaults.executionModelRef.trim() }
+            : {}),
+        ...(typeof runtimeDefaults?.reviewModelRef === "string" && runtimeDefaults.reviewModelRef.trim()
+            ? { review: runtimeDefaults.reviewModelRef.trim() }
+            : {}),
+        ...(typeof runtimeDefaults?.finalModelRef === "string" && runtimeDefaults.finalModelRef.trim()
+            ? { final: runtimeDefaults.finalModelRef.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/dist/workspace/validate.js

@@ -1,5 +1,5 @@
 import { hasAgentSystemPrompt, isDelegationCapableAgent, isMemoryCapableAgent, } from "./support/agent-capabilities.js";
-const allowedExecutionModes = new Set(["deepagent", "langchain-v1"]);
+const allowedExecutionModes = new Set(["deepagent", "langchain-v1", "langgraph"]);
 function validateCheckpointerConfig(agent) {
     const checkpointer = (typeof agent.deepAgentConfig?.checkpointer === "object" && agent.deepAgentConfig.checkpointer) ||
         (typeof agent.deepAgentConfig?.checkpointer === "boolean" ? agent.deepAgentConfig.checkpointer : undefined) ||

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botbotgo/agent-harness",
-  "version": "0.0.92",
+  "version": "0.0.94",
   "description": "Workspace runtime for multi-agent applications",
   "type": "module",
   "packageManager": "npm@10.9.2",
@@ -36,7 +36,7 @@
     "@langchain/community": "^1.1.24",
     "@langchain/core": "^1.1.33",
     "@langchain/google": "^0.1.7",
-    "@langchain/langgraph": "^1.2.5",
+    "@langchain/langgraph": "^1.2.6",
     "@langchain/langgraph-checkpoint-sqlite": "^1.0.1",
     "@langchain/ollama": "^1.2.6",
     "@langchain/openai": "^1.1.0",