@google/adk 2.0.0 → 2.2.0

package/dist/web/workflow/workflow.js

@@ -1,529 +0,0 @@
-import {createRequire as topLevelCreateRequire} from 'module';
-const require = topLevelCreateRequire(import.meta.url);
-var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __decorateClass = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
-  if (kind && result) __defProp(target, key, result);
-  return result;
-};
-var __await = function(promise, isYieldStar) {
-  this[0] = promise;
-  this[1] = isYieldStar;
-};
-var __asyncGenerator = (__this, __arguments, generator) => {
-  var resume = (k, v, yes, no) => {
-    try {
-      var x = generator[k](v), isAwait = (v = x.value) instanceof __await, done = x.done;
-      Promise.resolve(isAwait ? v[0] : v).then((y) => isAwait ? resume(k === "return" ? k : "next", v[1] ? { done: y.done, value: y.value } : y, yes, no) : yes({ value: y, done })).catch((e) => resume("throw", e, yes, no));
-    } catch (e) {
-      no(e);
-    }
-  }, method = (k) => it[k] = (x) => new Promise((yes, no) => resume(k, x, yes, no)), it = {};
-  return generator = generator.apply(__this, __arguments), it[__knownSymbol("asyncIterator")] = () => it, method("next"), method("throw"), method("return"), it;
-};
-/**
- * @license
- * Copyright 2026 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-var _a, _b;
-import { context, trace } from "@opentelemetry/api";
-import { tracer, traceWorkflowInvocation } from "../telemetry/tracing.js";
-import { experimental } from "../utils/experimental.js";
-import { BaseNode } from "./base_node.js";
-import { commonPrefixOf } from "./branch_path.js";
-import { DynamicNodeScheduler } from "./dynamic_node_scheduler.js";
-import { isInvocationAbortedError } from "./errors.js";
-import {
-  createGraphFromEdgeItems
-} from "./graph.js";
-import {
-  claimNodeErrorReport,
-  createNodeErrorEvent
-} from "./node_error_event.js";
-import { executeChildNode } from "./node_runner.js";
-import { createNodeState } from "./node_state.js";
-import { NodeStatus } from "./node_status.js";
-import { DynamicNodeState } from "./schedule_dynamic_node.js";
-import {
-  eventsForCurrentRun,
-  isFastForwardable,
-  makeFastForwardResult,
-  reconstructNodeRuns,
-  resolvedInterruptResponses
-} from "./utils/rehydration_utils.js";
-const WORKFLOW_SIGNATURE_SYMBOL = Symbol.for("google.adk.workflow.workflow");
-const _LoopState = class _LoopState {
-  constructor() {
-    this.nodes = /* @__PURE__ */ new Map();
-    this.nodeOutputs = /* @__PURE__ */ new Map();
-    this.nodeBranches = /* @__PURE__ */ new Map();
-    this.triggerBuffer = /* @__PURE__ */ new Map();
-    this.pending = /* @__PURE__ */ new Map();
-    this.interruptIds = /* @__PURE__ */ new Set();
-    /** Per-node state reconstructed from prior session events (resume). */
-    this.rehydrated = /* @__PURE__ */ new Map();
-    /** Nodes already activated in this turn, so a repeat activation is visible. */
-    this.activated = /* @__PURE__ */ new Set();
-    this.errorShutDown = false;
-  }
-};
-__name(_LoopState, "LoopState");
-let LoopState = _LoopState;
-let Workflow = class extends (_b = BaseNode, _a = WORKFLOW_SIGNATURE_SYMBOL, _b) {
-  constructor(config) {
-    var _a2;
-    super(__spreadProps(__spreadValues({}, config), { rerunOnResume: (_a2 = config.rerunOnResume) != null ? _a2 : true }));
-    /** Brand identifying this object as a {@link Workflow} (see `isWorkflow`). */
-    this[_a] = true;
-    const hasEdges = !!config.edges && config.edges.length > 0;
-    if (hasEdges && config.dynamicEntry) {
-      throw new Error(
-        'Workflow "'.concat(this.name, '": "edges" and "dynamicEntry" are mutually exclusive.')
-      );
-    }
-    if (!hasEdges && !config.dynamicEntry) {
-      throw new Error(
-        'Workflow "'.concat(this.name, '" requires either "edges" or "dynamicEntry".')
-      );
-    }
-    if (config.maxConcurrency !== void 0 && (!Number.isInteger(config.maxConcurrency) || config.maxConcurrency < 1)) {
-      throw new Error(
-        'Workflow "'.concat(this.name, '": "maxConcurrency" must be a positive integer ') + "(got ".concat(config.maxConcurrency, ").")
-      );
-    }
-    this.maxConcurrency = config.maxConcurrency;
-    this.dynamicEntry = config.dynamicEntry;
-    if (config.edges && config.edges.length > 0) {
-      this.graph = createGraphFromEdgeItems(config.edges);
-    }
-  }
-  // eslint-disable-next-line require-yield -- child events stream out via ctx.channel/ctx.runNode; this orchestration generator itself yields nothing
-  runImpl(ctx, nodeInput) {
-    return __asyncGenerator(this, null, function* () {
-      const dynamicState = new DynamicNodeState();
-      const abort = createWorkflowAbort(ctx.invocationContext.abortSignal);
-      ctx.scheduler = new DynamicNodeScheduler(
-        dynamicState,
-        abort.controller.signal
-      );
-      const span = tracer.startSpan("invoke_workflow ".concat(this.name));
-      try {
-        yield new __await(context.with(trace.setSpan(context.active(), span), () => {
-          traceWorkflowInvocation({
-            workflowName: this.name,
-            nodePath: ctx.nodePath,
-            sessionId: ctx.invocationContext.session.id
-          });
-          return this.orchestrate(ctx, nodeInput, dynamicState, abort.controller);
-        }));
-      } finally {
-        abort.dispose();
-        span.end();
-      }
-    });
-  }
-  /**
-   * The orchestration body, wrapped by {@link runImpl} so its workflow-scoped
-   * abort controller is always disposed.
-   */
-  async orchestrate(ctx, nodeInput, dynamicState, abortController) {
-    var _a2, _b2;
-    const runEvents = eventsForCurrentRun(
-      (_b2 = (_a2 = ctx.session) == null ? void 0 : _a2.events) != null ? _b2 : [],
-      ctx.invocationId
-    );
-    const rehydrated = reconstructNodeRuns(
-      runEvents,
-      ctx.nodePath || void 0
-    );
-    this.applyResumeInputs(ctx, runEvents);
-    if (this.dynamicEntry) {
-      await this.runDynamicEntry(ctx, nodeInput, dynamicState);
-      return;
-    }
-    const loop = new LoopState();
-    loop.rehydrated = rehydrated;
-    loop.abortSignal = abortController.signal;
-    this.seedStartTriggers(loop, nodeInput);
-    await this.runLoop(loop, ctx, abortController);
-    if (loop.errorShutDown) {
-      return;
-    }
-    this.collectRemainingInterrupts(loop);
-    for (const id of dynamicState.interruptIds) {
-      loop.interruptIds.add(id);
-    }
-    this.finalize(loop, ctx);
-  }
-  /**
-   * Runs an imperative `dynamicEntry` workflow. The entry drives execution via
-   * `ctx.runNode(...)` (routed through the scheduler) and returns the output.
-   */
-  async runDynamicEntry(ctx, nodeInput, dynamicState) {
-    const output = await this.dynamicEntry(ctx, nodeInput);
-    if (dynamicState.interruptIds.size > 0) {
-      ctx.interruptIds = [...dynamicState.interruptIds];
-      return;
-    }
-    if (output !== void 0) {
-      ctx.output = output;
-    }
-  }
-  /**
-   * 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.
-   */
-  applyResumeInputs(ctx, runEvents) {
-    for (const [interruptId, response] of resolvedInterruptResponses(
-      runEvents
-    )) {
-      ctx.resumeInputs[interruptId] = response;
-    }
-  }
-  // --- SETUP ---
-  seedStartTriggers(loop, nodeInput) {
-    const startEdges = this.graph.edges.filter(
-      (e) => e.fromNode.name === "__START__"
-    );
-    const useSubBranch = startEdges.length > 1;
-    for (const edge of startEdges) {
-      this.pushTrigger(loop, edge.toNode.name, {
-        input: nodeInput,
-        useSubBranch
-      });
-    }
-  }
-  // --- LOOP ---
-  async runLoop(loop, ctx, abortController) {
-    for (; ; ) {
-      this.scheduleReadyNodes(loop, ctx);
-      if (loop.pending.size === 0) {
-        break;
-      }
-      const result = await Promise.race(loop.pending.values());
-      loop.pending.delete(result.name);
-      if (result.error) {
-        const nodeState = loop.nodes.get(result.name);
-        if (nodeState) {
-          nodeState.status = NodeStatus.FAILED;
-        }
-        this.reportNodeError(loop, ctx, result.name, result.error);
-        loop.errorShutDown = true;
-        await this.cleanupPending(loop, abortController);
-        throw result.error;
-      }
-      await this.handleCompletion(loop, result.name, result.childCtx);
-    }
-  }
-  reportNodeError(loop, ctx, nodeName, error) {
-    var _a2, _b2, _c;
-    if (isInvocationAbortedError(error) || ((_a2 = loop.abortSignal) == null ? void 0 : _a2.aborted)) {
-      return;
-    }
-    if (!claimNodeErrorReport(error, ctx.invocationId)) {
-      return;
-    }
-    ctx.emit(
-      createNodeErrorEvent({
-        error,
-        attemptCount: (_c = (_b2 = loop.nodes.get(nodeName)) == null ? void 0 : _b2.attemptCount) != null ? _c : 1,
-        author: nodeName,
-        invocationId: ctx.invocationId,
-        nodeInfo: {
-          path: ctx.nodePath ? "".concat(ctx.nodePath, ".").concat(nodeName) : nodeName
-        },
-        branch: ctx.branch,
-        isolationScope: ctx.isolationScope
-      })
-    );
-  }
-  // --- Scheduling ---
-  scheduleReadyNodes(loop, ctx) {
-    for (const nodeName of [...loop.triggerBuffer.keys()]) {
-      if (loop.pending.has(nodeName)) {
-        continue;
-      }
-      const state = loop.nodes.get(nodeName);
-      if (state) {
-        if (state.status === NodeStatus.RUNNING) {
-          continue;
-        }
-        if (state.status === NodeStatus.WAITING && state.interrupts.length > 0) {
-          continue;
-        }
-      }
-      if (this.atConcurrencyLimit(loop)) {
-        break;
-      }
-      const trigger = this.popTrigger(loop, nodeName);
-      if (!trigger) {
-        continue;
-      }
-      this.prepareNodeStateForStarting(loop, nodeName, trigger);
-      this.startNodeTask(loop, ctx, nodeName, trigger);
-    }
-  }
-  atConcurrencyLimit(loop) {
-    return this.maxConcurrency !== void 0 && loop.pending.size >= this.maxConcurrency;
-  }
-  prepareNodeStateForStarting(loop, nodeName, trigger) {
-    var _a2;
-    const existing = loop.nodes.get(nodeName);
-    const state = createNodeState({
-      runCounter: (_a2 = existing == null ? void 0 : existing.runCounter) != null ? _a2 : 0
-    });
-    state.input = trigger.input;
-    state.status = NodeStatus.RUNNING;
-    loop.nodes.set(nodeName, state);
-  }
-  startNodeTask(loop, ctx, nodeName, trigger) {
-    var _a2, _b2;
-    const node = this.getStaticNode(nodeName);
-    const nodeState = loop.nodes.get(nodeName);
-    const repeatActivation = loop.activated.has(nodeName);
-    loop.activated.add(nodeName);
-    const prior = (_a2 = loop.rehydrated.get(nodeName)) == null ? void 0 : _a2.shift();
-    if (prior && isFastForwardable(prior)) {
-      loop.pending.set(
-        nodeName,
-        Promise.resolve({
-          name: nodeName,
-          childCtx: makeFastForwardResult(ctx, prior)
-        })
-      );
-      return;
-    }
-    if (prior && !node.rerunOnResume && prior.output === void 0 && prior.interruptIds.size > 0) {
-      const values = [...prior.interruptIds].map((id) => ctx.resumeInputs[id]);
-      if (values.every((v) => v !== void 0)) {
-        const output = values.length === 1 ? values[0] : values;
-        const resumeResult = {
-          output,
-          route: void 0,
-          branch: (_b2 = prior.branch) != null ? _b2 : ctx.branch,
-          interruptIds: []
-        };
-        loop.pending.set(
-          nodeName,
-          Promise.resolve({ name: nodeName, childCtx: resumeResult })
-        );
-        return;
-      }
-    }
-    let runId = nodeState.runId;
-    if (!runId) {
-      nodeState.runCounter += 1;
-      runId = String(nodeState.runCounter);
-      nodeState.runId = runId;
-    }
-    const resuming = prior !== void 0 && prior.interruptIds.size > 0 && prior.input !== void 0;
-    const nodeInput = resuming ? prior.input : trigger.input;
-    const task = executeChildNode({
-      parent: ctx,
-      node,
-      input: nodeInput,
-      abortSignal: loop.abortSignal,
-      nodeState,
-      resumeInputs: repeatActivation ? {} : void 0,
-      options: {
-        runId,
-        useSubBranch: trigger.useSubBranch,
-        overrideBranch: trigger.branch,
-        overrideIsolationScope: trigger.isolationScope
-      }
-    }).then(
-      (childCtx) => ({ name: nodeName, childCtx }),
-      (error) => ({ name: nodeName, error })
-    );
-    loop.pending.set(nodeName, task);
-  }
-  // --- Completion handling ---
-  async handleCompletion(loop, nodeName, childCtx) {
-    var _a2;
-    const nodeState = loop.nodes.get(nodeName);
-    const node = this.getStaticNode(nodeName);
-    if (childCtx.interruptIds.length > 0) {
-      nodeState.status = NodeStatus.WAITING;
-      nodeState.interrupts = [...childCtx.interruptIds];
-      childCtx.interruptIds.forEach((id) => loop.interruptIds.add(id));
-      return;
-    }
-    if (node.waitForOutput && childCtx.output === void 0 && childCtx.route === void 0) {
-      nodeState.status = NodeStatus.WAITING;
-      return;
-    }
-    nodeState.status = NodeStatus.COMPLETED;
-    if (childCtx.output !== void 0) {
-      loop.nodeOutputs.set(nodeName, childCtx.output);
-    }
-    loop.nodeBranches.set(nodeName, (_a2 = childCtx.branch) != null ? _a2 : "");
-    this.bufferDownstreamTriggers(
-      loop,
-      nodeName,
-      childCtx.output,
-      childCtx.route,
-      childCtx.branch
-    );
-  }
-  bufferDownstreamTriggers(loop, nodeName, output, route, branch) {
-    const nextNodes = this.graph.getNextPendingNodes(nodeName, route != null ? route : null);
-    const useSubBranch = nextNodes.length > 1;
-    for (const targetName of nextNodes) {
-      const targetNode = this.getStaticNode(targetName);
-      if (targetNode.requiresAllPredecessors) {
-        const predecessors = new Set(
-          this.graph.edges.filter((e) => e.toNode.name === targetName).map(
-            (e) => e.fromNode.name
-          )
-        );
-        const allCompleted = [...predecessors].every(
-          (p) => {
-            var _a2;
-            return ((_a2 = loop.nodes.get(p)) == null ? void 0 : _a2.status) === NodeStatus.COMPLETED;
-          }
-        );
-        if (allCompleted) {
-          const outputs = {};
-          for (const p of predecessors) {
-            outputs[p] = loop.nodeOutputs.get(p);
-          }
-          const branches = [...predecessors].map(
-            (p) => {
-              var _a2;
-              return (_a2 = loop.nodeBranches.get(p)) != null ? _a2 : "";
-            }
-          );
-          const commonBranch = commonPrefixOf(branches);
-          this.pushTrigger(loop, targetName, {
-            input: outputs,
-            useSubBranch: false,
-            branch: commonBranch || void 0
-          });
-        }
-      } else {
-        this.pushTrigger(loop, targetName, {
-          input: output,
-          useSubBranch,
-          branch
-        });
-      }
-    }
-  }
-  collectRemainingInterrupts(loop) {
-    for (const nodeState of loop.nodes.values()) {
-      if (nodeState.status === NodeStatus.WAITING && nodeState.interrupts.length > 0) {
-        nodeState.interrupts.forEach((id) => loop.interruptIds.add(id));
-      }
-    }
-  }
-  // --- FINALIZE ---
-  finalize(loop, ctx) {
-    if (loop.interruptIds.size > 0) {
-      ctx.interruptIds = [...loop.interruptIds];
-      return;
-    }
-    const terminalOutputs = [...this.graph.terminalNodeNames].filter((name) => loop.nodeOutputs.has(name)).map((name) => loop.nodeOutputs.get(name));
-    if (terminalOutputs.length === 1) {
-      ctx.output = terminalOutputs[0];
-    } else if (terminalOutputs.length > 1) {
-      throw new Error(
-        "Workflow ".concat(this.name, ": multiple terminal nodes produced output ") + "(".concat(terminalOutputs.length, "). A workflow must have at most one terminal output.")
-      );
-    }
-  }
-  // --- Utilities ---
-  pushTrigger(loop, nodeName, trigger) {
-    const buffer = loop.triggerBuffer.get(nodeName);
-    if (buffer) {
-      buffer.push(trigger);
-    } else {
-      loop.triggerBuffer.set(nodeName, [trigger]);
-    }
-  }
-  popTrigger(loop, nodeName) {
-    const buffer = loop.triggerBuffer.get(nodeName);
-    if (!buffer || buffer.length === 0) {
-      return void 0;
-    }
-    const trigger = buffer.shift();
-    if (buffer.length === 0) {
-      loop.triggerBuffer.delete(nodeName);
-    }
-    return trigger;
-  }
-  getStaticNode(name) {
-    const node = this.graph.nodes.find((n) => n.name === name);
-    if (!node) {
-      throw new Error("Node ".concat(name, " not found in graph."));
-    }
-    return node;
-  }
-  async cleanupPending(loop, abortController) {
-    abortController.abort();
-    const outstanding = [...loop.pending.values()];
-    loop.pending.clear();
-    await Promise.allSettled(outstanding);
-  }
-};
-__name(Workflow, "Workflow");
-Workflow = __decorateClass([
-  experimental
-], Workflow);
-function isWorkflow(value) {
-  return typeof value === "object" && value !== null && WORKFLOW_SIGNATURE_SYMBOL in value && value[WORKFLOW_SIGNATURE_SYMBOL] === true;
-}
-__name(isWorkflow, "isWorkflow");
-function createWorkflowAbort(parentSignal) {
-  const controller = new AbortController();
-  if (!parentSignal) {
-    return { controller, dispose: /* @__PURE__ */ __name(() => {
-    }, "dispose") };
-  }
-  if (parentSignal.aborted) {
-    controller.abort();
-    return { controller, dispose: /* @__PURE__ */ __name(() => {
-    }, "dispose") };
-  }
-  const onParentAbort = /* @__PURE__ */ __name(() => controller.abort(), "onParentAbort");
-  parentSignal.addEventListener("abort", onParentAbort, { once: true });
-  return {
-    controller,
-    dispose: /* @__PURE__ */ __name(() => parentSignal.removeEventListener("abort", onParentAbort), "dispose")
-  };
-}
-__name(createWorkflowAbort, "createWorkflowAbort");
-export {
-  Workflow,
-  isWorkflow
-};