@google/adk 1.6.0 → 2.0.0

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

@@ -0,0 +1,66 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { BaseNode } from './base_node.js';
+import type { NodeContext, NodeResult } from './node_context.js';
+import { NodeState } from './node_state.js';
+/**
+ * Options for scheduling a dynamic node via {@link ScheduleDynamicNode}.
+ */
+export interface ScheduleDynamicNodeOptions {
+    /** Deterministic tracking name; defaults to `node.name`. */
+    nodeName?: string;
+    /** Unique id for this specific execution (used for path/dedup keys). */
+    runId: string;
+    /** If true, the child's output replaces the caller's output. */
+    useAsOutput?: boolean;
+    /** If true, run the child in an isolated sub-branch. */
+    useSubBranch?: boolean;
+    /** Explicit branch override. */
+    overrideBranch?: string;
+    /** Explicit isolation-scope override. */
+    overrideIsolationScope?: string;
+}
+/**
+ * Protocol for scheduling a dynamically-invoked node (via `ctx.runNode()`).
+ *
+ * Implementations handle fresh execution, deduplication of concurrent calls,
+ * and (Phase 5) resumption from session events. Ported from
+ * `google/adk-python` `workflow/_schedule_dynamic_node.py`.
+ */
+export interface ScheduleDynamicNode {
+    schedule(ctx: NodeContext, node: BaseNode, input: unknown, options: ScheduleDynamicNodeOptions): Promise<NodeContext | NodeResult>;
+}
+/**
+ * Combines state, output, and the running task for a single dynamic node
+ * execution.
+ */
+export interface DynamicNodeRun {
+    state: NodeState;
+    output?: unknown;
+    task?: Promise<NodeContext>;
+    transferToAgent?: string;
+    /**
+     * The result of a run that completed without executing its body, kept so a
+     * repeat call for the same path hands back the same result. Runs that did
+     * execute are deduplicated by `task` instead.
+     */
+    result?: NodeResult;
+}
+/**
+ * State for tracking dynamic nodes scheduled via `ctx.runNode()`.
+ *
+ * Ported (Phase 4 subset) from `google/adk-python`
+ * `workflow/_dynamic_node_scheduler.py::DynamicNodeState`. Replay/rehydration
+ * fields are added in Phase 5.
+ */
+export declare class DynamicNodeState {
+    /** Dynamic node runs keyed by unique node path (e.g. `wf/node_a@1`). */
+    readonly runs: Map<string, DynamicNodeRun>;
+    /** Union of unresolved interrupt ids across dynamic child nodes. */
+    readonly interruptIds: Set<string>;
+    /** All in-flight dynamic node tasks. */
+    getDynamicTasks(): Array<Promise<NodeContext>>;
+}

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

@@ -0,0 +1,22 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * A buffered trigger for a downstream node.
+ *
+ * Ported from `google/adk-python` `workflow/_trigger.py`. Unlike the previous
+ * TypeScript `Trigger` (a route-matching predicate), this is a plain data record
+ * describing *how* a target node should be invoked when its turn comes.
+ */
+export interface Trigger {
+    /** The input to pass to the triggered node. */
+    input?: unknown;
+    /** Whether this trigger should run the node in an isolated sub-branch. */
+    useSubBranch?: boolean;
+    /** The branch inherited from the predecessor node. */
+    branch?: string;
+    /** Scope tag explicitly propagated to this trigger. */
+    isolationScope?: string;
+}

package/dist/types/workflow/utils/graph_parser.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Edge, EdgeItem } from '../graph.js';
+/** Parses a list of edge items into a flat list of {@link Edge} objects. */
+export declare function parseEdgeItems(edgeItems: EdgeItem[]): Edge[];

package/dist/types/workflow/utils/graph_validation.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Validates workflow graphs and computes terminal nodes.
+ *
+ * Ported from `google/adk-python` `workflow/utils/_graph_validation.py`.
+ * The Phase 3 static-schema check and the Phase 7 chat-agent wiring check are
+ * intentionally deferred to their respective phases.
+ */
+import { BaseNode } from '../base_node.js';
+import { Edge } from '../graph.js';
+/**
+ * Validates the workflow graph and returns the set of terminal node names.
+ */
+export declare function validateGraph(nodes: BaseNode[], edges: Edge[]): Set<string>;

package/dist/types/workflow/utils/hitl_utils.d.ts

