melchizedek-agents 0.20.0 → 1.0.0

package/dist/lib/workflow/turn.js

@@ -2,28 +2,27 @@
  * lib/workflow/turn.ts — one turn of a workflow syndicate on the native
  * runtime: the message stored, the graph walked by the engine's scheduler,
  * and every event the walk stores yielded in the order it was stored, the
- * node inputs aside, as ADK's Runner yields them (ADR 0095).
+ * node inputs aside, as ADK's Runner yielded them (ADR 0095).
  *
  * WHY this file exists:
- *   runSyndicateTurn (lib/runtime/syndicateTurn.ts) runs a workflow on ADK
- *   by handing ADK's Workflow to its Runner and draining the events the
- *   Runner yields (drainAgentStream). On the native runtime it hands this
- *   generator to the same drain, under the same root span, so the progress
- *   lines, onProgress calls, node errors, the paused input and the ledger
- *   rows come out of one reader on both runtimes. Everything a node does is
+ *   runSyndicateTurn (lib/runtime/syndicateTurn.ts) hands this generator to
+ *   the turn's reader (drainAgentStream), under the turn's root span, as it
+ *   once handed ADK's Runner stream, so the progress lines, onProgress
+ *   calls, node errors, the paused input and the ledger rows come out of
+ *   the one reader every turn uses. Everything a node does is
  *   the WS4 modules': the scheduler (scheduler.ts), agent nodes on the
  *   native loop (agentNode.ts), tool nodes (toolNode.ts), ask_user nodes and
  *   the workflow's pause record (pause.ts), and the resume rebuilt from the
  *   session (resume.ts). This file wires them for one turn, as ADK's Runner
- *   and Workflow wire theirs:
+ *   and Workflow wired theirs:
  *
  *   1. THE MESSAGE. Stored as the user's event under a new `e-` invocation
