@botbotgo/agent-harness 0.0.119 → 0.0.121

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

@@ -1,3 +1,4 @@
+import { attachLegacyExecutionAliases, stripLegacyExecutionAliases } from "../../utils/compiled-binding.js";
 import { asRecord } from "../../utils/object.js";
 const bindingExecutionViewCache = new WeakMap();
 function getLegacyAdapterParams(binding) {
@@ -21,11 +22,11 @@ function inferBindingAdapterKind(binding) {
 function normalizeBindingExecution(binding) {
     const adapterKind = inferBindingAdapterKind(binding);
     if (binding.execution?.kind === "langchain-v1") {
-        binding.langchainAgentParams ??= binding.execution.params;
+        attachLegacyExecutionAliases(binding);
         return { adapterKind, execution: binding.execution };
     }
     if (binding.execution?.kind === "deepagent") {
-        binding.deepAgentParams ??= binding.execution.params;
+        attachLegacyExecutionAliases(binding);
         return { adapterKind, execution: binding.execution };
     }
     if (adapterKind !== "langchain-v1" && adapterKind !== "deepagent") {
@@ -37,6 +38,7 @@ function normalizeBindingExecution(binding) {
             params: binding.langchainAgentParams,
         };
         binding.execution = execution;
+        attachLegacyExecutionAliases(binding);
         return { adapterKind, execution };
     }
     if (binding.deepAgentParams) {
@@ -45,25 +47,26 @@ function normalizeBindingExecution(binding) {
             params: binding.deepAgentParams,
         };
         binding.execution = execution;
+        attachLegacyExecutionAliases(binding);
         return { adapterKind, execution };
     }
     const legacyAdapterParams = getLegacyAdapterParams(binding);
     if (adapterKind === "langchain-v1" && legacyAdapterParams) {
         const params = legacyAdapterParams;
-        binding.langchainAgentParams = params;
         binding.execution = {
             kind: "langchain-v1",
             params,
         };
+        attachLegacyExecutionAliases(binding);
         return { adapterKind, execution: binding.execution };
     }
     if (adapterKind === "deepagent" && legacyAdapterParams) {
         const params = legacyAdapterParams;
-        binding.deepAgentParams = params;
         binding.execution = {
             kind: "deepagent",
             params,
         };
+        attachLegacyExecutionAliases(binding);
         return { adapterKind, execution: binding.execution };
     }
     return { adapterKind };
@@ -75,13 +78,16 @@ function deriveBindingExecutionView(binding) {
     }
     const normalized = normalizeBindingExecution(binding);
     const adapterKind = normalized.adapterKind;
-    const langchainParams = normalized.execution?.kind === "langchain-v1" ? normalized.execution.params : undefined;
-    const deepAgentParams = normalized.execution?.kind === "deepagent" ? normalized.execution.params : undefined;
+    const langchainParams = normalized.execution?.kind === "langchain-v1" ? binding.langchainAgentParams : undefined;
+    const deepAgentParams = normalized.execution?.kind === "deepagent" ? binding.deepAgentParams : undefined;
+    const canonicalLangchainParams = normalized.execution?.kind === "langchain-v1" ? normalized.execution.params : undefined;
+    const canonicalDeepAgentParams = normalized.execution?.kind === "deepagent" ? normalized.execution.params : undefined;
     const primaryTools = langchainParams?.tools ?? deepAgentParams?.tools ?? [];
     const middlewareConfigs = langchainParams?.middleware ?? deepAgentParams?.middleware;
     const middlewareKinds = new Set((middlewareConfigs ?? [])
         .map((entry) => typeof entry.kind === "string" ? entry.kind : "")
         .filter(Boolean));
+    const langchainRuntimeConfig = binding.harnessRuntime?.langchain;
     const view = {
         adapterKind,
         langchainParams,
@@ -93,13 +99,14 @@ function deriveBindingExecutionView(binding) {
         systemPrompt: langchainParams?.systemPrompt ?? deepAgentParams?.systemPrompt,
         middlewareConfigs,
         middlewareKinds,
-        interruptCompatibilityRules: langchainParams?.interruptOn ??
+        interruptCompatibilityRules: langchainRuntimeConfig?.interruptOn ??
+            langchainParams?.interruptOn ??
             deepAgentParams?.interruptOn,
-        storeConfig: deepAgentParams?.store ?? binding.harnessRuntime?.store,
-        langChainSubagentSupport: (langchainParams?.subagents?.length ?? 0) > 0 ||
-            langchainParams?.generalPurposeAgent === true ||
-            Boolean(langchainParams?.taskDescription?.trim()),
-        deepAgentSubagentCount: deepAgentParams?.subagents?.length ?? 0,
+        storeConfig: canonicalDeepAgentParams?.store ?? binding.harnessRuntime?.store,
+        langChainSubagentSupport: (langchainRuntimeConfig?.subagents?.length ?? 0) > 0 ||
+            (langchainRuntimeConfig?.generalPurposeAgent ?? langchainParams?.generalPurposeAgent) === true ||
+            Boolean((langchainRuntimeConfig?.taskDescription ?? langchainParams?.taskDescription)?.trim()),
+        deepAgentSubagentCount: canonicalDeepAgentParams?.subagents?.length ?? 0,
     };
     bindingExecutionViewCache.set(binding, view);
     return view;
@@ -137,48 +144,78 @@ export function withUpdatedBindingExecutionParams(binding, updater) {
     }
     const updatedParams = updater(params);
     if (kind === "langchain-v1") {
-        return {
-            ...binding,
+        return attachLegacyExecutionAliases({
+            ...stripLegacyExecutionAliases(binding),
             execution: {
                 kind,
                 params: updatedParams,
             },
-            langchainAgentParams: updatedParams,
-        };
+        });
     }
-    return {
-        ...binding,
+    return attachLegacyExecutionAliases({
+        ...stripLegacyExecutionAliases(binding),
         execution: {
             kind,
             params: updatedParams,
         },
-        deepAgentParams: updatedParams,
-    };
+    });
 }
 export function getBindingSkills(binding) {
+    const langchainSkills = binding.harnessRuntime?.langchain?.skills;
+    if (Array.isArray(langchainSkills)) {
+        return langchainSkills;
+    }
+    const legacyLangchainSkills = binding.langchainAgentParams?.skills;
+    if (Array.isArray(legacyLangchainSkills)) {
+        return legacyLangchainSkills;
+    }
     const execution = getBindingExecutionParams(binding);
-    return Array.isArray(execution?.skills) ? execution.skills : [];
+    return Array.isArray(execution?.skills)
+        ? (execution.skills)
+        : [];
 }
 export function getBindingMemorySources(binding) {
+    const langchainMemory = binding.harnessRuntime?.langchain?.memory;
+    if (Array.isArray(langchainMemory)) {
+        return langchainMemory;
+    }
+    const legacyLangchainMemory = binding.langchainAgentParams?.memory;
+    if (Array.isArray(legacyLangchainMemory)) {
+        return legacyLangchainMemory;
+    }
     const execution = getBindingExecutionParams(binding);
     return Array.isArray(execution?.memory)
         ? (execution.memory)
         : [];
 }
 export function getBindingSubagents(binding) {
+    const langchainSubagents = binding.harnessRuntime?.langchain?.subagents;
+    if (Array.isArray(langchainSubagents)) {
+        return langchainSubagents;
+    }
+    const legacyLangchainSubagents = binding.langchainAgentParams?.subagents;
+    if (Array.isArray(legacyLangchainSubagents)) {
+        return legacyLangchainSubagents;
+    }
     const execution = getBindingExecutionParams(binding);
     return Array.isArray(execution?.subagents)
         ? (execution.subagents)
         : [];
 }
 export function getBindingGeneralPurposeAgent(binding) {
-    const execution = getBindingExecutionParams(binding);
-    const value = execution?.generalPurposeAgent;
+    const langchainGeneralPurposeAgent = binding.harnessRuntime?.langchain?.generalPurposeAgent;
+    if (typeof langchainGeneralPurposeAgent === "boolean") {
+        return langchainGeneralPurposeAgent;
+    }
+    const value = binding.langchainAgentParams?.generalPurposeAgent;
     return typeof value === "boolean" ? value : undefined;
 }
 export function getBindingTaskDescription(binding) {
-    const execution = getBindingExecutionParams(binding);
-    const value = execution?.taskDescription;
+    const langchainTaskDescription = binding.harnessRuntime?.langchain?.taskDescription;
+    if (typeof langchainTaskDescription === "string" && langchainTaskDescription.trim().length > 0) {
+        return langchainTaskDescription;
+    }
+    const value = binding.langchainAgentParams?.taskDescription;
     return typeof value === "string" && value.trim().length > 0 ? value : undefined;
 }
 export function getBindingBackendConfig(binding) {
@@ -187,8 +224,11 @@ export function getBindingBackendConfig(binding) {
     return typeof backend === "object" && backend ? backend : undefined;
 }
 export function getBindingFilesystemConfig(binding) {
-    const execution = getBindingExecutionParams(binding);
-    const filesystem = execution?.filesystem;
+    const langchainFilesystem = binding.harnessRuntime?.langchain?.filesystem;
+    if (typeof langchainFilesystem === "object" && langchainFilesystem) {
+        return langchainFilesystem;
+    }
+    const filesystem = binding.langchainAgentParams?.filesystem;
     return typeof filesystem === "object" && filesystem ? filesystem : undefined;
 }
 export function isLangChainBinding(binding) {

package/dist/upstream-events.d.ts

@@ -0,0 +1,20 @@
+export type UpstreamTimelineProjection = {
+    type: "thinking";
+    text: string;
+} | {
+    type: "step";
+    step: string;
+    category: "llm" | "tool" | "skill" | "memory" | "chain" | "approval";
+    status: "started" | "completed" | "failed";
+    key: string;
+} | {
+    type: "tool-result";
+    toolName: string;
+    output: unknown;
+    isError?: boolean;
+    key: string;
+};
+export type UpstreamTimelineReducer = {
+    consume: (event: unknown) => UpstreamTimelineProjection[];
+};
+export declare function createUpstreamTimelineReducer(): UpstreamTimelineReducer;

package/dist/upstream-events.js

@@ -0,0 +1,172 @@
+import { extractInterruptPayload, extractReasoningStreamOutput, extractToolResult } from "./runtime/parsing/index.js";
+function asObject(value) {
+    return typeof value === "object" && value !== null ? value : null;
+}
+function readStringArray(value) {
+    return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+function normalizeSegment(value) {
+    return value
+        .replace(/[_-]+/g, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+function titleCase(value) {
+    return normalizeSegment(value)
+        .split(" ")
+        .filter(Boolean)
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join(" ");
+}
+function readEventContext(event) {
+    const typed = asObject(event);
+    return {
+        eventName: typeof typed?.event === 'string' ? typed.event : "",
+        name: typeof typed?.name === 'string' ? typed.name : "",
+        runType: typeof typed?.run_type === 'string' ? typed.run_type : "",
+        tags: readStringArray(typed?.tags),
+        ns: readStringArray(typed?.ns),
+    };
+}
+function containsSemanticHint(values, hint) {
+    return values.some((value) => hint.test(value));
+}
+function classifyStepCategory(context) {
+    const hints = [context.name, context.runType, ...context.tags, ...context.ns].map((value) => value.toLowerCase());
+    if (containsSemanticHint(hints, /\b(skill|skills)\b/)) {
+        return "skill";
+    }
+    if (containsSemanticHint(hints, /\b(memory|recall|store|checkpoint)\b/)) {
+        return "memory";
+    }
+    if (context.eventName.startsWith("on_tool_") || context.runType === "tool") {
+        return "tool";
+    }
+    return "chain";
+}
+function buildStepLabel(category, status, name) {
+    const displayName = titleCase(name || category);
+    if (category === "llm") {
+        return status === "started" ? `Calling LLM ${displayName}` : `Completed LLM ${displayName}`;
+    }
+    if (category === "tool") {
+        if (status === "failed") {
+            return `Tool ${displayName} failed`;
+        }
+        return status === "started" ? `Calling tool ${displayName}` : `Completed tool ${displayName}`;
+    }
+    if (category === "skill") {
+        return status === "started" ? `Calling skill ${displayName}` : `Completed skill ${displayName}`;
+    }
+    if (category === "memory") {
+        return status === "started" ? `Accessing memory ${displayName}` : `Completed memory ${displayName}`;
+    }
+    return status === "started" ? `Running ${displayName}` : `Completed ${displayName}`;
+}
+function createProjectionKey(parts) {
+    return JSON.stringify(parts);
+}
+export function createUpstreamTimelineReducer() {
+    const emittedStepKeys = new Set();
+    const emittedToolResultKeys = new Set();
+    return {
+        consume(event) {
+            const projections = [];
+            const context = readEventContext(event);
+            const reasoning = extractReasoningStreamOutput(event);
+            if (reasoning) {
+                projections.push({
+                    type: "thinking",
+                    text: reasoning,
+                });
+            }
+            const interruptPayload = extractInterruptPayload(event);
+            if (interruptPayload) {
+                const key = createProjectionKey(["approval", context.eventName || "interrupt", interruptPayload]);
+                if (!emittedStepKeys.has(key)) {
+                    emittedStepKeys.add(key);
+                    projections.push({
+                        type: "step",
+                        step: "Waiting for approval",
+                        category: "approval",
+                        status: "started",
+                        key,
+                    });
+                }
+            }
+            if (context.eventName === "on_chat_model_start") {
+                const stepName = context.name || "model";
+                const key = createProjectionKey(["llm", "started", stepName]);
+                if (!emittedStepKeys.has(key)) {
+                    emittedStepKeys.add(key);
+                    projections.push({
+                        type: "step",
+                        step: buildStepLabel("llm", "started", stepName),
+                        category: "llm",
+                        status: "started",
+                        key,
+                    });
+                }
+            }
+            if (context.eventName === "on_tool_start"
+                || (context.eventName === "on_chain_start" && context.runType === "tool")
+                || context.eventName === "on_chain_start") {
+                const category = classifyStepCategory(context);
+                if (category !== "llm") {
+                    const stepName = context.name || context.runType || "chain";
+                    const key = createProjectionKey([category, "started", stepName]);
+                    if (!emittedStepKeys.has(key)) {
+                        emittedStepKeys.add(key);
+                        projections.push({
+                            type: "step",
+                            step: buildStepLabel(category, "started", stepName),
+                            category,
+                            status: "started",
+                            key,
+                        });
+                    }
+                }
+            }
+            const toolResult = extractToolResult(event);
+            if (toolResult) {
+                const resultKey = createProjectionKey(["tool-result", toolResult.toolName, toolResult.output, toolResult.isError === true]);
+                if (!emittedToolResultKeys.has(resultKey)) {
+                    emittedToolResultKeys.add(resultKey);
+                    projections.push({
+                        type: "tool-result",
+                        toolName: toolResult.toolName,
+                        output: toolResult.output,
+                        ...(toolResult.isError !== undefined ? { isError: toolResult.isError } : {}),
+                        key: resultKey,
+                    });
+                }
+                const stepKey = createProjectionKey(["tool", toolResult.isError ? "failed" : "completed", toolResult.toolName]);
+                if (!emittedStepKeys.has(stepKey)) {
+                    emittedStepKeys.add(stepKey);
+                    projections.push({
+                        type: "step",
+                        step: buildStepLabel("tool", toolResult.isError ? "failed" : "completed", toolResult.toolName),
+                        category: "tool",
+                        status: toolResult.isError ? "failed" : "completed",
+                        key: stepKey,
+                    });
+                }
+            }
+            if (context.eventName === "on_chain_end" && context.runType !== "tool" && context.name) {
+                const category = classifyStepCategory(context);
+                const key = createProjectionKey([category, "completed", context.name]);
+                if (!emittedStepKeys.has(key)) {
+                    emittedStepKeys.add(key);
+                    projections.push({
+                        type: "step",
+                        step: buildStepLabel(category, "completed", context.name),
+                        category,
+                        status: "completed",
+                        key,
+                    });
+                }
+            }
+            return projections;
+        },
+    };
+}

package/dist/utils/compiled-binding.d.ts

@@ -0,0 +1,3 @@
+import type { CompiledAgentBinding } from "../contracts/types.js";
+export declare function attachLegacyExecutionAliases(binding: CompiledAgentBinding): CompiledAgentBinding;
+export declare function stripLegacyExecutionAliases(binding: CompiledAgentBinding): CompiledAgentBinding;

package/dist/utils/compiled-binding.js

@@ -0,0 +1,33 @@
+function defineExecutionAlias(binding, property, kind) {
+    if (Object.prototype.hasOwnProperty.call(binding, property)) {
+        return;
+    }
+    Object.defineProperty(binding, property, {
+        configurable: true,
+        enumerable: false,
+        get() {
+            return binding.execution?.kind === kind ? binding.execution.params : undefined;
+        },
+        set(value) {
+            if (value === undefined) {
+                if (binding.execution?.kind === kind) {
+                    delete binding.execution;
+                }
+                return;
+            }
+            binding.execution = {
+                kind,
+                params: value,
+            };
+        },
+    });
+}
+export function attachLegacyExecutionAliases(binding) {
+    defineExecutionAlias(binding, "langchainAgentParams", "langchain-v1");
+    defineExecutionAlias(binding, "deepAgentParams", "deepagent");
+    return binding;
+}
+export function stripLegacyExecutionAliases(binding) {
+    const { langchainAgentParams: _langchainAgentParams, deepAgentParams: _deepAgentParams, ...rest } = binding;
+    return rest;
+}

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

@@ -1,5 +1,6 @@
 import path from "node:path";
 import { getSkillInheritancePolicy, resolveToolTargets } from "../extensions.js";
+import { attachLegacyExecutionAliases } from "../utils/compiled-binding.js";
 import { compileModel, compileTool } from "./resource-compilers.js";
 import { inferAgentCapabilities } from "./support/agent-capabilities.js";
 import { getAgentExecutionConfigValue, getAgentExecutionObject, getAgentExecutionString } from "./support/agent-execution-config.js";
@@ -142,7 +143,6 @@ function compileExecutionCore(agent, models, tools) {
         responseFormat: resolveResponseFormat(agent),
         contextSchema: resolveContextSchema(agent),
         middleware: resolveCompiledMiddleware(agent, models),
-        passthrough: resolvePassthrough(agent),
     };
 }
 function resolveBackendConfig(agent, refs) {
@@ -251,6 +251,7 @@ export function compileBinding(workspaceRoot, agent, agents, referencedSubagentI
         ...agent,
         modelRef: agent.modelRef || (internalSubagent ? "model/default" : ""),
     }, models, tools);
+    const passthrough = resolvePassthrough(agent);
     const compiledAgentModel = executionCore.model;
     const backend = resolveBackendConfig(agent, refs);
     const store = resolveStoreConfig(agent, refs);
@@ -268,6 +269,28 @@ export function compileBinding(workspaceRoot, agent, agents, referencedSubagentI
             workspaceRoot,
             capabilities: inferAgentCapabilities(agent),
             resilience,
+            ...(agent.executionMode === "deepagent"
+                ? {
+                    deepagent: {
+                        description: agent.description,
+                        passthrough,
+                    },
+                }
+                : {}),
+            ...(agent.executionMode === "langchain-v1"
+                ? {
+                    langchain: {
+                        passthrough,
+                        interruptOn: resolveInterruptOn(agent),
+                        filesystem: getAgentExecutionObject(agent, "filesystem", { executionMode: "langchain-v1" }),
+                        subagents: compileSubagents(agent, agents, workspaceRoot, models, tools, compiledAgentSkills, compiledAgentModel),
+                        memory: compiledAgentMemory,
+                        skills: compiledAgentSkills,
+                        generalPurposeAgent: getAgentExecutionConfigValue(agent, "generalPurposeAgent", { executionMode: "langchain-v1" }),
+                        taskDescription: getAgentExecutionString(agent, "taskDescription", { executionMode: "langchain-v1" }),
+                    },
+                }
+                : {}),
             ...(checkpointer ? { checkpointer: checkpointer.config } : {}),
             ...(store ? { store: store.config } : {}),
             ...(runtimeMemory ? { runtimeMemory: runtimeMemory.config } : {}),
@@ -281,18 +304,10 @@ export function compileBinding(workspaceRoot, agent, agents, referencedSubagentI
                 model: executionCore.model,
                 tools: executionCore.tools,
                 systemPrompt: executionCore.systemPrompt,
-                interruptOn: resolveInterruptOn(agent),
                 stateSchema: getAgentExecutionConfigValue(agent, "stateSchema", { executionMode: "langchain-v1" }),
                 responseFormat: executionCore.responseFormat,
                 contextSchema: executionCore.contextSchema,
-                filesystem: getAgentExecutionObject(agent, "filesystem", { executionMode: "langchain-v1" }),
                 middleware: executionCore.middleware,
-                passthrough: executionCore.passthrough,
-                subagents: compileSubagents(agent, agents, workspaceRoot, models, tools, compiledAgentSkills, compiledAgentModel),
-                memory: compiledAgentMemory,
-                skills: compiledAgentSkills,
-                generalPurposeAgent: getAgentExecutionConfigValue(agent, "generalPurposeAgent", { executionMode: "langchain-v1" }),
-                taskDescription: getAgentExecutionString(agent, "taskDescription", { executionMode: "langchain-v1" }),
                 includeAgentName: getAgentExecutionConfigValue(agent, "includeAgentName", { executionMode: "langchain-v1" }) === "inline" ? "inline" : undefined,
                 version: langchainVersion === "v1" || langchainVersion === "v2"
                     ? langchainVersion
@@ -301,11 +316,10 @@ export function compileBinding(workspaceRoot, agent, agents, referencedSubagentI
                 description: agent.description,
             },
         };
-        return {
+        return attachLegacyExecutionAliases({
             ...base,
             execution: executionBinding,
-            langchainAgentParams: executionBinding.params,
-        };
+        });
     }
     const executionBinding = {
         kind: "deepagent",
@@ -316,8 +330,6 @@ export function compileBinding(workspaceRoot, agent, agents, referencedSubagentI
             responseFormat: executionCore.responseFormat,
             contextSchema: executionCore.contextSchema,
             middleware: executionCore.middleware,
-            passthrough: executionCore.passthrough,
-            description: agent.description,
             subagents: compileSubagents(agent, agents, workspaceRoot, models, tools, compiledAgentSkills, compiledAgentModel),
             interruptOn: resolveInterruptOn(agent),
             ...(backend ? { backend: backend.config } : {}),
@@ -327,9 +339,8 @@ export function compileBinding(workspaceRoot, agent, agents, referencedSubagentI
             skills: compiledAgentSkills,
         },
     };
-    return {
+    return attachLegacyExecutionAliases({
         ...base,
         execution: executionBinding,
-        deepAgentParams: executionBinding.params,
-    };
+    });
 }

package/package.json

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