@google/adk 1.6.0 → 2.1.0

package/dist/types/workflow/base_node.d.ts

@@ -0,0 +1,142 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Content } from '@google/genai';
+import { Event } from '../events/event.js';
+import { SchemaLike } from '../utils/schema.js';
+import type { NodeContext } from './node_context.js';
+import { PreparedRetryConfig, RetryConfig } from './retry_config.js';
+/**
+ * A unique symbol branding {@link BaseNode} instances.
+ *
+ * Guards match on this brand rather than `instanceof` so a node stays
+ * recognisable when it crosses a package boundary (two copies of adk-js in one
+ * runtime would fail an `instanceof` check between them) — mirroring the
+ * `Symbol.for('google.adk.*')` brands used across ADK (`isBaseAgent`,
+ * `isBaseTool`, `isEvent`).
+ */
+declare const BASE_NODE_SIGNATURE_SYMBOL: unique symbol;
+/**
+ * Configuration shared by all workflow nodes.
+ *
+ * Mirrors the fields of `google/adk-python` `workflow/_base_node.py::BaseNode`.
+ */
+export interface BaseNodeConfig {
+    /** Canonical, unique-within-a-graph node name. */
+    name: string;
+    /** Human-readable description (used when a node is exposed as a tool). */
+    description?: string;
+    /**
+     * If true, the node re-executes when a workflow resumes even if it already
+     * completed in a prior turn. Default false.
+     */
+    rerunOnResume?: boolean;
+    /**
+     * If true, the node only produces its output once all of its predecessors
+     * have triggered it (fan-in / join semantics). Default false.
+     */
+    waitForOutput?: boolean;
+    /** Optional retry configuration for transient failures. */
+    retryConfig?: RetryConfig;
+    /** Maximum time, in seconds, for this node to complete. */
+    timeout?: number;
+    /** Optional schema validating the node input (Zod v3/v4 or genai `Schema`). */
+    inputSchema?: SchemaLike;
+    /** Optional schema validating the node output (Zod v3/v4 or genai `Schema`). */
+    outputSchema?: SchemaLike;
+    /** Optional schema validating relevant session state (Zod v3/v4 or genai `Schema`). */
+    stateSchema?: SchemaLike;
+    /**
+     * Runs this node's subtree in an isolated conversation scope: an agent inside
+     * it sees only session events carrying the same scope, plus untagged ones.
+     * `true` derives a scope per node run; a string is an explicit shared tag.
+     */
+    isolationScope?: string | true;
+}
+/**
+ * Abstract base class for all nodes in an ADK workflow.
+ *
+ * A node is a discrete unit of execution. Subclasses implement {@link runImpl},
+ * which may yield {@link Event}s, raw values (boxed into an event), or
+ * `null`/`undefined` (skipped). {@link run} normalizes those into a stream of
+ * {@link Event}s consumed by the engine.
+ */
+export declare abstract class BaseNode<TInput = unknown, TOutput = unknown> {
+    /** Brand identifying this object as a {@link BaseNode} (see `isBaseNode`). */
+    readonly [BASE_NODE_SIGNATURE_SYMBOL] = true;
+    readonly name: string;
+    readonly description: string;
+    readonly rerunOnResume: boolean;
+    readonly waitForOutput: boolean;
+    readonly retryConfig?: RetryConfig;
+    /**
+     * The retry config with its exception filter normalized once, up front (see
+     * {@link prepareRetryConfig}). Used by the node runner so the retry hot path
+     * never re-normalizes or throws on a malformed config mid-retry.
+     */
+    readonly preparedRetryConfig?: PreparedRetryConfig;
+    readonly timeout?: number;
+    readonly inputSchema?: SchemaLike;
+    readonly outputSchema?: SchemaLike;
+    readonly stateSchema?: SchemaLike;
+    readonly isolationScope?: string | true;
+    constructor(config: BaseNodeConfig);
+    /**
+     * Whether this node must wait for ALL of its predecessors to trigger before
+     * it runs (fan-in barrier). Overridden by `JoinNode`.
+     */
+    get requiresAllPredecessors(): boolean;
+    /**
+     * Core execution contract. Subclasses yield one of:
+     *  - an {@link Event} (emitted as-is),
+     *  - a raw value (boxed into an event whose `output` is that value),
+     *  - `null`/`undefined` (skipped).
+     */
+    protected abstract runImpl(ctx: NodeContext, input: TInput): AsyncGenerator<Event | TOutput | unknown, void, void>;
+    /**
+     * Runs the node, normalizing every yielded item into an {@link Event}. This
+     * is what the engine (and `ctx.runNode()`) consumes. Validates the input
+     * against `inputSchema` once, up front (skipping genai `Content`, which nodes
+     * coerce themselves).
+     */
+    run(ctx: NodeContext, input: TInput): AsyncGenerator<Event, void, void>;
+    /**
+     * Validates node input against `inputSchema` (Content passes through). Only
+     * enforced for Zod schemas; a genai `Schema` is left unvalidated (see
+     * `parseWithSchema`).
+     */
+    protected validateInput(input: TInput): TInput;
+    /**
+     * Validates node output against `outputSchema` (Content passes through). Only
+     * enforced for Zod schemas; a genai `Schema` is left unvalidated (see
+     * `parseWithSchema`).
+     */
+    protected validateOutput(output: unknown): unknown;
+    /**
+     * Normalizes a single yielded item into an {@link Event} (or `null` to skip).
+     * Subclasses may override for richer coercion (e.g. `FunctionNode`).
+     */
+    protected toEvent(ctx: NodeContext, data: unknown): Event | null;
+}
+/**
+ * Type guard for {@link BaseNode}.
+ *
+ * Matches on the {@link BASE_NODE_SIGNATURE_SYMBOL} brand rather than
+ * `instanceof` so it stays correct across package copies (see the brand's doc).
+ */
+export declare function isBaseNode(value: unknown): value is BaseNode;
+/** Returns whether a value looks like a genai `Content` object. */
+export declare function isContent(value: unknown): value is Content;
+/** The workflow entry-point sentinel node (name `__START__`). */
+export declare const START: BaseNode;
+/**
+ * Best-effort conversion of an arbitrary value to genai `Content` for display.
+ *
+ * Strings, `Part`s, and arrays of them are converted via `createModelContent`.
+ * Any other value (a plain object, number, boolean, …) is not a valid genai
+ * part list, so it is serialized to text rather than throwing.
+ */
+export declare function toContent(val: unknown): Content | undefined;
+export {};

