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

package/README.md

@@ -6,5 +6,5 @@ The ArcGIS Maps SDK for JavaScript provides a suite of ready-to-use UI component
 
 ## License
 
-This package is licensed under the terms described in the `LICENSE.md` file, located in the root of the package, and at https://js.arcgis.com/5.0/LICENSE.txt.
-For third party notices, see https://js.arcgis.com/5.0/third-party-notices.txt.
+This package is licensed under the terms described in the `LICENSE.md` file, located in the root of the package, and at https://js.arcgis.com/5.1/LICENSE.txt.
+For third party notices, see https://js.arcgis.com/5.1/third-party-notices.txt.

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

@@ -0,0 +1,90 @@
+import type Accessor from "@arcgis/core/core/Accessor.js";
+import type { AgentMiddleware } from "./middlewares/types.js";
+import type { AgentCreateGraph, AgentData, AgentExecutionConfig, AgentGraphState, AgentStateAnnotation, EmptyAgentData, ZodObjectSchema } from "./types.js";
+import type { AgentRegistration } from "../utils/index.js";
+
+/**
+ * BaseAgent serves as the foundational class for all agent implementations. It
+ * provides common properties and methods that are shared across different types of agents.
+ * This class is not intended to be used directly, use any of the subclasses that extend BaseAgent
+ * instead.
+ *
+ * @since 5.1
+ */
+export abstract class BaseAgent<TCustomState extends AgentData = EmptyAgentData> extends Accessor {
+  /**
+   * The createGraph function defines the internal graph structure of the agent,
+   * including its nodes, edges, and associated state.
+   *
+   * @internal
+   */
+  get createGraph(): AgentCreateGraph<TCustomState>;
+  /**
+   * Description of the agent's purpose and functionality. This can be used in registration metadata to provide context about the agent's functionality. A good description is clear and concise. Use bullet points to describe tasks the agent can accomplish. Provide examples of user questions or prompts that could be answered by the agent.
+   *
+   * @default ""
+   */
+  accessor description: string;
+  /** The unique identifier for the agent, derived from the name property. This ID is used for registration and invocation purposes. */
+  get id(): string;
+  /**
+   * An optional array of middleware functions that can be used to extend or modify the agent's
+   * behavior during execution.
+   * This allows for flexible customization of the agent's execution logic. For example, middlewares
+   * can be used to implement trace messages (i.e. logging), human-in-the-loop interrupts, or other custom actions.
+   */
+  accessor middlewares: AgentMiddleware<TCustomState>[];
+  /**
+   * A name for the agent, which is used in the registration metadata and can be displayed in tooling.
+   * It should be unique across agents to avoid registration conflicts. A good agent name clearly
+   * indicates the scope and purpose of the agent. For example, "WeatherAgent" or "CustomerSupportAgent"
+   * are descriptive names that convey the agent's functionality as opposed to generic names like
+   * "Agent1" or "MyAgent".
+   *
+   * The name is also used to generate the agent's [id](https://developers.arcgis.com/javascript/latest/references/ai-components/agent-utils/BaseAgent/#id).
+   *
+   * @required
+   */
+  accessor name: string;
+  /**
+   * The registration property assembles the necessary metadata and graph definition for this agent,
+   * which is consumed by the orchestrator during registration.
+   */
+  get registration(): AgentRegistration;
+  /**
+   * The workspace property serves as the agent's internal state storage, which is used to maintain
+   * context across graph node executions.
+   * This is where the agent's state is read from and written to during graph execution, allowing for
+   * dynamic behavior based on previous steps in the graph.
+   *
+   * @internal
+   */
+  get workspace(): AgentStateAnnotation<TCustomState>;
+  /**
+   * Rebuilds internal workspace and createGraph wiring. This is automatically called during initialization and whenever
+   * the name or description properties change, but can also be called manually if needed to refresh the agent's graph definition.
+   *
+   * The agent implementation is responsible for defining the createGraph function and workspace structure in this method, which are then used during execution.
+   *
+   * @internal
+   */
+  abstract generate(): void;
+  /**
+   * Returns all schemas required by this agent implementation.
+   *
+   * @returns An array of Zod object schemas that define the structure of the agent's expected input and output data.
+   * These schemas are used for validation and type inference during graph execution.
+   * @internal
+   */
+  abstract getSchemas(): ZodObjectSchema<object>[];
+  initialize(): void;
+  /**
+   * Executes the agent's graph with the provided state and configuration. This method is responsible
+   * for invoking the compiled graph and returning the resulting state after execution.
+   *
+   * @param state - An optional partial state object to initialize the graph execution. This can include any custom fields defined by the agent.
+   * @param config - An optional execution configuration that can influence the agent's behavior during invocation.
+   * @returns A promise that resolves to the updated agent graph state after execution.
+   */
+  run(state?: Partial<AgentGraphState<TCustomState>>, config?: AgentExecutionConfig): Promise<AgentGraphState<TCustomState>>;
+}

