@arcgis/ai-components 5.1.0-next.99 → 5.2.0-next.1

package/dist/agent-utils/tools/FunctionTool.js

@@ -0,0 +1,80 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
+import c from "@arcgis/core/core/Accessor.js";
+import { property as a, subclass as p } from "@arcgis/core/core/accessorSupport/decorators.js";
+import { tool as d } from "@langchain/core/tools";
+var h = Object.defineProperty, m = Object.getOwnPropertyDescriptor, s = (o, t, n, u) => {
+  for (var e = u > 1 ? void 0 : u ? m(t, n) : t, i = o.length - 1, l; i >= 0; i--)
+    (l = o[i]) && (e = (u ? l(t, n, e) : l(e)) || e);
+  return u && e && h(t, n, e), e;
+};
+let r = class extends c {
+  //#region Lifecycle
+  constructor(o) {
+    super(o), this.resultMode = "continue", this.middlewares = [];
+  }
+  //#endregion
+  //#region Public Methods
+  /**
+   * Builds the LangChain tool adapter used by LLM agents.
+   */
+  getTool() {
+    return d(this._executeWithMiddlewares.bind(this), {
+      name: this.name,
+      description: this.description,
+      returnDirect: this.resultMode === "terminal",
+      schema: this.inputSchema
+    });
+  }
+  //#endregion
+  //#region Private Methods
+  async _executeWithMiddlewares(o, t) {
+    const n = async (e) => {
+      const i = await this.execute(e.input, e.config);
+      return this._validateOutput(i);
+    };
+    return await this.middlewares.reduceRight(
+      (e, i) => async (l) => await i.handler(l, e),
+      n
+    )({ config: t, input: o, tool: this, toolCallId: f(t) });
+  }
+  _validateOutput(o) {
+    if (!this.outputSchema)
+      return o;
+    const t = this.outputSchema.safeParse(o);
+    if (!t.success)
+      throw new Error(`FunctionTool output schema validation failed: ${t.error.message}`);
+    return t.data;
+  }
+  //#endregion
+};
+s([
+  a()
+], r.prototype, "name", 2);
+s([
+  a()
+], r.prototype, "description", 2);
+s([
+  a()
+], r.prototype, "resultMode", 2);
+s([
+  a()
+], r.prototype, "inputSchema", 2);
+s([
+  a()
+], r.prototype, "outputSchema", 2);
+s([
+  a()
+], r.prototype, "middlewares", 2);
+s([
+  a()
+], r.prototype, "execute", 2);
+r = s([
+  p("FunctionTool")
+], r);
+function f(o) {
+  const t = o?.toolCall;
+  return typeof t?.id == "string" ? t.id : void 0;
+}
+export {
+  r as FunctionTool
+};

package/dist/agent-utils/types.d.ts