@@ -0,0 +1,92 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Utilities for Human-in-the-Loop (HITL) workflows.
+ *
+ * Ported (subset) from `google/adk-python`
+ * `workflow/utils/_workflow_hitl_utils.py`.
+ */
+import { Part } from '@google/genai';
+import { AuthConfig } from '../../auth/auth_tool.js';
+import { Event } from '../../events/event.js';
+import { State } from '../../sessions/state.js';
+import { RequestInput } from '../request_input.js';
+export { REQUEST_CREDENTIAL_FUNCTION_CALL_NAME, REQUEST_INPUT_FUNCTION_CALL_NAME, } from '../../agents/functions.js';
+/**
+ * Creates an interrupt {@link Event} from a {@link RequestInput}. The event
+ * carries an `adk_request_input` function call and marks the interrupt id as a
+ * long-running tool id.
+ */
+export declare function createRequestInputEvent(requestInput: RequestInput): Event;
+/**
+ * Collects the `responseSchema` each pending interrupt declared, keyed by
+ * interrupt id, as the JSON Schema recorded on its `adk_request_input` call.
+ *
+ * The original {@link RequestInput} is long gone by the time a reply arrives —
+ * a node with `rerunOnResume: false` never runs its body again — so the
+ * serialized copy on the event is the only surviving record of the contract.
+ */
+export declare function responseSchemasByInterruptId(events: Event[]): Map<string, unknown>;
+/**
+ * Checks a *structured* reply against the `responseSchema` its interrupt
+ * declared, and describes the mismatch when there is one. Returns `undefined`
+ * when the reply is acceptable.
+ *
+ * Reporting rather than throwing is what lets a caller be loud about the reply
+ * that just arrived and quiet about the same reply on every later replay: a
+ * rejected reply stays in the session forever, so a checker that threw on
+ * sight would end the session rather than the turn.
+ *
+ * Only structured replies are checked. A plain-text reply is routed to every
+ * pending interrupt as-is (the interactive CLI and the dev UI both rely on
+ * that), and holding free text to an object schema would break it.
+ *
+ * A reply that unwraps to a bare scalar counts as plain text and is exempt for
+ * the same reason: `{result: <text>}` is the envelope a client sends when it
+ * has only a chat box to offer, so checking it would reject the very answer
+ * the plain-text path accepts.
+ *
+ * What remains checked is the case this exists for: a reply in the wrong
+ * *shape*. A client that wraps its answer as `{response: x}` instead of
+ * `{result: x}` gets the whole envelope delivered as the node's input, which
+ * typically surfaces far downstream as a stringified `[object Object]`.
+ */
+export declare function interruptResponseMismatch(interruptId: string, value: unknown, jsonSchema: unknown): string | undefined;
+/** Returns whether an event contains a `request_input` function call. */
+export declare function hasRequestInputFunctionCall(event: Event): boolean;
+/** Returns whether an event contains an `adk_request_credential` function call. */
+export declare function hasAuthRequestFunctionCall(event: Event): boolean;
+/** Extracts interrupt ids from `request_input` function calls in an event. */
+export declare function getRequestInputInterruptIds(event: Event): string[];
+/**
+ * Creates a `FunctionResponse` part answering a `request_input` interrupt,
+ * suitable for appending to a session as the user's resume response.
+ */
+export declare function createRequestInputResponse(interruptId: string, response: Record<string, unknown>): Part;
+/** Whether a credential for the given auth config already exists in state. */
+export declare function hasAuthCredential(authConfig: AuthConfig, state: State): boolean;
+/**
+ * Creates an event requesting user authentication credentials
+ * (`adk_request_credential`), marking the interrupt id as a long-running tool.
+ *
+ * Ported from `google/adk-python` `create_auth_request_event`.
+ */
+export declare function createAuthRequestEvent(authConfig: AuthConfig, interruptId: string): Event;
+/** Parameters for {@link processAuthResume}. */
+export interface ProcessAuthResumeParams {
+    /** The resume response: a full {@link AuthConfig} or a plain value. */
+    responseData: unknown;
+    /** The auth config the credential is being stored for. */
+    authConfig: AuthConfig;
+    /** The session state to store the credential in. */
+    state: State;
+}
+/**
+ * Stores credentials from an auth resume response into session state. Accepts a
+ * full {@link AuthConfig} (web UI flow) or a plain value (e.g. an API key
+ * string), mirroring `google/adk-python` `process_auth_resume`.
+ */
+export declare function processAuthResume({ responseData, authConfig, state, }: ProcessAuthResumeParams): Promise<void>;