package/dist/agent-utils/BaseAgent.js

@@ -0,0 +1,87 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
+import m from "@arcgis/core/core/Accessor.js";
+import { property as i, subclass as l } from "@arcgis/core/core/accessorSupport/decorators.js";
+import { a as u } from "../chunks/state.js";
+import { watch as h } from "@arcgis/core/core/reactiveUtils.js";
+var y = Object.defineProperty, w = Object.getOwnPropertyDescriptor, t = (s, a, o, p) => {
+  for (var r = p > 1 ? void 0 : p ? w(a, o) : a, n = s.length - 1, c; n >= 0; n--)
+    (c = s[n]) && (r = (p ? c(a, o, r) : c(r)) || r);
+  return p && r && y(a, o, r), r;
+};
+const d = () => {
+  throw new Error("createGraph method not implemented.");
+};
+let e = class extends m {
+  constructor() {
+    super(...arguments), this.description = "", this.middlewares = [], this.createGraph = d, this.workspace = u();
+  }
+  //#region Lifecycle
+  initialize() {
+    this.addHandles([
+      h(
+        () => [this.name, this.description],
+        () => this.generate(),
+        { initial: !0, sync: !0 }
+      ),
+      h(
+        () => this.createGraph,
+        () => this._compiledGraph = void 0
+      )
+    ]);
+  }
+  get id() {
+    return this.name.replace(/\s+/gu, "-").toLowerCase();
+  }
+  get registration() {
+    return {
+      id: this.id,
+      name: this.name,
+      description: this.description,
+      createGraph: this.createGraph,
+      workspace: this.workspace
+    };
+  }
+  //#endregion
+  //#region Public Methods
+  /**
+   * Executes the agent's graph with the provided state and configuration. This method is responsible
+   * for invoking the compiled graph and returning the resulting state after execution.
+   *
+   * @param state - An optional partial state object to initialize the graph execution. This can include any custom fields defined by the agent.
+   * @param config - An optional execution configuration that can influence the agent's behavior during invocation.
+   * @returns A promise that resolves to the updated agent graph state after execution.
+   *
+   * @public
+   */
+  async run(s = {}, a) {
+    return this.createGraph === d && this.generate(), this._compiledGraph = this._compiledGraph ?? this.createGraph().compile(), await this._compiledGraph.invoke(s, a);
+  }
+  //#endregion
+};
+t([
+  i({ readOnly: !0 })
+], e.prototype, "id", 1);
+t([
+  i()
+], e.prototype, "name", 2);
+t([
+  i()
+], e.prototype, "description", 2);
+t([
+  i()
+], e.prototype, "middlewares", 2);
+t([
+  i({ readOnly: !0 })
+], e.prototype, "createGraph", 2);
+t([
+  i({ readOnly: !0 })
+], e.prototype, "workspace", 2);
+t([
+  i({ readOnly: !0 })
+], e.prototype, "registration", 1);
+e = t([
+  l("BaseAgent")
+], e);
+export {
+  e as BaseAgent
+};

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