- *      id, before the walk, as the Runner stores it (runNativeAgent does the
+ *      id, before the walk, as the Runner stored it (runNativeAgent does the
  *      same for one agent). A turn whose signal aborted first stores nothing.
  *   2. THE START. workflowResume rebuilds every node's prior runs and the
- *      answers from the session, as ADK's rehydration does on every message:
+ *      answers from the session, as ADK's rehydration did on every message:
  *      with nothing paused every node runs fresh. The walk's input is the
- *      message's text, not its content, as ADK hands its root workflow, and
+ *      message's text, not its content, as ADK handed its root workflow, and
  *      that text is what the workflow's pause record keeps. A pause only ADK
  *      can resume (UnsupportedWorkflowResumeError) fails the turn; it never
  *      walks afresh and asks the person again.
@@ -32,18 +31,18 @@
  *      turn's signal. Every event a runner stores goes through the agent
  *      node runtime's one queue, in walk order: node inputs, the agents'
  *      events, tool and ask_user events, route steps, joins and maps, and
- *      the node-error event ADK writes for a node that gave up
+ *      the node-error event ADK wrote for a node that gave up
  *      (nodeErrorEvent, on the scheduler's `workflow` node_error). A node's
- *      input turn is stored and not yielded, as ADK's Runner never yields
+ *      input turn is stored and not yielded, as ADK's Runner never yielded
  *      it; a node agent's partial (streamed) event is yielded and not
- *      stored, as the Runner yields it.
+ *      stored, as the Runner yielded it.
  *   4. THE END. A paused walk stores the workflow's own record
  *      (workflowPauseEvent) after every node's event. A walk the turn
  *      stopped (InvocationAbortedError, or any failure once the signal
- *      fired) ends quietly, as ADK's Runner ends an aborted run: the turn
+ *      fired) ends quietly, as ADK's Runner ended an aborted run: the turn
  *      runner reads the stop reason from its control. A node that gave up
  *      rethrows its error once every event is stored and yielded, as ADK's
- *      Runner throws it.
+ *      Runner threw it.
  *   5. THE SPANS. `workflow.invoke <name>` around the walk, `node.execute
  *      <name>` around each node run (the scheduler's traceNode hook), and
  *      `tool.execute <name>` around a tool node's call
@@ -53,24 +52,104 @@
  *
  * WHAT IT REFUSES before any model call: refuseUnrunnableNodes throws, for
  * a tool node, ADK's compile-time refusals (an unregistered tool, a
- * long-running one). A pause raised inside an agent node is refused by
+ * long-running one), and an ADK tool (anything with runAsync), which 1.0.0
+ * no longer runs. A pause raised inside an agent node is refused by
  * runAgentNode by name.
  *
  * It imports nothing from ADK: the caller passes the tool lookup (the
- * registry builds ADK's tools) and the store as the engine's interface.
+ * registry's own Tools) and the store as the engine's interface.
  * The message, the answers and every stored event are data the walk
  * carries, never instructions this module acts on.
  */
 import { randomUUID } from 'node:crypto';
 import { createTurnEvent } from '../runtime/events.js';
 import { traceNodeExecution, traceToolNodeCall, traceWorkflowInvocation } from '../runtime/native/telemetry.js';
-import { agentNodeRuntime } from './agentNode.js';
+import { TEMP_STATE_PREFIX } from '../runtime/sessions.js';
+import { NodeStoppedError, agentNodeRuntime, nodeInputContent } from './agentNode.js';
 import { askUserNodeRunner, workflowPauseEvent } from './pause.js';
 import { workflowResume } from './resume.js';
 import { InvocationAbortedError, nodeErrorEvent, runWorkflowGraph } from './scheduler.js';
-import { resolveToolNode, toolNodeRunner } from './toolNode.js';
+import { enrichNodeEvent, resolveToolNode, toolNodeRunner } from './toolNode.js';
+/** ADK's AgentTool answer: the last event's non-thought text parts, joined by a newline. */
+function lastText(event) {
+    return (event?.content?.parts ?? [])
+        .filter((p) => !p.thought)
+        .map((p) => p.text)
+        .filter((t) => t)
+        .join('\n');
+}
+/**
+ * Runs `workflow` as the node `run` names (ADR 0106), as a delegated nested
+ * workflow runs (ADR 0098): the whole graph walked on the child session
+ * under the node's name (created from the caller's state the first time,
+ * `temp:` keys dropped, and kept), the node's input as its message, its last
+ * yielded event's text the node's output. The caller stores one event for
+ * the node, carrying that output and the walk's state writes, so a resumed
+ * walk completes the node from it. A walk that ends paused is refused by
+ * name: a pause cannot reach the caller's walk yet (WS6-2).
+ */
+async function runWorkflowNode(name, workflow, run, params, parent) {
+    const { sessions, userId, sessionId } = params;
+    const key = { appName: name, userId, sessionId };
+    const state = Object.fromEntries(Object.entries(parent.session.state ?? {}).filter(([k]) => !k.startsWith(TEMP_STATE_PREFIX)));
+    if (!(await sessions.get(key)))
+        await sessions.create({ ...key, state });
+    const input = run.input === undefined || run.input === null ? parent.userContent : nodeInputContent(run.input);
+    const walk = runNativeWorkflow({
+        graph: workflow.graph,
+        agents: workflow.agents,
+        resolveTool: workflow.resolveTool,
+        ...(workflow.workflows ? { workflows: workflow.workflows } : {}),
+        sessions,
+        appName: name,
+        userId,
+        sessionId,
+        userParts: input.parts ?? [],
+        adapterFor: params.adapterFor,
+        signal: run.signal,
+        stream: false,
+        ...(params.memory ? { memory: params.memory } : {}),
+        ...(params.log ? { log: params.log } : {}),
+        ...(params.selfCorrection ? { selfCorrection: params.selfCorrection } : {}),
+        ...(params.credentials ? { credentials: params.credentials } : {}),
+    });
+    let last;
+    const stateDelta = {};
+    let end;
+    for (;;) {
+        const next = await walk.next();
+        if (next.done) {
+            end = next.value;
+            break;
+        }
+        if (next.value.partial)
+            continue;
+        for (const [k, v] of Object.entries(next.value.actions?.stateDelta ?? {}))
+            if (!k.startsWith(TEMP_STATE_PREFIX))
+                stateDelta[k] = v;
+        last = next.value;
+    }
+    if (!end || end.stopped)
+        throw new NodeStoppedError(name, undefined);
+    const paused = end.run?.interruptIds ?? [];
+    if (paused.length > 0) {
+        throw new Error(`Node '${name}': the workflow it runs paused on ${paused.join(', ')}; a pause inside a workflow run as a node cannot reach the walk yet.`);
+    }
+    const output = lastText(last);
+    const event = createTurnEvent({
+        author: name,
+        invocationId: parent.invocationId,
+        content: { role: 'model', parts: [{ text: output }] },
+        ...(Object.keys(stateDelta).length ? { actions: { stateDelta } } : {}),
+    });
+    event.output = output;
+    event.nodeInfo = { messageAsOutput: true };
+    enrichNodeEvent(event, run, { invocationId: parent.invocationId });
+    parent.store(event);
+    return { output };
+}
 /**
- * Throws, before any model call, what ADK's compileWorkflow throws for a
+ * Throws, before any model call, what ADK's workflow compile threw for a
  * tool node: an unregistered tool, or a long-running one (ADR 0091).
  */
 export function refuseUnrunnableNodes(graph, resolveTool) {
@@ -83,7 +162,7 @@ const isAborted = (error) => error instanceof InvocationAbortedError || error?.n
  * Runs one turn of the workflow: stores the message, walks the graph (a
  * resume when the session holds a paused walk), and yields every event the
  * walk stores, in the order stored, but the node inputs (ADK's Runner
- * yields none of them). Returns how the walk ended, or
+ * yielded none of them). Returns how the walk ended, or
  * undefined when the signal fired before the message was stored. Throws
  * the error a node gave up with (after its events), ADK's message for a
  * reply that answers nothing, and UnsupportedWorkflowResumeError.
@@ -129,11 +208,19 @@ export async function* runNativeWorkflow(params) {
             queue.push(event);
             wake?.();
         },
-        // A node agent's streamed text, yielded as ADK's Runner yields its partial events.
+        // A node agent's streamed text, yielded as ADK's Runner yielded its partial events.
         onPartial: (event) => {
             queue.push(event);
             wake?.();
         },
+        ...(params.workflows?.size
+            ? {
+                workflowNodes: {
+                    has: (name) => params.workflows.has(name),
+                    run: (name, run) => runWorkflowNode(name, params.workflows.get(name), run, params, { session, invocationId, userContent, store }),
+                },
+            }
+            : {}),
     });
     // Every event handed over is queued a microtask later (agentNodeRuntime.store); `stored` waits for all of them.
     const handed = new Set();