package/dist/types/workflow/branch_path.d.ts

@@ -0,0 +1,40 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Hierarchical, dot-separated path for execution branches. Each segment is a
+ * node run, typically formatted as `name@runId` (or just `name`).
+ *
+ * Ported from `google/adk-python` `events/_branch_path.py::_BranchPath`.
+ *
+ * @example 'parent_agent@1.collect_tool@2.sub_workflow'
+ */
+export declare class BranchPath {
+    private readonly segments;
+    constructor(segments: string[]);
+    toString(): string;
+    /** Returns a copy of the path segments. */
+    getSegments(): string[];
+    /** Whether this path is a strict descendant of `ancestor`. */
+    isDescendantOf(ancestor: BranchPath): boolean;
+    /** Returns a new path with a `name@runId` (or `name`) segment appended. */
+    append(name: string, runId?: string): BranchPath;
+}
+/** Parses a dot-separated string into a {@link BranchPath}. */
+export declare function branchPathFromString(path?: string | null): BranchPath;
+/** Finds the common prefix across a list of {@link BranchPath}s. */
+export declare function commonPrefixOfPaths(paths: BranchPath[]): BranchPath;
+/**
+ * Creates a new dot-separated sub-branch string by appending a segment.
+ *
+ * @example createSubBranch('parent', {name: 'child', runId: '1'}) -> 'parent.child@1'
+ * @example createSubBranch(undefined, {name: 'agent'}) -> 'agent'
+ */
+export declare function createSubBranch(baseBranch: string | undefined | null, options: {
+    name: string;
+    runId?: string;
+}): string;
+/** Finds the common prefix of a list of dot-separated branch strings. */
+export declare function commonPrefixOf(branches: string[]): string;