@@ -0,0 +1,64 @@
+import type { BaseAgent } from "./BaseAgent.js";
+import type { AgentCustomState, AgentData, AgentExecutionConfig, AgentNodeState, ZodObjectSchema } from "./types.js";
+
+/**
+ * FunctionAgentExecute defines the signature for the execute function used by FunctionAgent.
+ *
+ * @param state - Agent state at invocation time.
+ * @param config - Optional execution configuration.
+ * @returns Structured output object or final message string.
+ * @since 5.1
+ */
+export type FunctionAgentExecute<TInput extends AgentData, TOutput extends AgentData> = (state: AgentNodeState<TInput, TOutput>, config?: AgentExecutionConfig) => Promise<TOutput | string> | TOutput | string;
+
+/**
+ * FunctionAgent executes a user-provided function as its core logic.
+ * It supports optional input and output schemas for validation and structured data handling.
+ *
+ * @since 5.1
+ */
+export class FunctionAgent<TInput extends AgentData = AgentData, TOutput extends AgentData = AgentData> extends BaseAgent<AgentCustomState<TInput, TOutput>> {
+  constructor(properties?: ConstructProperties<TInput, TOutput>);
+  /**
+   * The execute function contains the core logic of the FunctionAgent.
+   * It receives the current agent state and an optional execution configuration,
+   * and returns one of the following:
+   *
+   * - a structured output object - used in a follow-up node for further processing in the graph, or
+   * - a string representing a the final message to display in the chat UI.
+   *
+   * @required
+   */
+  accessor execute: FunctionAgentExecute<TInput, TOutput>;
+  /**
+   * The input schema defines the expected structure of the agent state when the execute function is invoked.
+   * If provided, the agent will validate incoming state against this schema and throw an error if validation fails.
+   */
+  accessor inputSchema: ZodObjectSchema<TInput> | undefined;
+  /**
+   * The output schema defines the expected structure of the result returned by the execute function.
+   * If provided, the agent will validate the output against this schema and handle it accordingly.
+   */
+  accessor outputSchema: ZodObjectSchema<TOutput> | undefined;
+  /**
+   * Rebuilds internal workspace and createGraph wiring. This is automatically called during initialization and whenever
+   * the name or description properties change, but can also be called manually if needed to refresh the agent's graph definition.
+   *
+   * The agent implementation is responsible for defining the createGraph function and workspace structure in this method, which are then used during execution.
+   *
+   * @internal
+   */
+  generate(): void;
+  /**
+   * Returns all schemas required by this agent implementation.
+   *
+   * @returns An array of Zod object schemas that define the structure of the agent's expected input and output data.
+   * These schemas are used for validation and type inference during graph execution.
+   * @internal
+   */
+  getSchemas(): ZodObjectSchema<object>[];
+  initialize(): void;
+}
+
+export type ConstructProperties<TInput extends AgentData, TOutput extends AgentData> = Partial<Pick<FunctionAgent<TInput, TOutput>, "description" | "inputSchema" | "middlewares" | "outputSchema">>
+  & Pick<FunctionAgent<TInput, TOutput>, "execute" | "name">;

package/dist/agent-utils/FunctionAgent.js