@@ -192,7 +279,7 @@ export async function* runNativeWorkflow(params) {
     }).then((run) => {
         end = { run };
     }, (error) => {
-        // ADK's Runner ends an aborted run without an error; the turn's control holds why.
+        // An aborted run ends without an error, as ADK's Runner ended one; the turn's control holds why.
         if (isAborted(error) || signal?.aborted)
             end = { stopped: true };
         else

package/dist/lib/workflow.d.ts

@@ -18,77 +18,51 @@
  *       Confirm: { ask_user: "Publish? yes, or say what to change." }
  *       Planner: { route_key: "kind", retry: { max_attempts: 2 } }
  *
- * ADK 2.2 runs it (`Workflow`, `FunctionNode`, `JoinNode`, `ParallelWorker`,
- * `ToolNode`, `RequestInput`): per-node retries and timeouts, fan-out and
- * fan-in, a pause that waits for a person and resumes on the next message,
- * and resumption from the session's own events. Every agent is already a
- * node (`LlmAgent extends BaseNode`): a node agent receives the previous
- * node's output as its user turn and, unless its YAML sets
- * `includeContents`, sees nothing else of the conversation.
+ * The engine's scheduler walks it (lib/workflow/, ADR 0095): per-node
+ * retries and timeouts, fan-out and fan-in, a pause that waits for a person
+ * and resumes on the next message, and resumption from the session's own
+ * events, which are the JSON ADK's Workflow stored before 1.0.0. A node
+ * agent receives the previous node's output as its user turn and, unless
+ * its YAML sets `includeContents`, sees nothing else of the conversation.
  *
- * ── What the engine adds to ADK ───────────────────────────────────────────
- * ROUTING. ADK's TypeScript port never derives a route from an agent's
- *   output, so a routing map in YAML gets a hidden step after the agent
+ * ROUTING. A routing map in YAML gets a hidden step after the agent
  *   (`<Agent>__route`) that reads the route from the output — the
  *   `route_key` property of a JSON output, else the trimmed text — and
  *   re-emits the output with it. A `default` key catches what no key
  *   matched.
- * THE PAUSE. `ask_user` is a node that raises ADK's `RequestInput`. The
- *   turn ends `input-required` carrying the question (`result.input`); the
- *   next message on the conversation is the answer and becomes that node's
- *   output. The A2A server publishes the question; the chat prints it.
+ * THE PAUSE. `ask_user` is a node that asks the person (`adk_request_input`).
+ *   The turn ends `input-required` carrying the question (`result.input`);
+ *   the next message on the conversation is the answer and becomes that
+ *   node's output. The A2A server publishes the question; the chat prints it.
  * NAMES. Nodes are addressed by their YAML names everywhere (edges, events,
- *   the wiki), including a `map` node, which ADK would otherwise name after
- *   the agent it wraps.
+ *   the wiki), including a `map` node.
  *
  * ── As a subagent (ADR 0098) ─────────────────────────────────────────────
- * A delegated `yaml_reference` to a workflow syndicate is the whole graph:
- * `assembleWorkflow` builds its Workflow under the subagent entry's name
- * and description, and lib/compileAdk.ts wraps it in ADK's AgentTool, whose
- * answer is the graph's last event's text. A nested workflow with an
+ * A delegated `yaml_reference` to a workflow syndicate is the whole graph,
+ * walked under the subagent entry's name and description on a child
+ * session (lib/compileNative.ts workflowSubagentOf); its answer is the
+ * graph's last event's text. A nested workflow with an
  * `ask_user` node is refused by name (lib/compile.ts compileWorkflowSpec): a
- * pause inside a tool call cannot reach the caller (ADR 0028). As a dispatch
- * route or a workflow node, a workflow syndicate is still its orchestrator
- * alone.
+ * pause inside a tool call cannot reach the caller (ADR 0028).
  *
- * ── Approval gates (ADR 0098) ────────────────────────────────────────────
- * A tool in a node agent's `require_approval` pauses the node on ADK's
- * `adk_request_confirmation`, and the walk with it. Only the native walk
- * resumes it (lib/workflow/agentNode.ts): ADK's runLlmAgentAsNode reruns the
- * node from its input and never runs the pinned call, so runSyndicateTurn
- * refuses a gated workflow on ADK. The schema refuses a gate on an agent a
- * map runs (an item cannot pause the walk).
+ * ── As a dispatch route or a workflow node (ADR 0106) ────────────────────
+ * A `yaml_reference` to a workflow syndicate runs its whole graph there too,
+ * on the child session filed under the entry's name, as a subagent does. A
+ * route's answer is what the graph would answer as its own syndicate
+ * (lib/runtime/syndicateTurn.ts); a node's is the nested walk's
+ * (lib/workflow/turn.ts). A map over one is refused (lib/compile.ts).
+ *
+ * ── Approval gates (ADR 0098, ADR 0106) ──────────────────────────────────
+ * A tool in a node agent's `require_approval`, and a skill script
+ * (`skills.scripts: local`, run_skill_script), pause the node on
+ * `adk_request_confirmation`, and the walk with it; the answer resumes the
+ * pinned call (lib/workflow/agentNode.ts). The schema refuses
+ * a gate or skill scripts on an agent a map runs (an item cannot pause the
+ * walk). A script runs with ADR 0086's minimal environment, as anywhere.
  *
  * ── Not in this version ───────────────────────────────────────────────────
- * Skill scripts (`skills.scripts: local`, an approval pause) and remote
- * `a2a_agent_url` subagents are refused inside a workflow by the schema; a
- * remote agent is reachable only as a tool. Both are open for a later
- * record.
+ * Remote `a2a_agent_url` subagents are refused inside a workflow by the
+ * schema; a remote agent is reachable only as a tool. It is open for a
+ * later record.
  */
-import type { BaseNode, LlmAgent, Workflow } from '@google/adk';
-import type { CompileOptions, WorkflowSpec } from './compile.ts';
-import type { SyndicateYamlConfig } from './loadSyndicate.ts';
 export * from './workflowConfig.ts';
-export interface CompiledWorkflow {
-    workflow: Workflow;
-    /** Every agent node by YAML name, compiled. */
-    agents: Map<string, LlmAgent>;
-    /** Every node by YAML name, hidden route steps excluded. */
-    nodes: Map<string, BaseNode>;
-}
-/**
- * Compile a workflow syndicate: every agent through `compileSubagentSpec` (its
- * tools, skills and MCP server as in any mode), the declared nodes, the
- * hidden route steps, and the edge chains, into one ADK `Workflow` named
- * after the syndicate. Throws on a name the schema let through, a tool that
- * is not registered, or a graph ADK rejects (unreachable node, cycle).
- */
-export declare function compileWorkflow(config: SyndicateYamlConfig, opts?: CompileOptions, transformAgent?: (agent: LlmAgent) => LlmAgent): Promise<CompiledWorkflow>;
-/**
- * ADK's Workflow from a compiled workflow spec, synchronously: each agent
- * built by compileAdk with its node modifiers (retry, timeout) at
- * construction, then the declared nodes, route steps and edges. A nested
- * workflow (ADR 0098) is this Workflow under its subagent entry's name and
- * description, which lib/compileAdk.ts wraps in ADK's AgentTool.
- */
-export declare function assembleWorkflow(spec: WorkflowSpec, opts?: CompileOptions, transformAgent?: (agent: LlmAgent) => LlmAgent): CompiledWorkflow;

package/dist/lib/workflow.js

@@ -18,185 +18,51 @@
  *       Confirm: { ask_user: "Publish? yes, or say what to change." }
  *       Planner: { route_key: "kind", retry: { max_attempts: 2 } }
  *
- * ADK 2.2 runs it (`Workflow`, `FunctionNode`, `JoinNode`, `ParallelWorker`,
- * `ToolNode`, `RequestInput`): per-node retries and timeouts, fan-out and
- * fan-in, a pause that waits for a person and resumes on the next message,
- * and resumption from the session's own events. Every agent is already a
- * node (`LlmAgent extends BaseNode`): a node agent receives the previous
- * node's output as its user turn and, unless its YAML sets
- * `includeContents`, sees nothing else of the conversation.
+ * The engine's scheduler walks it (lib/workflow/, ADR 0095): per-node
+ * retries and timeouts, fan-out and fan-in, a pause that waits for a person
+ * and resumes on the next message, and resumption from the session's own
+ * events, which are the JSON ADK's Workflow stored before 1.0.0. A node
+ * agent receives the previous node's output as its user turn and, unless
+ * its YAML sets `includeContents`, sees nothing else of the conversation.
  *
- * ── What the engine adds to ADK ───────────────────────────────────────────
- * ROUTING. ADK's TypeScript port never derives a route from an agent's
- *   output, so a routing map in YAML gets a hidden step after the agent
+ * ROUTING. A routing map in YAML gets a hidden step after the agent
  *   (`<Agent>__route`) that reads the route from the output — the
  *   `route_key` property of a JSON output, else the trimmed text — and
  *   re-emits the output with it. A `default` key catches what no key
  *   matched.
- * THE PAUSE. `ask_user` is a node that raises ADK's `RequestInput`. The
- *   turn ends `input-required` carrying the question (`result.input`); the
- *   next message on the conversation is the answer and becomes that node's
- *   output. The A2A server publishes the question; the chat prints it.
+ * THE PAUSE. `ask_user` is a node that asks the person (`adk_request_input`).
+ *   The turn ends `input-required` carrying the question (`result.input`);
+ *   the next message on the conversation is the answer and becomes that
+ *   node's output. The A2A server publishes the question; the chat prints it.
  * NAMES. Nodes are addressed by their YAML names everywhere (edges, events,
- *   the wiki), including a `map` node, which ADK would otherwise name after
- *   the agent it wraps.
+ *   the wiki), including a `map` node.
  *
  * ── As a subagent (ADR 0098) ─────────────────────────────────────────────
