@botbotgo/agent-harness 0.0.92 → 0.0.93

package/dist/runtime/harness.d.ts

@@ -102,6 +102,8 @@ export declare class AgentHarnessRuntime {
     private executeQueuedRun;
     private checkpointRefForState;
     private finalizeContinuedRun;
+    private synthesizeCompletedRun;
+    private reviewCompletedRun;
     private emitOutputDeltaAndCreateItem;
     private createContentBlocksItem;
     private createToolResultKey;

package/dist/runtime/harness.js

@@ -660,7 +660,7 @@ export class AgentHarnessRuntime {
             if (cancelledAfterInvoke.requested) {
                 return this.finalizeCancelledRun(threadId, runId, previousState === "queued" ? "running" : previousState, cancelledAfterInvoke.reason);
             }
-            const finalized = await this.finalizeContinuedRun(threadId, runId, input, actual, {
+            const finalized = await this.finalizeContinuedRun(binding, threadId, runId, input, actual, {
                 previousState: previousState === "queued" ? "running" : previousState,
                 stateSequence: options.stateSequence ?? 103,
                 approvalSequence: options.approvalSequence ?? 104,
@@ -691,25 +691,68 @@ export class AgentHarnessRuntime {
     checkpointRefForState(threadId, runId, state) {
         return state === "waiting_for_approval" ? `checkpoints/${threadId}/${runId}/cp-1` : null;
     }
-    async finalizeContinuedRun(threadId, runId, input, actual, options) {
+    async finalizeContinuedRun(binding, threadId, runId, input, actual, options) {
         let approval;
-        await this.appendAssistantMessage(threadId, runId, actual.output);
+        const finalizedActual = actual.state === "completed"
+            ? await this.synthesizeCompletedRun(binding, input, actual)
+            : actual;
+        await this.appendAssistantMessage(threadId, runId, finalizedActual.output);
         const checkpointRef = this.checkpointRefForState(threadId, runId, actual.state);
-        await this.setRunStateAndEmit(threadId, runId, options.stateSequence, actual.state, {
+        await this.setRunStateAndEmit(threadId, runId, options.stateSequence, finalizedActual.state, {
             previousState: options.previousState,
             checkpointRef,
         });
-        if (actual.state === "waiting_for_approval" && options.approvalSequence) {
-            approval = (await this.requestApprovalAndEmit(threadId, runId, input, actual.interruptContent, checkpointRef, options.approvalSequence)).approval;
+        if (finalizedActual.state === "waiting_for_approval" && options.approvalSequence) {
+            approval = (await this.requestApprovalAndEmit(threadId, runId, input, finalizedActual.interruptContent, checkpointRef, options.approvalSequence)).approval;
+        }
+        if (finalizedActual.state === "completed") {
+            await this.reviewCompletedRun(binding, threadId, runId, input, finalizedActual);
         }
         return {
-            ...actual,
+            ...finalizedActual,
             threadId,
             runId,
-            approvalId: approval?.approvalId ?? actual.approvalId,
-            pendingActionId: approval?.pendingActionId ?? actual.pendingActionId,
+            approvalId: approval?.approvalId ?? finalizedActual.approvalId,
+            pendingActionId: approval?.pendingActionId ?? finalizedActual.pendingActionId,
         };
     }
+    async synthesizeCompletedRun(binding, input, actual) {
+        try {
+            const synthesized = await this.runtimeAdapter.synthesizeFinalResult(binding, input, actual);
+            if (!synthesized) {
+                return actual;
+            }
+            return {
+                ...actual,
+                output: synthesized.output,
+                finalMessageText: synthesized.finalMessageText,
+                metadata: {
+                    ...(typeof actual.metadata === "object" && actual.metadata ? actual.metadata : {}),
+                    finalSynthesis: {
+                        modelId: synthesized.modelId,
+                    },
+                },
+            };
+        }
+        catch {
+            return actual;
+        }
+    }
+    async reviewCompletedRun(binding, threadId, runId, input, actual) {
+        try {
+            const review = await this.runtimeAdapter.reviewRunResult(binding, input, actual);
+            if (!review) {
+                return;
+            }
+            await this.emit(threadId, runId, 7, "run.reviewed", {
+                modelId: review.modelId,
+                assessment: review.assessment,
+            });
+        }
+        catch {
+            // Review is advisory; do not fail the completed run if the review pass fails.
+        }
+    }
     async emitOutputDeltaAndCreateItem(threadId, runId, agentId, content) {
         await this.emit(threadId, runId, 3, "output.delta", {
             content,
@@ -1139,6 +1182,7 @@ export class AgentHarnessRuntime {
                     context: invocation.context,
                     state: invocation.state,
                     files: invocation.files,
+                    runId,
                 })) {
                     if (chunk) {
                         streamActivityObserved = true;
@@ -1425,7 +1469,7 @@ export class AgentHarnessRuntime {
                     return this.finalizeCancelledRun(threadId, runId, "resuming", cancelledAfterInvoke.reason);
                 }
                 await this.persistence.clearRecoveryIntent(threadId, runId);
-                const finalized = await this.finalizeContinuedRun(threadId, runId, runInput, actual, {
+                const finalized = await this.finalizeContinuedRun(binding, threadId, runId, runInput, actual, {
                     previousState: "resuming",
                     stateSequence: 7,
                     approvalSequence: 8,
@@ -1668,7 +1712,7 @@ export class AgentHarnessRuntime {
                 const actual = await this.runtimeAdapter.invoke(binding, "", thread.threadId, thread.latestRunId, recoveryIntent.resumePayload, priorHistory);
                 this.healthMonitor.recordLlmSuccess(Date.now() - startedAt);
                 await this.persistence.clearRecoveryIntent(thread.threadId, thread.latestRunId);
-                await this.finalizeContinuedRun(thread.threadId, thread.latestRunId, runInput, actual, {
+                await this.finalizeContinuedRun(binding, thread.threadId, thread.latestRunId, runInput, actual, {
                     previousState: "resuming",
                     stateSequence: 101,
                     approvalSequence: 102,

package/dist/runtime/inventory.d.ts

@@ -20,7 +20,7 @@ export type InventorySkillRecord = {
 export type InventoryAgentRecord = {
     id: string;
     description: string;
-    role: "runtime-entry" | "specialist";
+    role: "agent" | "specialist";
     tools: InventoryToolRecord[];
     skills: InventorySkillRecord[];
 };

package/dist/runtime/inventory.js

@@ -96,7 +96,7 @@ export function listAvailableAgents(workspace, options = {}) {
     const topLevel = listHostBindings(workspace).map((binding) => ({
         id: binding.agent.id,
         description: binding.agent.description,
-        role: "runtime-entry",
+        role: "agent",
         tools: listAgentTools(workspace, binding.agent.id),
         skills: listAgentSkills(workspace, binding.agent.id, options),
     }));

package/dist/runtime/langgraph-presets.d.ts

@@ -0,0 +1,23 @@
+type LangGraphPresetNode = {
+    id: string;
+    kind: string;
+    prompt?: string;
+    specialist?: string;
+};
+type LangGraphPresetEdge = {
+    from: string;
+    to: string;
+    when?: string;
+};
+export type LangGraphPresetWorkflow = {
+    entryNode: string;
+    nodes: LangGraphPresetNode[];
+    edges: LangGraphPresetEdge[];
+};
+export type LangGraphPresetName = "react" | "prompt-chaining" | "routing" | "parallelization" | "plan-execute" | "review-loop" | "evaluator-optimizer" | "approval-gate" | "handoff" | "orchestrator-workers";
+type LangGraphPresetOptions = {
+    specialist?: string;
+};
+export declare const SUPPORTED_LANGGRAPH_PRESETS: LangGraphPresetName[];
+export declare function resolveLangGraphPresetWorkflow(presetName: string | undefined, options?: LangGraphPresetOptions): LangGraphPresetWorkflow | undefined;
+export {};

package/dist/runtime/langgraph-presets.js

@@ -0,0 +1,165 @@
+const DEFAULT_PLANNER_PROMPT = "You are the workflow planner. Produce a concise execution plan for the user request before execution starts.";
+const DEFAULT_REVIEWER_PROMPT = "Review the current result, call out missing verification or obvious gaps, and state whether the work looks sufficient.";
+const DEFAULT_REPLANNER_PROMPT = "Refine the plan based on the reviewer feedback and current result. Return only the updated plan.";
+const DEFAULT_FINALIZER_PROMPT = "Rewrite the current result into a concise user-facing final answer. Preserve facts and caveats.";
+export const SUPPORTED_LANGGRAPH_PRESETS = [
+    "react",
+    "prompt-chaining",
+    "routing",
+    "parallelization",
+    "plan-execute",
+    "review-loop",
+    "evaluator-optimizer",
+    "approval-gate",
+    "handoff",
+    "orchestrator-workers",
+];
+function requireSpecialist(preset, options) {
+    if (typeof options.specialist === "string" && options.specialist.trim()) {
+        return options.specialist.trim();
+    }
+    throw new Error(`LangGraph preset ${preset} requires config.specialist`);
+}
+export function resolveLangGraphPresetWorkflow(presetName, options = {}) {
+    switch (presetName) {
+        case undefined:
+        case "":
+            return undefined;
+        case "react":
+            return {
+                entryNode: "executor",
+                nodes: [
+                    { id: "executor", kind: "executor" },
+                ],
+                edges: [],
+            };
+        case "prompt-chaining":
+        case "plan-execute":
+            return {
+                entryNode: "planner",
+                nodes: [
+                    { id: "planner", kind: "planner", prompt: DEFAULT_PLANNER_PROMPT },
+                    { id: "executor", kind: "executor" },
+                    { id: "finalizer", kind: "finalizer", prompt: DEFAULT_FINALIZER_PROMPT },
+                ],
+                edges: [
+                    { from: "planner", to: "executor" },
+                    { from: "executor", to: "finalizer", when: "has_result" },
+                ],
+            };
+        case "routing": {
+            const specialist = requireSpecialist("routing", options);
+            return {
+                entryNode: "planner",
+                nodes: [
+                    { id: "planner", kind: "planner", prompt: DEFAULT_PLANNER_PROMPT },
+                    { id: "specialist", kind: "specialist", specialist },
+                    { id: "finalizer", kind: "finalizer", prompt: DEFAULT_FINALIZER_PROMPT },
+                ],
+                edges: [
+                    { from: "planner", to: "specialist" },
+                    { from: "specialist", to: "finalizer", when: "has_result" },
+                ],
+            };
+        }
+        case "parallelization": {
+            const specialist = requireSpecialist("parallelization", options);
+            return {
+                entryNode: "planner",
+                nodes: [
+                    { id: "planner", kind: "planner", prompt: DEFAULT_PLANNER_PROMPT },
+                    { id: "specialist", kind: "specialist", specialist },
+                    { id: "reviewer", kind: "reviewer", prompt: DEFAULT_REVIEWER_PROMPT },
+                    { id: "finalizer", kind: "finalizer", prompt: DEFAULT_FINALIZER_PROMPT },
+                ],
+                edges: [
+                    { from: "planner", to: "specialist" },
+                    { from: "specialist", to: "reviewer", when: "has_result" },
+                    { from: "reviewer", to: "finalizer", when: "review_ok" },
+                ],
+            };
+        }
+        case "review-loop":
+            return {
+                entryNode: "planner",
+                nodes: [
+                    { id: "planner", kind: "planner", prompt: DEFAULT_PLANNER_PROMPT },
+                    { id: "executor", kind: "executor" },
+                    { id: "reviewer", kind: "reviewer", prompt: DEFAULT_REVIEWER_PROMPT },
+                    { id: "replanner", kind: "replanner", prompt: DEFAULT_REPLANNER_PROMPT },
+                    { id: "finalizer", kind: "finalizer", prompt: DEFAULT_FINALIZER_PROMPT },
+                ],
+                edges: [
+                    { from: "planner", to: "executor" },
+                    { from: "executor", to: "reviewer", when: "has_result" },
+                    { from: "reviewer", to: "finalizer", when: "review_ok" },
+                    { from: "reviewer", to: "replanner", when: "review_incomplete" },
+                    { from: "replanner", to: "executor", when: "has_plan" },
+                ],
+            };
+        case "evaluator-optimizer":
+            return {
+                entryNode: "executor",
+                nodes: [
+                    { id: "executor", kind: "executor" },
+                    { id: "reviewer", kind: "reviewer", prompt: DEFAULT_REVIEWER_PROMPT },
+                    { id: "replanner", kind: "replanner", prompt: DEFAULT_REPLANNER_PROMPT },
+                    { id: "finalizer", kind: "finalizer", prompt: DEFAULT_FINALIZER_PROMPT },
+                ],
+                edges: [
+                    { from: "executor", to: "reviewer", when: "has_result" },
+                    { from: "reviewer", to: "finalizer", when: "review_ok" },
+                    { from: "reviewer", to: "replanner", when: "review_incomplete" },
+                    { from: "replanner", to: "executor", when: "has_plan" },
+                ],
+            };
+        case "approval-gate":
+            return {
+                entryNode: "planner",
+                nodes: [
+                    { id: "planner", kind: "planner", prompt: DEFAULT_PLANNER_PROMPT },
+                    { id: "approval", kind: "approval" },
+                    { id: "executor", kind: "executor" },
+                    { id: "finalizer", kind: "finalizer", prompt: DEFAULT_FINALIZER_PROMPT },
+                ],
+                edges: [
+                    { from: "planner", to: "approval" },
+                    { from: "approval", to: "executor", when: "approval_approved" },
+                    { from: "approval", to: "executor", when: "approval_edited" },
+                    { from: "executor", to: "finalizer", when: "has_result" },
+                ],
+            };
+        case "handoff": {
+            const specialist = requireSpecialist("handoff", options);
+            return {
+                entryNode: "specialist",
+                nodes: [
+                    { id: "specialist", kind: "specialist", specialist },
+                    { id: "finalizer", kind: "finalizer", prompt: DEFAULT_FINALIZER_PROMPT },
+                ],
+                edges: [
+                    { from: "specialist", to: "finalizer", when: "has_result" },
+                ],
+            };
+        }
+        case "orchestrator-workers": {
+            const specialist = requireSpecialist("orchestrator-workers", options);
+            return {
+                entryNode: "planner",
+                nodes: [
+                    { id: "planner", kind: "planner", prompt: DEFAULT_PLANNER_PROMPT },
+                    { id: "specialist", kind: "specialist", specialist },
+                    { id: "reviewer", kind: "reviewer", prompt: DEFAULT_REVIEWER_PROMPT },
+                    { id: "finalizer", kind: "finalizer", prompt: DEFAULT_FINALIZER_PROMPT },
+                ],
+                edges: [
+                    { from: "planner", to: "specialist" },
+                    { from: "specialist", to: "reviewer", when: "has_result" },
+                    { from: "reviewer", to: "finalizer", when: "review_ok" },
+                ],
+            };
+        }
+        default:
+            throw new Error(`Unsupported LangGraph preset ${String(presetName)}. Supported presets: ${SUPPORTED_LANGGRAPH_PRESETS.join(", ")}`);
+    }
+}

package/dist/runtime/policy-engine.js

@@ -1,13 +1,8 @@
 import { getPolicyEvaluators } from "../extensions.js";
-import { isRuntimeEntryBinding } from "./support/runtime-entry.js";
 export class PolicyEngine {
     evaluate(binding) {
         const reasons = [];
         let allowed = true;
-        if (!isRuntimeEntryBinding(binding)) {
-            allowed = false;
-            reasons.push("internal subagents cannot be used as runtime entry agents");
-        }
         for (const evaluator of getPolicyEvaluators()) {
             const decision = evaluator.evaluate(binding);
             if (!decision) {

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

@@ -1,12 +1,15 @@
-import type { CompiledAgentBinding, CompiledModel, CompiledTool, DeepAgentParams, LangChainAgentParams } from "../../contracts/types.js";
+import type { CompiledAgentBinding, CompiledModel, CompiledTool, DeepAgentParams, LangChainAgentParams, RuntimeModelSlot } from "../../contracts/types.js";
 export declare function getBindingAdapterKind(binding: CompiledAgentBinding): string;
 export declare function getBindingAdapterConfig(binding: CompiledAgentBinding): Record<string, unknown>;
+export declare function getBindingLangGraphWorkflow(binding: CompiledAgentBinding): Record<string, unknown> | undefined;
+export declare function getBindingLangGraphPreset(binding: CompiledAgentBinding): string | undefined;
 export declare function getBindingLangChainParams(binding: CompiledAgentBinding): LangChainAgentParams | undefined;
 export declare function getBindingDeepAgentParams(binding: CompiledAgentBinding): DeepAgentParams | undefined;
 export declare function isLangChainBinding(binding: CompiledAgentBinding): boolean;
 export declare function isDeepAgentBinding(binding: CompiledAgentBinding): boolean;
 export declare function getBindingPrimaryTools(binding: CompiledAgentBinding): CompiledTool[];
 export declare function getBindingPrimaryModel(binding: CompiledAgentBinding): CompiledModel | undefined;
+export declare function getBindingRuntimeModel(binding: CompiledAgentBinding, slot: RuntimeModelSlot): CompiledModel | undefined;
 export declare function getBindingSystemPrompt(binding: CompiledAgentBinding): string | undefined;
 export declare function getBindingMiddlewareConfigs(binding: CompiledAgentBinding): Array<Record<string, unknown>> | undefined;
 export declare function getBindingInterruptCompatibilityRules(binding: CompiledAgentBinding): Record<string, boolean | object> | undefined;

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

@@ -9,9 +9,26 @@ export function getBindingAdapterKind(binding) {
 export function getBindingAdapterConfig(binding) {
     return binding.adapter?.config ?? {};
 }
+export function getBindingLangGraphWorkflow(binding) {
+    const workflow = asRecord(getBindingAdapterConfig(binding).workflow);
+    if (workflow) {
+        return workflow;
+    }
+    return asRecord(asRecord(getBindingLangChainParams(binding)?.passthrough)?.workflow);
+}
+export function getBindingLangGraphPreset(binding) {
+    const adapterPreset = getBindingAdapterConfig(binding).preset;
+    if (typeof adapterPreset === "string" && adapterPreset.trim()) {
+        return adapterPreset.trim();
+    }
+    const passthroughPreset = asRecord(getBindingLangChainParams(binding)?.passthrough)?.preset;
+    return typeof passthroughPreset === "string" && passthroughPreset.trim()
+        ? passthroughPreset.trim()
+        : undefined;
+}
 export function getBindingLangChainParams(binding) {
     const adapterParams = asRecord(getBindingAdapterConfig(binding).params);
-    if (getBindingAdapterKind(binding) === "langchain-v1" && adapterParams) {
+    if ((getBindingAdapterKind(binding) === "langchain-v1" || getBindingAdapterKind(binding) === "langgraph") && adapterParams) {
         return adapterParams;
     }
     return binding.langchainAgentParams;
@@ -24,7 +41,9 @@ export function getBindingDeepAgentParams(binding) {
     return binding.deepAgentParams;
 }
 export function isLangChainBinding(binding) {
-    return getBindingAdapterKind(binding) === "langchain-v1" || Boolean(binding.langchainAgentParams);
+    return getBindingAdapterKind(binding) === "langchain-v1" ||
+        getBindingAdapterKind(binding) === "langgraph" ||
+        Boolean(binding.langchainAgentParams);
 }
 export function isDeepAgentBinding(binding) {
     return getBindingAdapterKind(binding) === "deepagent" || Boolean(binding.deepAgentParams);
@@ -35,6 +54,9 @@ export function getBindingPrimaryTools(binding) {
 export function getBindingPrimaryModel(binding) {
     return binding.langchainAgentParams?.model ?? binding.deepAgentParams?.model;
 }
+export function getBindingRuntimeModel(binding, slot) {
+    return binding.harnessRuntime.models?.[slot];
+}
 export function getBindingSystemPrompt(binding) {
     return binding.langchainAgentParams?.systemPrompt ?? binding.deepAgentParams?.systemPrompt;
 }

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

@@ -131,8 +131,8 @@ export function createPendingApproval(threadId, runId, checkpointRef, input, int
 }
 export function inferRoutingBindings(workspace) {
     const runtimeEntryBindings = Array.from(workspace.bindings.values()).filter((binding) => isRuntimeEntryBinding(binding));
-    const deepAgentHosts = runtimeEntryBindings.filter((binding) => binding.agent.executionMode === "deepagent" || Boolean(binding.deepAgentParams));
-    const routingHosts = deepAgentHosts.length > 0 ? deepAgentHosts : runtimeEntryBindings;
+    const orchestrationHosts = runtimeEntryBindings.filter((binding) => binding.agent.executionMode === "deepagent" || binding.agent.executionMode === "langgraph" || Boolean(binding.deepAgentParams));
+    const routingHosts = orchestrationHosts.length > 0 ? orchestrationHosts : runtimeEntryBindings;
     const researchBinding = routingHosts.find((binding) => binding.agent.id === "research-lite" || binding.agent.id === "research");
     const directBinding = routingHosts.find((binding) => binding.agent.id === "direct");
     const delegationHosts = routingHosts.filter((binding) => isDelegationCapableBinding(binding));
@@ -151,6 +151,6 @@ export function inferRoutingBindings(workspace) {
             : delegationPreferredSecondary && delegationPreferredSecondary.agent.id !== primaryBinding?.agent.id
                 ? delegationPreferredSecondary
                 : routingHosts.find((binding) => binding.agent.id !== primaryBinding?.agent.id) ??
-                    (deepAgentHosts.length > 0 ? undefined : runtimeEntryBindings.find((binding) => binding.agent.id !== primaryBinding?.agent.id));
+                    (orchestrationHosts.length > 0 ? undefined : runtimeEntryBindings.find((binding) => binding.agent.id !== primaryBinding?.agent.id));
     return { primaryBinding, secondaryBinding, researchBinding, hostBindings: runtimeEntryBindings };
 }

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,58 @@ function resolveRuntimeMemoryConfig(agent, refs) {
     const runtimeMemoryDefaults = getRuntimeMemoryDefaults(refs);
     return runtimeMemoryDefaults ? { config: runtimeMemoryDefaults } : undefined;
 }
+function resolveLangGraphWorkflowConfig(agent, refs) {
+    if (agent.executionMode !== "langgraph") {
+        return 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 preset ? { preset } : undefined;
+    }
+    if (isRefConfig(workflowConfig)) {
+        return {
+            config: materializeWorkspaceObjectConfig(refs, workflowConfig.ref, ["langgraph-workflow"], `Agent ${agent.id} workflow`),
+            ...(preset ? { preset } : {}),
+        };
+    }
+    return { config: workflowConfig, ...(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 +304,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 +320,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 +341,9 @@ export function compileBinding(workspaceRoot, agent, agents, referencedSubagentI
         },
     };
     if (agent.executionMode !== "deepagent") {
+        const langGraphPassthrough = agent.executionMode === "langgraph" && langGraphWorkflow?.config
+            ? { workflow: langGraphWorkflow.config }
+            : undefined;
         const langchainAgentParams = {
             model: compiledAgentModel,
             tools: requireTools(tools, agent.toolRefs, agent.id),
@@ -283,9 +355,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 +381,10 @@ 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?.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}`);