@botbotgo/agent-harness 0.0.119 → 0.0.120

package/dist/contracts/runtime.d.ts

@@ -1,5 +1,6 @@
 import type { RunState } from "./core.js";
 import type { CompiledAgentBinding, CompiledModel, CompiledTool, ParsedAgentObject, ParsedToolObject, WorkspaceBundle } from "./workspace.js";
+import type { CompatibleStreamPart as InternalCompatibleStreamPart, NormalizedUpstreamEvent as InternalNormalizedUpstreamEvent, UpstreamRuntimeEvent as InternalUpstreamRuntimeEvent } from "../runtime/parsing/stream-event-types.js";
 export type ThreadSummary = {
     agentId: string;
     threadId: string;
@@ -85,74 +86,9 @@ export type RunResult = {
     artifacts?: ArtifactRecord[];
     metadata?: Record<string, unknown>;
 };
-export type NormalizedUpstreamEvent = {
-    kind: "text-delta";
-    source: "model" | "state";
-    text: string;
-    ns?: string[];
-    nodeName?: string;
-} | {
-    kind: "reasoning-delta";
-    text: string;
-    ns?: string[];
-    nodeName?: string;
-} | {
-    kind: "tool-start";
-    toolName: string;
-    input?: unknown;
-    ns?: string[];
-    nodeName?: string;
-} | {
-    kind: "tool-end";
-    toolName: string;
-    output?: unknown;
-    isError?: boolean;
-    ns?: string[];
-    nodeName?: string;
-} | {
-    kind: "agent-step";
-    label: string;
-    ns?: string[];
-    nodeName?: string;
-} | {
-    kind: "interrupt";
-    interrupt: unknown;
-    ns?: string[];
-    nodeName?: string;
-} | {
-    kind: "run-event";
-    eventName: string;
-    data?: Record<string, unknown>;
-    ns?: string[];
-    nodeName?: string;
-};
-export type CompatibleStreamPart = {
-    type: "messages";
-    ns: string[];
-    data: [unknown, Record<string, unknown>];
-} | {
-    type: "updates";
-    ns: string[];
-    data: Record<string, unknown>;
-} | {
-    type: "custom";
-    ns: string[];
-    data: unknown;
-};
-export type UpstreamRuntimeEvent = {
-    format: "langgraph-v2";
-    /** @deprecated Prefer streamPart plus raw/event/name/data/ns for upstream-aligned consumption. */
-    normalized: NormalizedUpstreamEvent;
-    streamPart: CompatibleStreamPart;
-    raw: unknown;
-    event?: string;
-    name?: string;
-    runType?: string;
-    data?: Record<string, unknown>;
-    metadata?: Record<string, unknown>;
-    tags?: string[];
-    ns?: string[];
-};
+export type NormalizedUpstreamEvent = InternalNormalizedUpstreamEvent;
+export type CompatibleStreamPart = InternalCompatibleStreamPart;
+export type UpstreamRuntimeEvent = InternalUpstreamRuntimeEvent;
 export type RuntimeListeners = {
     onEvent?: (event: HarnessEvent) => void | Promise<void>;
 };

package/dist/contracts/workspace.d.ts

@@ -146,18 +146,10 @@ export type LangChainAgentParams = {
     model: CompiledModel;
     tools: CompiledTool[];
     systemPrompt?: string;
-    interruptOn?: Record<string, boolean | object>;
     stateSchema?: unknown;
     responseFormat?: unknown;
     contextSchema?: unknown;
-    filesystem?: Record<string, unknown>;
     middleware?: Array<Record<string, unknown>>;
-    passthrough?: Record<string, unknown>;
-    subagents?: CompiledSubAgent[];
-    memory?: string[];
-    skills?: string[];
-    generalPurposeAgent?: boolean;
-    taskDescription?: string;
     includeAgentName?: "inline";
     version?: "v1" | "v2";
     name?: string;
@@ -170,8 +162,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>;
     backend?: Record<string, unknown>;
@@ -180,6 +170,20 @@ export type DeepAgentParams = {
     memory: string[];
     skills: string[];
 };
+export type LegacyLangChainAgentParams = LangChainAgentParams & {
+    passthrough?: Record<string, unknown>;
+    interruptOn?: Record<string, boolean | object>;
+    filesystem?: Record<string, unknown>;
+    subagents?: CompiledSubAgent[];
+    memory?: string[];
+    skills?: string[];
+    generalPurposeAgent?: boolean;
+    taskDescription?: string;
+};
+export type LegacyDeepAgentParams = DeepAgentParams & {
+    description?: string;
+    passthrough?: Record<string, unknown>;
+};
 export type CompiledExecutionBinding = {
     kind: "langchain-v1";
     params: LangChainAgentParams;
@@ -203,17 +207,31 @@ export type CompiledAgentBinding = {
      * Compatibility alias for older tests and callers.
      * Prefer `execution.kind === "langchain-v1"` and `execution.params`.
      */
-    langchainAgentParams?: LangChainAgentParams;
+    langchainAgentParams?: LegacyLangChainAgentParams;
     /**
      * Compatibility alias for older tests and callers.
      * Prefer `execution.kind === "deepagent"` and `execution.params`.
      */
-    deepAgentParams?: DeepAgentParams;
+    deepAgentParams?: LegacyDeepAgentParams;
     harnessRuntime: {
         runRoot: string;
         workspaceRoot?: string;
         capabilities?: RuntimeCapabilities;
         resilience?: Record<string, unknown>;
+        deepagent?: {
+            description?: string;
+            passthrough?: Record<string, unknown>;
+        };
+        langchain?: {
+            passthrough?: Record<string, unknown>;
+            interruptOn?: Record<string, boolean | object>;
+            filesystem?: Record<string, unknown>;
+            subagents?: CompiledSubAgent[];
+            memory?: string[];
+            skills?: string[];
+            generalPurposeAgent?: boolean;
+            taskDescription?: string;
+        };
         checkpointer?: Record<string, unknown> | boolean;
         store?: Record<string, unknown>;
         runtimeMemory?: Record<string, unknown>;

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.118";
+export declare const AGENT_HARNESS_VERSION = "0.0.119";

package/dist/package-version.js

@@ -1 +1 @@
-export const AGENT_HARNESS_VERSION = "0.0.118";
+export const AGENT_HARNESS_VERSION = "0.0.119";

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

@@ -1,6 +1,20 @@
 import { FilesystemBackend } from "deepagents";
 import type { CompiledAgentBinding, CompiledModel, CompiledSubAgent, DeepAgentParams, RuntimeAdapterOptions } from "../../contracts/types.js";
 import type { ExecutableTool } from "./flow/invoke-runtime.js";
+export type LangChainRuntimeExtensionPlan = {
+    includePatchToolCalls: boolean;
+    includeAutomaticSummarization: boolean;
+    context: {
+        skills: string[];
+        memory: string[];
+    };
+    delegation?: {
+        subagents: CompiledSubAgent[];
+        generalPurposeAgent?: boolean;
+        taskDescription?: string;
+        interruptOn?: Record<string, boolean | object>;
+    };
+};
 export type UpstreamSubagentConfig = {
     name: string;
     description: string;
@@ -19,6 +33,7 @@ export declare function buildBuiltinTaskSubagentMiddleware(input: {
     builtinBackend: unknown;
     summarizationModel: unknown;
 }): unknown[];
+export declare function planLangChainRuntimeExtensions(binding: CompiledAgentBinding): LangChainRuntimeExtensionPlan | undefined;
 export declare function resolveBuiltinMiddlewareBackend(input: {
     binding: CompiledAgentBinding;
     runtimeAdapterOptions: RuntimeAdapterOptions;
@@ -70,13 +85,22 @@ export declare function resolveBuiltinMiddlewareTools(input: {
         files?: Record<string, unknown>;
     }) => Promise<unknown>;
 }): Promise<Map<string, ExecutableTool>>;
-export declare function resolveAutomaticSummarizationMiddleware(input: {
+export declare function materializeAutomaticSummarizationMiddleware(input: {
     binding: CompiledAgentBinding;
     createDeclaredMiddlewareResolverOptions: (binding?: CompiledAgentBinding) => unknown;
 }): Promise<unknown[]>;
-export declare function resolveLangChainAutomaticMiddleware(input: {
+export declare function materializeLangChainRuntimeMiddleware(input: {
+    binding: CompiledAgentBinding;
+    plan: LangChainRuntimeExtensionPlan;
+    materializeAutomaticSummarizationMiddleware: (binding: CompiledAgentBinding) => Promise<unknown[]>;
+    resolveFilesystemBackend: (binding: CompiledAgentBinding) => FilesystemBackend;
+    resolveModel: (model: CompiledModel) => Promise<unknown>;
+    resolveTools: (tools: Parameters<DeepAgentParams["tools"]["slice"]>[0] extends never ? never : any, binding?: CompiledAgentBinding) => unknown[];
+    resolveSubagents: (subagents: CompiledSubAgent[], binding?: CompiledAgentBinding) => Promise<UpstreamSubagentConfig[]>;
+}): Promise<unknown[]>;
+export declare function resolveLangChainRuntimeExtensionMiddleware(input: {
     binding: CompiledAgentBinding;
-    resolveAutomaticSummarizationMiddleware: (binding: CompiledAgentBinding) => Promise<unknown[]>;
+    materializeAutomaticSummarizationMiddleware: (binding: CompiledAgentBinding) => Promise<unknown[]>;
     resolveFilesystemBackend: (binding: CompiledAgentBinding) => FilesystemBackend;
     resolveModel: (model: CompiledModel) => Promise<unknown>;
     resolveTools: (tools: Parameters<DeepAgentParams["tools"]["slice"]>[0] extends never ? never : any, binding?: CompiledAgentBinding) => unknown[];
@@ -89,5 +113,5 @@ export declare function resolveMiddleware(input: {
     }>;
     runtimeAdapterOptions: RuntimeAdapterOptions;
     createDeclaredMiddlewareResolverOptions: (binding?: CompiledAgentBinding) => unknown;
-    resolveLangChainAutomaticMiddleware: (binding: CompiledAgentBinding) => Promise<unknown[]>;
+    resolveLangChainRuntimeExtensionMiddleware: (binding: CompiledAgentBinding) => Promise<unknown[]>;
 }): Promise<unknown[]>;

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

@@ -62,6 +62,36 @@ function resolveLangChainDelegationCompatibility(params) {
         taskDescription: params.taskDescription,
     });
 }
+export function planLangChainRuntimeExtensions(binding) {
+    const primaryModel = getBindingPrimaryModel(binding);
+    if (!isLangChainBinding(binding) || !primaryModel) {
+        return undefined;
+    }
+    const skills = getBindingSkills(binding);
+    const memory = getBindingMemorySources(binding);
+    const delegationCompatibility = resolveLangChainDelegationCompatibility({
+        model: primaryModel,
+        subagents: getBindingSubagents(binding),
+        generalPurposeAgent: getBindingGeneralPurposeAgent(binding),
+        taskDescription: getBindingTaskDescription(binding),
+    });
+    return {
+        includePatchToolCalls: !bindingHasMiddlewareKind(binding, "patchToolCalls"),
+        includeAutomaticSummarization: !bindingHasMiddlewareKind(binding, "summarization"),
+        context: {
+            skills,
+            memory,
+        },
+        delegation: bindingHasLangChainSubagentSupport(binding)
+            ? {
+                subagents: delegationCompatibility.subagents ?? [],
+                generalPurposeAgent: delegationCompatibility.generalPurposeAgent,
+                taskDescription: delegationCompatibility.taskDescription,
+                interruptOn: getBindingInterruptCompatibilityRules(binding),
+            }
+            : undefined,
+    };
+}
 export function resolveBuiltinMiddlewareBackend(input) {
     const runtimeState = {
         ...(input.options?.state ?? {}),
@@ -154,57 +184,62 @@ export async function resolveBuiltinMiddlewareTools(input) {
             : undefined,
     });
 }
-export async function resolveAutomaticSummarizationMiddleware(input) {
-    if (bindingHasMiddlewareKind(input.binding, "summarization")) {
-        return [];
-    }
+export async function materializeAutomaticSummarizationMiddleware(input) {
     const primaryModel = getBindingPrimaryModel(input.binding);
     if (!primaryModel) {
         return [];
     }
     return resolveDeclaredMiddleware([{ kind: "summarization", model: primaryModel }], input.createDeclaredMiddlewareResolverOptions(input.binding));
 }
-export async function resolveLangChainAutomaticMiddleware(input) {
+export async function materializeLangChainRuntimeMiddleware(input) {
     const primaryModel = getBindingPrimaryModel(input.binding);
     const primaryTools = getBindingPrimaryTools(input.binding);
-    if (!isLangChainBinding(input.binding) || !primaryModel) {
+    if (!primaryModel) {
         return [];
     }
-    const delegationCompatibility = resolveLangChainDelegationCompatibility({
-        model: primaryModel,
-        subagents: getBindingSubagents(input.binding),
-        generalPurposeAgent: getBindingGeneralPurposeAgent(input.binding),
-        taskDescription: getBindingTaskDescription(input.binding),
-    });
-    const automaticMiddleware = [];
-    automaticMiddleware.push(createPatchToolCallsMiddleware());
-    automaticMiddleware.push(...(await input.resolveAutomaticSummarizationMiddleware(input.binding)));
-    automaticMiddleware.push(...buildLangChainContextMiddleware({
+    const runtimeMiddleware = [];
+    if (input.plan.includePatchToolCalls) {
+        runtimeMiddleware.push(createPatchToolCallsMiddleware());
+    }
+    if (input.plan.includeAutomaticSummarization) {
+        runtimeMiddleware.push(...(await input.materializeAutomaticSummarizationMiddleware(input.binding)));
+    }
+    runtimeMiddleware.push(...buildLangChainContextMiddleware({
         binding: input.binding,
-        skills: getBindingSkills(input.binding),
-        memory: getBindingMemorySources(input.binding),
+        skills: input.plan.context.skills,
+        memory: input.plan.context.memory,
         resolveFilesystemBackend: input.resolveFilesystemBackend,
     }));
-    if (bindingHasLangChainSubagentSupport(input.binding)) {
-        automaticMiddleware.push(createSubAgentMiddleware({
+    if (input.plan.delegation) {
+        runtimeMiddleware.push(createSubAgentMiddleware({
             defaultModel: (await input.resolveModel(primaryModel)),
             defaultTools: input.resolveTools(primaryTools, input.binding),
-            defaultInterruptOn: getBindingInterruptCompatibilityRules(input.binding),
-            subagents: (await input.resolveSubagents(delegationCompatibility.subagents ?? [], input.binding)),
-            generalPurposeAgent: delegationCompatibility.generalPurposeAgent,
-            taskDescription: delegationCompatibility.taskDescription ?? null,
+            defaultInterruptOn: input.plan.delegation.interruptOn,
+            subagents: (await input.resolveSubagents(input.plan.delegation.subagents, input.binding)),
+            generalPurposeAgent: input.plan.delegation.generalPurposeAgent,
+            taskDescription: input.plan.delegation.taskDescription ?? null,
         }));
     }
-    return automaticMiddleware;
+    return runtimeMiddleware;
+}
+export async function resolveLangChainRuntimeExtensionMiddleware(input) {
+    const plan = planLangChainRuntimeExtensions(input.binding);
+    if (!plan) {
+        return [];
+    }
+    return materializeLangChainRuntimeMiddleware({
+        ...input,
+        plan,
+    });
 }
 export async function resolveMiddleware(input) {
-    const declarativeMiddleware = await resolveDeclaredMiddleware(getBindingMiddlewareConfigs(input.binding), input.createDeclaredMiddlewareResolverOptions(input.binding));
-    const automaticMiddleware = isLangChainBinding(input.binding)
-        ? await input.resolveLangChainAutomaticMiddleware(input.binding)
+    const declarativeUpstreamMiddleware = await resolveDeclaredMiddleware(getBindingMiddlewareConfigs(input.binding), input.createDeclaredMiddlewareResolverOptions(input.binding));
+    const runtimeExtensionMiddleware = isLangChainBinding(input.binding)
+        ? await input.resolveLangChainRuntimeExtensionMiddleware(input.binding)
         : [];
     const middleware = [
-        ...declarativeMiddleware,
-        ...automaticMiddleware,
+        ...declarativeUpstreamMiddleware,
+        ...runtimeExtensionMiddleware,
         ...(input.runtimeAdapterOptions.middlewareResolver ? input.runtimeAdapterOptions.middlewareResolver(input.binding) : []),
     ];
     if (input.interruptOn && Object.keys(input.interruptOn).length > 0) {

package/dist/runtime/adapter/stream-event-projection.js

@@ -1,6 +1,108 @@
 import { sanitizeVisibleText } from "../parsing/output-parsing.js";
-import { computeIncrementalOutput, extractAgentStep, extractInterruptPayload, extractReasoningStreamOutput, extractStateStreamOutput, extractTerminalStreamOutput, extractToolResult, extractVisibleStreamOutput, normalizeTerminalOutputKey, normalizeUpstreamRuntimeEvent, } from "../parsing/stream-event-parsing.js";
+import { computeIncrementalOutput, extractInterruptPayload, extractReasoningStreamOutput, extractStateStreamOutput, extractTerminalStreamOutput, extractToolResult, extractVisibleStreamOutput, normalizeTerminalOutputKey, normalizeUpstreamRuntimeEvent, } from "../parsing/stream-event-parsing.js";
 import { resolveModelFacingToolName } from "./tool/tool-name-mapping.js";
+function formatStepValue(value, maxLength = 120) {
+    if (value == null)
+        return "";
+    const normalized = typeof value === "string"
+        ? parseMaybeJson(value)
+        : value;
+    const summarized = summarizeStepValue(normalized);
+    const serialized = typeof summarized === "string"
+        ? summarized
+        : (() => {
+            try {
+                return JSON.stringify(summarized);
+            }
+            catch {
+                return String(summarized);
+            }
+        })();
+    return serialized.length > maxLength ? serialized.slice(0, maxLength) + "…" : serialized;
+}
+function parseMaybeJson(value) {
+    const trimmed = value.trim();
+    if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) {
+        return value;
+    }
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        return value;
+    }
+}
+function summarizeStepValue(value) {
+    if (typeof value !== "object" || !value) {
+        return value;
+    }
+    const record = value;
+    if (typeof record.url === "string" && typeof record.status === "number") {
+        const warnings = Array.isArray(record.warnings) ? record.warnings.filter((item) => typeof item === "string") : [];
+        return {
+            status: record.status,
+            ok: record.ok,
+            quality: record.quality,
+            source: record.source,
+            warnings,
+        };
+    }
+    return value;
+}
+function humanizeEventName(name) {
+    return name.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[._-]+/g, " ").replace(/\s+/g, " ").trim().toLowerCase();
+}
+function deriveAgentStep(event) {
+    if (typeof event !== "object" || !event)
+        return null;
+    const typed = event;
+    const name = typeof typed.name === "string" ? typed.name : "";
+    if (typed.event === "on_tool_start" || (typed.event === "on_chain_start" && typed.run_type === "tool")) {
+        const inputSummary = formatStepValue(typed.data?.input);
+        return inputSummary ? `tool ${name || "tool"}  ${inputSummary}` : `tool ${name || "tool"}`;
+    }
+    if (typed.event === "on_tool_end" || (typed.event === "on_chain_end" && typed.run_type === "tool")) {
+        const outputSummary = formatStepValue(typed.data?.output, 80);
+        return outputSummary ? `tool ${name || "tool"} done  ${outputSummary}` : `tool ${name || "tool"} done`;
+    }
+    if (typed.event === "on_tool_error" || (typed.event === "on_chain_error" && typed.run_type === "tool")) {
+        const errorSummary = formatStepValue(typed.data?.error ?? typed.data?.output, 80);
+        return errorSummary ? `tool ${name || "tool"} error  ${errorSummary}` : `tool ${name || "tool"} error`;
+    }
+    if (typed.event === "on_chat_model_start") {
+        const inputTools = typed.data?.input?.tools;
+        const tools = typed.invocation_params?.tools ?? inputTools ?? [];
+        const toolNames = tools.map((tool) => tool.name ?? tool.function?.name).filter((toolName) => typeof toolName === "string").join(", ");
+        return toolNames ? `calling model  tools: [${toolNames}]` : "calling model…";
+    }
+    if (typed.event === "on_chain_start") {
+        if (/SkillsMiddleware/i.test(name))
+            return "loading skills…";
+        if (/MemoryMiddleware/i.test(name))
+            return "loading memory…";
+        if (/patchToolCallsMiddleware/i.test(name))
+            return "normalizing tool calls…";
+        if (/HumanInTheLoopMiddleware/i.test(name))
+            return "checking approvals…";
+        if (/todoListMiddleware/i.test(name))
+            return "updating plan…";
+        if (/model_request/i.test(name))
+            return "preparing model request…";
+        if (/RunnableLambda/i.test(name) || /^__start__$/.test(name))
+            return null;
+        if (/(subagent|specialist)/i.test(name))
+            return `starting ${humanizeEventName(name)}…`;
+        if (/agent$/i.test(name))
+            return `running ${humanizeEventName(name)}…`;
+    }
+    if (typed.event === "on_chain_end") {
+        if (/(subagent|specialist)/i.test(name))
+            return `${humanizeEventName(name)} done`;
+        if (/agent$/i.test(name) && !/^__start__$/.test(name))
+            return `${humanizeEventName(name)} done`;
+    }
+    return null;
+}
 export function createStreamEventProjectionState() {
     return {
         emittedOutput: "",
@@ -45,7 +147,7 @@ export function projectRuntimeStreamEvent(params) {
             }
         }
     }
-    const agentStep = extractAgentStep(event);
+    const agentStep = deriveAgentStep(event);
     if (agentStep && agentStep !== state.lastStep) {
         state.lastStep = agentStep;
         chunks.push({ kind: "step", content: agentStep });

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

@@ -62,8 +62,8 @@ export declare class AgentRuntimeAdapter {
     private createAssemblyResolvers;
     private invokeBuiltinTaskTool;
     private resolveBuiltinMiddlewareTools;
-    private resolveAutomaticSummarizationMiddleware;
-    private resolveLangChainAutomaticMiddleware;
+    private materializeAutomaticSummarizationMiddleware;
+    private resolveLangChainRuntimeExtensionMiddleware;
     private resolveMiddleware;
     private resolveSubagents;
     private createLangChainRunnable;

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

@@ -8,7 +8,7 @@ import { buildToolNameMapping, } from "./adapter/tool/tool-name-mapping.js";
 import { executeRuntimeInvocation } from "./adapter/flow/invocation-flow.js";
 import { streamRuntimeExecution } from "./adapter/flow/stream-runtime.js";
 import { applyStrictToolJsonInstruction as applyStrictToolJsonInstructionHelper, callRuntimeWithToolParseRecovery as callRuntimeWithToolParseRecoveryHelper, createModelFallbackRunnable as createModelFallbackRunnableHelper, invokeWithProviderRetry as invokeWithProviderRetryHelper, iterateWithTimeout as iterateWithTimeoutHelper, materializeModelStream as materializeModelStreamHelper, RuntimeOperationTimeoutError, withRuntimeTimeout, } from "./adapter/runtime-shell.js";
-import { invokeBuiltinTaskTool as invokeBuiltinTaskToolHelper, resolveAutomaticSummarizationMiddleware as resolveAutomaticSummarizationMiddlewareHelper, resolveBuiltinMiddlewareBackend as resolveBuiltinMiddlewareBackendHelper, resolveBuiltinMiddlewareTools as resolveBuiltinMiddlewareToolsHelper, resolveLangChainAutomaticMiddleware as resolveLangChainAutomaticMiddlewareHelper, resolveMiddleware as resolveMiddlewareHelper, resolveSubagents as resolveSubagentsHelper, } from "./adapter/middleware-assembly.js";
+import { invokeBuiltinTaskTool as invokeBuiltinTaskToolHelper, materializeAutomaticSummarizationMiddleware as materializeAutomaticSummarizationMiddlewareHelper, resolveBuiltinMiddlewareBackend as resolveBuiltinMiddlewareBackendHelper, resolveBuiltinMiddlewareTools as resolveBuiltinMiddlewareToolsHelper, resolveLangChainRuntimeExtensionMiddleware as resolveLangChainRuntimeExtensionMiddlewareHelper, resolveMiddleware as resolveMiddlewareHelper, resolveSubagents as resolveSubagentsHelper, } from "./adapter/middleware-assembly.js";
 import { computeRemainingTimeoutMs, resolveBindingTimeout, resolveStreamIdleTimeout, } from "./adapter/resilience.js";
 import { createResolvedModel } from "./adapter/model/model-providers.js";
 import { compileInterruptOn } from "./adapter/tool/interrupt-policy.js";
@@ -37,20 +37,16 @@ export function resolveRunnableCheckpointer(options, binding) {
 export function resolveRunnableInterruptOn(binding) {
     return compileInterruptOn(getBindingPrimaryTools(binding), getBindingInterruptCompatibilityRules(binding));
 }
-function buildUpstreamCreateBaseParams(binding, compileOnlyFields) {
+function buildUpstreamCreateBaseParams(binding, supportedFields) {
     const executionParams = getBindingExecutionParams(binding);
     if (!executionParams) {
         throw new Error(`Agent ${binding.agent.id} has no compiled execution params`);
     }
     const source = executionParams;
-    const passthrough = typeof source.passthrough === "object" && source.passthrough
-        ? source.passthrough
-        : undefined;
-    const stripped = Object.fromEntries(Object.entries(source).filter(([key]) => key !== "passthrough" && !compileOnlyFields.includes(key)));
-    return {
-        ...(passthrough ?? {}),
-        ...stripped,
-    };
+    const upstreamParams = Object.fromEntries(supportedFields
+        .filter((key) => key in source && source[key] !== undefined)
+        .map((key) => [key, source[key]]));
+    return upstreamParams;
 }
 export function buildLangChainCreateParams(input) {
     const executionKind = getBindingExecutionKind(input.binding);
@@ -61,17 +57,29 @@ export function buildLangChainCreateParams(input) {
     const upstreamParams = buildUpstreamCreateBaseParams(input.binding, [
         "model",
         "tools",
+        "systemPrompt",
+        "stateSchema",
+        "contextSchema",
+        "checkpointer",
+        "store",
+        "responseFormat",
         "middleware",
-        "interruptOn",
-        "filesystem",
-        "subagents",
-        "memory",
-        "skills",
-        "generalPurposeAgent",
-        "taskDescription",
+        "name",
+        "description",
+        "includeAgentName",
+        "version",
     ]);
+    const legacyPassthrough = typeof input.binding.langchainAgentParams?.passthrough === "object" &&
+        input.binding.langchainAgentParams?.passthrough
+        ? input.binding.langchainAgentParams.passthrough
+        : undefined;
+    const langchainPassthrough = typeof input.binding.harnessRuntime.langchain?.passthrough === "object" && input.binding.harnessRuntime.langchain?.passthrough
+        ? input.binding.harnessRuntime.langchain.passthrough
+        : undefined;
     return {
         ...upstreamParams,
+        ...(legacyPassthrough ?? {}),
+        ...(langchainPassthrough ?? {}),
         ...(input.passthroughOverride ?? {}),
         systemPrompt: input.systemPromptOverride ?? executionParams.systemPrompt,
         model: input.resolvedModel,
@@ -89,16 +97,18 @@ export function buildDeepAgentCreateParams(input) {
     const upstreamParams = buildUpstreamCreateBaseParams(input.binding, [
         "model",
         "tools",
+        "systemPrompt",
         "middleware",
         "subagents",
+        "responseFormat",
+        "contextSchema",
+        "checkpointer",
+        "store",
+        "backend",
         "interruptOn",
+        "name",
+        "memory",
         "skills",
-        "backend",
-        "store",
-        // These do not belong to DeepAgents top-level create params even if
-        // compatibility fixtures stuff them into compiled deepagent params.
-        "generalPurposeAgent",
-        "taskDescription",
     ]);
     return {
         ...upstreamParams,
@@ -255,18 +265,18 @@ export class AgentRuntimeAdapter {
             invokeBuiltinTaskTool: assembly.invokeBuiltinTaskTool,
         });
     }
-    async resolveAutomaticSummarizationMiddleware(binding) {
+    async materializeAutomaticSummarizationMiddleware(binding) {
         const assembly = this.createAssemblyResolvers(binding);
-        return resolveAutomaticSummarizationMiddlewareHelper({
+        return materializeAutomaticSummarizationMiddlewareHelper({
             binding,
             createDeclaredMiddlewareResolverOptions: assembly.createDeclaredMiddlewareResolverOptions,
         });
     }
-    async resolveLangChainAutomaticMiddleware(binding) {
+    async resolveLangChainRuntimeExtensionMiddleware(binding) {
         const assembly = this.createAssemblyResolvers(binding);
-        return resolveLangChainAutomaticMiddlewareHelper({
+        return resolveLangChainRuntimeExtensionMiddlewareHelper({
             binding,
-            resolveAutomaticSummarizationMiddleware: (currentBinding) => this.resolveAutomaticSummarizationMiddleware(currentBinding),
+            materializeAutomaticSummarizationMiddleware: (currentBinding) => this.materializeAutomaticSummarizationMiddleware(currentBinding),
             resolveFilesystemBackend: assembly.resolveFilesystemBackend,
             resolveModel: assembly.resolveModel,
             resolveTools: assembly.resolveTools,
@@ -280,7 +290,7 @@ export class AgentRuntimeAdapter {
             interruptOn,
             runtimeAdapterOptions: this.options,
             createDeclaredMiddlewareResolverOptions: assembly.createDeclaredMiddlewareResolverOptions,
-            resolveLangChainAutomaticMiddleware: (currentBinding) => this.resolveLangChainAutomaticMiddleware(currentBinding),
+            resolveLangChainRuntimeExtensionMiddleware: (currentBinding) => this.resolveLangChainRuntimeExtensionMiddleware(currentBinding),
         });
     }
     async resolveSubagents(subagents, binding) {

package/dist/runtime/parsing/index.d.ts

@@ -1,2 +1,3 @@
 export { extractReasoningText, extractToolFallbackContext, extractVisibleOutput, hasToolCalls, isLikelyToolArgsObject, readTextContent, sanitizeVisibleText, tryParseJson, wrapResolvedModel, } from "./output-parsing.js";
-export { extractAgentStep, extractInterruptPayload, extractReasoningStreamOutput, extractTerminalStreamOutput, extractToolResult, normalizeTerminalOutputKey, readStreamDelta, type RuntimeStreamChunk, } from "./stream-event-parsing.js";
+export { extractInterruptPayload, extractReasoningStreamOutput, extractTerminalStreamOutput, extractToolResult, normalizeTerminalOutputKey, readStreamDelta, type RuntimeStreamChunk, } from "./stream-event-parsing.js";
+export type { CompatibleStreamPart, NormalizedUpstreamEvent, UpstreamRuntimeEvent, } from "./stream-event-types.js";

package/dist/runtime/parsing/index.js

@@ -1,2 +1,2 @@
 export { extractReasoningText, extractToolFallbackContext, extractVisibleOutput, hasToolCalls, isLikelyToolArgsObject, readTextContent, sanitizeVisibleText, tryParseJson, wrapResolvedModel, } from "./output-parsing.js";
-export { extractAgentStep, extractInterruptPayload, extractReasoningStreamOutput, extractTerminalStreamOutput, extractToolResult, normalizeTerminalOutputKey, readStreamDelta, } from "./stream-event-parsing.js";
+export { extractInterruptPayload, extractReasoningStreamOutput, extractTerminalStreamOutput, extractToolResult, normalizeTerminalOutputKey, readStreamDelta, } from "./stream-event-parsing.js";

package/dist/runtime/parsing/stream-event-parsing.d.ts

@@ -1,4 +1,4 @@
-import type { CompatibleStreamPart, UpstreamRuntimeEvent } from "../../contracts/types.js";
+import type { CompatibleStreamPart, UpstreamRuntimeEvent } from "./stream-event-types.js";
 export type RuntimeStreamChunk = {
     kind: "upstream-event";
     event: UpstreamRuntimeEvent;
@@ -26,7 +26,6 @@ export declare function extractTerminalStreamOutput(event: unknown): string;
 export declare function extractReasoningStreamOutput(event: unknown): string;
 export declare function extractVisibleStreamOutput(event: unknown): string;
 export declare function extractStateStreamOutput(event: unknown): string;
-export declare function extractAgentStep(event: unknown): string | null;
 export declare function extractToolResult(event: unknown): {
     toolName: string;
     output: unknown;

package/dist/runtime/parsing/stream-event-parsing.js

@@ -129,15 +129,6 @@ function normalizeUpstreamEventShape(event) {
             ...(nodeName ? { nodeName } : {}),
         };
     }
-    const agentStep = extractAgentStep(event.raw);
-    if (agentStep) {
-        return {
-            kind: "agent-step",
-            label: agentStep,
-            ...(ns && ns.length > 0 ? { ns } : {}),
-            ...(nodeName ? { nodeName } : {}),
-        };
-    }
     return {
         kind: "run-event",
         eventName: event.event ?? "unknown",
@@ -230,25 +221,6 @@ export function extractCustomCompatibleStreamPart(event) {
         data: custom.data,
     };
 }
-function formatStepValue(value, maxLength = 120) {
-    if (value == null)
-        return "";
-    const normalized = typeof value === "string"
-        ? parseMaybeJson(value)
-        : value;
-    const summarized = summarizeStepValue(normalized);
-    const serialized = typeof summarized === "string"
-        ? summarized
-        : (() => {
-            try {
-                return JSON.stringify(summarized);
-            }
-            catch {
-                return String(summarized);
-            }
-        })();
-    return serialized.length > maxLength ? serialized.slice(0, maxLength) + "…" : serialized;
-}
 function parseMaybeJson(value) {
     const trimmed = value.trim();
     if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) {
@@ -261,26 +233,6 @@ function parseMaybeJson(value) {
         return value;
     }
 }
-function summarizeStepValue(value) {
-    if (typeof value !== "object" || !value) {
-        return value;
-    }
-    const record = value;
-    if (typeof record.url === "string" && typeof record.status === "number") {
-        const warnings = Array.isArray(record.warnings) ? record.warnings.filter((item) => typeof item === "string") : [];
-        return {
-            status: record.status,
-            ok: record.ok,
-            quality: record.quality,
-            source: record.source,
-            warnings,
-        };
-    }
-    return value;
-}
-function humanizeEventName(name) {
-    return name.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[._-]+/g, " ").replace(/\s+/g, " ").trim().toLowerCase();
-}
 function readToolErrorText(value) {
     if (typeof value === "string") {
         return value;
@@ -352,57 +304,6 @@ export function extractStateStreamOutput(event) {
     }
     return extractVisibleOutput(chunk);
 }
-export function extractAgentStep(event) {
-    if (typeof event !== "object" || !event)
-        return null;
-    const typed = event;
-    const name = typeof typed.name === "string" ? typed.name : "";
-    if (typed.event === "on_tool_start" || (typed.event === "on_chain_start" && typed.run_type === "tool")) {
-        const inputSummary = formatStepValue(typed.data?.input);
-        return inputSummary ? `tool ${name || "tool"}  ${inputSummary}` : `tool ${name || "tool"}`;
-    }
-    if (typed.event === "on_tool_end" || (typed.event === "on_chain_end" && typed.run_type === "tool")) {
-        const outputSummary = formatStepValue(typed.data?.output, 80);
-        return outputSummary ? `tool ${name || "tool"} done  ${outputSummary}` : `tool ${name || "tool"} done`;
-    }
-    if (typed.event === "on_tool_error" || (typed.event === "on_chain_error" && typed.run_type === "tool")) {
-        const errorSummary = formatStepValue(typed.data?.error ?? typed.data?.output, 80);
-        return errorSummary ? `tool ${name || "tool"} error  ${errorSummary}` : `tool ${name || "tool"} error`;
-    }
-    if (typed.event === "on_chat_model_start") {
-        const inputTools = typed.data?.input?.tools;
-        const tools = typed.invocation_params?.tools ?? inputTools ?? [];
-        const toolNames = tools.map((tool) => tool.name ?? tool.function?.name).filter((toolName) => typeof toolName === "string").join(", ");
-        return toolNames ? `calling model  tools: [${toolNames}]` : "calling model…";
-    }
-    if (typed.event === "on_chain_start") {
-        if (/SkillsMiddleware/i.test(name))
-            return "loading skills…";
-        if (/MemoryMiddleware/i.test(name))
-            return "loading memory…";
-        if (/patchToolCallsMiddleware/i.test(name))
-            return "normalizing tool calls…";
-        if (/HumanInTheLoopMiddleware/i.test(name))
-            return "checking approvals…";
-        if (/todoListMiddleware/i.test(name))
-            return "updating plan…";
-        if (/model_request/i.test(name))
-            return "preparing model request…";
-        if (/RunnableLambda/i.test(name) || /^__start__$/.test(name))
-            return null;
-        if (/(subagent|specialist)/i.test(name))
-            return `starting ${humanizeEventName(name)}…`;
-        if (/agent$/i.test(name))
-            return `running ${humanizeEventName(name)}…`;
-    }
-    if (typed.event === "on_chain_end") {
-        if (/(subagent|specialist)/i.test(name))
-            return `${humanizeEventName(name)} done`;
-        if (/agent$/i.test(name) && !/^__start__$/.test(name))
-            return `${humanizeEventName(name)} done`;
-    }
-    return null;
-}
 export function extractToolResult(event) {
     if (typeof event !== "object" || !event)
         return null;

package/dist/runtime/parsing/stream-event-types.d.ts

@@ -0,0 +1,62 @@
+export type NormalizedUpstreamEvent = {
+    kind: "text-delta";
+    source: "model" | "state";
+    text: string;
+    ns?: string[];
+    nodeName?: string;
+} | {
+    kind: "reasoning-delta";
+    text: string;
+    ns?: string[];
+    nodeName?: string;
+} | {
+    kind: "tool-start";
+    toolName: string;
+    input?: unknown;
+    ns?: string[];
+    nodeName?: string;
+} | {
+    kind: "tool-end";
+    toolName: string;
+    output?: unknown;
+    isError?: boolean;
+    ns?: string[];
+    nodeName?: string;
+} | {
+    kind: "interrupt";
+    interrupt: unknown;
+    ns?: string[];
+    nodeName?: string;
+} | {
+    kind: "run-event";
+    eventName: string;
+    data?: Record<string, unknown>;
+    ns?: string[];
+    nodeName?: string;
+};
+export type CompatibleStreamPart = {
+    type: "messages";
+    ns: string[];
+    data: [unknown, Record<string, unknown>];
+} | {
+    type: "updates";
+    ns: string[];
+    data: Record<string, unknown>;
+} | {
+    type: "custom";
+    ns: string[];
+    data: unknown;
+};
+export type UpstreamRuntimeEvent = {
+    format: "langgraph-v2";
+    normalized: NormalizedUpstreamEvent;
+    streamPart: CompatibleStreamPart;
+    raw: unknown;
+    event?: string;
+    name?: string;
+    runType?: string;
+    data?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+    tags?: string[];
+    ns?: string[];
+};

package/dist/runtime/parsing/stream-event-types.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/support/compiled-binding.d.ts

@@ -1,8 +1,8 @@
-import type { CompiledAgentBinding, CompiledExecutionBinding, CompiledModel, CompiledSubAgent, CompiledTool, DeepAgentParams, LangChainAgentParams } from "../../contracts/types.js";
+import type { CompiledAgentBinding, CompiledExecutionBinding, CompiledModel, CompiledSubAgent, CompiledTool, DeepAgentParams, LegacyDeepAgentParams, LegacyLangChainAgentParams, LangChainAgentParams } from "../../contracts/types.js";
 export type BindingExecutionView = {
     adapterKind: string;
-    langchainParams?: LangChainAgentParams;
-    deepAgentParams?: DeepAgentParams;
+    langchainParams?: LegacyLangChainAgentParams;
+    deepAgentParams?: LegacyDeepAgentParams;
     executionParams?: LangChainAgentParams | DeepAgentParams;
     primaryTools: CompiledTool[];
     primaryModel?: CompiledModel;
@@ -19,8 +19,8 @@ export declare function getBindingExecutionView(binding: CompiledAgentBinding):
 export declare function getBindingAdapterKind(binding: CompiledAgentBinding): string;
 export declare function getBindingCanonicalExecution(binding: CompiledAgentBinding): CompiledExecutionBinding | undefined;
 export declare function getBindingRuntimeExecutionMode(binding: CompiledAgentBinding): string;
-export declare function getBindingLangChainParams(binding: CompiledAgentBinding): LangChainAgentParams | undefined;
-export declare function getBindingDeepAgentParams(binding: CompiledAgentBinding): DeepAgentParams | undefined;
+export declare function getBindingLangChainParams(binding: CompiledAgentBinding): LegacyLangChainAgentParams | undefined;
+export declare function getBindingDeepAgentParams(binding: CompiledAgentBinding): LegacyDeepAgentParams | undefined;
 export declare function getBindingExecutionParams(binding: CompiledAgentBinding): LangChainAgentParams | DeepAgentParams | undefined;
 export declare function getBindingExecutionKind(binding: CompiledAgentBinding): "langchain-v1" | "deepagent" | undefined;
 export declare function withUpdatedBindingExecutionParams(binding: CompiledAgentBinding, updater: (params: LangChainAgentParams | DeepAgentParams) => LangChainAgentParams | DeepAgentParams): CompiledAgentBinding;

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/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.120",
   "description": "Workspace runtime for multi-agent applications",
   "type": "module",
   "packageManager": "npm@10.9.2",