@@ -0,0 +1,152 @@
+import type z from "zod";
+import type { BaseChannel, BinaryOperatorAggregate } from "@langchain/langgraph/channels";
+import type { AnnotationRoot, StateDefinitionInit, StateGraph } from "@langchain/langgraph/web";
+import type { AgentExecutionContext, AgentRegistration, AgentStatus } from "../utils/index.js";
+
+/** @internal */
+export type AgentData = Record<string, unknown>;
+
+/** @internal */
+export type EmptyAgentData = Record<never, never>;
+
+/** @privateRemark All ADK agents are orchestrator-driven, so these channels exist for every agent graph. */
+export type AgentRuntimeState = {
+  agentExecutionContext: AgentExecutionContext;
+  /** The outputMessage is a string representing the output of an agent execution. */
+  outputMessage: string;
+  /** The summary is a string providing a brief overview of the agent execution. */
+  summary: string;
+  /** The status field represents the current status of the agent execution, which can be used to indicate success, failure, or other relevant states. */
+  status?: AgentStatus;
+};
+
+export type AgentGraphState<TState extends AgentData = EmptyAgentData> = AgentRuntimeState
+  & Omit<TState, keyof AgentRuntimeState>;
+
+export interface BaseAgentLike<TCustomState extends AgentData = EmptyAgentData> {
+  /**
+   * Stable ID derived from the agent name and used for graph node and registration identity.
+   *
+   * @since 5.1
+   */
+  id: string;
+  /**
+   * Optional schema used to validate and shape agent input state.
+   *
+   * @since 5.1
+   */
+  inputSchema?: ZodObjectSchema<object>;
+  /**
+   * Human-readable name shown in registration metadata and tooling.
+   *
+   * @since 5.1
+   */
+  name: string;
+  /**
+   * Optional schema used to validate structured agent output.
+   *
+   * @since 5.1
+   */
+  outputSchema?: ZodObjectSchema<object>;
+  /**
+   * Registration payload consumed by the orchestrator.
+   *
+   * @since 5.1
+   */
+  registration: AgentRegistration;
+  /** Regenerates workspace and graph wiring for this agent. */
+  generate: () => void;
+  /** Returns all schemas the agent contributes to state/input/output validation. */
+  getSchemas: () => ZodObjectSchema<object>[];
+  /**
+   * Executes the compiled graph for this agent.
+   *
+   * @param state - Optional partial state used as graph input.
+   * @param config - Optional runtime execution configuration.
+   * @return The resulting graph state after execution.
+   * @since 5.1
+   */
+  run(state?: Partial<AgentGraphState<TCustomState>>, config?: AgentExecutionConfig): Promise<AgentGraphState<TCustomState>>;
+}
+
+/** AgentExecutionConfig defines the shape of the configuration object that can be passed to agent execution methods to influence their behavior at runtime. */
+export interface AgentExecutionConfig {
+  /**
+   * The configurable field allows passing arbitrary key-value pairs that can be used by agents during execution to modify their behavior or provide additional context.
+   * This can include flags, parameters, or any other relevant information that an agent might need to access at runtime.
+   *
+   * @since 5.1
+   */
+  configurable?: Record<string, unknown>;
+  metadata?: Record<string, unknown>;
+  recursionLimit?: number;
+  runName?: string;
+  /**
+   * The signal property is an optional AbortSignal that can be used to cancel the execution of an agent. Agents should listen for the abort signal and gracefully handle cancellation when it is triggered.
+   *
+   * @since 5.1
+   */
+  signal?: AbortSignal;
+  tags?: string[];
+}
+
+export type AgentCustomState<TInput extends AgentData = AgentData, TOutput extends AgentData = AgentData> = Omit<TInput, keyof AgentRuntimeState>
+  & Partial<Omit<TOutput, keyof AgentRuntimeState>>;
+
+export type AgentNodeState<TInput extends AgentData = AgentData, TOutput extends AgentData = AgentData> = AgentGraphState<AgentCustomState<TInput, TOutput>>;
+
+export type AgentNodeUpdate<TInput extends AgentData, TOutput extends AgentData> = Partial<AgentNodeState<TInput, TOutput>>;
+
+/**
+ * AgentStateAnnotation defines the shape of the agent state used in LangGraph nodes, including both the built-in runtime channels
+ * and any custom fields defined by the agent.
+ *
+ * @internal
+ * @since 5.1
+ */
+export type AgentStateAnnotation<TState extends AgentData> = AnnotationRoot<{
+    [K in keyof TState]: BinaryOperatorAggregate<TState[K] | undefined, TState[K] | undefined>;
+} & {
+    agentExecutionContext: BaseChannel<AgentExecutionContext, unknown, unknown>;
+    outputMessage: BaseChannel<string, unknown, unknown>;
+    summary: BaseChannel<string, unknown, unknown>;
+    status: BaseChannel<AgentStatus | undefined, unknown, unknown>;
+}>;
+
+/**
+ * State update shape produced by graph nodes.
+ *
+ * @since 5.1
+ */
+export type RunnableUpdate<TState extends AgentData> = Partial<TState> extends object ? Partial<TState> & Record<string, any> : Partial<TState>;
+
+/**
+ * Internal type representing the compiled graph used for agent execution.
+ *
+ * @internal
+ * @since 5.1
+ */
+export type TypedStateGraph<TState extends AgentData> = StateGraph<StateDefinitionInit, AgentGraphState<TState>, RunnableUpdate<AgentGraphState<TState>>, string>;
+
+/**
+ * The shape of the `createGraph` function used by agents to generate their internal graph representation.
+ * This function is responsible for defining the nodes and edges of the graph, as well as any associated state and middleware.
+ *
+ * @internal
+ * @since 5.1
+ */
+export type AgentCreateGraph<TState extends AgentData> = () => TypedStateGraph<TState>;
+
+/** ZodObjectSchema is a simplified type representing Zod object schemas used for input and output validation in agents. */
+export type ZodObjectSchema<T extends object = AgentData> = Pick<z.ZodType<T>, "safeParse">
+  & z.ZodObject;
+
+export type GraphNodes<S extends AgentData> = Record<string, (state: S, config?: AgentExecutionConfig) => Partial<S> | Promise<Partial<S> | S> | S>;
+
+export type GraphEdge<S extends AgentData> = {
+    from: string;
+    decide: (state: S, config?: AgentExecutionConfig) => Promise<string | undefined> | string | undefined;
+} | {
+    from: string;
+    to: string;
+};

