@arcgis/ai-components 5.1.0-next.13 → 5.1.0-next.130

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

@@ -0,0 +1,129 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.1/LICENSE.txt */
+import { property as A, subclass as I } from "@arcgis/core/core/accessorSupport/decorators.js";
+import { c as U } from "../../chunks/graph.js";
+import { a as W } from "../../chunks/state.js";
+import { B as G, c as J, g as m, a as j } from "../../chunks/BaseWorkflow.js";
+var k = Object.defineProperty, B = Object.getOwnPropertyDescriptor, C = (e, t, s, n) => {
+  for (var a = n > 1 ? void 0 : n ? B(t, s) : t, o = e.length - 1, r; o >= 0; o--)
+    (r = e[o]) && (a = (n ? r(t, s, a) : r(a)) || a);
+  return n && a && k(t, s, a), a;
+};
+let y = class extends G {
+  //#region Lifecycle
+  constructor(e) {
+    super(e);
+  }
+  //#endregion
+  //#region Public Methods
+  getAgents() {
+    return this.agents;
+  }
+  generate() {
+    const e = this.getAgents();
+    this.validateAgents(e);
+    for (const r of e)
+      r.generate();
+    const t = J(e.flatMap((r) => r.getSchemas()));
+    for (const [r] of e.entries())
+      t[_(r)] = void 0;
+    const s = W(t), n = this.buildNodes(e), a = this.buildEdges(e);
+    return { workspace: s, createGraph: () => U(n, a, s, { entryNode: this.getEntryNode(e) }) };
+  }
+  //#endregion
+  //#region Protected Methods
+  getEntryNode(e) {
+    return h;
+  }
+  isTerminalAgent(e, t) {
+    return !1;
+  }
+  buildNodes(e) {
+    const t = {};
+    for (const [s, n] of e.entries()) {
+      const a = _(s), o = m(n, s);
+      t[o] = async (r, i) => {
+        const d = await n.run(K(r, n), i), u = {}, f = u;
+        return f[a] = d, u;
+      };
+    }
+    return t[h] = () => ({}), t[w] = (s) => $(s, e), t;
+  }
+  buildEdges(e) {
+    return [
+      ...e.map((t, s) => ({ from: h, to: m(t, s) })),
+      ...e.map((t, s) => ({ from: m(t, s), to: w }))
+    ];
+  }
+  //#endregion
+};
+C([
+  A()
+], y.prototype, "agents", 2);
+y = C([
+  I("ParallelWorkflow")
+], y);
+const h = "__parallel_fanOut", w = "__parallel_join";
+function _(e) {
+  return `__parallel_update_${e}`;
+}
+function F(e, t) {
+  return Object.fromEntries(
+    t.filter((s) => Object.hasOwn(e, s)).map((s) => [s, e[s]])
+  );
+}
+function K(e, t) {
+  const s = t.inputSchema;
+  return s ? {
+    ...F(e, j(s)),
+    agentExecutionContext: e.agentExecutionContext,
+    outputMessage: e.outputMessage,
+    status: void 0,
+    summary: ""
+  } : { ...e, status: void 0, summary: "" };
+}
+function D(e, t) {
+  return e.outputSchema ? F(t, j(e.outputSchema)) : {};
+}
+function R(e, t) {
+  const s = e.agentExecutionContext?.messages ?? [], n = t.agentExecutionContext?.messages ?? [];
+  return n.length > s.length ? n.slice(s.length) : void 0;
+}
+function $(e, t) {
+  const s = [], n = [], a = [], o = {}, r = {}, i = /* @__PURE__ */ new Set();
+  for (const [f, P] of t.entries()) {
+    const x = _(f), g = e[x];
+    if (r[x] = void 0, !g || typeof g != "object")
+      continue;
+    const c = g, S = c.outputMessage, b = R(e, c), v = c.summary, M = D(P, c), O = S.trim();
+    typeof S == "string" && O && s.push(O);
+    const E = v.trim();
+    typeof v == "string" && E && n.push(E), Array.isArray(b) && a.push(...b), c.status && i.add(c.status);
+    for (const [l, p] of Object.entries(M))
+      if (!(p === void 0 || l.startsWith("__parallel_update_")) && !N(e[l], p)) {
+        if (!Object.hasOwn(o, l)) {
+          o[l] = p;
+          continue;
+        }
+        if (!N(o[l], p))
+          throw new Error(`ParallelWorkflow detected conflicting updates for state key "${l}".`);
+      }
+  }
+  const d = {
+    ...r,
+    ...o
+  }, u = d;
+  return a.length > 0 && (u.agentExecutionContext = {
+    ...e.agentExecutionContext,
+    messages: [...e.agentExecutionContext.messages, ...a]
+  }), s.length && (u.outputMessage = s.join(`
+
+`)), n.length && (u.summary = n.join(`
+
+`)), i.size && (u.status = i.has("failed") ? "failed" : i.has("success") ? "success" : void 0), d;
+}
+function N(e, t) {
+  return e === t ? !0 : e && t ? JSON.stringify(e) === JSON.stringify(t) : !1;
+}
+export {
+  y as ParallelWorkflow
+};

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

