@botbotgo/agent-harness 0.0.95 → 0.0.96

package/dist/runtime/langgraph-profiles.js

@@ -28,28 +28,28 @@ function buildCodingRuntimeWorkflow(options) {
     const verifierAgent = readStringOption(options, "verifierAgent");
     const needsVerification = Boolean(verifierAgent) || options.runIntegrationVerification === true;
     return {
-        entryNode: "planner",
+        entryNode: "step1",
         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 },
+            { id: "step1", kind: "llm", role: "planner", prompt: DEFAULT_PLANNER_PROMPT },
+            { id: "step2", kind: "agent", agent: coderAgent },
+            { id: "step3", kind: "llm", role: "reviewer", prompt: DEFAULT_REVIEWER_PROMPT },
+            { id: "step4", kind: "llm", role: "replanner", prompt: DEFAULT_REPLANNER_PROMPT },
             ...(needsVerification
-                ? [{ id: "approval", kind: "approval" }, { id: "verifier", kind: "agent", agent: verifierAgent ?? coderAgent }]
+                ? [{ id: "step5", kind: "approval" }, { id: "step6", kind: "agent", agent: verifierAgent ?? coderAgent }]
                 : []),
-            { id: "finalizer", kind: "llm", role: "finalizer", prompt: DEFAULT_FINALIZER_PROMPT },
+            { id: "step7", 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" },
+            { from: "step1", to: "step2" },
+            { from: "step2", to: "step3", when: "has_result" },
+            { from: "step3", to: needsVerification ? "step5" : "step7", when: "review_ok" },
+            { from: "step3", to: "step4", when: "review_incomplete" },
+            { from: "step4", to: "step2", 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" },
+                    { from: "step5", to: "step6", when: "approval_approved" },
+                    { from: "step5", to: "step6", when: "approval_edited" },
+                    { from: "step6", to: "step7", when: "has_result" },
                 ]
                 : []),
         ],
@@ -61,21 +61,21 @@ function buildAssistantWorkflow(options) {
         readStringOption(options, "defaultWritingAgent") ??
         readStringOption(options, "defaultSchedulingAgent");
     return {
-        entryNode: "intake",
+        entryNode: "step1",
         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 },
+            { id: "step1", kind: "llm", role: "planner", prompt: DEFAULT_PLANNER_PROMPT },
+            ...(worker ? [{ id: "step2", kind: "agent", agent: worker }] : [{ id: "step2", kind: "tool", tool: "repo_inventory" }]),
+            { id: "step3", kind: "llm", role: "reviewer", prompt: DEFAULT_REVIEWER_PROMPT },
+            { id: "step4", kind: "approval" },
+            { id: "step5", 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" },
+            { from: "step1", to: "step2" },
+            { from: "step2", to: "step3", when: "has_result" },
+            { from: "step3", to: "step4", when: "review_incomplete" },
+            { from: "step3", to: "step5", when: "review_ok" },
+            { from: "step4", to: "step5", when: "approval_approved" },
+            { from: "step4", to: "step5", when: "approval_edited" },
         ],
     };
 }
@@ -84,22 +84,22 @@ function buildResearchWorkflow(options) {
     const analystAgent = requireAgentOption("research-runtime", options, "analystAgent");
     const synthesizerAgent = readStringOption(options, "synthesizerAgent");
     return {
-        entryNode: "planner",
+        entryNode: "step1",
         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 },
+            { id: "step1", kind: "llm", role: "planner", prompt: DEFAULT_PLANNER_PROMPT },
+            { id: "step2", kind: "agent", agent: gathererAgent },
+            { id: "step3", kind: "llm", role: "reviewer", prompt: DEFAULT_REVIEWER_PROMPT },
+            { id: "step4", kind: "agent", agent: analystAgent },
+            ...(synthesizerAgent ? [{ id: "step5", kind: "agent", agent: synthesizerAgent }] : []),
+            { id: "step6", 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" }] : []),
+            { from: "step1", to: "step2" },
+            { from: "step2", to: "step3", when: "has_result" },
+            { from: "step3", to: "step4", when: "review_ok" },
+            { from: "step3", to: "step2", when: "review_incomplete" },
+            { from: "step4", to: synthesizerAgent ? "step5" : "step6", when: "has_result" },
+            ...(synthesizerAgent ? [{ from: "step5", to: "step6", when: "has_result" }] : []),
         ],
     };
 }