@@ -0,0 +1,98 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
+import { property as u, subclass as p } from "@arcgis/core/core/accessorSupport/decorators.js";
+import { isGraphInterrupt as m } from "@langchain/langgraph/web";
+import { BaseAgent as d } from "./BaseAgent.js";
+import { c as l } from "../chunks/graph.js";
+import { c as f } from "../chunks/state.js";
+import { watch as S } from "@arcgis/core/core/reactiveUtils.js";
+import { c as h, h as g, g as v } from "../chunks/utils.js";
+var w = Object.defineProperty, _ = Object.getOwnPropertyDescriptor, o = (t, e, s, r) => {
+  for (var i = r > 1 ? void 0 : r ? _(e, s) : e, a = t.length - 1, c; a >= 0; a--)
+    (c = t[a]) && (i = (r ? c(e, s, i) : c(i)) || i);
+  return r && i && w(e, s, i), i;
+};
+let n = class extends d {
+  //#region Lifecycle
+  constructor(t) {
+    super(t);
+  }
+  initialize() {
+    this.addHandles(
+      S(
+        () => [this.name, this.description, this.inputSchema, this.outputSchema, this.execute],
+        () => {
+          this.generate();
+        },
+        { initial: !0, sync: !0 }
+      )
+    );
+  }
+  //#endregion
+  //#region Public Methods
+  getSchemas() {
+    return [this.inputSchema, this.outputSchema].filter(Boolean);
+  }
+  generate() {
+    const t = f(this.getSchemas());
+    this._set("workspace", t);
+    const e = `${this.id}-execute`, s = { [e]: this._invokeExecuteNode.bind(this) }, r = [{ from: e, decide: () => {
+    } }];
+    this._set(
+      "createGraph",
+      () => l(s, r, t, { agent: this, entryNode: e, middlewares: this.middlewares })
+    );
+  }
+  //#endregion
+  //#region Private Methods
+  async _invokeExecuteNode(t, e) {
+    try {
+      return this.outputSchema ? await this._invokeStructured(t, e) : await this._invokeUnstructured(t, e);
+    } catch (s) {
+      if (m(s))
+        throw s;
+      const r = s instanceof Error ? s.message : String(s);
+      return h({ outputMessage: r }, "failed", r);
+    }
+  }
+  async _invokeStructured(t, e) {
+    if (!this.outputSchema)
+      throw new Error("Output schema is required for structured invocation.");
+    const s = this._validateInputState(t), r = await this.execute(s, e);
+    if (typeof r == "string")
+      throw new Error(
+        "Expected execute function to return an object matching the output schema, but received a string."
+      );
+    return g(r, this.outputSchema, t.agentExecutionContext.messages);
+  }
+  async _invokeUnstructured(t, e) {
+    const s = this._validateInputState(t), r = await this.execute(s, e), i = typeof r == "string" ? r : JSON.stringify(r), a = i.trim() || "FunctionAgent completed.";
+    return h({ outputMessage: i }, "success", a);
+  }
+  _validateInputState(t) {
+    if (!this.inputSchema)
+      return t;
+    const e = this.inputSchema.safeParse(v(t, this.inputSchema));
+    if (!e.success)
+      throw new Error(`FunctionAgent input schema validation failed: ${e.error.message}`);
+    return {
+      ...t,
+      ...e.data
+    };
+  }
+  //#endregion
+};
+o([
+  u()
+], n.prototype, "inputSchema", 2);
+o([
+  u()
+], n.prototype, "outputSchema", 2);
+o([
+  u()
+], n.prototype, "execute", 2);
+n = o([
+  p("FunctionAgent")
+], n);
+export {
+  n as FunctionAgent
+};

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