package/dist/agent-utils/workflows/BaseWorkflow.d.ts

@@ -0,0 +1,87 @@
+import type Accessor from "@arcgis/core/core/Accessor.js";
+import type { AgentCreateGraph, AgentData, AgentGraphState, AgentStateAnnotation, BaseAgentLike, GraphEdge, GraphNodes } from "../types.js";
+
+/**
+ * Return payload from `BaseWorkflow.generate()`.
+ *
+ * @since 5.1
+ */
+export type WorkflowGenerateResult<TState extends AgentData = AgentData> = {
+  /**
+   * Shared workflow state annotation.
+   *
+   * @since 5.1
+   */
+  workspace: AgentStateAnnotation<TState>;
+  /**
+   * Factory that creates the workflow graph.
+   *
+   * @since 5.1
+   */
+  createGraph: AgentCreateGraph<TState>;
+};
+
+/**
+ * BaseWorkflow is the foundational class for defining workflows. A workflow defines a sequence of
+ * agents that work together to accomplish a task. This class provides the structure and common
+ * building blocks for constructing a workflow, including generating the shared workspace and
+ * creating the graph that defines how agents are connected and executed.
+ *
+ * Specific workflows extend this base class and implement the abstract methods to define
+ * their unique behavior and structure.
+ *
+ * The following workflow types are supported:
+ *
+ * - `SequentialWorkflow` - executes agents in a sequence, where the output of one agent can be passed as input to the next.
+ * - `ConditionalWorkflow` - allows for branching logic based on conditions evaluated at runtime, enabling different paths of execution depending on user input or LLM output.
+ * - `LoopWorkflow` - supports repeating a set of agents until a certain condition is met, useful for iterative processes.
+ * - `ParallelWorkflow` - enables concurrent execution of multiple agents, allowing for tasks that can be performed simultaneously.
+ * - `RouterWorkflow` - dynamically routes execution to different agents based on the input or state, providing flexibility in handling various scenarios.
+ * - `SwitchWorkflow` - similar to RouterWorkflow but designed for cases where there are multiple distinct paths based on discrete values in the input or state.
+ *
+ * @since 5.1
+ */
+export abstract class BaseWorkflow<TState extends AgentData = AgentData> extends Accessor {
+  /**
+   * Builds the workflow-specific edges.
+   *
+   * @param agents
+   */
+  protected abstract buildEdges(agents: BaseAgentLike<TState>[]): GraphEdge<AgentGraphState<TState>>[];
+  /**
+   * Builds the workflow's graph nodes.
+   *
+   * Node ids use the agent id plus its position (`agent.id_index`) instead of only the raw
+   * agent id. That prevents collisions when the same agent instance is used multiple times.
+   *
+   * @param agents
+   */
+  protected buildNodes(agents: BaseAgentLike<TState>[]): GraphNodes<AgentGraphState<TState>>;
+  /**
+   * Generates the workflow's graph and shared workspace based on the defined agents and their schemas. This method is
+   * called by the WorkflowAgent when it generates its graph, and it orchestrates the creation of the workflow's structure,
+   * including validating the agents, deriving shared state from their schemas, and building the nodes and edges of the graph.
+   */
+  generate(): WorkflowGenerateResult<TState>;
+  /** A list of agents that are part of this workflow. */
+  abstract getAgents(): BaseAgentLike<TState>[];
+  /**
+   * Returns the id of the first node in the workflow graph.
+   *
+   * @param agents
+   */
+  protected abstract getEntryNode(agents: BaseAgentLike<TState>[]): string | undefined;
+  /**
+   * Returns whether the agent at this position should expose terminal runtime fields.
+   *
+   * @param agents
+   * @param index
+   */
+  protected abstract isTerminalAgent(agents: BaseAgentLike<TState>[], index: number): boolean;
+  /**
+   * Validates the workflow configuration and throws if invalid.
+   *
+   * @param agents
+   */
+  protected validateAgents(agents: BaseAgentLike<TState>[]): void;
+}