package/dist/types/workflow/dynamic_node_scheduler.d.ts

@@ -0,0 +1,64 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { BaseNode } from './base_node.js';
+import { NodeContext, NodeResult } from './node_context.js';
+import { DynamicNodeState, ScheduleDynamicNode, ScheduleDynamicNodeOptions } from './schedule_dynamic_node.js';
+/**
+ * Handles `ctx.runNode()` calls for a {@link Workflow} subtree.
+ *
+ * Ported (Phase 4 subset) from `google/adk-python`
+ * `workflow/_dynamic_node_scheduler.py`. Implemented now: fresh execution and
+ * deduplication of concurrent calls to the same node path. Resumption from
+ * session events (rehydration + replay interception) is added in Phase 5 at the
+ * marked hook point.
+ */
+export declare class DynamicNodeScheduler implements ScheduleDynamicNode {
+    private readonly state;
+    private readonly abortSignal?;
+    /**
+     * @param state Shared dynamic-node bookkeeping for this workflow subtree.
+     * @param abortSignal Workflow-scoped cancellation signal, forwarded to each
+     *   dynamic child so a workflow shutting down on error can cancel in-flight
+     *   `ctx.runNode()` children too.
+     */
+    constructor(state: DynamicNodeState, abortSignal?: AbortSignal | undefined);
+    /**
+     * Runs a `ctx.runNode()` call and reports any interrupt it is still waiting
+     * on to the caller's own context.
+     *
+     * A child's interrupt is the caller's problem: the caller cannot produce a
+     * trustworthy result until the human answers, and until the engine knows the
+     * caller is waiting it marks it COMPLETED and schedules its successor —
+     * which then runs on the `undefined` the caller returned when it bailed out.
+     * `ParallelWorker` has always copied its items' interrupt ids onto its own
+     * context for exactly this reason; doing it here extends that to every
+     * caller instead of only the one that remembered.
+     *
+     * Only unresolved interrupts arrive here. A child fast-forwarded from a
+     * checkpoint, or handed a resolved reply as its output, reports none.
+     */
+    schedule(ctx: NodeContext, node: BaseNode, input: unknown, options: ScheduleDynamicNodeOptions): Promise<NodeContext | NodeResult>;
+    private scheduleRun;
+    /**
+     * Books a dynamic run that completed WITHOUT executing its body — either
+     * fast-forwarded from a cached output or handed the resolved resume value —
+     * and returns `result` for `ctx.runNode()` to give back to the caller.
+     */
+    private completeWithoutRunning;
+    /**
+     * Applies a settled result to the caller's context and returns it, so a first
+     * call and a repeat call for the same path are indistinguishable.
+     */
+    private handBack;
+    /**
+     * Builds the completion result for a child that interrupted in a prior turn
+     * and whose interrupts are now all resolved, or `undefined` when the child is
+     * not in that state (so the caller falls through to a fresh run).
+     */
+    private resumeHandoff;
+    private runFresh;
+    private recordResult;
+}

package/dist/types/workflow/errors.d.ts