package/dist/types/workflow/utils/rehydration_utils.d.ts

@@ -0,0 +1,132 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Event } from '../../events/event.js';
+import { RouteValue } from '../graph.js';
+import type { NodeContext, NodeResult } from '../node_context.js';
+/** Reconstructed state for a single node, keyed by node name. */
+export interface RehydratedNode {
+    /** The node's cached output from a prior run, if it produced one. */
+    output?: unknown;
+    /** The route(s) the node emitted, if any (array = multi-route). */
+    route?: RouteValue | RouteValue[];
+    /** The branch the node ran on. */
+    branch?: string;
+    /** The input the node was invoked with (captured when it interrupted). */
+    input?: unknown;
+    /** Interrupt ids the node raised. */
+    interruptIds: Set<string>;
+    /** Resolved interrupt responses, keyed by interrupt id. */
+    resolvedResponses: Map<string, unknown>;
+}
+/**
+ * Narrows session events to the workflow run still in progress, dropping every
+ * earlier run that already finished.
+ *
+ * Rehydration exists to resume a run that paused, so it must not see a run that
+ * already completed: the finished nodes' cached outputs would be fast-forwarded
+ * into the new run, and the workflow would replay its previous answer instead
+ * of acting on the new input.
+ *
+ * `google/adk-python` scopes this by invocation id, because there a resumed
+ * invocation keeps its id. The TypeScript runner mints a fresh invocation id
+ * for every turn (`Runner.runAsync`), so a run that spans a pause covers
+ * several invocations and an id filter would discard the very outputs resume
+ * needs. Runs are delimited by pausing instead:
+ *
+ *   - An invocation that raised an interrupt ended paused, so it belongs to the
+ *     run still in progress.
+ *   - An invocation that emitted node events without raising one ran to
+ *     completion; it is the boundary, and it and everything before it are
+ *     dropped.
+ *
+ * The current invocation is always kept: it is in progress by definition, and
+ * it carries the user function responses that resolve the pending interrupts.
+ */
+export declare function eventsForCurrentRun(events: Event[], currentInvocationId: string): Event[];
+/**
+ * Scans session events and reconstructs per-node state (outputs, routes, raised
+ * interrupts, and resolved interrupt responses).
+ *
+ * When `parentPath` is given, reconstruction is scoped to that path's DIRECT
+ * children (keyed by child name), so nested workflows whose nodes share a name
+ * do not collide on resume. When omitted, nodes are keyed by their path leaf
+ * (utility mode, robust to author rewrite).
+ */
+export declare function reconstructNodeStates(events: Event[], parentPath?: string): Map<string, RehydratedNode>;
+/**
+ * Like {@link reconstructNodeStates} but keyed by the full node path
+ * (`wf.node@runId`), so distinct dynamic (`ctx.runNode`) iterations are tracked
+ * separately for per-run resume/dedup.
+ */
+export declare function reconstructNodeStatesByPath(events: Event[]): Map<string, RehydratedNode>;
+/**
+ * Every interrupt raised in `events` that now has an accepted reply, as
+ * interrupt id -> value.
+ *
+ * Flat and unscoped, unlike {@link reconstructNodeStates}: interrupt ids are
+ * unique, and a reply has to reach whoever raised it however deep that sits. A
+ * dynamic (`ctx.runNode`) child or a nested workflow's leaf is keyed out of the
+ * per-parent view, so a scoped map silently drops its answer and the run pauses
+ * on the same question forever.
+ *
+ * A reply that does not match the schema its interrupt declared resolves
+ * nothing. It throws while it is the turn being processed, so the client hears
+ * about it once, and is skipped on every replay after that (see
+ * {@link interruptResponseMismatch}).
+ */
+export declare function resolvedInterruptResponses(events: Event[]): Map<string, unknown>;
+/**
+ * Reconstructs each node's prior runs in order, rather than merging them into
+ * one record per node.
+ *
+ * A node the graph routes back to runs more than once, and a pause can fall
+ * between two of its runs — the revise loop in the request-input samples pauses
+ * on `request_human_review@1`, resumes, and pauses again on `@2`. Merged into a
+ * single record those two runs are indistinguishable, and the resumed turn
+ * replays the first run's answer forever. `google/adk-python` avoids this by
+ * keying its recovered executions on `name@run_id`; TypeScript node paths carry
+ * no run id for static graph nodes, so the runs are recovered positionally
+ * instead: the Nth activation in the resumed turn matches the Nth prior run.
+ *
+ * A run is closed once it has produced an output, a route, or an interrupt, so
+ * the next event for that node opens the next run. Events a run emits before
+ * that (messages, state deltas) accumulate into the run in progress.
+ */
+export declare function reconstructNodeRuns(events: Event[], parentPath?: string): Map<string, RehydratedNode[]>;
+/**
+ * Whether a rehydrated node can be fast-forwarded on resume: it produced a
+ * result — an output or a route — and all of its raised interrupts have been
+ * resolved.
+ */
+export declare function isFastForwardable(node: RehydratedNode): boolean;
+/**
+ * Builds the completion result for a fast-forwarded (cached) node on resume.
+ * The node's body is not re-run and its events are NOT re-emitted (they already
+ * exist in the session), so this returns a bare {@link NodeResult} rather than a
+ * live {@link NodeContext} — the honest type for "cached output, no behaviour".
+ */
+export declare function makeFastForwardResult(parent: NodeContext, prior: RehydratedNode): NodeResult;
+/** Extracts the node name (leaf, without run id) from a dotted node path. */
+export declare function nodeNameFromPath(path: string): string;
+/**
+ * Unwraps a `{result: value}` FunctionResponse envelope to the bare value.
+ *
+ * A string value is JSON-parsed when it parses, because the envelope does not
+ * say whether the text is structured: a client answering a `RequestInput` that
+ * declared a `responseSchema` sends the object as text (the web frontend wraps
+ * whatever the user submitted as `{result: text}`), and the node expects the
+ * object back. Text that is not JSON — "approve", "shorter" — is returned
+ * as-is. That is parity with Python's `_unwrap_response`.
+ *
+ * `responseSchema`, when the interrupt declared one, decides whether parsing
+ * applies at all. Parsing text the schema asked for as text is destructive
+ * rather than helpful: an answer of "42" to a `z.string()` interrupt reached
+ * the node as the number 42 and crashed it on the first string method, and
+ * every JSON literal did the same — "true", "null", "1e3". So a schema that
+ * accepts a string keeps the text verbatim, and only a schema that cannot
+ * (an object, an array, a number) still parses.
+ */
+export declare function unwrapResponse(response: unknown, responseSchema?: unknown): unknown;