@@ -0,0 +1,65 @@
+import type { BaseAgent } from "./BaseAgent.js";
+import type { FunctionToolLike } from "./tools/FunctionTool.js";
+import type { AgentCustomState, AgentData, ZodObjectSchema } from "./types.js";
+
+/**
+ * LLMAgent uses a language model to generate its output based on a provided prompt template and optional tools.
+ * It supports structured input and output through Zod schemas, allowing for validation and type safety. The agent's logic is defined by the prompt and the tools it has access to, making it a flexible option for a wide range of use cases.
+ *
+ * @since 5.1
+ */
+export class LLMAgent<TInput extends AgentData = AgentData, TOutput extends AgentData = AgentData> extends BaseAgent<AgentCustomState<TInput, TOutput>> {
+  constructor(properties?: ConstructProperties<TInput, TOutput>);
+  /**
+   * The inputSchema property is an optional Zod schema describing the expected structured input for the agent.
+   * This can be used for validation of the input state before execution and also to extract variables from the input
+   * state for prompt formatting.
+   */
+  accessor inputSchema: ZodObjectSchema<TInput> | undefined;
+  /**
+   * The tier of the model to use for the agent. This can affect the capabilities and performance of the agent.
+   *
+   * @default "default"
+   */
+  accessor modelTier: "advanced" | "default" | "fast";
+  /**
+   * The outputSchema property is an optional Zod schema describing the expected structured output from the agent.
+   * If provided, the agent will attempt to parse the language model's response according to this schema and return structured data.
+   * If not provided, the agent will treat the language model's response as an unstructured string message.
+   */
+  accessor outputSchema: ZodObjectSchema<TOutput> | undefined;
+  /**
+   * Defines the prompt template the agent will use to generate its output.
+   * This prompt can include variables that are populated from the agent's state at runtime through the input schema,
+   * allowing for dynamic and context-aware responses from the language model.
+   *
+   * In this example below, {location} and {weather} would be variables extracted from the agent's state according to the input schema.
+   *
+   * @example "Generate a weather report for {location} based on the current {weather} conditions."
+   * @required
+   */
+  accessor prompt: string;
+  /** The tools property is an optional array of FunctionTools that the agent can use during execution. */
+  accessor tools: FunctionToolLike[] | undefined;
+  /**
+   * Rebuilds internal workspace and createGraph wiring. This is automatically called during initialization and whenever
+   * the name or description properties change, but can also be called manually if needed to refresh the agent's graph definition.
+   *
+   * The agent implementation is responsible for defining the createGraph function and workspace structure in this method, which are then used during execution.
+   *
+   * @internal
+   */
+  generate(): void;
+  /**
+   * Returns all schemas required by this agent implementation.
+   *
+   * @returns An array of Zod object schemas that define the structure of the agent's expected input and output data.
+   * These schemas are used for validation and type inference during graph execution.
+   * @internal
+   */
+  getSchemas(): ZodObjectSchema<object>[];
+  initialize(): void;
+}
+
+export type ConstructProperties<TInput extends AgentData, TOutput extends AgentData> = Partial<Pick<LLMAgent<TInput, TOutput>, "description" | "inputSchema" | "middlewares" | "modelTier" | "outputSchema" | "tools">>
+  & Pick<LLMAgent<TInput, TOutput>, "name" | "prompt">;

package/dist/agent-utils/LLMAgent.js