- * A delegated `yaml_reference` to a workflow syndicate is the whole graph:
- * `assembleWorkflow` builds its Workflow under the subagent entry's name
- * and description, and lib/compileAdk.ts wraps it in ADK's AgentTool, whose
- * answer is the graph's last event's text. A nested workflow with an
+ * A delegated `yaml_reference` to a workflow syndicate is the whole graph,
+ * walked under the subagent entry's name and description on a child
+ * session (lib/compileNative.ts workflowSubagentOf); its answer is the
+ * graph's last event's text. A nested workflow with an
  * `ask_user` node is refused by name (lib/compile.ts compileWorkflowSpec): a
- * pause inside a tool call cannot reach the caller (ADR 0028). As a dispatch
- * route or a workflow node, a workflow syndicate is still its orchestrator
- * alone.
+ * pause inside a tool call cannot reach the caller (ADR 0028).
  *
- * ── Approval gates (ADR 0098) ────────────────────────────────────────────
- * A tool in a node agent's `require_approval` pauses the node on ADK's
- * `adk_request_confirmation`, and the walk with it. Only the native walk
- * resumes it (lib/workflow/agentNode.ts): ADK's runLlmAgentAsNode reruns the
- * node from its input and never runs the pinned call, so runSyndicateTurn
- * refuses a gated workflow on ADK. The schema refuses a gate on an agent a
- * map runs (an item cannot pause the walk).
+ * ── As a dispatch route or a workflow node (ADR 0106) ────────────────────
+ * A `yaml_reference` to a workflow syndicate runs its whole graph there too,
+ * on the child session filed under the entry's name, as a subagent does. A
+ * route's answer is what the graph would answer as its own syndicate
+ * (lib/runtime/syndicateTurn.ts); a node's is the nested walk's
+ * (lib/workflow/turn.ts). A map over one is refused (lib/compile.ts).
+ *
+ * ── Approval gates (ADR 0098, ADR 0106) ──────────────────────────────────
+ * A tool in a node agent's `require_approval`, and a skill script
+ * (`skills.scripts: local`, run_skill_script), pause the node on
+ * `adk_request_confirmation`, and the walk with it; the answer resumes the
+ * pinned call (lib/workflow/agentNode.ts). The schema refuses
+ * a gate or skill scripts on an agent a map runs (an item cannot pause the
+ * walk). A script runs with ADR 0086's minimal environment, as anywhere.
  *
  * ── Not in this version ───────────────────────────────────────────────────