@@ -0,0 +1,132 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Errors raised by the workflow framework.
+ *
+ * Ported from `google/adk-python` `workflow/_errors.py`.
+ */
+/**
+ * Internal: raised when a dynamic node interrupts (HITL).
+ *
+ * Used exclusively by `ctx.runNode()` to signal that the dynamic child has
+ * unresolved interrupt IDs. The parent's NodeRunner catches this and reads the
+ * interrupt IDs from the parent's ctx (set by `ctx.runNode()` before throwing).
+ *
+ * Internal to the framework — not part of the public API.
+ */
+export declare class NodeInterruptedError extends Error {
+    constructor(message?: string);
+}
+/**
+ * Type guard for {@link NodeInterruptedError}.
+ *
+ * Matches on `name` rather than `instanceof <subclass>` so it stays correct when
+ * errors cross a package boundary (two copies of adk-js in one runtime would
+ * fail an `instanceof` check between them).
+ */
+export declare function isNodeInterruptedError(e: unknown): e is NodeInterruptedError;
+/**
+ * Raised when a node exceeds its configured timeout.
+ *
+ * This is a regular `Error` (retryable) so a timed-out node can be retried via
+ * `retryConfig`.
+ */
+export declare class NodeTimeoutError extends Error {
+    readonly nodeName: string;
+    readonly timeout: number;
+    /**
+     * @param options.nodeName The name of the node that timed out.
+     * @param options.timeout The timeout, in seconds, that was exceeded.
+     */
+    constructor(options: {
+        nodeName: string;
+        timeout: number;
+    });
+}
+/** Type guard for {@link NodeTimeoutError} (name-based; see above). */
+export declare function isNodeTimeoutError(e: unknown): e is NodeTimeoutError;
+/**
+ * Raised when a dynamic node fails.
+ *
+ * Caught by the parent node's NodeRunner to propagate the error.
+ * Internal to the framework — not part of the public API.
+ */
+export declare class DynamicNodeFailError extends Error {
+    readonly error: Error;
+    readonly errorNodePath: string;
+    /**
+     * @param options.message Human-readable failure message.
+     * @param options.error The underlying error thrown by the dynamic node.
+     * @param options.errorNodePath The node path where the failure occurred.
+     */
+    constructor(options: {
+        message: string;
+        error: Error;
+        errorNodePath: string;
+    });
+}
+/** Type guard for {@link DynamicNodeFailError} (name-based; see above). */
+export declare function isDynamicNodeFailError(e: unknown): e is DynamicNodeFailError;
+/**
+ * Raised when a node reported a failure by emitting an error event instead of
+ * throwing, and produced nothing.
+ *
+ * A regular `Error`, so `retryConfig` can retry it via
+ * `exceptions: ['NodeReportedError']`; `code` carries the reported error code.
+ */
+export declare class NodeReportedError extends Error {
+    readonly code: string;
+    readonly nodeName: string;
+    /**
+     * @param options.nodeName The node that reported the error.
+     * @param options.errorCode The code carried on the reported event.
+     * @param options.errorMessage The message carried on the reported event.
+     */
+    constructor(options: {
+        nodeName: string;
+        errorCode?: string;
+        errorMessage?: string;
+    });
+}
+/** Type guard for {@link NodeReportedError} (name-based; see above). */
+export declare function isNodeReportedError(e: unknown): e is NodeReportedError;
+/**
+ * Raised when the invocation is aborted (e.g. its abort signal fires) while the
+ * engine is waiting — currently during a node's retry backoff delay.
+ *
+ * Distinct from a node's own failure so a caller can tell "the invocation was
+ * cancelled" apart from "the node threw".
+ */
+export declare class InvocationAbortedError extends Error {
+    constructor(message?: string);
+}
+/** Type guard for {@link InvocationAbortedError} (name-based; see above). */
+export declare function isInvocationAbortedError(e: unknown): e is InvocationAbortedError;
+/**
+ * Raised when a node's input or output fails its declared schema.
+ *
+ * The underlying validation error (a `ZodError`, typically) carries the field
+ * path but not the node it came from, which leaves a failure in a large graph
+ * effectively unattributed. This wrapper names the node and which side of it
+ * failed, and keeps the original error on `cause` for the full detail.
+ */
+export declare class NodeSchemaValidationError extends Error {
+    readonly nodeName: string;
+    /** Which side of the node failed: its `inputSchema` or its `outputSchema`. */
+    readonly direction: 'input' | 'output';
+    /**
+     * @param options.nodeName The name of the node that failed validation.
+     * @param options.direction Whether the input or the output failed.
+     * @param options.cause The underlying validation error.
+     */
+    constructor(options: {
+        nodeName: string;
+        direction: 'input' | 'output';
+        cause: unknown;
+    });
+}
+/** Type guard for {@link NodeSchemaValidationError} (name-based; see above). */
+export declare function isNodeSchemaValidationError(e: unknown): e is NodeSchemaValidationError;

package/dist/types/workflow/graph.d.ts