package/dist/types/workflow/utils/retry_utils.d.ts

@@ -0,0 +1,54 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Utility functions for retrying nodes in a workflow.
+ *
+ * Ported from `google/adk-python` `workflow/utils/_retry_utils.py`.
+ */
+import { NodeState } from '../node_state.js';
+import { PreparedRetryConfig } from '../retry_config.js';
+/**
+ * Resolves every runtime name a thrown value can be matched by: its class name,
+ * as Python's `type(exception).__name__` gives, and any `name` assigned on top
+ * of it. A subclass that never sets `this.name` inherits `'Error'`, so the two
+ * disagree exactly when matching on one alone would miss.
+ */
+export declare function errorNames(error: unknown): string[];
+/**
+ * Resolves the most specific runtime name of a thrown value, for reporting.
+ * Mirrors Python's `type(exception).__name__`, preferring an assigned `name`
+ * only when the class name carries nothing more than `Error`.
+ */
+export declare function errorName(error: unknown): string;
+/** Parameters for {@link shouldRetryNode}. */
+export interface ShouldRetryNodeParams {
+    /** The error thrown by the node. */
+    error: unknown;
+    /** The node's prepared (normalized) retry configuration. */
+    retryConfig: PreparedRetryConfig;
+    /** The current node state (its `attemptCount` is 1-based). */
+    nodeState: NodeState;
+}
+/**
+ * Checks if a failed node should be retried based on its retry config.
+ */
+export declare function shouldRetryNode({ error, retryConfig, nodeState, }: ShouldRetryNodeParams): boolean;
+/** Parameters for {@link getRetryDelaySeconds}. */
+export interface GetRetryDelaySecondsParams {
+    /** The node's prepared (normalized) retry configuration. */
+    retryConfig: PreparedRetryConfig;
+    /**
+     * The current node state (its `attemptCount` is the 1-based attempt number
+     * that just failed).
+     */
+    nodeState: NodeState;
+    /** Injectable uniform RNG in [0, 1) for deterministic testing. */
+    randomFn?: () => number;
+}
+/**
+ * Calculates the delay, in seconds, before retrying a node.
+ */
+export declare function getRetryDelaySeconds({ retryConfig, nodeState, randomFn, }: GetRetryDelaySecondsParams): number;