package/dist/agent-utils/workflows/ConditionalWorkflow.d.ts

@@ -0,0 +1,72 @@
+import type { AgentData, AgentExecutionConfig, AgentGraphState, BaseAgentLike, GraphEdge, GraphNodes } from "../types.js";
+import type { BaseWorkflow } from "./BaseWorkflow.js";
+
+/**
+ * Condition function that routes execution to either the true branch or false branch.
+ *
+ * @param state - Current workflow graph state.
+ * @param config - Optional execution configuration.
+ * @since 5.1
+ */
+export type ConditionDecider<TState extends AgentData = AgentData> = (state: AgentGraphState<TState>, config?: AgentExecutionConfig) => Promise<boolean> | boolean;
+
+/**
+ * ConditionalWorkflow chooses between two branch agents based on a boolean condition and
+ * routes execution through a simple true/false branch.
+ *
+ * Use when:
+ * - you want an if/else style decision or
+ * - only two branches are needed.
+ *
+ * How it works:
+ * - evaluate `condition(state, config)`,
+ * - if true, run the first branch agent,
+ * - if false, run the second branch agent.
+ *
+ * @since 5.1
+ */
+export class ConditionalWorkflow<TState extends AgentData = AgentData> extends BaseWorkflow<TState> {
+  constructor(properties: ConstructProperties<TState>);
+  /**
+   * Must contain exactly two agents: `[trueAgent, falseAgent]`. The first agent is executed when
+   * the condition is true, the second when the condition is false.
+   *
+   * @required
+   */
+  accessor agents: BaseAgentLike<TState>[];
+  /**
+   * Predicate that chooses the next branch.
+   *
+   * @required
+   */
+  accessor condition: ConditionDecider<TState>;
+  /**
+   * Builds the workflow-specific edges.
+   *
+   * @param agents
+   */
+  protected buildEdges(agents: BaseAgentLike<TState>[]): GraphEdge<AgentGraphState<TState>>[];
+  /**
+   * Builds the workflow's graph nodes.
+   *
+   * Node ids use the agent id plus its position (`agent.id_index`) instead of only the raw
+   * agent id. That prevents collisions when the same agent instance is used multiple times.
+   *
+   * @param agents
+   */
+  protected buildNodes(agents: BaseAgentLike<TState>[]): GraphNodes<AgentGraphState<TState>>;
+  /** A list of agents that are part of this workflow. */
+  getAgents(): BaseAgentLike<TState>[];
+  /** Returns the id of the first node in the workflow graph. */
+  protected getEntryNode(): string;
+  /** Returns whether the agent at this position should expose terminal runtime fields. */
+  protected isTerminalAgent(): boolean;
+  /**
+   * Validates the workflow configuration and throws if invalid.
+   *
+   * @param agents
+   */
+  protected validateAgents(agents: BaseAgentLike<TState>[]): void;
+}
+
+export type ConstructProperties<TState extends AgentData> = Pick<ConditionalWorkflow<TState>, "agents" | "condition">;

package/dist/agent-utils/workflows/ConditionalWorkflow.js

