@arcgis/ai-components 5.2.0-next.9 → 5.2.0-next.91

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

@@ -3,13 +3,43 @@ import type { BaseChannel, BinaryOperatorAggregate } from "@langchain/langgraph/
 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. */
+/** @internal */
+export type ZodModule = {
+  z: typeof z;
+};
+
+export type SchemaPrimitiveFieldType = "boolean" | "number" | "string";
+
+export type SchemaArrayItemDefinition = SchemaFieldDefinition | SchemaPrimitiveFieldType;
+
+export type SchemaFieldDefinition = ({
+    type: "array";
+    itemType: SchemaArrayItemDefinition;
+} | { type: "boolean" | "number"; } | {
+    type: "object";
+    fields: SchemaDefinition;
+} | {
+    type: "string";
+    enum?: readonly string[];
+}) & {
+  description?: string;
+  required?: boolean;
+};
+
+export type SchemaDefinition = Record<string, SchemaFieldDefinition>;
+
+export type SchemaDefinitionData<TDefinition extends SchemaDefinition> = {
+    [K in keyof TDefinition as TDefinition[K] extends { required: true; } ? K : never]: SchemaFieldData<TDefinition[K]>;
+} &
+  {
+    [K in keyof TDefinition as TDefinition[K] extends { required: true; } ? never : K]?: SchemaFieldData<TDefinition[K]>;
+};
+
+/** @privateRemark All 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. */
@@ -101,7 +131,6 @@ export type AgentNodeUpdate<TInput extends AgentData, TOutput extends AgentData>
  * 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<{
@@ -123,7 +152,6 @@ export type RunnableUpdate<TState extends AgentData> = Partial<TState> extends o
 /**
  * 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>;
@@ -132,7 +160,6 @@ export type TypedStateGraph<TState extends AgentData> = StateGraph<StateDefiniti
  * 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>;
@@ -141,7 +168,7 @@ export type AgentCreateGraph<TState extends AgentData> = () => TypedStateGraph<T
 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 GraphNodes<S extends AgentData, TUpdate = Partial<S>> = Record<string, (state: S, config?: AgentExecutionConfig) => Promise<S | TUpdate> | S | TUpdate>;
 
 export type GraphEdge<S extends AgentData> = {
     from: string;
@@ -149,4 +176,6 @@ export type GraphEdge<S extends AgentData> = {
 } | {
     from: string;
     to: string;
-};
+};
+
+export type SchemaFieldData<TField extends SchemaFieldDefinition> = TField extends { type: "string"; } ? TField["enum"] extends readonly (infer TValue extends string)[] ? TValue : string : TField extends { type: "array"; } ? (TField["itemType"] extends "string" ? string : TField["itemType"] extends "number" ? number : TField["itemType"] extends "boolean" ? boolean : TField["itemType"] extends SchemaFieldDefinition ? SchemaFieldData<TField["itemType"]> : never)[] : TField extends { type: "object"; } ? SchemaDefinitionData<TField["fields"]> : TField extends { type: "number"; } ? number : boolean;

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

@@ -26,7 +26,7 @@ export type ConditionDecider<TState extends AgentData = AgentData> = (state: Age
  * @since 5.1
  */
 export class ConditionalWorkflow<TState extends AgentData = AgentData> extends BaseWorkflow<TState> {
-  constructor(properties: ConstructProperties<TState>);
+  constructor(properties: ConditionalWorkflowConstructProperties<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.
@@ -69,4 +69,4 @@ export class ConditionalWorkflow<TState extends AgentData = AgentData> extends B
   protected validateAgents(agents: BaseAgentLike<TState>[]): void;
 }
 
-export type ConstructProperties<TState extends AgentData> = Pick<ConditionalWorkflow<TState>, "agents" | "condition">;
+export type ConditionalWorkflowConstructProperties<TState extends AgentData> = Pick<ConditionalWorkflow<TState>, "agents" | "condition">;

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

@@ -26,7 +26,7 @@ export type LoopDecider<TState extends AgentData = AgentData> = (state: AgentGra
  * @since 5.1
  */
 export class LoopWorkflow<TState extends AgentData = AgentData> extends BaseWorkflow<TState> {
-  constructor(properties: ConstructProperties<TState>);
+  constructor(properties: LoopWorkflowConstructProperties<TState>);
   /**
    * Function that decides whether the loop should continue.
    *
@@ -55,4 +55,4 @@ export class LoopWorkflow<TState extends AgentData = AgentData> extends BaseWork
   protected isTerminalAgent(): boolean;
 }
 
-export type ConstructProperties<TState extends AgentData> = Pick<LoopWorkflow<TState>, "decideContinue" | "workflow">;
+export type LoopWorkflowConstructProperties<TState extends AgentData> = Pick<LoopWorkflow<TState>, "decideContinue" | "workflow">;

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

@@ -20,7 +20,7 @@ import type { BaseWorkflow, WorkflowGenerateResult } from "./BaseWorkflow.js";
  * @since 5.1
  */
 export class ParallelWorkflow<TState extends AgentData = AgentData> extends BaseWorkflow<TState> {
-  constructor(properties: ConstructProperties<TState>);
+  constructor(properties: ParallelWorkflowConstructProperties<TState>);
   /**
    * Agents to run in parallel from the same input snapshot.
    *
@@ -65,4 +65,4 @@ export class ParallelWorkflow<TState extends AgentData = AgentData> extends Base
   protected isTerminalAgent(_agents: BaseAgentLike<TState>[], _index: number): boolean;
 }
 
-export type ConstructProperties<TState extends AgentData> = Pick<ParallelWorkflow<TState>, "agents">;
+export type ParallelWorkflowConstructProperties<TState extends AgentData> = Pick<ParallelWorkflow<TState>, "agents">;

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

@@ -16,7 +16,7 @@ import type { BaseWorkflow } from "./BaseWorkflow.js";
  * @since 5.1
  */
 export class RouterWorkflow<TState extends AgentData = AgentData> extends BaseWorkflow<TState> {
-  constructor(properties: ConstructProperties<TState>);
+  constructor(properties: RouterWorkflowConstructProperties<TState>);
   /**
    * Mapping of route keys to destination agents.
    *
@@ -60,4 +60,4 @@ export class RouterWorkflow<TState extends AgentData = AgentData> extends BaseWo
   protected validateAgents(agents: BaseAgentLike<TState>[]): void;
 }
 
-export type ConstructProperties<TState extends AgentData> = Pick<RouterWorkflow<TState>, "agentsMap" | "routerAgent" | "routerOutputKey">;
+export type RouterWorkflowConstructProperties<TState extends AgentData> = Pick<RouterWorkflow<TState>, "agentsMap" | "routerAgent" | "routerOutputKey">;

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

@@ -17,7 +17,7 @@ import type { AgentData, AgentGraphState, BaseAgentLike, GraphEdge } from "../ty
  * @since 5.1
  */
 export class SequentialWorkflow<TState extends AgentData = AgentData> extends BaseWorkflow<TState> {
-  constructor(properties: ConstructProperties<TState>);
+  constructor(properties: SequentialWorkflowConstructProperties<TState>);
   /**
    * A list of agents to execute in the specified order.
    *
@@ -53,4 +53,4 @@ export class SequentialWorkflow<TState extends AgentData = AgentData> extends Ba
   protected validateAgents(agents: BaseAgentLike<TState>[]): void;
 }
 
-export type ConstructProperties<TState extends AgentData> = Pick<SequentialWorkflow<TState>, "agents">;
+export type SequentialWorkflowConstructProperties<TState extends AgentData> = Pick<SequentialWorkflow<TState>, "agents">;

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

@@ -26,7 +26,7 @@ export type SwitchDecider<TState extends AgentData = AgentData> = (state: AgentG
  * @since 5.1
  */
 export class SwitchWorkflow<TState extends AgentData = AgentData> extends BaseWorkflow<TState> {
-  constructor(properties: ConstructProperties<TState>);
+  constructor(properties: SwitchWorkflowConstructProperties<TState>);
   /**
    * Mapping of keys to destination agents.
    *
@@ -70,5 +70,5 @@ export class SwitchWorkflow<TState extends AgentData = AgentData> extends BaseWo
   protected validateAgents(agents: BaseAgentLike<TState>[]): void;
 }
 
-export type ConstructProperties<TState extends AgentData> = Partial<Pick<SwitchWorkflow<TState>, "defaultAgent">>
+export type SwitchWorkflowConstructProperties<TState extends AgentData> = Partial<Pick<SwitchWorkflow<TState>, "defaultAgent">>
   & Pick<SwitchWorkflow<TState>, "agentsMap" | "resolver">;

package/dist/agentic-workflow/AgenticWorkflowRuntime.d.ts

@@ -0,0 +1,24 @@
+import type { AgentCreateGraph, AgentCustomState, AgentData, AgentStateAnnotation, ZodObjectSchema } from "../agent-utils/types.js";
+import type { AgenticWorkflowJson } from "./jsonTypes.js";
+import type { GraphNodeResultsState } from "./types.js";
+
+/**
+ * Loads and compiles an ArcGIS Agentic Workflow definition into an executable graph.
+ *
+ * @internal
+ */
+export class AgenticWorkflowRuntime<TInput extends AgentData = AgentData, TOutput extends AgentData = AgentData> {
+  /** @param sourceJSON */
+  static fromJSON<TInput extends AgentData = AgentData, TOutput extends AgentData = AgentData>(sourceJSON: AgenticWorkflowJson): AgenticWorkflowRuntime<TInput, TOutput>;
+  generate(): AgenticWorkflowGenerateResult<TInput, TOutput>;
+  getSchemas(): ZodObjectSchema<object>[];
+  load(): Promise<this>;
+}
+
+export type AgenticWorkflowGenerateResult<TInput extends AgentData, TOutput extends AgentData> = {
+  createGraph: AgentCreateGraph<AgenticWorkflowState<TInput, TOutput>>;
+  workspace: AgentStateAnnotation<AgenticWorkflowState<TInput, TOutput>>;
+};
+
+export type AgenticWorkflowState<TInput extends AgentData, TOutput extends AgentData> = GraphNodeResultsState
+  & Omit<AgentCustomState<TInput, TOutput>, "nodes">;

package/dist/agentic-workflow/Edge.d.ts

@@ -0,0 +1,16 @@
+import type Accessor from "@arcgis/core/core/Accessor.js";
+import type { AgenticWorkflowEdgeJson } from "./jsonTypes.js";
+
+/** @internal */
+export class Edge extends Accessor {
+  /** @param json */
+  static fromJSON(json: AgenticWorkflowEdgeJson): Edge;
+  constructor(properties?: EdgeConstructProperties);
+  accessor id: string;
+  accessor sourceAnchorId: string;
+  accessor sourceNodeId: string;
+  accessor targetAnchorId: string | undefined;
+  accessor targetNodeId: string;
+}
+
+export type EdgeConstructProperties = Pick<Edge, "id" | "sourceAnchorId" | "sourceNodeId" | "targetAnchorId" | "targetNodeId">;

package/dist/agentic-workflow/WebAgent.d.ts

@@ -0,0 +1,39 @@
+import type PortalItem from "@arcgis/core/portal/PortalItem.js";
+import type { BaseAgent } from "../agent-utils/BaseAgent.js";
+import type { AgentData, ZodObjectSchema } from "../agent-utils/types.js";
+import type { AgenticWorkflowJson } from "./jsonTypes.js";
+import type { AgenticWorkflowState } from "./AgenticWorkflowRuntime.js";
+
+/** @internal */
+export class WebAgent<TInput extends AgentData = AgentData, TOutput extends AgentData = AgentData> extends BaseAgent<WebAgentState<TInput, TOutput>> {
+  constructor(properties?: WebAgentConstructProperties<TInput, TOutput>);
+  /**
+   * The portal item associated with this web agent
+   *
+   * @required
+   */
+  accessor portalItem: PortalItem | undefined;
+  accessor sourceJSON: AgenticWorkflowJson | 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>[];
+  load(): Promise<this>;
+}
+
+export type WebAgentState<TInput extends AgentData, TOutput extends AgentData> = AgenticWorkflowState<TInput, TOutput>;
+
+export type WebAgentConstructProperties<TInput extends AgentData, TOutput extends AgentData> = Partial<Pick<WebAgent<TInput, TOutput>, "portalItem" | "sourceJSON">>;

package/dist/agentic-workflow/jsonTypes.d.ts

@@ -0,0 +1,189 @@
+export type AgenticWorkflowJson = AgenticWorkflowJsonObject
+  & {
+  readonly description?: string;
+  readonly graph: AgenticWorkflowGraphJson;
+  readonly variables: AgenticWorkflowVariableJson[];
+  readonly version: string;
+};
+
+export type AgenticWorkflowEdgeJson = AgenticWorkflowJsonObject
+  & {
+  readonly id: string;
+  readonly source_anchor_id: AgenticWorkflowSourceAnchorIdJson;
+  readonly source_node_id: AgenticWorkflowNodeIdJson;
+  readonly target_anchor_id?: AgenticWorkflowNodeIdJson;
+  readonly target_node_id: AgenticWorkflowNodeIdJson;
+};
+
+export type AgenticWorkflowNodeTypeJson = "agent_node" | "end_message_node" | "guardrails_node" | "hitl_node" | "loop_node" | "start_node";
+
+export type AgenticWorkflowBaseNodeJson<TType extends AgenticWorkflowNodeTypeJson> = AgenticWorkflowJsonObject
+  & {
+  readonly id: AgenticWorkflowNodeIdJson;
+  readonly label: string;
+  readonly type: TType;
+};
+
+export type AgenticWorkflowStartNodeJson = AgenticWorkflowBaseNodeJson<"start_node">;
+
+export type AgenticWorkflowEndMessageNodeJson = AgenticWorkflowBaseNodeJson<"end_message_node">
+  & {
+  readonly message: string;
+};
+
+export type AgenticWorkflowAgentNodeJson = AgenticWorkflowBaseNodeJson<"agent_node">
+  & {
+  readonly prompt?: AgenticWorkflowPromptJson;
+  readonly structured_output?: AgenticWorkflowStructuredJsonSchemaJson;
+  readonly tools?: AgenticWorkflowToolJson[];
+  readonly llm_model?: AgenticWorkflowLLMModelJson;
+};
+
+export type AgenticWorkflowArcgisToolJson = AgenticWorkflowJsonObject
+  & {
+  readonly type: "arcgis_tool";
+  readonly name: string;
+  readonly require_approval: AgenticWorkflowApprovalRequirementJson;
+};
+
+export type AgenticWorkflowJsonObject = { readonly [key: string]: AgenticWorkflowJsonValue | undefined; };
+
+export type AgenticWorkflowJsonValue = AgenticWorkflowJsonObject | AgenticWorkflowJsonPrimitive | AgenticWorkflowJsonValue[] | undefined;
+
+export type AgenticWorkflowVariableJson = AgenticWorkflowJsonObject
+  & {
+  readonly data_type?: "array" | "boolean" | "number" | "object" | "string";
+  readonly description?: string;
+  readonly key: string;
+  readonly persisted: boolean;
+  readonly private: boolean;
+  readonly type: "value";
+  readonly value: AgenticWorkflowJsonValue;
+};
+
+export type AgenticWorkflowGraphJson = AgenticWorkflowJsonObject
+  & {
+  readonly edges: AgenticWorkflowEdgeJson[];
+  readonly nodes: AgenticWorkflowNodeJson[];
+};
+
+export type AgenticWorkflowNodeIdJson = `${string}_node_${number}`;
+
+export type AgenticWorkflowSourceAnchorIdJson = `source_anchor_${string}`;
+
+export type AgenticWorkflowNodeJson = AgenticWorkflowAgentNodeJson | AgenticWorkflowEndMessageNodeJson | AgenticWorkflowGuardrailsNodeJson | AgenticWorkflowHumanInTheLoopNodeJson | AgenticWorkflowLoopNodeJson | AgenticWorkflowStartNodeJson;
+
+export type AgenticWorkflowLLMModelJson = {
+  readonly model_tier: "advanced" | "default" | "fast";
+};
+
+export type AgenticWorkflowGuardrailsNodeJson = AgenticWorkflowBaseNodeJson<"guardrails_node">
+  & {
+  readonly conditions: AgenticWorkflowConditionJson[];
+  readonly confidence_threshold: number;
+  readonly prompt?: AgenticWorkflowPromptJson;
+  readonly llm_model?: AgenticWorkflowLLMModelJson;
+};
+
+export type AgenticWorkflowHumanInTheLoopNodeJson = AgenticWorkflowBaseNodeJson<"hitl_node">
+  & {
+  readonly conditions?: AgenticWorkflowConditionJson[];
+  readonly enable_feedback: boolean;
+  readonly human_input_description: string;
+  readonly human_input_description_type?: "dynamic" | "fixed";
+};
+
+export type AgenticWorkflowLoopNodeJson = AgenticWorkflowBaseNodeJson<"loop_node">
+  & {
+  readonly loop_back_node_id: AgenticWorkflowNodeIdJson;
+  readonly max_loop_count: number;
+};
+
+export type AgenticWorkflowConditionJson = AgenticWorkflowJsonObject
+  & {
+  readonly preset?: "process" | "reject";
+  readonly source_anchor_id: AgenticWorkflowSourceAnchorIdJson;
+};
+
+export type AgenticWorkflowPromptJson = AgenticWorkflowJsonObject
+  & {
+  readonly content?: string;
+};
+
+export type AgenticWorkflowStructuredJsonSchemaJson = AgenticWorkflowJsonObject
+  & {
+  readonly properties: Record<string, AgenticWorkflowStructuredJsonPropertyJson>;
+  readonly required?: string[];
+  readonly type: "object";
+  readonly additionalProperties: boolean;
+};
+
+export type AgenticWorkflowStructuredJsonPropertyJson = AgenticWorkflowJsonObject
+  & {
+  readonly description?: string;
+  readonly enum?: string[];
+  readonly items?: AgenticWorkflowStructuredJsonPropertyJson;
+  readonly properties?: Record<string, AgenticWorkflowStructuredJsonPropertyJson>;
+  readonly required?: string[];
+  readonly type: "array" | "boolean" | "number" | "object" | "string";
+  readonly additionalProperties?: boolean;
+};
+
+export type AgenticWorkflowToolJson = AgenticWorkflowArcgisToolJson | AgenticWorkflowMcpToolJson;
+
+export type AgenticWorkflowMcpToolJson = AgenticWorkflowJsonObject
+  & {
+  readonly allowed_tools?: string[];
+  readonly args?: string[];
+  readonly auth?: AgenticWorkflowMcpToolAuthAPIKeyJson | AgenticWorkflowMcpToolAuthBearerJson | AgenticWorkflowMcpToolAuthOAuth2Json;
+  readonly command?: string;
+  readonly env?: Record<string, string>;
+  readonly label?: string;
+  readonly override_params?: AgenticWorkflowUpdateVariableJson[];
+  readonly require_approval: AgenticWorkflowApprovalRequirementJson;
+  readonly return_direct?: boolean;
+  readonly server_description?: string;
+  readonly server_label?: string;
+  readonly server_url?: string;
+  readonly type: "mcp";
+};
+
+export type AgenticWorkflowApprovalRequirementJson = "always" | "never";
+
+export type AgenticWorkflowUpdateVariableJson = AgenticWorkflowJsonObject
+  & {
+  readonly key: string;
+  readonly value: AgenticWorkflowExpressionValueJson;
+};
+
+export type AgenticWorkflowExpressionValueJson = AgenticWorkflowJsonObject
+  & {
+  readonly return_type?: "array" | "boolean" | "number" | "object" | "string" | "unknown";
+  readonly type: "constant" | "variable";
+  readonly value: boolean | number | string;
+};
+
+export type AgenticWorkflowMcpToolAuthBearerJson = {
+  mode: string;
+  header_name?: string;
+  scheme?: string;
+};
+
+export type AgenticWorkflowMcpToolAuthAPIKeyJson = {
+  mode: string;
+  header_name?: string;
+  prefix?: string;
+};
+
+export type AgenticWorkflowMcpToolAuthOAuth2Json = {
+  mode: string;
+  discovery?: string;
+  client_id?: string;
+  authorization_url?: string;
+  token_url?: string;
+  refresh_url?: string;
+  redirect_url?: string;
+  scope?: string;
+};
+
+export type AgenticWorkflowJsonPrimitive = boolean | number | string | null;

package/dist/agentic-workflow/nodes/AgentNode.d.ts

@@ -0,0 +1,28 @@
+import type { BaseNode } from "./BaseNode.js";
+import type { AgenticWorkflowAgentNodeJson } from "../jsonTypes.js";
+import type { AgentData, ZodObjectSchema } from "../../agent-utils/types.js";
+import type { RuntimeNode, NodeCompilation, NodeCompilationContext } from "../types.js";
+import type { ArcgisTool } from "./tools/ArcgisTool.js";
+
+/** @internal */
+export class AgentNode extends BaseNode {
+  /** @param json */
+  static fromJSON(json: AgenticWorkflowAgentNodeJson): AgentNode;
+  constructor(properties?: AgentNodeConstructProperties);
+  accessor modelTier: "advanced" | "default" | "fast" | undefined;
+  accessor outputSchema: ZodObjectSchema<AgentData> | undefined;
+  accessor prompt: string | undefined;
+  accessor tools: ArcgisTool[] | undefined;
+  /**
+   * The type of this node, which identifies it as an agent node within the workflow.
+   *
+   * @default "agent-node"
+   * @required
+   */
+  accessor type: "agent-node";
+  /** @param context */
+  compile<TCustomState extends AgentData>(context: NodeCompilationContext): NodeCompilation<TCustomState>;
+  createRuntimeNode<TCustomState extends AgentData>(): RuntimeNode<TCustomState>;
+}
+
+export type AgentNodeConstructProperties = Pick<AgentNode, "id" | "label" | "modelTier" | "prompt" | "type">;

package/dist/agentic-workflow/nodes/BaseNode.d.ts

@@ -0,0 +1,35 @@
+import type Accessor from "@arcgis/core/core/Accessor.js";
+import type { AgenticWorkflowBaseNodeJson, AgenticWorkflowNodeTypeJson } from "../jsonTypes.js";
+import type { AgentData } from "../../agent-utils/types.js";
+import type { NodeCompilation, NodeCompilationContext, RuntimeNode } from "../types.js";
+
+/** @internal */
+export abstract class BaseNode extends Accessor {
+  /** @param _json */
+  static fromJSON(_json: AgenticWorkflowBaseNodeJson<AgenticWorkflowNodeTypeJson>): BaseNode;
+  constructor(properties?: BaseNodeConstructProperties);
+  /**
+   * The unique identifier for this node.
+   *
+   * @required
+   */
+  accessor id: string;
+  /**
+   * The label for this node, which is used for display purposes.
+   *
+   * @required
+   */
+  accessor label: string;
+  /**
+   * The type of this node, which can be used to categorize or differentiate nodes within the agent's workflow.
+   *
+   * @required
+   */
+  accessor type: string;
+  /** @param context */
+  compile<TCustomState extends AgentData>(context: NodeCompilationContext): NodeCompilation<TCustomState>;
+  abstract createRuntimeNode<TCustomState extends AgentData>(): RuntimeNode<TCustomState>;
+  load(): Promise<this>;
+}
+
+export type BaseNodeConstructProperties = Pick<BaseNode, "id" | "label" | "type">;

package/dist/agentic-workflow/nodes/EndMessageNode.d.ts

@@ -0,0 +1,25 @@
+import type { BaseNode } from "./BaseNode.js";
+import type { AgenticWorkflowEndMessageNodeJson } from "../jsonTypes.js";
+import type { AgentData } from "../../agent-utils/types.js";
+import type { NodeCompilation, NodeCompilationContext, RuntimeNode } from "../types.js";
+
+/** @internal */
+export class EndMessageNode extends BaseNode {
+  /** @param json */
+  static fromJSON(json: AgenticWorkflowEndMessageNodeJson): EndMessageNode;
+  constructor(properties?: EndMessageNodeConstructProperties);
+  /** The message associated with this end message node, which is displayed when the node is reached in the workflow. */
+  accessor message: string;
+  /**
+   * The type of this node, which identifies it as an end message node within the workflow.
+   *
+   * @default "end-message-node"
+   * @required
+   */
+  accessor type: "end-message-node";
+  /** @param _context */
+  compile<TCustomState extends AgentData>(_context: NodeCompilationContext): NodeCompilation<TCustomState>;
+  createRuntimeNode<TCustomState extends AgentData>(): RuntimeNode<TCustomState>;
+}
+
+export type EndMessageNodeConstructProperties = Pick<EndMessageNode, "id" | "label" | "type">;

package/dist/agentic-workflow/nodes/StartNode.d.ts

@@ -0,0 +1,21 @@
+import type { BaseNode } from "./BaseNode.js";
+import type { AgenticWorkflowStartNodeJson } from "../jsonTypes.js";
+import type { RuntimeNode } from "../types.js";
+import type { AgentData } from "../../agent-utils/types.js";
+
+/** @internal */
+export class StartNode extends BaseNode {
+  /** @param json */
+  static fromJSON(json: AgenticWorkflowStartNodeJson): StartNode;
+  constructor(properties?: StartNodeConstructProperties);
+  /**
+   * The type of this node, which can be used to categorize or differentiate nodes within the agent's workflow.
+   *
+   * @default "start-node"
+   * @required
+   */
+  accessor type: "start-node";
+  createRuntimeNode<TCustomState extends AgentData>(): RuntimeNode<TCustomState>;
+}
+
+export type StartNodeConstructProperties = Pick<StartNode, "id" | "label" | "type">;

package/dist/agentic-workflow/nodes/tools/ArcgisTool.d.ts

@@ -0,0 +1,21 @@
+import type Accessor from "@arcgis/core/core/Accessor.js";
+import type { AgenticWorkflowArcgisToolJson } from "../../jsonTypes.js";
+import type { StructuredToolInterface } from "@langchain/core/tools";
+
+/**
+ * Portal configuration for ArcGIS tools.
+ *
+ * @internal
+ */
+export class ArcgisTool extends Accessor {
+  /** @param json */
+  static fromJSON(json: AgenticWorkflowArcgisToolJson): ArcgisTool;
+  constructor(properties?: ArcgisToolConstructProperties);
+  accessor name: string | undefined;
+  accessor requireApproval: "always" | "never" | undefined;
+  /** @default "arcgis-tool" */
+  accessor type: "arcgis-tool";
+  createRuntimeTools(): Promise<StructuredToolInterface[]>;
+}
+
+export type ArcgisToolConstructProperties = Pick<ArcgisTool, "name" | "requireApproval">;

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

@@ -0,0 +1,29 @@
+import type { AgentData, AgentGraphState, AgentRuntimeState, GraphEdge, GraphNodes, ZodObjectSchema } from "../agent-utils/types.js";
+import type { Edge } from "./Edge.js";
+
+export type GraphNodeResultsState = {
+  nodes: GraphNodeResults;
+};
+
+export type RuntimeNode<TCustomState extends AgentData> = GraphNodes<AgentGraphState<GraphNodeResultsState & Omit<TCustomState, "nodes">>, AgentNodeGraphUpdate>[string];
+
+export type NodeCompilationContext = {
+  outgoingEdges: Edge[];
+};
+
+export type NodeCompilation<TCustomState extends AgentData> = {
+  runtimeNode?: RuntimeNode<TCustomState>;
+  edges: GraphEdge<WebAgentRuntimeState<TCustomState>>[];
+  schemas?: ZodObjectSchema<object>[];
+};
+
+export type GraphNodeResults = Record<string, GraphNodeResult>;
+
+export type AgentNodeGraphUpdate = Partial<AgentRuntimeState & GraphNodeResultsState>
+  & Record<string, unknown>;
+
+export type WebAgentRuntimeState<TCustomState extends AgentData> = AgentGraphState<GraphNodeResultsState & Omit<TCustomState, "nodes">>;
+
+export type GraphNodeResult<TOutput extends AgentData = AgentData> = {
+  output: Omit<TOutput, keyof AgentRuntimeState | "output"> | string;
+};

package/dist/agents/tools/filter/clearFilters/adapter.d.ts

@@ -0,0 +1,8 @@
+import type { StructuredToolInterface } from "@langchain/core/tools";
+
+/**
+ * Clears all feature effects without changing the current map view.
+ *
+ * @internal
+ */
+export const clearFiltersTool: StructuredToolInterface;

package/dist/agents/tools/filter/clearFilters/adapter.js

@@ -0,0 +1,22 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
+import { tool as l } from "@langchain/core/tools";
+import o from "zod";
+import { f } from "../../../../chunks/fetchAgentContext.js";
+const i = (a) => {
+  const r = a.map?.allLayers.filter((t) => t.type === "feature");
+  let e = 0;
+  return r?.forEach((t) => {
+    const s = t;
+    s.featureEffect && (s.featureEffect = null, e++);
+  }), e > 0 ? `Cleared filters from ${e} layer(s). View unchanged.` : "No active filters to clear. View unchanged.";
+}, n = async (a, r) => {
+  const { mapView: e } = f(r, ["mapView"]);
+  return i(e);
+}, p = l(n, {
+  name: "clearFilters",
+  description: "Clears all feature effects/filters from the map but does NOT change the current view. Use when user says 'clear filters', 'reset filters', 'remove filters', 'show all features', or wants to remove emphasis without navigating anywhere.",
+  schema: o.object({})
+});
+export {
+  p as clearFiltersTool
+};