@@ -0,0 +1,63 @@
+import type { AgentData, AgentGraphState, BaseAgentLike, GraphEdge } from "../types.js";
+import type { BaseWorkflow } from "./BaseWorkflow.js";
+
+/**
+ * RouterWorkflow runs a router agent, then dispatches to exactly one downstream agent.
+ *
+ * Use in the following scenarios:
+ * - A model (or routing step) should choose the destination,
+ * - Only one branch should run per request
+ *
+ * How it works:
+ * - `routerAgent` always runs first,
+ * - `routerAgent` reads the selected route key from `routerOutputKey`,
+ * - The agent corresponding to the selected route key is dispatched from `agentsMap`.
+ *
+ * @since 5.1
+ */
+export class RouterWorkflow<TState extends AgentData = AgentData> extends BaseWorkflow<TState> {
+  constructor(properties: ConstructProperties<TState>);
+  /**
+   * Mapping of route keys to destination agents.
+   *
+   * @required
+   */
+  accessor agentsMap: Record<string, BaseAgentLike<TState>>;
+  /**
+   * The agent that decides which route key to select.
+   *
+   * @required
+   */
+  accessor routerAgent: BaseAgentLike<TState>;
+  /**
+   * State key containing the selected route returned by the router agent.
+   *
+   * @required
+   */
+  accessor routerOutputKey: keyof AgentGraphState<TState>;
+  /**
+   * Builds the workflow-specific edges.
+   *
+   * @param agents
+   */
+  protected buildEdges(agents: BaseAgentLike<TState>[]): GraphEdge<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.
+   *
+   * @param _agents
+   * @param index
+   */
+  protected isTerminalAgent(_agents: BaseAgentLike<TState>[], index: number): boolean;
+  /**
+   * Validates the workflow configuration and throws if invalid.
+   *
+   * @param agents
+   */
+  protected validateAgents(agents: BaseAgentLike<TState>[]): void;
+}
+
+export type ConstructProperties<TState extends AgentData> = Pick<RouterWorkflow<TState>, "agentsMap" | "routerAgent" | "routerOutputKey">;

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

@@ -0,0 +1,75 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.1/LICENSE.txt */
+import { property as h, subclass as g } from "@arcgis/core/core/accessorSupport/decorators.js";
+import { B as v, g as l } from "../../chunks/BaseWorkflow.js";
+var w = Object.defineProperty, _ = Object.getOwnPropertyDescriptor, f = (e) => {
+  throw TypeError(e);
+}, c = (e, t, o, s) => {
+  for (var r = s > 1 ? void 0 : s ? _(t, o) : t, n = e.length - 1, d; n >= 0; n--)
+    (d = e[n]) && (r = (s ? d(t, o, r) : d(r)) || r);
+  return s && r && w(t, o, r), r;
+}, y = (e, t, o) => t.has(e) || f("Cannot " + o), A = (e, t, o) => t.has(e) ? f("Cannot add the same private member more than once") : t instanceof WeakSet ? t.add(e) : t.set(e, o), p = (e, t, o) => (y(e, t, "access private method"), o), a, i;
+let u = class extends v {
+  //#region Lifecycle
+  constructor(e) {
+    super(e), A(this, a);
+  }
+  //#endregion
+  //#region Public Methods
+  getAgents() {
+    return p(this, a, i).call(this), [this.routerAgent, ...Object.values(this.agentsMap)];
+  }
+  buildEdges(e) {
+    p(this, a, i).call(this);
+    const t = l(this.routerAgent, 0), o = /* @__PURE__ */ new Map();
+    for (const [s, [r]] of Object.entries(this.agentsMap).entries())
+      o.set(r, l(e[s + 1], s + 1));
+    return [
+      {
+        from: t,
+        decide: (s) => {
+          const r = s[this.routerOutputKey];
+          if (typeof r != "string" || !r)
+            throw new Error("RouterWorkflow decideRoute could not determine next agent from state.");
+          const n = o.get(r);
+          if (!n)
+            throw new Error(
+              `RouterWorkflow decideRoute returned unknown agent: ${r}. Expected one of: ${Object.keys(this.agentsMap).join(", ") || "(none)"}.`
+            );
+          return n;
+        }
+      }
+    ];
+  }
+  //#endregion
+  //#region Protected Methods
+  getEntryNode() {
+    return p(this, a, i).call(this), l(this.routerAgent, 0);
+  }
+  isTerminalAgent(e, t) {
+    return t > 0;
+  }
+  validateAgents(e) {
+    p(this, a, i).call(this), super.validateAgents(e);
+  }
+  //#endregion
+};
+a = /* @__PURE__ */ new WeakSet();
+i = function() {
+  if (!Object.keys(this.agentsMap).length)
+    throw new Error("RouterWorkflow requires a non-empty agentsMap.");
+};
+c([
+  h()
+], u.prototype, "agentsMap", 2);
+c([
+  h()
+], u.prototype, "routerAgent", 2);
+c([
+  h()
+], u.prototype, "routerOutputKey", 2);
+u = c([
+  g("RouterWorkflow")
+], u);
+export {
+  u as RouterWorkflow
+};

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