- * Skill scripts (`skills.scripts: local`, an approval pause) and remote
- * `a2a_agent_url` subagents are refused inside a workflow by the schema; a
- * remote agent is reachable only as a tool. Both are open for a later
- * record.
+ * Remote `a2a_agent_url` subagents are refused inside a workflow by the
+ * schema; a remote agent is reachable only as a tool. It is open for a
+ * later record.
  */
-import { requireAdk } from './adkPeer.js';
-import { compileWorkflowSpec } from './compile.js';
-import { compileAdk } from './compileAdk.js';
-import { DEFAULT_ROUTE_KEY, ROUTE_STEP_SUFFIX, START_NAME, isWorkflowSyndicate, nodeKind, nodeSettings, routeOf } from './workflowConfig.js';
 export * from './workflowConfig.js';
-/**
- * Compile a workflow syndicate: every agent through `compileSubagentSpec` (its
- * tools, skills and MCP server as in any mode), the declared nodes, the
- * hidden route steps, and the edge chains, into one ADK `Workflow` named
- * after the syndicate. Throws on a name the schema let through, a tool that
- * is not registered, or a graph ADK rejects (unreachable node, cycle).
- */
-export async function compileWorkflow(config, opts = {}, transformAgent = (a) => a) {
-    if (!isWorkflowSyndicate(config))
-        throw new Error(`${config.syndicate_name}: no workflow block`);
-    return assembleWorkflow(await compileWorkflowSpec(config, opts), opts, transformAgent);
-}
-/**
- * ADK's Workflow from a compiled workflow spec, synchronously: each agent
- * built by compileAdk with its node modifiers (retry, timeout) at
- * construction, then the declared nodes, route steps and edges. A nested
- * workflow (ADR 0098) is this Workflow under its subagent entry's name and
- * description, which lib/compileAdk.ts wraps in ADK's AgentTool.
- */
-export function assembleWorkflow(spec, opts = {}, transformAgent = (a) => a) {
-    const config = spec.config;
-    if (!isWorkflowSyndicate(config))
-        throw new Error(`${config.syndicate_name}: no workflow block`);
-    // ADK's Workflow is the adk runtime's; the native walk (lib/workflow/turn.ts) needs none of this (ADR 0102).
-    const { DEFAULT_ROUTE, FunctionNode, JoinNode, ParallelWorker, RequestInput, ToolNode, Workflow, createEvent } = requireAdk("ADK's Workflow (a workflow syndicate on the adk runtime, compileWorkflow)");
-    const wf = config.workflow;
-    const nodeYaml = wf.nodes ?? {};
-    // Agents, with their node modifiers (retry, timeout) at construction; not on a nested syndicate's orchestrator.
-    const agents = new Map();
-    for (const { yaml, spec: agentSpec } of spec.agents) {
-        const settings = yaml.yaml_reference ? {} : nodeSettings(nodeYaml[yaml.name]);
-        agents.set(yaml.name, transformAgent(compileAdk(agentSpec, opts, settings)));
-    }
-    // Declared nodes.
-    const nodes = new Map(agents);
-    for (const [name, entry] of Object.entries(nodeYaml)) {
-        const kind = nodeKind(entry);
-        if (!kind)
-            continue; // modifiers on an agent
-        const settings = nodeSettings(entry);
-        if (kind === 'ask_user') {
-            const message = entry.ask_user ?? '';
-            const schema = entry.schema;
-            // The node runs again on resume (rerunOnResume): ADK then hands it the
-            // same input and the answers resolved so far, so its output can carry
-            // BOTH the reply and what the person was asked about. A node fast-
-            // forwarded by ADK would output the bare reply, and the next agent
-            // would never see the draft it is meant to act on.
-            nodes.set(name, new FunctionNode(name, (ctx, input) => {
-                const replies = Object.values(ctx.resumeInputs);
-                if (replies.length > 0)
-                    return { reply: replies[replies.length - 1], input };
-                return new RequestInput({ message, payload: input, ...(schema ? { responseSchema: schema } : {}) });
-            }, { ...settings, rerunOnResume: true }));
-        }
-        else if (kind === 'join') {
-            nodes.set(name, new JoinNode({ name, ...settings }));
-        }
-        else if (kind === 'map') {
-            const inner = agents.get(entry.map);
-            if (!inner)
-                throw new Error(`workflow node '${name}': map names '${entry.map}', which is not an agent of this syndicate`);
-            const worker = new ParallelWorker(inner, entry.max_parallel !== undefined ? { maxParallelWorkers: entry.max_parallel } : {});
-            // ADK names a worker after the agent it wraps; the YAML name is what
-            // the edges, the events and the docs use.
-            Object.defineProperty(worker, 'name', { value: name, enumerable: true });
-            nodes.set(name, worker);
-        }
-        else if (kind === 'tool') {
-            const tool = spec.resolveTool(entry.tool);
-            if (!tool)
-                throw new Error(`workflow node '${name}': tool '${entry.tool}' is not registered`);
-            nodes.set(name, new ToolNode(tool, { name, ...settings }));
-        }
-    }
-    const nodeOf = (name) => {
-        const node = nodes.get(name);
-        if (!node)
-            throw new Error(`workflow: '${name}' is not an agent or a declared node of this syndicate`);
-        return node;
-    };
-    const routeSteps = new Map();
-    const routeStepAfter = (name) => {
-        let step = routeSteps.get(name);
-        if (step)
-            return step;
-        const routeKey = nodeYaml[name]?.route_key ?? 'route';
-        const stepName = `${name}${ROUTE_STEP_SUFFIX}`;
-        step = new FunctionNode(stepName, (ctx, input) => createEvent({
-            author: stepName,
-            invocationId: ctx.invocationId,
-            branch: ctx.branch,
-            output: input,
-            route: routeOf(input, routeKey),
-        }));
-        routeSteps.set(name, step);
-        return step;
-    };
-    const edges = wf.edges.map((chain) => {
-        const out = [];
-        chain.forEach((element, i) => {
-            if (typeof element === 'string') {
-                out.push(element === START_NAME ? 'START' : nodeOf(element));
-            }
-            else if (Array.isArray(element)) {
-                out.push(element.map(nodeOf));
-            }
-            else {
-                const previous = chain[i - 1];
-                if (typeof previous !== 'string' || previous === START_NAME) {
-                    throw new Error(`workflow: a routing map must follow the name of the node whose output it routes`);
-                }
-                out.push(routeStepAfter(previous));
-                const map = {};
-                for (const [key, target] of Object.entries(element)) {
-                    map[key === DEFAULT_ROUTE_KEY ? DEFAULT_ROUTE : key] = Array.isArray(target) ? target.map(nodeOf) : nodeOf(target);
-                }
-                out.push(map);
-            }
-        });
-        return out;
-    });
-    const workflow = new Workflow({
-        name: spec.name,
-        ...(spec.description ? { description: spec.description } : {}),
-        edges,
-        ...(wf.max_concurrency !== undefined ? { maxConcurrency: wf.max_concurrency } : {}),
-    });
-    return { workflow, agents, nodes };
-}

