@arcgis/ai-components 5.2.0-next.12 → 5.2.0-next.121

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

@@ -0,0 +1,223 @@
+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" | "human_input_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 AgenticWorkflowHumanInTheLoopNodeJson = AgenticWorkflowBaseNodeJson<"human_input_node">
+  & {
+  readonly conditions: AgenticWorkflowConditionJson[];
+  readonly message: AgenticWorkflowHumanInTheLoopMessageJson;
+  readonly response: AgenticWorkflowHumanInTheLoopResponseJson;
+};
+
+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 = 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 AgenticWorkflowHumanInTheLoopMessageJson = {
+    readonly content: string;
+    readonly source: "fixed";
+} | {
+    readonly generationInstructions: string;
+    readonly model: AgenticWorkflowLLMModelJson;
+    readonly source: "generated";
+};
+
+export type AgenticWorkflowHumanInTheLoopResponseJson = {
+    readonly choices: AgenticWorkflowHumanInTheLoopChoicesJson;
+    readonly freeTextInput?: AgenticWorkflowHumanInTheLoopFreeTextJson;
+    readonly type: "multipleSelect" | "singleSelect";
+} | {
+    readonly type: "confirmation";
+    readonly freeTextInput?: AgenticWorkflowHumanInTheLoopFreeTextJson;
+} | { readonly type: "textInput"; };
+
+export type AgenticWorkflowHumanInTheLoopChoicesJson = {
+    readonly items: {
+        readonly label: string;
+        readonly value: string;
+    }[];
+    readonly source: "fixed";
+} | {
+    readonly reference: string;
+    readonly source: "reference";
+};
+
+export type AgenticWorkflowHumanInTheLoopFreeTextJson = {
+  readonly enabled: boolean;
+  readonly maxLength?: number;
+  readonly placeholder?: string;
+};
+
+export type AgenticWorkflowLoopNodeJson = AgenticWorkflowBaseNodeJson<"loop_node">
+  & {
+  readonly loop_back_node_id: AgenticWorkflowNodeIdJson;
+  readonly max_loop_count: number;
+};
+
+export type AgenticWorkflowConditionJson = AgenticWorkflowJsonObject
+  & {
+  readonly outcome: "confirmed" | "dismissed";
+  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/HumanInTheLoopNode.d.ts

@@ -0,0 +1,37 @@
+import type { AgenticWorkflowHumanInTheLoopNodeJson } from "../jsonTypes.js";
+import type { AgentData } from "../../agent-utils/types.js";
+import type { RuntimeNode, NodeCompilation, NodeCompilationContext } from "../types.js";
+import type { BaseNode } from "./BaseNode.js";
+
+/**
+ * Pauses a workflow and requests a response from the user.
+ *
+ * @internal
+ */
+export class HumanInTheLoopNode extends BaseNode {
+  /** @param json */
+  static fromJSON(json: AgenticWorkflowHumanInTheLoopNodeJson): HumanInTheLoopNode;
+  constructor(properties?: HumanInTheLoopNodeConstructProperties);
+  accessor conditions: HumanInTheLoopCondition[];
+  accessor message: AgenticWorkflowHumanInTheLoopNodeJson["message"] | undefined;
+  accessor response: HumanInTheLoopResponseConfig | undefined;
+  /**
+   * The type of this node, which can be used to categorize or differentiate nodes within the agent's workflow.
+   *
+   * @default "human-in-the-loop-node"
+   * @required
+   */
+  accessor type: "human-in-the-loop-node";
+  /** @param context */
+  compile<TCustomState extends AgentData>(context: NodeCompilationContext): NodeCompilation<TCustomState>;
+  createRuntimeNode<TCustomState extends AgentData>(): RuntimeNode<TCustomState>;
+}
+
+export type HumanInTheLoopNodeConstructProperties = Pick<HumanInTheLoopNode, "id" | "label" | "type">;
+
+export type HumanInTheLoopResponseConfig = NonNullable<AgenticWorkflowHumanInTheLoopNodeJson["response"]>;
+
+export type HumanInTheLoopCondition = {
+  outcome: "confirmed" | "dismissed";
+  sourceAnchorId: string;
+};

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[] | boolean | string;
+};

package/dist/agents/runtime/skill/createSkillAgent.d.ts

@@ -0,0 +1,28 @@
+import type { createChatModel } from "../../../orchestrator/providers/arcgis/aiFactory.js";
+import type { AgentRegistration } from "../../../orchestrator/registry/agentRegistry.js";
+import type { SkillLoader } from "./loadAgentSkills.js";
+import type { ToolLoaders, RuntimeContextLoaderOptions } from "./types.js";
+
+/**
+ * Creates an agent registration that loads and runs bundled skills.
+ *
+ * @param parameter0
+ */
+export function createSkillAgent(parameter0: SkillAgentOptions): AgentRegistration;
+
+export type SkillAgentOptions = {
+  id: string;
+  name: string;
+  description: string;
+  systemPrompt: string;
+  skillLoaders: readonly [SkillLoader, ...SkillLoader[]];
+  toolLoaders?: ToolLoaders;
+  modelTier?: ModelTier;
+  runtimeContextLoader?: RuntimeContextLoader;
+  instructions?: string;
+};
+
+export type ModelTier = NonNullable<Parameters<typeof createChatModel>[0]>["modelTier"];
+
+/** @param options */
+export type RuntimeContextLoader = (options: RuntimeContextLoaderOptions) => Promise<string> | string;