@@ -0,0 +1,61 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
+import { property as u, subclass as f } from "@arcgis/core/core/accessorSupport/decorators.js";
+import { B as p, g as c } from "../../chunks/BaseWorkflow.js";
+var g = Object.defineProperty, w = Object.getOwnPropertyDescriptor, a = (e, r, n, t) => {
+  for (var o = t > 1 ? void 0 : t ? w(r, n) : r, i = e.length - 1, s; i >= 0; i--)
+    (s = e[i]) && (o = (t ? s(r, n, o) : s(o)) || o);
+  return t && o && g(r, n, o), o;
+};
+let l = class extends p {
+  //#region Lifecycle
+  constructor(e) {
+    super(e);
+  }
+  //#endregion
+  //#region Public Methods
+  getAgents() {
+    return this.agents;
+  }
+  //#endregion
+  //#region Protected Methods
+  buildNodes(e) {
+    const r = super.buildNodes(e);
+    return r[d] = () => ({}), r;
+  }
+  buildEdges(e) {
+    const r = this.condition;
+    if (!r)
+      throw new Error("ConditionalWorkflow requires a condition.");
+    const n = c(e[0], 0), t = c(e[1], 1);
+    return [
+      {
+        from: d,
+        decide: async (o, i) => await Promise.resolve(r(o, i)) ? n : t
+      }
+    ];
+  }
+  getEntryNode() {
+    return d;
+  }
+  isTerminalAgent() {
+    return !0;
+  }
+  validateAgents(e) {
+    if (super.validateAgents(e), e.length !== 2)
+      throw new Error(`ConditionalWorkflow requires exactly 2 agents; received ${e.length}.`);
+  }
+  //#endregion
+};
+a([
+  u()
+], l.prototype, "condition", 2);
+a([
+  u()
+], l.prototype, "agents", 2);
+l = a([
+  f("ConditionalWorkflow")
+], l);
+const d = "__conditional_decide";
+export {
+  l as ConditionalWorkflow
+};

package/dist/agent-utils/workflows/LoopWorkflow.d.ts

@@ -0,0 +1,58 @@
+import type { AgentData, AgentExecutionConfig, AgentGraphState, BaseAgentLike, GraphEdge } from "../types.js";
+import type { BaseWorkflow, WorkflowGenerateResult } from "./BaseWorkflow.js";
+
+/**
+ * Loop continuation predicate. Return true to run another iteration.
+ *
+ * @param state - Current workflow graph state.
+ * @param config - Optional execution configuration.
+ * @since 5.1
+ */
+export type LoopDecider<TState extends AgentData = AgentData> = (state: AgentGraphState<TState>, config?: AgentExecutionConfig) => Promise<boolean> | boolean;
+
+/**
+ * LoopWorkflow repeatedly executes an inner workflow until a stop condition is met.
+ *
+ * Use in the following scenarios:
+ *
+ * - You need retry/refine loops,
+ * - You want iterative planning and execution.
+ *
+ * How it works:
+ * - Runs the inner `workflow`,
+ * - Evaluates `decideContinue(state, config)`,
+ * - If true, runs again; if false (or unset), stops.
+ *
+ * @since 5.1
+ */
+export class LoopWorkflow<TState extends AgentData = AgentData> extends BaseWorkflow<TState> {
+  constructor(properties: ConstructProperties<TState>);
+  /**
+   * Function that decides whether the loop should continue.
+   *
+   * @required
+   */
+  accessor decideContinue: LoopDecider<TState>;
+  /**
+   * Inner workflow to execute on each loop iteration.
+   *
+   * @required
+   */
+  accessor workflow: BaseWorkflow<TState>;
+  /** Builds the workflow-specific edges. */
+  protected buildEdges(): GraphEdge<AgentGraphState<TState>>[];
+  /**
+   * Generates the workflow's graph and shared workspace based on the defined agents and their schemas. This method is
+   * called by the WorkflowAgent when it generates its graph, and it orchestrates the creation of the workflow's structure,
+   * including validating the agents, deriving shared state from their schemas, and building the nodes and edges of the graph.
+   */
+  generate(): WorkflowGenerateResult<TState>;
+  /** A list of agents that are part of this workflow. */
+  getAgents(): BaseAgentLike<TState>[];
+  /** Returns the id of the first node in the workflow graph. */
+  protected getEntryNode(): string;
+  /** Returns whether the agent at this position should expose terminal runtime fields. */
+  protected isTerminalAgent(): boolean;
+}
+
+export type ConstructProperties<TState extends AgentData> = Pick<LoopWorkflow<TState>, "decideContinue" | "workflow">;

package/dist/agent-utils/workflows/LoopWorkflow.js