@@ -107,20 +107,20 @@ function buildApprovalReviewWorkflow(options) {
     const preparerAgent = requireAgentOption("approval-review-runtime", options, "preparerAgent");
     const reviewerAgent = readStringOption(options, "reviewerAgent");
     return {
-        entryNode: "scope",
+        entryNode: "step1",
         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 },
+            { id: "step1", kind: "llm", role: "planner", prompt: DEFAULT_PLANNER_PROMPT },
+            { id: "step2", kind: "agent", agent: preparerAgent },
+            ...(reviewerAgent ? [{ id: "step3", kind: "agent", agent: reviewerAgent }] : [{ id: "step3", kind: "llm", role: "reviewer", prompt: DEFAULT_REVIEWER_PROMPT }]),
+            { id: "step4", kind: "approval" },
+            { id: "step5", 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" },
+            { from: "step1", to: "step2" },
+            { from: "step2", to: "step3", when: "has_result" },
+            { from: "step3", to: "step4", when: "has_result" },
+            { from: "step4", to: "step5", when: "approval_approved" },
+            { from: "step4", to: "step5", when: "approval_edited" },
         ],
     };
 }
@@ -133,30 +133,30 @@ function buildChatOperatorWorkflow(options) {
         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",
+        entryNode: "step1",
         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 },
+            { id: "step1", kind: "llm", role: "planner", prompt: DEFAULT_PLANNER_PROMPT },
+            { id: "step2", kind: "agent", agent: routedAgent },
+            { id: "step3", kind: "llm", role: "finalizer", prompt: DEFAULT_FINALIZER_PROMPT },
         ],
         edges: [
-            { from: "router", to: "worker" },
-            { from: "worker", to: "finalizer", when: "has_result" },
+            { from: "step1", to: "step2" },
+            { from: "step2", to: "step3", when: "has_result" },
         ],
     };
 }
 function buildCopilotSidecarWorkflow(options) {
     const coderAgent = requireAgentOption("copilot-sidecar", options, "coderAgent");
     return {
-        entryNode: "intake",
+        entryNode: "step1",
         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 },
+            { id: "step1", kind: "llm", role: "planner", prompt: DEFAULT_PLANNER_PROMPT },
+            { id: "step2", kind: "agent", agent: coderAgent },
+            { id: "step3", kind: "llm", role: "finalizer", prompt: DEFAULT_FINALIZER_PROMPT },
         ],
         edges: [
-            { from: "intake", to: "coder" },
-            { from: "coder", to: "finalizer", when: "has_result" },
+            { from: "step1", to: "step2" },
+            { from: "step2", to: "step3", when: "has_result" },
         ],
     };
 }
@@ -166,17 +166,17 @@ function buildDelegationHubWorkflow(options) {
         throw new Error("LangGraph profile task-delegation-hub requires with.defaultWorkerFallback");
     }
     return {
-        entryNode: "router",
+        entryNode: "step1",
         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 },
+            { id: "step1", kind: "llm", role: "planner", prompt: DEFAULT_PLANNER_PROMPT },
+            { id: "step2", kind: "agent", agent: workerAgent },
+            { id: "step3", kind: "llm", role: "reviewer", prompt: DEFAULT_REVIEWER_PROMPT },
+            { id: "step4", 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" },
+            { from: "step1", to: "step2" },
+            { from: "step2", to: "step3", when: "has_result" },
+            { from: "step3", to: "step4", when: "review_ok" },
         ],
     };
 }

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

@@ -1,4 +1,8 @@
+import type { CompatibleStreamPart, UpstreamRuntimeEvent } from "../../contracts/types.js";
 export type RuntimeStreamChunk = {
+    kind: "upstream-event";
+    event: UpstreamRuntimeEvent;
+} | {
     kind: "content";
     content: string;
 } | {
@@ -16,6 +20,8 @@ export type RuntimeStreamChunk = {
     output: unknown;
     isError?: boolean;
 };
+export declare function normalizeUpstreamRuntimeEvent(event: unknown): UpstreamRuntimeEvent;
+export declare function extractCustomCompatibleStreamPart(event: unknown): CompatibleStreamPart | null;
 export declare function extractTerminalStreamOutput(event: unknown): string;
 export declare function extractReasoningStreamOutput(event: unknown): string;
 export declare function extractVisibleStreamOutput(event: unknown): string;

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