package/dist/lib/workflowConfig.d.ts

@@ -4,7 +4,6 @@
  * the compiler (lib/workflow.ts) and the turn runner share. No imports
  * beyond types, so the schema can read it without pulling the compiler in.
  */
-import type { RetryConfig as AdkRetryConfig } from '@google/adk';
 /** `START` in an edge chain: the graph's entry. Not a node. */
 export declare const START_NAME = "START";
 /** The routing-map key that catches an unmatched route. */
@@ -63,18 +62,11 @@ export declare const NODE_KINDS: readonly ['ask_user', 'join', 'map', 'tool'];
 export declare function nodeKind(node: WorkflowNodeYaml | undefined): (typeof NODE_KINDS)[number] | undefined;
 /** Every name an edge element references (`START` excluded). */
 export declare function elementNames(element: EdgeElement): string[];
-/** ADK's retry config from the YAML spelling. */
-export declare function toRetryConfig(retry: RetryYaml | undefined): AdkRetryConfig | undefined;
-/** The BaseNode fields a node entry's modifiers map to. */
-export declare function nodeSettings(node: WorkflowNodeYaml | undefined): {
-    retryConfig?: AdkRetryConfig;
-    timeout?: number;
-};
 /**
  * The route an output names: the `routeKey` property of an object (a parsed
  * JSON output), else the trimmed text. Never undefined, so an edge with a
- * `default` key always has something to fall back from. One function for
- * both runtimes; it lives in lib/workflow/route.ts.
+ * `default` key always has something to fall back from. It lives in
+ * lib/workflow/route.ts.
  */
 export { routeOf } from './workflow/route.ts';
 /** A pause raised by an `ask_user` node, read from the run's events (`adk_request_input`). */