package/dist/types/workflow/utils/workflow_graph_utils.d.ts

@@ -0,0 +1,76 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { AuthConfig } from '../../auth/auth_tool.js';
+import { SchemaLike } from '../../utils/schema.js';
+import { BaseNode } from '../base_node.js';
+import { NodeLike } from '../graph.js';
+import { RetryConfig } from '../retry_config.js';
+/**
+ * Property overrides applied when building a node from a {@link NodeLike}.
+ */
+export interface BuildNodeOptions {
+    name?: string;
+    description?: string;
+    rerunOnResume?: boolean;
+    retryConfig?: RetryConfig;
+    timeout?: number;
+    inputSchema?: SchemaLike;
+    outputSchema?: SchemaLike;
+    stateSchema?: SchemaLike;
+    authConfig?: AuthConfig;
+    /** Runs the node's subtree in an isolated conversation scope. */
+    isolationScope?: string | true;
+    /** If true, wrap the built node in a parallel worker. */
+    parallelWorker?: boolean;
+    /** Concurrency limit for the parallel worker (requires `parallelWorker`). */
+    maxParallelWorkers?: number;
+}
+/**
+ * Converts a matched {@link NodeLike} value into a concrete {@link BaseNode}.
+ *
+ * Builders are wired into the static {@link NODE_BUILDERS} list (in
+ * `node_builders.ts`) and consulted by {@link buildNode} / {@link isNodeLike} in
+ * order — first match wins. Keeping them in one explicit list (rather than a
+ * runtime registry) means no global mutable state and no import-order side
+ * effects: `node_builders.ts` imports the concrete node modules, and the engine
+ * core imports that one list.
+ */
+export interface NodeBuilder {
+    /** Returns whether this builder can convert `value` into a node. */
+    match(value: unknown): boolean;
+    /** Builds a node from a value this builder previously matched. */
+    build(value: NodeLike, options: BuildNodeOptions): BaseNode;
+}
+/**
+ * Wraps an already-built node in a parallel worker. Provided by the
+ * `parallel_worker` node module via {@link PARALLEL_WORKER_FACTORY}.
+ *
+ * `retryConfig`/`timeout` are intentionally not forwarded to the wrapper: they
+ * apply to the inner node (per item), so the two levels don't compose.
+ */
+export type ParallelWorkerFactory = (inner: BaseNode, options: {
+    maxParallelWorkers?: number;
+}) => BaseNode;
+/**
+ * Returns whether a value is a plain object literal (a `RoutingMap`) rather than
+ * a class instance such as a node/tool/agent.
+ */
+export declare function isPlainObject(value: unknown): boolean;
+/**
+ * Returns whether a value can be converted into a workflow node via
+ * {@link buildNode}: the `'START'` sentinel, an existing {@link BaseNode}, or a
+ * value matched by a registered {@link NodeBuilder}.
+ */
+export declare function isNodeLike(value: unknown): value is NodeLike;
+/**
+ * Converts a {@link NodeLike} into a concrete {@link BaseNode}.
+ *
+ * Handles the `'START'` sentinel and existing {@link BaseNode} instances
+ * directly — an agent is one, so it goes into the graph as itself; every other
+ * value is delegated to the registered {@link NodeBuilder}s (function →
+ * `FunctionNode`, tool → `ToolNode`).
+ */
+export declare function buildNode(nodeLike: NodeLike, options?: BuildNodeOptions): BaseNode;

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

