@botbotgo/agent-harness 0.0.92 → 0.0.94

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,25 @@
+type LangGraphPresetNode = {
+    id: string;
+    kind: string;
+    prompt?: string;
+    role?: string;
+    agent?: string;
+    tool?: 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 = {
+    agent?: 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 requireAgent(preset, options) {
+    if (typeof options.agent === "string" && options.agent.trim()) {
+        return options.agent.trim();
+    }
+    throw new Error(`LangGraph preset ${preset} requires config.agent`);
+}
+export function resolveLangGraphPresetWorkflow(presetName, options = {}) {
+    switch (presetName) {
+        case undefined:
+        case "":
+            return undefined;
+        case "react":
+            return {
+                entryNode: "executor",
+                nodes: [
+                    { id: "executor", kind: "agent" },
+                ],
+                edges: [],
+            };
+        case "prompt-chaining":
+        case "plan-execute":
+            return {
+                entryNode: "planner",
+                nodes: [
+                    { id: "planner", kind: "llm", role: "planner", prompt: DEFAULT_PLANNER_PROMPT },
+                    { id: "executor", kind: "agent" },
+                    { id: "finalizer", kind: "llm", role: "finalizer", prompt: DEFAULT_FINALIZER_PROMPT },
+                ],
+                edges: [
+                    { from: "planner", to: "executor" },
+                    { from: "executor", to: "finalizer", when: "has_result" },
+                ],
+            };
+        case "routing": {
+            const agent = requireAgent("routing", options);
+            return {
+                entryNode: "planner",
+                nodes: [
+                    { id: "planner", kind: "llm", role: "planner", prompt: DEFAULT_PLANNER_PROMPT },
+                    { id: "worker", kind: "agent", agent },
+                    { id: "finalizer", kind: "llm", role: "finalizer", prompt: DEFAULT_FINALIZER_PROMPT },
+                ],
+                edges: [
+                    { from: "planner", to: "worker" },
+                    { from: "worker", to: "finalizer", when: "has_result" },
+                ],
+            };
+        }
+        case "parallelization": {
+            const agent = requireAgent("parallelization", options);
+            return {
+                entryNode: "planner",
+                nodes: [
+                    { id: "planner", kind: "llm", role: "planner", prompt: DEFAULT_PLANNER_PROMPT },
+                    { id: "worker", kind: "agent", agent },
+                    { id: "reviewer", kind: "llm", role: "reviewer", prompt: DEFAULT_REVIEWER_PROMPT },
+                    { id: "finalizer", kind: "llm", role: "finalizer", prompt: DEFAULT_FINALIZER_PROMPT },
+                ],
+                edges: [
+                    { from: "planner", to: "worker" },
+                    { from: "worker", to: "reviewer", when: "has_result" },
+                    { from: "reviewer", to: "finalizer", when: "review_ok" },
+                ],
+            };
+        }
+        case "review-loop":
+            return {
+                entryNode: "planner",
+                nodes: [
+                    { id: "planner", kind: "llm", role: "planner", prompt: DEFAULT_PLANNER_PROMPT },
+                    { id: "executor", kind: "agent" },
+                    { id: "reviewer", kind: "llm", role: "reviewer", prompt: DEFAULT_REVIEWER_PROMPT },
+                    { id: "replanner", kind: "llm", role: "replanner", prompt: DEFAULT_REPLANNER_PROMPT },
+                    { id: "finalizer", kind: "llm", role: "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: "agent" },
+                    { id: "reviewer", kind: "llm", role: "reviewer", prompt: DEFAULT_REVIEWER_PROMPT },
+                    { id: "replanner", kind: "llm", role: "replanner", prompt: DEFAULT_REPLANNER_PROMPT },
+                    { id: "finalizer", kind: "llm", role: "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: "llm", role: "planner", prompt: DEFAULT_PLANNER_PROMPT },
+                    { id: "approval", kind: "approval" },
+                    { id: "executor", kind: "agent" },
+                    { id: "finalizer", kind: "llm", role: "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 agent = requireAgent("handoff", options);
+            return {
+                entryNode: "worker",
+                nodes: [
+                    { id: "worker", kind: "agent", agent },
+                    { id: "finalizer", kind: "llm", role: "finalizer", prompt: DEFAULT_FINALIZER_PROMPT },
+                ],
+                edges: [
+                    { from: "worker", to: "finalizer", when: "has_result" },
+                ],
+            };
+        }
+        case "orchestrator-workers": {
+            const agent = requireAgent("orchestrator-workers", options);
+            return {
+                entryNode: "planner",
+                nodes: [
+                    { id: "planner", kind: "llm", role: "planner", prompt: DEFAULT_PLANNER_PROMPT },
+                    { id: "worker", kind: "agent", agent },
+                    { id: "reviewer", kind: "llm", role: "reviewer", prompt: DEFAULT_REVIEWER_PROMPT },
+                    { id: "finalizer", kind: "llm", role: "finalizer", prompt: DEFAULT_FINALIZER_PROMPT },
+                ],
+                edges: [
+                    { from: "planner", to: "worker" },
+                    { from: "worker", 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/langgraph-profiles.d.ts

@@ -0,0 +1,6 @@
+import type { LangGraphPresetWorkflow } from "./langgraph-presets.js";
+export type LangGraphProfileName = "coding-runtime" | "personal-assistant" | "research-runtime" | "approval-review-runtime" | "claw-style-assistant" | "chat-operator" | "copilot-sidecar" | "task-delegation-hub";
+type LangGraphProfileOptions = Record<string, unknown>;
+export declare const SUPPORTED_LANGGRAPH_PROFILES: LangGraphProfileName[];
+export declare function resolveLangGraphProfileWorkflow(profileName: string | undefined, options?: LangGraphProfileOptions): LangGraphPresetWorkflow | undefined;
+export {};

package/dist/runtime/langgraph-profiles.js

@@ -0,0 +1,206 @@
+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_FINALIZER_PROMPT = "Rewrite the current result into a concise user-facing final answer. Preserve facts and caveats.";
+const DEFAULT_REPLANNER_PROMPT = "Refine the plan based on the reviewer feedback and current result. Return only the updated plan.";
+export const SUPPORTED_LANGGRAPH_PROFILES = [
+    "coding-runtime",
+    "personal-assistant",
+    "research-runtime",
+    "approval-review-runtime",
+    "claw-style-assistant",
+    "chat-operator",
+    "copilot-sidecar",
+    "task-delegation-hub",
+];
+function readStringOption(options, key) {
+    const value = options[key];
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function requireAgentOption(profile, options, key) {
+    const value = readStringOption(options, key);
+    if (value) {
+        return value;
+    }
+    throw new Error(`LangGraph profile ${profile} requires with.${key}`);
+}
+function buildCodingRuntimeWorkflow(options) {
+    const coderAgent = requireAgentOption("coding-runtime", options, "coderAgent");
+    const verifierAgent = readStringOption(options, "verifierAgent");
+    const needsVerification = Boolean(verifierAgent) || options.runIntegrationVerification === true;
+    return {
+        entryNode: "planner",
+        nodes: [
+            { id: "planner", kind: "llm", role: "planner", prompt: DEFAULT_PLANNER_PROMPT },
+            { id: "coder", kind: "agent", agent: coderAgent },
+            { id: "reviewer", kind: "llm", role: "reviewer", prompt: DEFAULT_REVIEWER_PROMPT },
+            { id: "replanner", kind: "llm", role: "replanner", prompt: DEFAULT_REPLANNER_PROMPT },
+            ...(needsVerification
+                ? [{ id: "approval", kind: "approval" }, { id: "verifier", kind: "agent", agent: verifierAgent ?? coderAgent }]
+                : []),
+            { id: "finalizer", kind: "llm", role: "finalizer", prompt: DEFAULT_FINALIZER_PROMPT },
+        ],
+        edges: [
+            { from: "planner", to: "coder" },
+            { from: "coder", to: "reviewer", when: "has_result" },
+            { from: "reviewer", to: needsVerification ? "approval" : "finalizer", when: "review_ok" },
+            { from: "reviewer", to: "replanner", when: "review_incomplete" },
+            { from: "replanner", to: "coder", when: "has_plan" },
+            ...(needsVerification
+                ? [
+                    { from: "approval", to: "verifier", when: "approval_approved" },
+                    { from: "approval", to: "verifier", when: "approval_edited" },
+                    { from: "verifier", to: "finalizer", when: "has_result" },
+                ]
+                : []),
+        ],
+    };
+}
+function buildAssistantWorkflow(options) {
+    const worker = readStringOption(options, "defaultWorkerAgent") ??
+        readStringOption(options, "defaultResearchAgent") ??
+        readStringOption(options, "defaultWritingAgent") ??
+        readStringOption(options, "defaultSchedulingAgent");
+    return {
+        entryNode: "intake",
+        nodes: [
+            { id: "intake", kind: "llm", role: "planner", prompt: DEFAULT_PLANNER_PROMPT },
+            ...(worker ? [{ id: "worker", kind: "agent", agent: worker }] : [{ id: "lookup", kind: "tool", tool: "repo_inventory" }]),
+            { id: "reviewer", kind: "llm", role: "reviewer", prompt: DEFAULT_REVIEWER_PROMPT },
+            { id: "approval", kind: "approval" },
+            { id: "finalizer", kind: "llm", role: "finalizer", prompt: DEFAULT_FINALIZER_PROMPT },
+        ],
+        edges: [
+            { from: "intake", to: worker ? "worker" : "lookup" },
+            { from: worker ? "worker" : "lookup", to: "reviewer", when: "has_result" },
+            { from: "reviewer", to: "approval", when: "review_incomplete" },
+            { from: "reviewer", to: "finalizer", when: "review_ok" },
+            { from: "approval", to: "finalizer", when: "approval_approved" },
+            { from: "approval", to: "finalizer", when: "approval_edited" },
+        ],
+    };
+}
+function buildResearchWorkflow(options) {
+    const gathererAgent = requireAgentOption("research-runtime", options, "gathererAgent");
+    const analystAgent = requireAgentOption("research-runtime", options, "analystAgent");
+    const synthesizerAgent = readStringOption(options, "synthesizerAgent");
+    return {
+        entryNode: "planner",
+        nodes: [
+            { id: "planner", kind: "llm", role: "planner", prompt: DEFAULT_PLANNER_PROMPT },
+            { id: "gatherer", kind: "agent", agent: gathererAgent },
+            { id: "coverage-review", kind: "llm", role: "reviewer", prompt: DEFAULT_REVIEWER_PROMPT },
+            { id: "analyst", kind: "agent", agent: analystAgent },
+            ...(synthesizerAgent ? [{ id: "synthesizer", kind: "agent", agent: synthesizerAgent }] : []),
+            { id: "finalizer", kind: "llm", role: "finalizer", prompt: DEFAULT_FINALIZER_PROMPT },
+        ],
+        edges: [
+            { from: "planner", to: "gatherer" },
+            { from: "gatherer", to: "coverage-review", when: "has_result" },
+            { from: "coverage-review", to: "analyst", when: "review_ok" },
+            { from: "coverage-review", to: "gatherer", when: "review_incomplete" },
+            { from: "analyst", to: synthesizerAgent ? "synthesizer" : "finalizer", when: "has_result" },
+            ...(synthesizerAgent ? [{ from: "synthesizer", to: "finalizer", when: "has_result" }] : []),
+        ],
+    };
+}
+function buildApprovalReviewWorkflow(options) {
+    const preparerAgent = requireAgentOption("approval-review-runtime", options, "preparerAgent");
+    const reviewerAgent = readStringOption(options, "reviewerAgent");
+    return {
+        entryNode: "scope",
+        nodes: [
+            { id: "scope", kind: "llm", role: "planner", prompt: DEFAULT_PLANNER_PROMPT },
+            { id: "preparer", kind: "agent", agent: preparerAgent },
+            ...(reviewerAgent ? [{ id: "reviewer-agent", kind: "agent", agent: reviewerAgent }] : [{ id: "risk-review", kind: "llm", role: "reviewer", prompt: DEFAULT_REVIEWER_PROMPT }]),
+            { id: "approval", kind: "approval" },
+            { id: "finalizer", kind: "llm", role: "finalizer", prompt: DEFAULT_FINALIZER_PROMPT },
+        ],
+        edges: [
+            { from: "scope", to: "preparer" },
+            { from: "preparer", to: reviewerAgent ? "reviewer-agent" : "risk-review", when: "has_result" },
+            { from: reviewerAgent ? "reviewer-agent" : "risk-review", to: "approval", when: "has_result" },
+            { from: "approval", to: "finalizer", when: "approval_approved" },
+            { from: "approval", to: "finalizer", when: "approval_edited" },
+        ],
+    };
+}
+function buildChatOperatorWorkflow(options) {
+    const routedAgent = readStringOption(options, "assistantAgent") ??
+        readStringOption(options, "researchAgent") ??
+        readStringOption(options, "codingAgent") ??
+        readStringOption(options, "approvalAgent");
+    if (!routedAgent) {
+        throw new Error("LangGraph profile chat-operator requires at least one target agent in with.assistantAgent, with.researchAgent, with.codingAgent, or with.approvalAgent");
+    }
+    return {
+        entryNode: "router",
+        nodes: [
+            { id: "router", kind: "llm", role: "planner", prompt: DEFAULT_PLANNER_PROMPT },
+            { id: "worker", kind: "agent", agent: routedAgent },
+            { id: "finalizer", kind: "llm", role: "finalizer", prompt: DEFAULT_FINALIZER_PROMPT },
+        ],
+        edges: [
+            { from: "router", to: "worker" },
+            { from: "worker", to: "finalizer", when: "has_result" },
+        ],
+    };
+}
+function buildCopilotSidecarWorkflow(options) {
+    const coderAgent = requireAgentOption("copilot-sidecar", options, "coderAgent");
+    return {
+        entryNode: "intake",
+        nodes: [
+            { id: "intake", kind: "llm", role: "planner", prompt: DEFAULT_PLANNER_PROMPT },
+            { id: "coder", kind: "agent", agent: coderAgent },
+            { id: "finalizer", kind: "llm", role: "finalizer", prompt: DEFAULT_FINALIZER_PROMPT },
+        ],
+        edges: [
+            { from: "intake", to: "coder" },
+            { from: "coder", to: "finalizer", when: "has_result" },
+        ],
+    };
+}
+function buildDelegationHubWorkflow(options) {
+    const workerAgent = readStringOption(options, "defaultWorkerFallback");
+    if (!workerAgent) {
+        throw new Error("LangGraph profile task-delegation-hub requires with.defaultWorkerFallback");
+    }
+    return {
+        entryNode: "router",
+        nodes: [
+            { id: "router", kind: "llm", role: "planner", prompt: DEFAULT_PLANNER_PROMPT },
+            { id: "worker", kind: "agent", agent: workerAgent },
+            { id: "reviewer", kind: "llm", role: "reviewer", prompt: DEFAULT_REVIEWER_PROMPT },
+            { id: "finalizer", kind: "llm", role: "finalizer", prompt: DEFAULT_FINALIZER_PROMPT },
+        ],
+        edges: [
+            { from: "router", to: "worker" },
+            { from: "worker", to: "reviewer", when: "has_result" },
+            { from: "reviewer", to: "finalizer", when: "review_ok" },
+        ],
+    };
+}
+export function resolveLangGraphProfileWorkflow(profileName, options = {}) {
+    switch (profileName) {
+        case undefined:
+        case "":
+            return undefined;
+        case "coding-runtime":
+            return buildCodingRuntimeWorkflow(options);
+        case "personal-assistant":
+        case "claw-style-assistant":
+            return buildAssistantWorkflow(options);
+        case "research-runtime":
+            return buildResearchWorkflow(options);
+        case "approval-review-runtime":
+            return buildApprovalReviewWorkflow(options);
+        case "chat-operator":
+            return buildChatOperatorWorkflow(options);
+        case "copilot-sidecar":
+            return buildCopilotSidecarWorkflow(options);
+        case "task-delegation-hub":
+            return buildDelegationHubWorkflow(options);
+        default:
+            throw new Error(`Unsupported LangGraph profile ${String(profileName)}. Supported profiles: ${SUPPORTED_LANGGRAPH_PROFILES.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 };
 }