@@ -0,0 +1,127 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { BaseAgent } from '../agents/base_agent.js';
+import { BaseTool } from '../tools/base_tool.js';
+import { BaseNode } from './base_node.js';
+/**
+ * A unique symbol branding {@link Edge} instances.
+ *
+ * `isEdge` matches on this brand rather than `instanceof` so an edge built
+ * by another copy of adk-js in the same runtime is still recognised (an
+ * `instanceof` check fails across package copies) — mirroring the
+ * `Symbol.for('google.adk.*')` brands used across ADK.
+ */
+declare const EDGE_SIGNATURE_SYMBOL: unique symbol;
+/** Valid routing values used in conditional graph edges. */
+export type RouteValue = boolean | number | string;
+/** The fallback route key used when no specific route matches. */
+export declare const DEFAULT_ROUTE = "__DEFAULT__";
+/**
+ * Any value that can be converted to a workflow node: a node, a tool, a plain
+ * function, or the `'START'` sentinel literal. (Agent wrapping is added in
+ * Phase 3 via `build_node`.)
+ */
+export type NodeLike = BaseNode | BaseAgent | BaseTool | ((...args: never[]) => unknown) | 'START';
+/**
+ * What `ctx.runNode()` accepts: everything an edge accepts except the `'START'`
+ * sentinel, which marks a graph entry point rather than something runnable.
+ */
+export type RunnableNode = Exclude<NodeLike, 'START'>;
+/**
+ * A mapping from route values to destination node(s). A value may be a single
+ * node or an array of nodes (fan-out).
+ *
+ * @example
+ *   {question: answerNode, statement: commentNode}
+ *   {retry: [nodeA, nodeB]}   // fan-out: both triggered
+ *
+ * @remarks
+ * JavaScript object keys are always strings, so a numeric key (`{2: node}`) and
+ * a boolean key (`{true: node}`) are reconstructed to their typed
+ * {@link RouteValue} (`2`, `true`) when parsed — mirroring Python dict keys.
+ * Because of this, routes are matched **by string value**
+ * ({@link Graph.getNextPendingNodes} compares `String(route)` on both sides), so
+ * a node emitting `2` and one emitting `'2'` both fire a `{2: node}` edge. The
+ * flip side is that a numeric/boolean-looking route and its string spelling
+ * cannot be distinguished in a routing map; use distinct, non-ambiguous route
+ * keys when that matters.
+ */
+export type RoutingMap = Record<string | number, NodeLike | readonly NodeLike[]>;
+/** An element within a workflow chain. */
+export type ChainElement = NodeLike | readonly NodeLike[] | RoutingMap;
+/**
+ * An item that can be parsed into workflow edges: an explicit {@link Edge}, or a
+ * chain expressed as an array of {@link ChainElement}s (e.g.
+ * `['START', nodeA, nodeB]`).
+ */
+export type EdgeItem = Edge | ChainElement[];
+/**
+ * A directed edge in the workflow graph.
+ *
+ * Mirrors `google/adk-python` `workflow/_graph.py::Edge`.
+ */
+export declare class Edge {
+    readonly fromNode: BaseNode;
+    readonly toNode: BaseNode;
+    /**
+     * The route(s) this edge is associated with. `null` means unconditional
+     * (always triggered). A single value or a list; the edge fires when the
+     * emitted route matches any listed value.
+     */
+    readonly route: RouteValue | RouteValue[] | null;
+    /** Brand identifying this object as an {@link Edge} (see `isEdge`). */
+    readonly [EDGE_SIGNATURE_SYMBOL] = true;
+    constructor(fromNode: BaseNode, toNode: BaseNode, 
+    /**
+     * The route(s) this edge is associated with. `null` means unconditional
+     * (always triggered). A single value or a list; the edge fires when the
+     * emitted route matches any listed value.
+     */
+    route?: RouteValue | RouteValue[] | null);
+}
+/**
+ * Type guard for {@link Edge}.
+ *
+ * Matches on the {@link EDGE_SIGNATURE_SYMBOL} brand rather than `instanceof` so
+ * it stays correct across package copies (see the brand's doc).
+ */
+export declare function isEdge(value: unknown): value is Edge;
+/**
+ * A compiled workflow graph. Nodes are inferred (deduped by identity) from the
+ * edges.
+ *
+ * Mirrors `google/adk-python` `workflow/_graph.py::Graph`.
+ */
+export declare class Graph {
+    readonly nodes: BaseNode[];
+    readonly edges: Edge[];
+    private _terminalNodeNames;
+    constructor(edges: Edge[]);
+    /** Terminal node names (no outgoing edges); populated by {@link validate}. */
+    get terminalNodeNames(): ReadonlySet<string>;
+    /**
+     * Determines the next nodes to transition to PENDING based on the route(s)
+     * emitted by a completed node. Ported from Python `get_next_pending_nodes`.
+     *
+     * Logs at debug when the node emitted a route, has conditional outgoing
+     * edges, and none of them (nor a `DEFAULT_ROUTE` edge) matched — the branch
+     * stops there, which is easy to mistake for a bug. Behaviour is unchanged.
+     */
+    getNextPendingNodes(nodeName: string, routesToMatch: RouteValue | RouteValue[] | null | undefined): string[];
+    /** Validates the graph and computes terminal node names. */
+    validate(): void;
+}
+/**
+ * Builds, validates, and returns a {@link Graph} from a list of edge items.
+ *
+ * Validation runs here (not opt-in) so structural problems a graph can only
+ * have at build time — unreachable nodes, duplicate names/edges, routed edges
+ * from START, unconditional cycles — fail loudly at construction rather than
+ * surfacing as silent mis-routing at run time. It also populates the graph's
+ * {@link Graph.terminalNodeNames}, which is otherwise empty.
+ */
+export declare function createGraphFromEdgeItems(edgeItems: EdgeItem[]): Graph;
+export {};