@@ -0,0 +1,115 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Event } from '../events/event.js';
+import { BaseNode, BaseNodeConfig } from './base_node.js';
+import { EdgeItem, Graph } from './graph.js';
+import { NodeContext } from './node_context.js';
+/**
+ * A unique symbol branding {@link Workflow} instances.
+ *
+ * `isWorkflow` matches on this brand rather than `instanceof` so a workflow
+ * built by another copy of adk-js in the same runtime is still recognised —
+ * mirroring the `Symbol.for('google.adk.*')` brands used across ADK.
+ */
+declare const WORKFLOW_SIGNATURE_SYMBOL: unique symbol;
+/**
+ * An imperative workflow entry point. Receives the workflow's node context and
+ * input, drives execution via `ctx.runNode(...)`, and returns the workflow
+ * output. Mutually exclusive with `edges`.
+ */
+export type DynamicEntry = (ctx: NodeContext, input: unknown) => unknown | Promise<unknown>;
+/**
+ * Configuration for a {@link Workflow}.
+ *
+ * A workflow is driven either by a static `edges` graph or by an imperative
+ * `dynamicEntry` function — exactly one is required, and the two are mutually
+ * exclusive. The type is a discriminated union so that constraint is enforced at
+ * compile time (the runtime constructor keeps the equivalent throws for JS
+ * callers).
+ */
+export type WorkflowConfig = BaseNodeConfig & {
+    /**
+     * Maximum number of graph-scheduled nodes running in parallel. `undefined`
+     * means unlimited; must be a positive integer otherwise. Does not throttle
+     * dynamic (`ctx.runNode`) children.
+     */
+    maxConcurrency?: number;
+} & ({
+    /** Edge definitions used to build the workflow graph. */
+    edges: EdgeItem[];
+    dynamicEntry?: never;
+} | {
+    /**
+     * An imperative entry function driving execution via `ctx.runNode(...)`.
+     * Mutually exclusive with `edges`.
+     */
+    dynamicEntry: DynamicEntry;
+    edges?: never;
+});
+/**
+ * A graph-based workflow node. `runImpl()` IS the orchestration loop:
+ * SETUP (seed START triggers) → LOOP (schedule ready nodes, handle
+ * completions) → FINALIZE (collect the terminal output).
+ *
+ * Ported (Phase 2 subset) from `google/adk-python` `workflow/_workflow.py`.
+ * Replay/checkpointing, dynamic scheduling, and task/chat isolation scopes are
+ * added in later phases; hook points are marked with TODO(phase-N).
+ */
+export declare class Workflow extends BaseNode {
+    /** Brand identifying this object as a {@link Workflow} (see `isWorkflow`). */
+    readonly [WORKFLOW_SIGNATURE_SYMBOL] = true;
+    readonly graph?: Graph;
+    readonly dynamicEntry?: DynamicEntry;
+    readonly maxConcurrency?: number;
+    constructor(config: WorkflowConfig);
+    protected runImpl(ctx: NodeContext, nodeInput: unknown): AsyncGenerator<Event, void, void>;
+    /**
+     * The orchestration body, wrapped by {@link runImpl} so its workflow-scoped
+     * abort controller is always disposed.
+     */
+    private orchestrate;
+    /**
+     * Runs an imperative `dynamicEntry` workflow. The entry drives execution via
+     * `ctx.runNode(...)` (routed through the scheduler) and returns the output.
+     */
+    private runDynamicEntry;
+    /**
+     * Merges resolved interrupt responses from prior session events into
+     * `ctx.resumeInputs`, so waiting nodes (which read `ctx.resumeInputs[id]`)
+     * resume with the user's response. Shared by child contexts via propagation.
+     *
+     * Taken from the events rather than from `rehydrated`, because that view is
+     * scoped to this workflow's direct children: an interrupt raised deeper — by
+     * a `ctx.runNode` child, or inside a nested workflow — is keyed out of it,
+     * and its answer would never reach the node waiting on it.
+     */
+    private applyResumeInputs;
+    private seedStartTriggers;
+    private runLoop;
+    private reportNodeError;
+    private scheduleReadyNodes;
+    private atConcurrencyLimit;
+    private prepareNodeStateForStarting;
+    private startNodeTask;
+    private handleCompletion;
+    private bufferDownstreamTriggers;
+    private collectRemainingInterrupts;
+    private finalize;
+    private pushTrigger;
+    private popTrigger;
+    private getStaticNode;
+    private cleanupPending;
+}
+/**
+ * Type guard for {@link Workflow}.
+ *
+ * Matches on the `google.adk.workflow.workflow` brand rather than `instanceof`
+ * so it stays correct across package copies — two copies of adk-js in one
+ * runtime would fail an `instanceof` check between them. Named rather than
+ * `{@link}`ed because the brand itself is internal, and this guard is public.
+ */
+export declare function isWorkflow(value: unknown): value is Workflow;
+export {};