@@ -0,0 +1,56 @@
+import type { BaseWorkflow } from "./BaseWorkflow.js";
+import type { AgentData, AgentGraphState, BaseAgentLike, GraphEdge } from "../types.js";
+
+/**
+ * SequentialWorkflow executes agents in strict linear order.
+ *
+ * Use in the following scenarios:
+ * - Later steps depend on values produced by earlier steps,
+ * - You want a simple linear pipeline.
+ *
+ * How it works:
+ * - First agent runs and passes shared state forward,
+ * - Each subsequent agent receives the updated shared state from the previous agent,
+ * - Run agent 2, then agent 3, and so on,
+ * - Stop after the final agent in the sequence runs.
+ *
+ * @since 5.1
+ */
+export class SequentialWorkflow<TState extends AgentData = AgentData> extends BaseWorkflow<TState> {
+  constructor(properties: ConstructProperties<TState>);
+  /**
+   * A list of agents to execute in the specified order.
+   *
+   * @required
+   */
+  accessor agents: BaseAgentLike<TState>[];
+  /**
+   * Builds the workflow-specific edges.
+   *
+   * @param agents
+   */
+  protected buildEdges(agents: BaseAgentLike<TState>[]): GraphEdge<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.
+   *
+   * @param agents
+   */
+  protected getEntryNode(agents: BaseAgentLike<TState>[]): string | undefined;
+  /**
+   * Returns whether the agent at this position should expose terminal runtime fields.
+   *
+   * @param agents
+   * @param index
+   */
+  protected isTerminalAgent(agents: BaseAgentLike<TState>[], index: number): boolean;
+  /**
+   * Validates the workflow configuration and throws if invalid.
+   *
+   * @param agents
+   */
+  protected validateAgents(agents: BaseAgentLike<TState>[]): void;
+}
+
+export type ConstructProperties<TState extends AgentData> = Pick<SequentialWorkflow<TState>, "agents">;

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

@@ -0,0 +1,69 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.1/LICENSE.txt */
+import { property as p, subclass as f } from "@arcgis/core/core/accessorSupport/decorators.js";
+import { B as c, g as i, a as m } from "../../chunks/BaseWorkflow.js";
+var d = Object.defineProperty, w = Object.getOwnPropertyDescriptor, u = (e, o, r, t) => {
+  for (var s = t > 1 ? void 0 : t ? w(o, r) : o, n = e.length - 1, a; n >= 0; n--)
+    (a = e[n]) && (s = (t ? a(o, r, s) : a(s)) || s);
+  return t && s && d(o, r, s), s;
+};
+let l = class extends c {
+  //#region Lifecycle
+  constructor(e) {
+    super(e);
+  }
+  //#endregion
+  //#region Public Methods
+  getAgents() {
+    return this.agents;
+  }
+  //#endregion
+  //#region Protected Methods
+  getEntryNode(e) {
+    return e[0] ? i(e[0], 0) : void 0;
+  }
+  isTerminalAgent(e, o) {
+    return o === e.length - 1;
+  }
+  validateAgents(e) {
+    super.validateAgents(e);
+    const o = /* @__PURE__ */ new Map();
+    for (const [r, t] of e.entries()) {
+      const s = e[r - 1];
+      if (t.outputSchema)
+        for (const n of m(t.outputSchema)) {
+          const a = o.get(n) ?? [];
+          a.push(`${t.name} [${r}]`), o.set(n, a);
+        }
+      if (!(r === 0 || !t.inputSchema || s?.outputSchema))
+        throw new Error(
+          `Workflow agent "${t.name}" declares an input schema, so upstream agent "${s.name}" must declare an output schema.`
+        );
+    }
+    for (const [r, t] of o.entries())
+      t.length > 1 && console.warn(
+        `Workflow output field "${r}" is declared by multiple steps (${t.join(", ")}). Later steps will overwrite earlier values in shared state.`
+      );
+  }
+  buildEdges(e) {
+    return e.length === 1 ? [
+      {
+        from: i(e[0], 0),
+        decide: () => {
+        }
+      }
+    ] : e.slice(0, -1).map((o, r) => ({
+      from: i(o, r),
+      decide: (t) => t.status === "failed" ? void 0 : i(e[r + 1], r + 1)
+    }));
+  }
+  //#endregion
+};
+u([
+  p()
+], l.prototype, "agents", 2);
+l = u([
+  f("SequentialWorkflow")
+], l);
+export {
+  l as SequentialWorkflow
+};

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