package/dist/types/workflow/index.d.ts

@@ -0,0 +1,46 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * The new ADK workflow module (parity port of `google/adk-python`
+ * `google/adk/workflow`). Public surface mirrors Python's `__all__`, plus the
+ * TypeScript-specific helpers and the types needed to use the
+ * API from TypeScript.
+ */
+export { asRunnableRoot, isRunnableRoot, runNodeAsInvocation, } from './run_node_as_invocation.js';
+export type { RunNodeAsInvocationOptions, RunnableRoot, } from './run_node_as_invocation.js';
+export { Workflow, isWorkflow } from './workflow.js';
+export type { DynamicEntry, WorkflowConfig } from './workflow.js';
+export { BaseNode, START } from './base_node.js';
+export type { BaseNodeConfig } from './base_node.js';
+export { WorkflowNode, node } from './node.js';
+export type { NodeOptions } from './node.js';
+export { FunctionNode } from './nodes/function_node.js';
+export type { FunctionNodeConfig, FunctionNodeHandler, FunctionNodeResult, } from './nodes/function_node.js';
+export { JoinNode } from './nodes/join_node.js';
+export { NodeTool } from './nodes/node_tool.js';
+export { ParallelWorker } from './nodes/parallel_worker.js';
+export type { ParallelWorkerConfig } from './nodes/parallel_worker.js';
+export { ToolNode } from './nodes/tool_node.js';
+export type { ToolNodeConfig } from './nodes/tool_node.js';
+export type { BuildNodeOptions } from './utils/workflow_graph_utils.js';
+export { DEFAULT_ROUTE, Edge, Graph } from './graph.js';
+export type { ChainElement, EdgeItem, NodeLike, RouteValue, RoutingMap, RunnableNode, } from './graph.js';
+export { BranchPath, commonPrefixOf, createSubBranch } from './branch_path.js';
+export { NodeContext } from './node_context.js';
+export type { NodeContextOptions, NodeResult } from './node_context.js';
+export type { RunNodeOptions } from './node_runner.js';
+export { createNodeState, isNodeState } from './node_state.js';
+export type { NodeState } from './node_state.js';
+export { NodeStatus } from './node_status.js';
+export type { ScheduleDynamicNode, ScheduleDynamicNodeOptions, } from './schedule_dynamic_node.js';
+export { RequestInput, isRequestInput } from './request_input.js';
+export type { RequestInputParams } from './request_input.js';
+export { REQUEST_CREDENTIAL_FUNCTION_CALL_NAME, REQUEST_INPUT_FUNCTION_CALL_NAME, } from './utils/hitl_utils.js';
+export { normalizeRetryExceptions, prepareRetryConfig } from './retry_config.js';
+export type { ErrorClass, PreparedRetryConfig, RetryConfig, } from './retry_config.js';
+export { NodeReportedError, NodeSchemaValidationError, NodeTimeoutError, isNodeReportedError, isNodeSchemaValidationError, isNodeTimeoutError, } from './errors.js';
+export { createNodeErrorEvent, isNodeErrorEvent } from './node_error_event.js';
+export type { CreateNodeErrorEventParams, NodeErrorEvent, } from './node_error_event.js';