package/dist/lib/workflowConfig.js

@@ -29,40 +29,11 @@ export function elementNames(element) {
         return element;
     return Object.values(element).flatMap((v) => (Array.isArray(v) ? v : [v]));
 }
-/** ADK's retry config from the YAML spelling. */
-export function toRetryConfig(retry) {
-    if (!retry)
-        return undefined;
-    const out = {};
-    if (retry.max_attempts !== undefined)
-        out.maxAttempts = retry.max_attempts;
-    if (retry.initial_delay !== undefined)
-        out.initialDelay = retry.initial_delay;
-    if (retry.max_delay !== undefined)
-        out.maxDelay = retry.max_delay;
-    if (retry.backoff_factor !== undefined)
-        out.backoffFactor = retry.backoff_factor;
-    if (retry.jitter !== undefined)
-        out.jitter = retry.jitter;
-    if (retry.exceptions !== undefined)
-        out.exceptions = [...retry.exceptions];
-    return out;
-}
-/** The BaseNode fields a node entry's modifiers map to. */
-export function nodeSettings(node) {
-    const out = {};
-    const retry = toRetryConfig(node?.retry);
-    if (retry)
-        out.retryConfig = retry;
-    if (node?.timeout !== undefined)
-        out.timeout = node.timeout;
-    return out;
-}
 /**
  * The route an output names: the `routeKey` property of an object (a parsed
  * JSON output), else the trimmed text. Never undefined, so an edge with a
- * `default` key always has something to fall back from. One function for
- * both runtimes; it lives in lib/workflow/route.ts.
+ * `default` key always has something to fall back from. It lives in
+ * lib/workflow/route.ts.
  */
 export { routeOf } from './workflow/route.js';
 /** ADK's function-call name for a workflow input request. */

package/dist/scripts/a2a_server.js

@@ -138,8 +138,7 @@ export async function startServer(syndicateName = 'syndicate.yaml', extensions =
     // the root span carries the full user message and answer.
     if (process.env.OTEL_CONSOLE_SPANS === undefined)
         process.env.OTEL_CONSOLE_SPANS = 'false';
-    // The engine's level, which ADK's logger follows: ADK's INFO/DEBUG logs
-    // carry raw event JSON, so keep them quiet.
+    // The engine's level: INFO/DEBUG lines carry raw event JSON, so keep them quiet.
     setLogLevel('warn');
     const publicUrl = process.env.PUBLIC_URL?.trim() || undefined;
     const port = envInt('PORT', 4000);