@@ -0,0 +1,74 @@
+import type { AgentData, AgentExecutionConfig, AgentGraphState, BaseAgentLike, GraphEdge, GraphNodes } from "../types.js";
+import type { BaseWorkflow } from "./BaseWorkflow.js";
+
+/**
+ * Resolver function that chooses a switch case key from current graph state.
+ *
+ * @param state - Current workflow graph state.
+ * @param config - Optional execution configuration.
+ * @since 5.1
+ */
+export type SwitchDecider<TState extends AgentData = AgentData> = (state: AgentGraphState<TState>, config?: AgentExecutionConfig) => Promise<string | undefined> | string | undefined;
+
+/**
+ * SwitchWorkflow routes execution to one of several branches based on a resolver function.
+ *
+ * Use in the following scenarios:
+ * - Branch selection should be based on complex logic that doesn't fit a simple true/false condition.
+ * - You want explicit case handling with optional fallback.
+ *
+ * How it works:
+ * - Run `resolver(state, config)` to get a case key,
+ * - Route to matching `agentsMap` entry,
+ * - If unknown and `defaultAgent` exists, run default,
+ * - If unknown and no default, throw an error.
+ *
+ * @since 5.1
+ */
+export class SwitchWorkflow<TState extends AgentData = AgentData> extends BaseWorkflow<TState> {
+  constructor(properties: ConstructProperties<TState>);
+  /**
+   * Mapping of keys to destination agents.
+   *
+   * @required
+   */
+  accessor agentsMap: Record<string, BaseAgentLike<TState>>;
+  /** Optional fallback agent used when the resolver returns an unknown case. */
+  accessor defaultAgent: BaseAgentLike<TState> | undefined;
+  /**
+   * Resolver used to select the case key for routing.
+   *
+   * @required
+   */
+  accessor resolver: SwitchDecider<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> = Partial<Pick<SwitchWorkflow<TState>, "defaultAgent">>
+  & Pick<SwitchWorkflow<TState>, "agentsMap" | "resolver">;

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

@@ -0,0 +1,84 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.1/LICENSE.txt */
+import { property as u, subclass as _ } from "@arcgis/core/core/accessorSupport/decorators.js";
+import { B as y, g as v } from "../../chunks/BaseWorkflow.js";
+var A = Object.defineProperty, N = Object.getOwnPropertyDescriptor, g = (e) => {
+  throw TypeError(e);
+}, d = (e, t, r, o) => {
+  for (var s = o > 1 ? void 0 : o ? N(t, r) : t, n = e.length - 1, a; n >= 0; n--)
+    (a = e[n]) && (s = (o ? a(t, r, s) : a(s)) || s);
+  return o && s && A(t, r, s), s;
+}, m = (e, t, r) => t.has(e) || g("Cannot " + r), M = (e, t, r) => t.has(e) ? g("Cannot add the same private member more than once") : t instanceof WeakSet ? t.add(e) : t.set(e, r), w = (e, t, r) => (m(e, t, "access private method"), r), c, p;
+let i = class extends y {
+  //#region Lifecycle
+  constructor(e) {
+    super(e), M(this, c);
+  }
+  //#endregion
+  //#region Public Methods
+  getAgents() {
+    const e = Object.values(this.agentsMap);
+    return this.defaultAgent ? e.concat(this.defaultAgent) : e;
+  }
+  //#endregion
+  //#region Protected Methods
+  buildNodes(e) {
+    const t = super.buildNodes(e);
+    return t[h] = () => ({}), t;
+  }
+  buildEdges(e) {
+    w(this, c, p).call(this);
+    const t = this.resolver, r = /* @__PURE__ */ new Map();
+    for (const [n, [a]] of Object.entries(this.agentsMap).entries())
+      r.set(a, v(e[n], n));
+    const { defaultAgent: o } = this, s = o ? v(o, e.length - 1) : void 0;
+    return [
+      {
+        from: h,
+        decide: async (n, a) => {
+          const l = await Promise.resolve(t(n, a));
+          if (!l)
+            return;
+          const f = r.get(l);
+          if (f)
+            return f;
+          if (o)
+            return s;
+          throw new Error(
+            `SwitchWorkflow resolver returned unknown case: ${l}. Expected one of: ${Object.keys(this.agentsMap).join(", ") || "(none)"}.`
+          );
+        }
+      }
+    ];
+  }
+  getEntryNode() {
+    return h;
+  }
+  isTerminalAgent() {
+    return !0;
+  }
+  validateAgents(e) {
+    w(this, c, p).call(this), super.validateAgents(e);
+  }
+  //#endregion
+};
+c = /* @__PURE__ */ new WeakSet();
+p = function() {
+  if (!Object.keys(this.agentsMap).length)
+    throw new Error("SwitchWorkflow requires a non-empty agentsMap.");
+};
+d([
+  u()
+], i.prototype, "agentsMap", 2);
+d([
+  u()
+], i.prototype, "resolver", 2);
+d([
+  u()
+], i.prototype, "defaultAgent", 2);
+i = d([
+  _("SwitchWorkflow")
+], i);
+const h = "__switch_decide";
+export {
+  i as SwitchWorkflow
+};

package/dist/assets/embeddings.worker-k9_Ou679.js

@@ -0,0 +1 @@
+(function(){"use strict";const h=(a,r)=>{if(a.length!==r.length)throw new Error("Vectors must be the same length");let c=0,t=0,e=0;for(let n=0;n<a.length;++n){const s=a[n],l=r[n];c+=s*l,t+=s*s,e+=l*l}const i=Math.sqrt(t*e);if(i===0)return 0;const m=c/i;return Math.max(-1,Math.min(1,m))},f=(a,r,c=.6)=>{const t=[],e=[...a];for(;t.length<r&&e.length>0;){let i=-1,m=-1/0;for(let n=0;n<e.length;n++){const s=e[n].score,l=t.length===0?0:Math.max(...t.map(o=>h(e[n].vector,o.vector))),d=c*s-(1-c)*l;d>m&&(m=d,i=n)}t.push(e[i]),e.splice(i,1)}return t.map(({name:i,score:m})=>({name:i,score:m}))};let p=[];const u=new Map,v=12,y=10,M=a=>{p=a.layers.map(r=>({id:r.id,vector:r.vector}))},E=a=>{u.clear();for(const r of a.layers){const c=r.fields.map(t=>({name:t.name,vector:t.vector}));u.set(r.id,c)}};globalThis.addEventListener("message",a=>{(async()=>{const{type:r,webmapEmbeddings:c,layerIdForFieldsSearch:t=[],requestId:e,precomputedEmbedding:i,minScore:m=0,topResults:n=v}=a.data;switch(r){case"generateEmbeddings":{c&&(M(c),E(c)),globalThis.postMessage("completed");break}case"layerSearch":{if(p.length>0)try{const s=p.map(o=>({id:o.id,vector:o.vector,score:h(i,o.vector)})),d=f(s.map(o=>({name:o.id,vector:o.vector,score:o.score})),y).map(({name:o,score:b})=>({id:o,score:b}));globalThis.postMessage({requestId:e,results:d})}catch(s){globalThis.postMessage({requestId:e,results:[],error:s instanceof Error?s.message:"Calculation error"})}else globalThis.postMessage({requestId:e,results:[],error:"Layer embeddings not initialized"});break}case"fieldSearch":{if(t.length>0)try{const s=t.map(l=>{const d=u.get(l);if(!d)return{layerId:l,results:[]};const o=d.map(g=>({name:g.name,vector:g.vector,score:h(i,g.vector)})).filter(({score:g})=>g>=m),b=f(o,n);return{layerId:l,results:b}});globalThis.postMessage({requestId:e,results:s})}catch(s){globalThis.postMessage({requestId:e,results:[],error:s instanceof Error?s.message:"Field search calculation error"})}break}default:console.warn("Unknown message type:",r)}})()})})();