package/dist/types/workflow/node.d.ts

@@ -0,0 +1,48 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Event } from '../events/event.js';
+import { BaseNode } from './base_node.js';
+import { NodeLike } from './graph.js';
+import { NodeContext } from './node_context.js';
+import { BuildNodeOptions } from './utils/workflow_graph_utils.js';
+/** Options accepted by {@link node}. */
+export type NodeOptions = BuildNodeOptions;
+/**
+ * Wraps a {@link NodeLike} (function, tool, agent, or existing node) into a
+ * {@link BaseNode}, optionally overriding its properties.
+ *
+ * The TypeScript form is a plain function (there is no `@node` decorator form,
+ * unlike Python). Examples:
+ *
+ * ```ts
+ * const a = node(myFunction, {name: 'classify'});
+ * const b = node(myTool);
+ * ```
+ *
+ * Ported from `google/adk-python` `workflow/_node.py::node`.
+ */
+export declare function node(nodeLike: NodeLike, options?: NodeOptions): BaseNode;
+/**
+ * A base class designed for subclassing. Implement {@link runNodeImpl} to
+ * provide node logic; subclasses inherit the schema/retry/timeout machinery of
+ * {@link BaseNode}.
+ *
+ * Named `WorkflowNode` (not `Node`) to read consistently with `Workflow` and
+ * `WorkflowConfig`, and to avoid shadowing the DOM / `@types/node` `Node`
+ * global in the flat `@google/adk` namespace. The `node()` factory remains the
+ * ergonomic way to wrap a function/tool/agent.
+ *
+ * Mirrors `google/adk-python` `workflow/_node.py::Node`. The `parallel_worker`
+ * capability is added in Phase 6.
+ */
+export declare abstract class WorkflowNode<TInput = unknown, TOutput = unknown> extends BaseNode<TInput, TOutput> {
+    /**
+     * Implement node execution logic here. May yield `Event`s, raw values, or
+     * `null` (normalized by {@link BaseNode.run}).
+     */
+    protected abstract runNodeImpl(ctx: NodeContext, input: TInput): AsyncGenerator<Event | TOutput | unknown, void, void>;
+    protected runImpl(ctx: NodeContext, input: TInput): AsyncGenerator<Event | TOutput | unknown, void, void>;
+}

package/dist/types/workflow/node_builders.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { NodeBuilder, ParallelWorkerFactory } from './utils/workflow_graph_utils.js';
+/**
+ * The built-in node builders, consulted in order by `buildNode` / `isNodeLike`
+ * to turn a bare function or tool into the right `BaseNode`.
+ *
+ * There is no agent builder: an agent is already a `BaseNode` and goes into a
+ * graph as itself. What used to be built here — an `LLMAgentWrapper` around it
+ * — now lives on the agent, as `LlmAgent.runImpl`.
+ *
+ * This is a single, explicit, statically-imported list — node-type modules are
+ * wired in here rather than self-registering at import time, so there is no
+ * global mutable registry and no import-order side effects. Order is the match
+ * precedence (first match wins). Each node-type part adds its builder here.
+ */
+export declare const NODE_BUILDERS: readonly NodeBuilder[];
+/**
+ * Wraps an already-built node in a parallel worker, used by the engine for
+ * `buildNode(..., {parallelWorker: true})`.
+ */
+export declare const PARALLEL_WORKER_FACTORY: ParallelWorkerFactory | undefined;