@@ -0,0 +1,139 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
+import "@arcgis/core/identity/IdentityManager.js";
+import "@arcgis/core/portal/Portal.js";
+import { isGraphInterrupt as f } from "@langchain/langgraph/web";
+import { c as u } from "../chunks/generateLayerDescriptions.js";
+import "@langchain/core/messages";
+import "@langchain/core/callbacks/dispatch/web";
+import { watch as w } from "@arcgis/core/core/reactiveUtils.js";
+import "@arcgis/core/layers/FeatureLayer.js";
+import "@arcgis/core/request.js";
+import { ChatPromptTemplate as S } from "@langchain/core/prompts";
+import { property as m, subclass as _ } from "@arcgis/core/core/accessorSupport/decorators.js";
+import { createAgent as h } from "langchain";
+import { BaseAgent as v } from "./BaseAgent.js";
+import { convertToLangChainMiddlewares as l } from "./middlewares/middleware.js";
+import { c as y } from "../chunks/graph.js";
+import { c as T } from "../chunks/state.js";
+import { c as d, h as M, g as x } from "../chunks/utils.js";
+var P = Object.defineProperty, b = Object.getOwnPropertyDescriptor, n = (t, s, r, e) => {
+  for (var o = e > 1 ? void 0 : e ? b(s, r) : s, p = t.length - 1, i; p >= 0; p--)
+    (i = t[p]) && (o = (e ? i(s, r, o) : i(o)) || o);
+  return e && o && P(s, r, o), o;
+};
+let a = class extends v {
+  //#region Lifecycle
+  constructor(t) {
+    super(t), this.modelTier = "default";
+  }
+  initialize() {
+    this.addHandles(
+      w(
+        () => [
+          this.description,
+          this.inputSchema,
+          this.modelTier,
+          this.name,
+          this.outputSchema,
+          this.prompt,
+          this.tools
+        ],
+        () => {
+          this.generate();
+        },
+        { initial: !0, sync: !0 }
+      )
+    );
+  }
+  //#endregion
+  //#region Public Methods
+  getSchemas() {
+    return [this.inputSchema, this.outputSchema].filter(Boolean);
+  }
+  generate() {
+    const t = T(this.getSchemas());
+    this._set("workspace", t);
+    const s = this.id, r = { [s]: this._invoke.bind(this) }, e = [{ from: s, decide: () => {
+    } }];
+    this._set(
+      "createGraph",
+      () => y(r, e, t, {
+        agent: this,
+        entryNode: s,
+        middlewares: this.middlewares
+      })
+    );
+  }
+  //#endregion
+  //#region Private Methods
+  async _invoke(t, s) {
+    try {
+      return this.outputSchema ? await this._invokeStructured(t, s) : await this._invokeUnstructured(t, s);
+    } catch (r) {
+      if (f(r))
+        throw r;
+      const e = r instanceof Error ? r.message : String(r);
+      return d({ outputMessage: e }, "failed", e);
+    }
+  }
+  async _invokeStructured(t, s) {
+    if (!this.outputSchema)
+      throw new Error("Output schema is required for structured invocation.");
+    const e = await h({
+      model: await u(this.modelTier),
+      systemPrompt: await this._getPromptWithInputVariables(t),
+      tools: this._getTools(),
+      checkpointer: !0,
+      middleware: l(this.middlewares),
+      responseFormat: this.outputSchema
+    }).invoke({ messages: t.agentExecutionContext.messages }, s);
+    if (!("structuredResponse" in e) || e.structuredResponse === void 0)
+      throw new Error("LLMAgent did not receive structured output from createAgent.");
+    return M(e.structuredResponse, this.outputSchema, e.messages);
+  }
+  async _invokeUnstructured(t, s) {
+    const o = (await h({
+      model: await u(this.modelTier),
+      systemPrompt: await this._getPromptWithInputVariables(t),
+      tools: this._getTools(),
+      checkpointer: !0,
+      middleware: l(this.middlewares)
+    }).invoke({ messages: t.agentExecutionContext.messages }, s)).messages, i = o.at(-1)?.content ?? "", c = typeof i == "string" ? i : JSON.stringify(i), g = c.trim() || "LLMAgent completed.";
+    return d(
+      { agentExecutionContext: { ...t.agentExecutionContext, messages: o }, outputMessage: c },
+      "success",
+      g
+    );
+  }
+  async _getPromptWithInputVariables(t) {
+    const s = x(t, this.inputSchema);
+    for (const { outputKey: e } of this.middlewares)
+      e && (s[String(e)] = t[e]);
+    return await S.fromTemplate(this.prompt).format(s);
+  }
+  _getTools() {
+    return this.tools?.map((t) => t.getTool()) ?? [];
+  }
+  //#endregion
+};
+n([
+  m()
+], a.prototype, "prompt", 2);
+n([
+  m()
+], a.prototype, "tools", 2);
+n([
+  m()
+], a.prototype, "inputSchema", 2);
+n([
+  m()
+], a.prototype, "outputSchema", 2);
+n([
+  m()
+], a.prototype, "modelTier", 2);
+a = n([
+  _("LLMAgent")
+], a);
+export {
+  a as LLMAgent
+};

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