@@ -0,0 +1,56 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
+import { property as u, subclass as w } from "@arcgis/core/core/accessorSupport/decorators.js";
+import { c as f } from "../../chunks/graph.js";
+import { B as h } from "../../chunks/BaseWorkflow.js";
+var g = Object.defineProperty, m = Object.getOwnPropertyDescriptor, d = (o, r, n, t) => {
+  for (var e = t > 1 ? void 0 : t ? m(r, n) : r, s = o.length - 1, c; s >= 0; s--)
+    (c = o[s]) && (e = (t ? c(r, n, e) : c(e)) || e);
+  return t && e && g(r, n, e), e;
+};
+let p = class extends h {
+  //#region Lifecycle
+  constructor(o) {
+    super(o);
+  }
+  //#endregion
+  //#region Public Methods
+  getAgents() {
+    return this.workflow.getAgents();
+  }
+  generate() {
+    const o = this.workflow.generate(), r = o.workspace, n = o.createGraph().compile(), { decideContinue: t } = this, e = {
+      [a]: async (i, l) => await n.invoke(i, l)
+    }, s = [
+      {
+        from: a,
+        decide: async (i, l) => await Promise.resolve(t(i, l)) ? a : void 0
+      }
+    ];
+    return { workspace: r, createGraph: () => f(e, s, r, { entryNode: a }) };
+  }
+  //#endregion
+  //#region Protected Methods
+  buildEdges() {
+    throw new Error("LoopWorkflow overrides generate(); buildEdges should not be called.");
+  }
+  getEntryNode() {
+    return a;
+  }
+  isTerminalAgent() {
+    return !0;
+  }
+  //#endregion
+};
+d([
+  u()
+], p.prototype, "workflow", 2);
+d([
+  u()
+], p.prototype, "decideContinue", 2);
+p = d([
+  w("LoopWorkflow")
+], p);
+const a = "__loop_body";
+export {
+  p as LoopWorkflow
+};

package/dist/agent-utils/workflows/ParallelWorkflow.d.ts

@@ -0,0 +1,68 @@
+import type { AgentData, AgentGraphState, BaseAgentLike, GraphEdge, GraphNodes } from "../types.js";
+import type { BaseWorkflow, WorkflowGenerateResult } from "./BaseWorkflow.js";
+
+/**
+ * ParallelWorkflow fans out execution to multiple agents and merges branch outputs.
+ *
+ * Use in the following scenarios:
+ * - Branches can run independently from the same input,
+ * - You want fan-out/fan-in behavior.
+ *
+ * How it works:
+ * - Fan out - every agent receives the same input snapshot,
+ * - Each branch collects its result in a hidden state key,
+ * - Fan in - merge outputs in declared agent order.
+ *
+ * Merge rule:
+ * - If two branches set the same shared key to different values, an error is thrown,
+ * as this indicates a conflict the workflow cannot resolve on its own.
+ *
+ * @since 5.1
+ */
+export class ParallelWorkflow<TState extends AgentData = AgentData> extends BaseWorkflow<TState> {
+  constructor(properties: ConstructProperties<TState>);
+  /**
+   * Agents to run in parallel from the same input snapshot.
+   *
+   * @required
+   */
+  accessor agents: BaseAgentLike<TState>[];
+  /**
+   * Builds the workflow-specific edges.
+   *
+   * @param agents
+   */
+  protected buildEdges(agents: BaseAgentLike<TState>[]): GraphEdge<AgentGraphState<TState>>[];
+  /**
+   * Builds the workflow's graph nodes.
+   *
+   * Node ids use the agent id plus its position (`agent.id_index`) instead of only the raw
+   * agent id. That prevents collisions when the same agent instance is used multiple times.
+   *
+   * @param agents
+   */
+  protected buildNodes(agents: BaseAgentLike<TState>[]): GraphNodes<AgentGraphState<TState>>;
+  /**
+   * Generates the workflow's graph and shared workspace based on the defined agents and their schemas. This method is
+   * called by the WorkflowAgent when it generates its graph, and it orchestrates the creation of the workflow's structure,
+   * including validating the agents, deriving shared state from their schemas, and building the nodes and edges of the graph.
+   */
+  generate(): WorkflowGenerateResult<TState>;
+  /** A list of agents that are part of this workflow. */
+  getAgents(): BaseAgentLike<TState>[];
+  /**
+   * Returns the id of the first node in the workflow graph.
+   *
+   * @param _agents
+   */
+  protected getEntryNode(_agents: BaseAgentLike<TState>[]): string;
+  /**
+   * Returns whether the agent at this position should expose terminal runtime fields.
+   *
+   * @param _agents
+   * @param _index
+   */
+  protected isTerminalAgent(_agents: BaseAgentLike<TState>[], _index: number): boolean;
+}
+
+export type ConstructProperties<TState extends AgentData> = Pick<ParallelWorkflow<TState>, "agents">;