@botbotgo/agent-harness 0.0.95 → 0.0.97

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

@@ -1,4 +1,235 @@
 import { extractReasoningText, extractVisibleOutput, hasToolCalls, readTextContent } from "./output-parsing.js";
+function asObject(value) {
+    return typeof value === "object" && value !== null ? value : undefined;
+}
+function extractCustomStreamData(event) {
+    const typed = asObject(event);
+    if (!typed) {
+        return null;
+    }
+    const eventName = typeof typed.event === "string" ? typed.event : "";
+    const ns = Array.isArray(typed.ns) ? typed.ns.filter((item) => typeof item === "string") : undefined;
+    const data = asObject(typed.data);
+    if (eventName === "on_custom_event") {
+        return {
+            ...(ns && ns.length > 0 ? { ns } : {}),
+            data: typed.data,
+        };
+    }
+    if (eventName === "on_chain_stream" && data && "custom" in data) {
+        return {
+            ...(ns && ns.length > 0 ? { ns } : {}),
+            data: data.custom,
+        };
+    }
+    return null;
+}
+export function normalizeUpstreamRuntimeEvent(event) {
+    const typed = asObject(event);
+    const tags = Array.isArray(typed?.tags) ? typed.tags.filter((item) => typeof item === "string") : undefined;
+    const ns = Array.isArray(typed?.ns) ? typed.ns.filter((item) => typeof item === "string") : undefined;
+    const name = typeof typed?.name === "string" ? typed.name : undefined;
+    const eventName = typeof typed?.event === "string" ? typed.event : undefined;
+    const runType = typeof typed?.run_type === "string" ? typed.run_type : undefined;
+    const data = asObject(typed?.data);
+    const metadata = asObject(typed?.metadata);
+    const normalized = normalizeUpstreamEventShape({
+        raw: event,
+        event: eventName,
+        name,
+        runType,
+        metadata,
+        tags,
+        data,
+        ns,
+    });
+    const streamPart = normalizeCompatibleStreamPart({
+        raw: event,
+        event: eventName,
+        name,
+        runType,
+        metadata,
+        tags,
+        data,
+        ns,
+        normalized,
+    });
+    return {
+        format: "langgraph-v2",
+        normalized,
+        raw: event,
+        event: eventName,
+        name,
+        runType,
+        data,
+        metadata,
+        ...(tags && tags.length > 0 ? { tags } : {}),
+        ...(ns && ns.length > 0 ? { ns } : {}),
+        streamPart,
+    };
+}
+function normalizeUpstreamEventShape(event) {
+    const nodeName = event.name;
+    const ns = event.ns;
+    const interruptPayload = extractInterruptPayload(event.raw);
+    if (interruptPayload) {
+        return {
+            kind: "interrupt",
+            interrupt: parseMaybeJson(interruptPayload),
+            ...(ns && ns.length > 0 ? { ns } : {}),
+            ...(nodeName ? { nodeName } : {}),
+        };
+    }
+    const reasoning = extractReasoningStreamOutput(event.raw);
+    if (reasoning) {
+        return {
+            kind: "reasoning-delta",
+            text: reasoning,
+            ...(ns && ns.length > 0 ? { ns } : {}),
+            ...(nodeName ? { nodeName } : {}),
+        };
+    }
+    const visibleText = extractVisibleStreamOutput(event.raw);
+    if (visibleText) {
+        return {
+            kind: "text-delta",
+            source: "model",
+            text: visibleText,
+            ...(ns && ns.length > 0 ? { ns } : {}),
+            ...(nodeName ? { nodeName } : {}),
+        };
+    }
+    const stateText = extractStateStreamOutput(event.raw);
+    if (stateText) {
+        return {
+            kind: "text-delta",
+            source: "state",
+            text: stateText,
+            ...(ns && ns.length > 0 ? { ns } : {}),
+            ...(nodeName ? { nodeName } : {}),
+        };
+    }
+    if (event.event === "on_tool_start" || (event.event === "on_chain_start" && event.runType === "tool")) {
+        return {
+            kind: "tool-start",
+            toolName: nodeName ?? "tool",
+            ...(event.data && "input" in event.data ? { input: event.data.input } : {}),
+            ...(ns && ns.length > 0 ? { ns } : {}),
+            ...(nodeName ? { nodeName } : {}),
+        };
+    }
+    const toolResult = extractToolResult(event.raw);
+    if (toolResult) {
+        return {
+            kind: "tool-end",
+            toolName: toolResult.toolName,
+            ...(toolResult.output !== undefined ? { output: toolResult.output } : {}),
+            ...(toolResult.isError !== undefined ? { isError: toolResult.isError } : {}),
+            ...(ns && ns.length > 0 ? { ns } : {}),
+            ...(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",
+        ...(event.data ? { data: event.data } : {}),
+        ...(ns && ns.length > 0 ? { ns } : {}),
+        ...(nodeName ? { nodeName } : {}),
+    };
+}
+function normalizeCompatibleStreamPart(event) {
+    const custom = extractCustomCompatibleStreamPart(event.raw);
+    if (custom) {
+        return custom;
+    }
+    const ns = event.ns ?? [];
+    const messageChunk = extractMessageCompatibleStreamPart(event);
+    if (messageChunk) {
+        return {
+            type: "messages",
+            ns,
+            data: [messageChunk, buildStreamPartMetadata(event)],
+        };
+    }
+    return {
+        type: "updates",
+        ns,
+        data: buildUpdateCompatiblePayload(event),
+    };
+}
+function buildStreamPartMetadata(event) {
+    return {
+        ...(event.metadata ?? {}),
+        ...(event.event ? { event: event.event } : {}),
+        ...(event.name ? { name: event.name } : {}),
+        ...(event.runType ? { run_type: event.runType } : {}),
+        ...(event.tags && event.tags.length > 0 ? { tags: event.tags } : {}),
+    };
+}
+function extractMessageCompatibleStreamPart(event) {
+    const typed = asObject(event.raw);
+    const data = asObject(typed?.data);
+    if (event.event === "on_chat_model_stream" && data && "chunk" in data) {
+        return data.chunk;
+    }
+    if (event.normalized.kind === "tool-end") {
+        return {
+            type: "tool",
+            name: event.normalized.toolName,
+            content: event.normalized.output,
+            ...(event.normalized.isError !== undefined ? { isError: event.normalized.isError } : {}),
+        };
+    }
+    return null;
+}
+function buildUpdateCompatiblePayload(event) {
+    const key = event.name ?? event.event ?? "event";
+    return {
+        [key]: extractUpdateNodePayload(event),
+    };
+}
+function extractUpdateNodePayload(event) {
+    const data = event.data;
+    if (event.event === "on_chain_stream" && data && "chunk" in data) {
+        return data.chunk;
+    }
+    if ((event.event === "on_tool_start" || event.event === "on_chain_start") && data && "input" in data) {
+        return { input: data.input };
+    }
+    if ((event.event === "on_tool_end" || event.event === "on_chain_end" || event.event === "on_chat_model_end") && data && "output" in data) {
+        return data.output;
+    }
+    if ((event.event === "on_tool_error" || event.event === "on_chain_error") && data) {
+        return {
+            ...(data.output !== undefined ? { output: data.output } : {}),
+            ...(data.error !== undefined ? { error: data.error } : {}),
+        };
+    }
+    if (event.normalized.kind === "interrupt") {
+        return { __interrupt__: event.normalized.interrupt };
+    }
+    return data ?? {};
+}
+export function extractCustomCompatibleStreamPart(event) {
+    const custom = extractCustomStreamData(event);
+    if (!custom) {
+        return null;
+    }
+    return {
+        type: "custom",
+        ns: custom.ns ?? [],
+        data: custom.data,
+    };
+}
 function formatStepValue(value, maxLength = 120) {
     if (value == null)
         return "";

package/dist/runtime/sqlite-maintained-checkpoint-saver.d.ts

@@ -1,9 +1 @@
-import { SqliteSaver } from "@langchain/langgraph-checkpoint-sqlite";
-import type { RunnableConfig } from "@langchain/core/runnables";
-export declare class ManagedSqliteSaver extends SqliteSaver {
-    constructor(db: ConstructorParameters<typeof SqliteSaver>[0]);
-    prepareMaintenance(): void;
-    setup(): void;
-    put(config: RunnableConfig, checkpoint: Parameters<SqliteSaver["put"]>[1], metadata: Parameters<SqliteSaver["put"]>[2]): Promise<RunnableConfig<Record<string, any>>>;
-    deleteThread(threadId: string): Promise<void>;
-}
+export * from "./maintenance/sqlite-maintained-checkpoint-saver.js";

package/dist/runtime/sqlite-maintained-checkpoint-saver.js

@@ -1,39 +1 @@
-import { SqliteSaver } from "@langchain/langgraph-checkpoint-sqlite";
-export class ManagedSqliteSaver extends SqliteSaver {
-    constructor(db) {
-        super(db);
-    }
-    prepareMaintenance() {
-        this.setup();
-    }
-    setup() {
-        super.setup();
-        this.db.exec(`
-CREATE TABLE IF NOT EXISTS checkpoint_maintenance_meta (
-  thread_id TEXT NOT NULL,
-  checkpoint_ns TEXT NOT NULL DEFAULT '',
-  checkpoint_id TEXT NOT NULL,
-  created_at_ms INTEGER NOT NULL,
-  PRIMARY KEY (thread_id, checkpoint_ns, checkpoint_id)
-);`);
-    }
-    async put(config, checkpoint, metadata) {
-        const result = await super.put(config, checkpoint, metadata);
-        const threadId = result.configurable?.thread_id;
-        const checkpointNs = result.configurable?.checkpoint_ns ?? "";
-        const checkpointId = result.configurable?.checkpoint_id;
-        if (!threadId || !checkpointId) {
-            throw new Error("Missing checkpoint identity after SqliteSaver.put");
-        }
-        this.db
-            .prepare(`INSERT OR IGNORE INTO checkpoint_maintenance_meta
-         (thread_id, checkpoint_ns, checkpoint_id, created_at_ms)
-         VALUES (?, ?, ?, ?)`)
-            .run(threadId, checkpointNs, checkpointId, Date.now());
-        return result;
-    }
-    async deleteThread(threadId) {
-        await super.deleteThread(threadId);
-        this.db.prepare(`DELETE FROM checkpoint_maintenance_meta WHERE thread_id = ?`).run(threadId);
-    }
-}
+export * from "./maintenance/sqlite-maintained-checkpoint-saver.js";

package/dist/runtime/support/harness-support.d.ts

@@ -21,8 +21,8 @@ export declare function heuristicRoute(input: string, primaryBinding?: {
 export declare function createHarnessEvent(threadId: string, runId: string, sequence: number, eventType: string, payload: Record<string, unknown>, source?: HarnessEvent["source"]): HarnessEvent;
 export declare function createPendingApproval(threadId: string, runId: string, checkpointRef: string, input: string, interruptContent?: string): InternalApprovalRecord;
 export declare function inferRoutingBindings(workspace: WorkspaceBundle): {
-    primaryBinding: import("../../contracts/types.js").CompiledAgentBinding;
-    secondaryBinding: import("../../contracts/types.js").CompiledAgentBinding | undefined;
-    researchBinding: import("../../contracts/types.js").CompiledAgentBinding | undefined;
-    hostBindings: import("../../contracts/types.js").CompiledAgentBinding[];
+    primaryBinding: import("../../contracts/workspace.js").CompiledAgentBinding;
+    secondaryBinding: import("../../contracts/workspace.js").CompiledAgentBinding | undefined;
+    researchBinding: import("../../contracts/workspace.js").CompiledAgentBinding | undefined;
+    hostBindings: import("../../contracts/workspace.js").CompiledAgentBinding[];
 };

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

@@ -133,14 +133,25 @@ export function inferRoutingBindings(workspace) {
     const runtimeEntryBindings = Array.from(workspace.bindings.values()).filter((binding) => isRuntimeEntryBinding(binding));
     const orchestrationHosts = runtimeEntryBindings.filter((binding) => binding.agent.executionMode === "deepagent" || binding.agent.executionMode === "langgraph" || Boolean(binding.deepAgentParams));
     const routingHosts = orchestrationHosts.length > 0 ? orchestrationHosts : runtimeEntryBindings;
+    const deepAgentHosts = routingHosts.filter((binding) => binding.agent.executionMode === "deepagent" || Boolean(binding.deepAgentParams));
+    const nonDeepAgentHosts = routingHosts.filter((binding) => !deepAgentHosts.includes(binding));
     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));
+    const deepAgentDelegationHosts = deepAgentHosts.filter((binding) => isDelegationCapableBinding(binding));
+    const nonDeepAgentDelegationHosts = nonDeepAgentHosts.filter((binding) => isDelegationCapableBinding(binding));
     const lightweightHosts = routingHosts.filter((binding) => !isDelegationCapableBinding(binding));
     const defaultOrchestratingHost = routingHosts.find((binding) => binding.agent.id === "orchestra") ??
-        delegationHosts.find((binding) => (binding.deepAgentParams?.subagents.length ?? 0) > 0) ??
-        delegationHosts[0];
-    const delegationPreferredSecondary = delegationHosts.find((binding) => (binding.deepAgentParams?.subagents.length ?? 0) > 0) ??
+        deepAgentDelegationHosts.find((binding) => (binding.deepAgentParams?.subagents.length ?? 0) > 0) ??
+        deepAgentDelegationHosts[0] ??
+        deepAgentHosts[0] ??
+        nonDeepAgentDelegationHosts.find((binding) => (binding.deepAgentParams?.subagents.length ?? 0) > 0) ??
+        nonDeepAgentDelegationHosts[0] ??
+        nonDeepAgentHosts[0];
+    const delegationPreferredSecondary = deepAgentDelegationHosts.find((binding) => (binding.deepAgentParams?.subagents.length ?? 0) > 0) ??
+        deepAgentDelegationHosts[0] ??
+        nonDeepAgentDelegationHosts.find((binding) => (binding.deepAgentParams?.subagents.length ?? 0) > 0) ??
+        nonDeepAgentDelegationHosts[0] ??
         delegationHosts[0];
     const genericLightweightHost = lightweightHosts.find((binding) => binding.agent.id !== researchBinding?.agent.id);
     const primaryBinding = defaultOrchestratingHost ?? directBinding ?? genericLightweightHost ?? routingHosts[0] ?? runtimeEntryBindings[0];

package/dist/runtime/support/runtime-factories.d.ts

@@ -1,3 +1,3 @@
-import { type StoreLike } from "../store.js";
+import { type StoreLike } from "../harness/system/store.js";
 export declare function createStoreForConfig(storeConfig: Record<string, unknown>, runRoot: string): StoreLike;
 export declare function createCheckpointerForConfig(checkpointerConfig: Record<string, unknown> | boolean, runRoot: string): unknown;

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

@@ -3,7 +3,7 @@ import { MemorySaver } from "@langchain/langgraph";
 import { SqliteSaver } from "@langchain/langgraph-checkpoint-sqlite";
 import { FileCheckpointSaver } from "../file-checkpoint-saver.js";
 import { ManagedSqliteSaver } from "../sqlite-maintained-checkpoint-saver.js";
-import { createInMemoryStore, FileBackedStore } from "../store.js";
+import { createInMemoryStore, FileBackedStore } from "../harness/system/store.js";
 export function createStoreForConfig(storeConfig, runRoot) {
     const kind = typeof storeConfig.kind === "string" ? storeConfig.kind : "FileStore";
     switch (kind) {

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

@@ -261,6 +261,22 @@ function resolveLangGraphWorkflowConfig(agent, refs) {
             agent.langchainAgentConfig.passthrough.with
             ? { ...agent.langchainAgentConfig.passthrough.with }
             : undefined;
+    const workspaceProfile = profile ? getWorkspaceObject(refs, `runtime-profile/${profile}`) : undefined;
+    if (workspaceProfile && workspaceProfile.kind !== "runtime-profile") {
+        throw new Error(`Agent ${agent.id} profile ${profile} does not resolve to a RuntimeProfile object`);
+    }
+    const workspaceProfileValue = workspaceProfile?.value && typeof workspaceProfile.value === "object"
+        ? workspaceProfile.value
+        : undefined;
+    const workspaceProfileDefaults = typeof workspaceProfileValue?.defaults === "object" && workspaceProfileValue.defaults
+        ? workspaceProfileValue.defaults
+        : undefined;
+    const mergedProfileWith = workspaceProfileDefaults || profileWith
+        ? {
+            ...(workspaceProfileDefaults ?? {}),
+            ...(profileWith ?? {}),
+        }
+        : undefined;
     const preset = typeof agent.langchainAgentConfig?.preset === "string" && agent.langchainAgentConfig.preset.trim()
         ? agent.langchainAgentConfig.preset.trim()
         : typeof agent.langchainAgentConfig?.passthrough === "object" &&
@@ -284,21 +300,41 @@ function resolveLangGraphWorkflowConfig(agent, refs) {
                     agent.langchainAgentConfig.passthrough.langgraph
                     ? agent.langchainAgentConfig.passthrough.langgraph
                     : undefined;
+    const profileWorkflowRef = typeof workspaceProfileValue?.workflowRef === "string" && workspaceProfileValue.workflowRef.trim()
+        ? workspaceProfileValue.workflowRef.trim()
+        : typeof workspaceProfileValue?.workflow === "string" && workspaceProfileValue.workflow.trim()
+            ? workspaceProfileValue.workflow.trim()
+            : typeof workspaceProfileValue?.workflow === "object" &&
+                workspaceProfileValue.workflow &&
+                typeof workspaceProfileValue.workflow.ref === "string" &&
+                workspaceProfileValue.workflow.ref.trim()
+                ? workspaceProfileValue.workflow.ref.trim()
+                : undefined;
+    const resolvedProfileWorkflowConfig = !workflowConfig && profileWorkflowRef
+        ? materializeWorkspaceObjectConfig(refs, profileWorkflowRef, ["langgraph-workflow"], `Agent ${agent.id} profile ${profile} workflow`)
+        : undefined;
     if (!workflowConfig) {
-        return profile || preset ? { ...(profile ? { profile } : {}), ...(profileWith ? { with: profileWith } : {}), ...(preset ? { preset } : {}) } : undefined;
+        return profile || preset || resolvedProfileWorkflowConfig
+            ? {
+                ...(profile ? { profile } : {}),
+                ...(mergedProfileWith ? { with: mergedProfileWith } : {}),
+                ...(preset ? { preset } : {}),
+                ...(resolvedProfileWorkflowConfig ? { config: resolvedProfileWorkflowConfig } : {}),
+            }
+            : undefined;
     }
     if (isRefConfig(workflowConfig)) {
         return {
             config: materializeWorkspaceObjectConfig(refs, workflowConfig.ref, ["langgraph-workflow"], `Agent ${agent.id} workflow`),
             ...(profile ? { profile } : {}),
-            ...(profileWith ? { with: profileWith } : {}),
+            ...(mergedProfileWith ? { with: mergedProfileWith } : {}),
             ...(preset ? { preset } : {}),
         };
     }
     return {
         config: workflowConfig,
         ...(profile ? { profile } : {}),
-        ...(profileWith ? { with: profileWith } : {}),
+        ...(mergedProfileWith ? { with: mergedProfileWith } : {}),
         ...(preset ? { preset } : {}),
     };
 }

package/dist/workspace/object-loader.js

@@ -152,6 +152,8 @@ function normalizeKind(kind) {
             return "runtime-memory";
         case "LangGraphWorkflow":
             return "langgraph-workflow";
+        case "RuntimeProfile":
+            return "runtime-profile";
         case "Prompt":
             return "prompt";
         case "McpServer":
@@ -473,7 +475,9 @@ async function objectItemsFromDocument(document, sourcePath) {
                         ? normalizeCatalogSpec(document, { defaultKind: "McpServer" })
                         : catalogKind === "LangGraphWorkflows"
                             ? normalizeCatalogSpec(document, { defaultKind: "LangGraphWorkflow" })
-                            : [];
+                            : catalogKind === "RuntimeProfiles"
+                                ? normalizeCatalogSpec(document, { defaultKind: "RuntimeProfile" })
+                                : [];
     if (catalogItems.length > 0) {
         return catalogItems;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botbotgo/agent-harness",
-  "version": "0.0.95",
+  "version": "0.0.97",
   "description": "Workspace runtime for multi-agent applications",
   "type": "module",
   "packageManager": "npm@10.9.2",
@@ -53,9 +53,9 @@
   "scripts": {
     "build": "rm -rf dist tsconfig.tsbuildinfo && tsc -p tsconfig.json && cp -R config dist/",
     "check": "tsc -p tsconfig.json --noEmit",
-    "test": "vitest run test/hello-file.test.ts test/public-api.test.ts test/runtime-health.test.ts test/memory-runtime.test.ts test/sqlite-persistence.test.ts test/runtime-queue-lease.test.ts test/runtime-cancel.test.ts test/runtime-record-maintenance.test.ts test/resource-optional-provider.test.ts test/resource-isolation.test.ts test/stock-research-app-load-harness.test.ts test/stock-research-app-run.test.ts test/stock-research-app-config.test.ts test/release-workflow.test.ts test/release-version.test.ts test/gitignore.test.ts test/package-lock.test.ts test/readme.test.ts test/product-boundary-docs.test.ts test/long-term-memory-docs.test.ts test/local-docs-persistence-inventory.test.ts test/docs-site.test.ts test/runtime-adapter-regressions.test.ts test/runtime-capabilities.test.ts test/runtime-recovery.test.ts test/tool-extension-gaps.test.ts test/checkpoint-maintenance.test.ts test/llamaindex-dependency-compat.test.ts test/skill-standard.test.ts test/routing-config.test.ts test/workspace-compat-regressions.test.ts test/upstream-compat-regressions.test.ts test/upstream-runtime-ab-benchmark.test.ts test/yaml-format.test.ts test/config-secrets.test.ts test/init-command.test.ts test/coding-agent-guide.test.ts",
-    "test:upstream-ab-real": "vitest run test/upstream-runtime-ab-real.test.ts",
-    "test:real-providers": "vitest run test/real-provider-harness.test.ts",
+    "test": "vitest run $(find test -name '*.test.ts' -print | sort)",
+    "test:upstream-ab-real": "vitest run test/benchmark/upstream-runtime-ab-real.test.ts",
+    "test:real-providers": "vitest run test/providers/real-provider-harness.test.ts",
     "release:prepare": "npm version patch --no-git-tag-version && node ./scripts/sync-example-version.mjs",
     "release:pack": "npm pack --dry-run",
     "release:publish": "npm publish --access public --registry https://registry.npmjs.org/"

package/dist/runtime/langgraph-presets.js

@@ -1,165 +0,0 @@
-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(", ")}`);
-    }
-}