@@ -0,0 +1,44 @@
+import type { BaseAgent } from "./BaseAgent.js";
+import type { BaseWorkflow } from "./workflows/BaseWorkflow.js";
+import type { AgentData, ZodObjectSchema } from "./types.js";
+
+/**
+ * WorkflowAgent wraps agents and workflows so they can be executed and registered as a single agent.
+ * The workflow defines the internal graph structure and logic of the agent, while WorkflowAgent provides the interface for integration with the broader agent system.
+ *
+ * @since 5.1
+ */
+export class WorkflowAgent<TState extends AgentData = AgentData> extends BaseAgent<TState> {
+  constructor(properties: ConstructProperties<TState>);
+  /** Optional structured input schema for the workflow wrapper. */
+  accessor inputSchema: ZodObjectSchema<object> | undefined;
+  /** Optional structured output schema for the workflow wrapper. */
+  accessor outputSchema: ZodObjectSchema<object> | undefined;
+  /**
+   * The workflow to execute when generating and running this agent's graph.
+   *
+   * @required
+   */
+  accessor workflow: BaseWorkflow<TState>;
+  /**
+   * Rebuilds internal workspace and createGraph wiring. This is automatically called during initialization and whenever
+   * the name or description properties change, but can also be called manually if needed to refresh the agent's graph definition.
+   *
+   * The agent implementation is responsible for defining the createGraph function and workspace structure in this method, which are then used during execution.
+   *
+   * @internal
+   */
+  generate(): void;
+  /**
+   * Returns all schemas required by this agent implementation.
+   *
+   * @returns An array of Zod object schemas that define the structure of the agent's expected input and output data.
+   * These schemas are used for validation and type inference during graph execution.
+   * @internal
+   */
+  getSchemas(): ZodObjectSchema<object>[];
+  initialize(): void;
+}
+
+export type ConstructProperties<TState extends AgentData = AgentData> = Partial<Pick<WorkflowAgent<TState>, "description" | "inputSchema" | "middlewares" | "outputSchema">>
+  & Pick<WorkflowAgent<TState>, "name" | "workflow">;

package/dist/agent-utils/WorkflowAgent.js

@@ -0,0 +1,70 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
+import { property as h, subclass as c } from "@arcgis/core/core/accessorSupport/decorators.js";
+import { watch as l } from "@arcgis/core/core/reactiveUtils.js";
+import { BaseAgent as m } from "./BaseAgent.js";
+import { c as u } from "../chunks/graph.js";
+import "../chunks/BaseWorkflow.js";
+var f = Object.defineProperty, w = Object.getOwnPropertyDescriptor, n = (e, r, s, o) => {
+  for (var t = o > 1 ? void 0 : o ? w(r, s) : r, i = e.length - 1, a; i >= 0; i--)
+    (a = e[i]) && (t = (o ? a(r, s, t) : a(t)) || t);
+  return o && t && f(r, s, t), t;
+};
+let p = class extends m {
+  //#region Lifecycle
+  constructor(e) {
+    super(e);
+  }
+  initialize() {
+    this.addHandles(
+      l(
+        () => [this.name, this.description, this.inputSchema, this.outputSchema, this.workflow],
+        () => this.generate(),
+        { initial: !0, sync: !0 }
+      )
+    );
+  }
+  //#endregion
+  //#region Public Methods
+  getSchemas() {
+    return [
+      this.inputSchema,
+      ...this.workflow.getAgents().flatMap((e) => e.getSchemas()),
+      this.outputSchema
+    ].filter(Boolean);
+  }
+  generate() {
+    const { workspace: e, createGraph: r } = this.workflow.generate();
+    if (this._set("workspace", e), !this.middlewares?.length)
+      this._set("createGraph", r);
+    else {
+      const s = this.id, o = {
+        [s]: async (i, a) => await r().compile().invoke(i, a)
+      }, t = [{ from: s, decide: () => {
+      } }];
+      this._set(
+        "createGraph",
+        () => u(o, t, e, {
+          agent: this,
+          entryNode: s,
+          middlewares: this.middlewares
+        })
+      );
+    }
+  }
+  //#endregion
+};
+n([
+  h()
+], p.prototype, "workflow", 2);
+n([
+  h()
+], p.prototype, "inputSchema", 2);
+n([
+  h()
+], p.prototype, "outputSchema", 2);
+p = n([
+  c("WorkflowAgent")
+], p);
+export {
+  p as WorkflowAgent
+};