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

package/dist/chunks/field_descriptions_prompt.js

@@ -0,0 +1,112 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
+const e = `You are a knowledgeable GIS expert.
+
+You are given a Feature Service description and title.
+
+{existingItemTitle}
+{existingItemDescription}
+
+You are given Feature Layer descriptions and title.
+
+{existingLayerTitle}
+{existingLayerDescription}
+
+## Existing field descriptions:
+
+Here is an extensive list of fields with their existing descriptions. These fields together represent a summary of the data contained in this feature layer. NOTE that these field descriptions are not final and may need to be improved.
+Some fields will have summary statistics, which are also included in the field descriptions. Statistics can help you decipher the type of data better.
+
+    {fieldInformation}
+
+Your task is to generate the following for each field:
+
+1. field_description: A short description of the field.
+2. field_value_type: Field Value Type
+3. field_alias: A display name that concisely conveys the field contents to help readers understand the data
+
+## Instructions to generate Field Description:
+
+- You must generate a field description for each field in the feature layer.
+- You must not skip any field.
+- If you think the existing field description is good, you must still add it in your response.
+- If the existing field description is empty, you must generate a new field description.
+- The field description should be a short description of the field.
+- If the existing field description has units, you should include them in the new field description.
+- If the existing field description is not clear, you should improve it.
+- Do not have duplicate field descriptions. Always keep the one that is the best.
+
+## Instructions to determine Field Value Type:
+
+Following is a list of field value types you can assign to a field in a feature layer. Each field value type is used to define the kind of data that can be stored in that field. The field value type you choose for a field should be based on the kind of data stored in that field.
+
+- NAME_OR_TITLE:
+  Text that represents a name, title, label, or keyword for each feature.
+
+- DESCRIPTION:
+  Text that provides a longer description of the feature, more than just a name or title.
+
+  For example, if you have a layer to collect information from the public regarding issues in the community, a field in that layer that allows people to specify the nature of the issue can be defined with the Description field value type.
+
+- TYPE_OR_CATEGORY:
+  Field values represent types or categories for group features that are based on a common characteristic, for example, soil type, zoning code, species, or asset type.
+
+- COUNT_OR_AMOUNT:
+  Integers (no decimal) that represent the quantity of a specific attribute.
+
+- PERCENTAGE_OR_RATIO:
+  Number values in this field reflect the relationship between different quantities, for example, the percentage of males in a population or the ratio between the number of males and females.
+
+- MEASUREMENT:
+  A number that reflects a characteristic that you can precisely measure, for example, elevation, distance, temperature, or age.
+
+- CURRENCY:
+  A number that represents monetary values.
+
+- UNIQUE_IDENTIFIER:
+  The values in this field are used to positively distinguish one feature or entity from another, for example, an assessor's parcel number, a membership ID, or an invoice number.
+
+  Each value per entity must be unique, but that does not necessarily mean all the values in this field will be unique for the layer.
+
+  For example, if you have two layers—one for employees and one for job sites—both can contain an employee ID unique identifier field. In the employees layer, the employee ID field should contain unique values. In the job sites layer, the employee ID field can contain duplicate values, as an employee may work at multiple job sites. The employee ID field in the job sites layer is still a unique identifier because it distinguishes one employee from another, even though the field does not contain unique values in the job sites layer.
+
+- PHONE_NUMBER:
+  This field stores phone numbers.
+
+- EMAIL_ADDRESS:
+  This field stores email address strings.
+
+- ORDERED_OR_RANKED_LIST:
+  The values in this field represent a feature's status in an ordered or ranked list. For example, a feature can be one of the following:
+
+  Small, medium, or large
+  First, second, third, or fourth
+  Informational, warning, error, or failure
+
+- BINARY
+  Only one of two values are possible for each feature. Examples include the following:
+
+  On or off
+  Yes or no
+  True or false
+  Inhabited or vacant
+
+- LOCATION_OR_PLACE_NAME:
+  Values in this field represent a geographic location. Examples include a street address, city name, region, building name (such as A.K. Smiley Public Library), attraction name (such as Alameda County Fairgrounds or Cairngorms National Park), postal code, or country.
+
+- COORDINATE:
+  These fields store a geographic coordinate value such as x, y, z, latitude, or longitude.
+
+- DATE_AND_TIME:
+  Values in this field store explicit dates and times or date references such as days of the week, months, or years.
+
+- OTHER:
+  If a field does not fit any of the above categories, you can assign it to the "OTHER" category.
+
+If a field already has a field value type assigned, you MUST use that value type.
+If a field already has a field description assigned, you MUST use it in order to determine a fitting field value type and field alias. You can improve the field description if you think it is necessary.
+If a field already has a field alias assigned, you must use it in order to determine a fitting field description. You can improve the field alias if you think it is necessary.
+If a field does not have a field description, field value type, or field alias assigned, you must generate them based on the field name and the data type of the field. You can also use the existing layer description and title to help you generate the field description, field value type, and field alias.
+`;
+export {
+  e as default
+};

package/dist/chunks/generateLayerDescriptions.js

@@ -0,0 +1,413 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
+import { Annotation as d } from "@langchain/langgraph/web";
+import p, { z as r } from "zod";
+import { ChatPromptTemplate as C, SystemMessagePromptTemplate as K } from "@langchain/core/prompts";
+import { dispatchCustomEvent as F } from "@langchain/core/callbacks/dispatch/web";
+import { AIMessage as B, isAIMessage as W, isToolMessage as H } from "@langchain/core/messages";
+import { createAgent as J, summarizationMiddleware as X, modelCallLimitMiddleware as G } from "langchain";
+import { ChatOpenAI as Q, OpenAIEmbeddings as Y } from "@langchain/openai";
+import U from "@arcgis/core/identity/IdentityManager.js";
+import S from "@arcgis/core/portal/Portal.js";
+const _ = {
+  advanced: "gpt-5.2",
+  default: "gpt-5-mini",
+  fast: "gpt-5.4-nano"
+}, k = {
+  default: "text-embedding-ada-002"
+}, M = /* @__PURE__ */ new Map();
+let T = null;
+const Z = () => {
+  const t = S.getDefault().helperServices;
+  if (!t?.aiModels?.url)
+    throw new Error("AI Models Service URL is not defined in the portal's helper services.");
+  return t.aiModels.url;
+}, P = async (e) => {
+  const t = Z();
+  M.size === 0 && (T || (T = (async () => {
+    try {
+      const n = await fetch(`${t}/models`);
+      if (!n.ok)
+        throw new Error("Failed to fetch AI service discovery data.");
+      (await n.json()).models.forEach((o) => M.set(o.name, o));
+    } catch (n) {
+      throw T = null, n;
+    }
+  })()), await T);
+  const s = M.get(e);
+  if (!s)
+    throw new Error(`Model '${e}' is not available in the discovery service.`);
+  return s.endpoint;
+}, ee = async (e = "default") => await P(_[e]), te = async (e = "default") => await P(k[e]), u = (e, t) => t, q = (e, t) => ({
+  ...e,
+  ...t
+}), $ = (e = "", t) => {
+  const s = typeof t == "string" ? t.trim() : "";
+  if (!s)
+    return e;
+  const n = e.trim();
+  if (!n)
+    return s;
+  if (n === s)
+    return e;
+  const i = n.split(`
+
+`);
+  return i[i.length - 1]?.trim() === s ? e : `${e}
+
+${s}`;
+}, j = () => ({
+  userRequest: "",
+  assignedTask: "",
+  messages: [],
+  priorSteps: [],
+  sharedState: {}
+}), ne = () => ({
+  agentExecutionContext: d({
+    reducer: q,
+    default: j
+  }),
+  outputMessage: d({
+    reducer: $,
+    default: () => ""
+  }),
+  summary: d({
+    reducer: u,
+    default: () => ""
+  }),
+  status: d({
+    reducer: u
+  })
+}), Ee = () => ({
+  ...ne(),
+  sharedStatePatch: d({
+    reducer: u
+  })
+}), Ie = d.Root({
+  agentExecutionContext: d({
+    default: j,
+    reducer: q
+  }),
+  currentIntent: d({
+    default: () => "none",
+    reducer: u
+  }),
+  lastExecutedAgent: d({
+    default: () => "",
+    reducer: u
+  }),
+  requiresFollowUp: d({
+    default: () => !0,
+    reducer: u
+  }),
+  stepCount: d({
+    default: () => 0,
+    reducer: (e, t) => t ?? e + 1
+  }),
+  finalOutputMessage: d({
+    default: () => "",
+    reducer: $
+  })
+}), y = async (e, t) => {
+  await F("trace_message", e, t);
+}, De = async (e, t) => {
+  await F("graph_ux_suggestion", e, t);
+}, se = (e, t, s) => {
+  const n = e[t];
+  return n ? typeof n == "function" ? n() : Promise.resolve(n) : new Promise((i, o) => {
+    (typeof queueMicrotask == "function" ? queueMicrotask : setTimeout)(o.bind(null, /* @__PURE__ */ new Error("Unknown variable dynamic import: " + t + (t.split("/").length !== s ? ". Note that variables only represent file names one level deep." : ""))));
+  });
+}, A = async (e) => (await se(/* @__PURE__ */ Object.assign({ "./field_descriptions_prompt.md": () => import("./field_descriptions_prompt.js"), "./intent_prompt.md": () => import("./intent_prompt.js"), "./layer_descriptions_prompt.md": () => import("./layer_descriptions_prompt.js") }), `./${e}.md`, 2)).default, ie = async (e) => {
+  const { agent: t, messages: s, config: n } = e;
+  return { structuredResponse: (await t.invoke(
+    {
+      messages: s
+    },
+    n
+  )).structuredResponse };
+}, N = (e) => async (t, s) => {
+  const n = new Headers(s?.headers);
+  return n.delete("Authorization"), n.delete("api-key"), e && e.length > 0 && (n.set("X-Esri-Authorization", `Bearer ${e}`), n.set("X-Esri-Request-Source", "MapsSDK")), await fetch(t, {
+    ...s,
+    headers: n
+  });
+}, x = async (e = "default", t = 0) => {
+  const s = S.getDefault(), n = await U.getCredential(`${s.url}/sharing`), i = _[e], o = await ee(e);
+  return new Q({
+    modelName: i,
+    apiKey: "dummy-key",
+    // 5-mini does not support temperature parameter
+    ...e !== "default" && { temperature: t },
+    configuration: {
+      baseURL: o,
+      fetch: N(n.token)
+    }
+  });
+}, Re = async (e = "default") => {
+  const t = S.getDefault(), s = await U.getCredential(`${t.url}/sharing`), n = k[e], i = await te(e);
+  return new Y({
+    modelName: n,
+    apiKey: "dummy-key",
+    configuration: {
+      baseURL: i,
+      fetch: N(s.token)
+    },
+    batchSize: 2048,
+    maxConcurrency: 10
+  });
+}, re = r.object({
+  id: r.string().min(1),
+  name: r.string().min(1),
+  description: r.string().min(1)
+});
+r.array(re);
+const D = (e) => JSON.stringify(e, null, 2), oe = (e) => {
+  const t = e.map((n) => n.id), s = r.enum(t);
+  return r.object({
+    intent: s.nullable(),
+    assignedTask: r.string().nullable(),
+    requiresFollowUp: r.boolean()
+  });
+}, Ce = async (e, t) => {
+  try {
+    await y({ text: "Asking LLM to route to an agent" }, t);
+    const i = (t?.configurable?.services.agentRegistry?.list() ?? []).map(({ agent: h }) => ({
+      id: h.id,
+      name: h.name,
+      description: h.description
+    }));
+    if (!i.length)
+      return await y({ text: "No agents registered; skipping intent detection" }, t), { ...e, currentIntent: "none" };
+    const o = await A("intent_prompt"), a = D(i), c = oe(i), l = {
+      registeredAgents: a,
+      priorSteps: D(e.agentExecutionContext.priorSteps),
+      userRequest: e.agentExecutionContext.userRequest
+    }, g = await C.fromTemplate(o).format(l), I = J({
+      model: await x("fast"),
+      tools: [],
+      systemPrompt: g,
+      checkpointer: !0,
+      responseFormat: c,
+      middleware: [
+        // Preserve recent conversation context while summarizing older messages
+        // to control token usage without losing important intent signals.
+        // The trigger and keep parameters can be tuned based on token limits and behavior.
+        X({
+          model: await x("fast"),
+          trigger: { tokens: 4e3 },
+          keep: { messages: 6 }
+        }),
+        // Enforce no loop/retry.
+        // 1 usual LLM call and 1 optional summarization call.
+        G({ runLimit: 2 })
+      ]
+    }), { structuredResponse: z } = await ie({
+      agent: I,
+      messages: e.agentExecutionContext.messages,
+      config: t
+    }), f = c.parse(
+      z ?? { intent: null, assignedTask: null, requiresFollowUp: !1 }
+    ), v = f.intent ?? "none", L = {
+      ...e,
+      currentIntent: v,
+      requiresFollowUp: f.requiresFollowUp,
+      agentExecutionContext: {
+        ...e.agentExecutionContext,
+        assignedTask: f.assignedTask ?? ""
+      }
+    };
+    if (v === "none") {
+      const h = "I could not find a matching agent for that request. Please rephrase your question with more detail.";
+      return await y({ text: "LLM did not identify a clear intent." }, t), {
+        ...e,
+        currentIntent: v,
+        requiresFollowUp: !1,
+        agentExecutionContext: {
+          ...e.agentExecutionContext,
+          assignedTask: "",
+          messages: [...e.agentExecutionContext.messages, new B(h)],
+          priorSteps: [
+            ...e.agentExecutionContext.priorSteps ?? [],
+            {
+              agentId: "no-intent-router",
+              assignedTask: e.agentExecutionContext.userRequest,
+              summary: "No matching agent found; asked user to rephrase.",
+              status: "failed"
+            }
+          ]
+        }
+      };
+    }
+    return await y(
+      {
+        text: `Agent picked: ${v}
+Task Assigned: ${f.assignedTask ?? ""}
+Requires Follow-Up: ${f.requiresFollowUp}`
+      },
+      t
+    ), L;
+  } catch (s) {
+    throw await y({ text: "Error during intent detection" }, t), new Error(`Error during intent detection: ${s instanceof Error ? s.message : String(s)}`);
+  }
+}, ae = "0.1", w = 1536, ce = "openai", le = k.default, de = `Name: {name}
+Title: {title}
+Description: {description}`, pe = `Name: {name}
+Alias: {alias}
+Description: {description}`, Fe = r.object({
+  schemaVersion: r.literal(ae),
+  modified: r.number().int().nonnegative(),
+  embeddings: r.object({
+    modelProvider: r.literal(ce),
+    model: r.literal(le),
+    dimensions: r.literal(w),
+    templates: r.object({
+      layer: r.string().default(de),
+      field: r.string().default(pe)
+    })
+  }),
+  layers: r.array(
+    r.object({
+      id: r.string().min(1),
+      name: r.string().min(1),
+      title: r.string().catch(""),
+      description: r.string().catch(""),
+      vector: r.array(r.number()).length(w, {
+        message: `Layer vector must be exactly ${w} dimensions`
+      }),
+      fields: r.array(
+        r.object({
+          name: r.string().min(1),
+          alias: r.string().catch(""),
+          description: r.string().catch(""),
+          vector: r.array(r.number()).length(w, {
+            message: `Field vector must be exactly ${w} dimensions`
+          })
+        })
+      )
+    })
+  ).default([])
+}), me = (e) => {
+  const t = /* @__PURE__ */ new Set();
+  for (const n of e)
+    if (W(n)) {
+      const i = n;
+      i.tool_calls && i.tool_calls.length > 0 && i.tool_calls.forEach((o) => {
+        o.id && t.add(o.id);
+      });
+    }
+  return e.filter((n) => {
+    if (H(n)) {
+      const i = n;
+      return t.has(i.tool_call_id);
+    }
+    return !0;
+  });
+}, E = (e, t) => {
+  const s = K.fromTemplate(e);
+  return C.fromMessages([s, ...t]);
+}, ue = async (e) => {
+  const { promptText: t, modelTier: s, temperature: n, messages: i } = e, o = E(t, i ?? []), a = await x(s, n);
+  return o.pipe(a);
+}, Ue = async (e) => {
+  const { promptText: t, modelTier: s = "default", temperature: n = 0, messages: i, inputVariables: o } = e, c = await (await ue({
+    promptText: t,
+    modelTier: s,
+    temperature: n,
+    messages: i
+  })).invoke(o ?? {});
+  if (typeof c == "string")
+    return c;
+  const l = c.content;
+  return typeof l == "string" ? l : JSON.stringify(l);
+}, O = async (e) => {
+  const { promptText: t, modelTier: s = "default", temperature: n = 0, messages: i, inputVariables: o, schema: a } = e, c = E(t, i ?? []), m = (await x(s, n)).withStructuredOutput(a);
+  return await c.pipe(m).invoke(o ?? {});
+}, _e = async (e) => {
+  const { promptText: t, modelTier: s = "default", temperature: n = 0, messages: i, inputVariables: o, tools: a } = e, c = a.length > 0 ? me(i ?? []) : i ?? [], l = E(t, c), m = await x(s, n);
+  return await l.pipe(m.bindTools(a)).invoke(o ?? {});
+}, ge = p.object({
+  name: p.string(),
+  description: p.string(),
+  valueType: p.string(),
+  alias: p.string()
+}), fe = p.object({
+  fields: p.array(ge)
+}), V = (e, t) => e.getFieldAlias(t) ?? void 0, b = (e, t) => V(e, t.name) ?? t.alias ?? "", he = (e, t) => {
+  const s = V(e, t.name);
+  return !!(s && s !== (t.alias ?? ""));
+};
+function R(e, t) {
+  const s = /* @__PURE__ */ new Map();
+  for (const n of e.fields) {
+    const i = t.fields.find((l) => l.name === n.name), o = b(e, n), a = he(e, n), c = {
+      name: n.name,
+      type: n.type,
+      alias: a ? o : i?.alias ?? o,
+      description: i?.description ?? n.description ?? "",
+      valueType: i?.valueType ?? n.valueType ?? "",
+      domain: e.getFieldDomain(n.name) ?? void 0
+    };
+    s.set(n.name, c);
+  }
+  return s;
+}
+const Pe = async (e) => {
+  const s = await A("field_descriptions_prompt"), n = e.fields.filter((a) => !(b(e, a) && a.description)).map((a) => {
+    const { name: c, type: l, description: m } = a, g = b(e, a);
+    return [`Name: ${c}`, `Type: ${l}`, `Alias: ${g}`, `Description: ${m ?? "N/A"}`].join(", ");
+  }).join(`
+`);
+  if (n.length === 0)
+    return R(e, { fields: [] });
+  const i = {
+    existingItemTitle: e.portalItem?.title,
+    existingItemDescription: e.portalItem?.description,
+    existingLayerTitle: e.title,
+    existingLayerDescription: e.portalItem?.description,
+    fieldInformation: n
+  }, o = await O({
+    promptText: s,
+    schema: fe,
+    inputVariables: i
+  });
+  return R(e, o);
+}, ye = p.object({
+  title: p.string(),
+  description: p.string(),
+  name: p.string().nullable()
+}), qe = async (e, t) => {
+  const n = await A("layer_descriptions_prompt"), i = Array.from(t.values()), o = {
+    fieldInformation: JSON.stringify(i, null, 2),
+    existingLayerTitle: e.title,
+    existingLayerDescription: e.portalItem?.description,
+    existingLayerSnippet: e.portalItem?.snippet,
+    layerGeometryType: e.geometryType
+  };
+  return { ...await O({
+    promptText: n,
+    schema: ye,
+    inputVariables: o
+  }), name: e.title ?? null };
+};
+export {
+  Ie as D,
+  Fe as W,
+  qe as a,
+  ce as b,
+  x as c,
+  w as d,
+  ae as e,
+  pe as f,
+  Pe as g,
+  Ue as h,
+  O as i,
+  _e as j,
+  ne as k,
+  de as l,
+  le as m,
+  Ee as n,
+  De as o,
+  te as p,
+  Ce as q,
+  Re as r,
+  y as s
+};

package/dist/chunks/graph.js

@@ -0,0 +1,86 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
+import { StateGraph as G, END as p, START as k } from "@langchain/langgraph/web";
+function b(t, c, o, s = {}) {
+  const { agent: h, entryNode: u, middlewares: l = [] } = s;
+  let r = new G(o);
+  if (Object.keys(t).length === 0)
+    throw new Error("Graph requires at least one node.");
+  if (c.length === 0)
+    throw new Error("Graph requires at least one edge.");
+  if (l.length > 0 && !h)
+    throw new Error("Graph middleware requires agent metadata.");
+  const n = new Set(Object.keys(t)), d = /* @__PURE__ */ new Map(), w = /* @__PURE__ */ new Map();
+  for (const e of n)
+    d.set(e, 0), w.set(e, 0);
+  for (const e of c)
+    "to" in e ? (n.has(e.from) && w.set(e.from, (w.get(e.from) ?? 0) + 1), n.has(e.to) && d.set(e.to, (d.get(e.to) ?? 0) + 1)) : n.has(e.from) && w.set(e.from, (w.get(e.from) ?? 0) + 1);
+  for (const [e, a] of Object.entries(t)) {
+    const f = $(
+      h,
+      e,
+      l,
+      async (i, m) => await Promise.resolve(a(i, m))
+    ), g = async (i, m) => await f(i, m);
+    r = r.addNode(e, g);
+  }
+  for (const e of c)
+    if ("to" in e) {
+      const a = e.from, f = e.to;
+      if (!n.has(a))
+        throw new Error(`Graph edge references unknown from-node: ${a}`);
+      if (!n.has(f))
+        throw new Error(`Graph edge references unknown to-node: ${f}`);
+      r.addEdge(a, f);
+    } else {
+      const a = e.from;
+      if (!n.has(a))
+        throw new Error(`Graph conditional edge references unknown from-node: ${a}`);
+      r.addConditionalEdges(
+        a,
+        async (f, g) => {
+          const i = await e.decide(f, g);
+          if (!i)
+            return p;
+          if (!n.has(i))
+            throw new Error(`Graph conditional edge returned unknown node: ${i}`);
+          return i;
+        }
+      );
+    }
+  const E = x(n, d, u);
+  r.addEdge(k, E);
+  const y = [...n].filter((e) => (w.get(e) ?? 0) === 0);
+  for (const e of y)
+    r.addEdge(e, p);
+  return r;
+}
+function $(t, c, o, s) {
+  return !o.length || !t ? s : async (h, u) => await o.reduceRight(
+    (r, n) => async (d) => await n.handler(d, r),
+    async (r) => {
+      const n = await s(r.state, r.config);
+      return { ...r.state, ...n };
+    }
+  )({
+    agent: t,
+    config: u,
+    nodeName: c,
+    state: h
+  });
+}
+function x(t, c, o) {
+  if (o) {
+    if (!t.has(o))
+      throw new Error(`Graph entry node references unknown node: ${o}`);
+    return o;
+  }
+  const s = [...t].filter((h) => (c.get(h) ?? 0) === 0);
+  if (s.length !== 1)
+    throw new Error(
+      `Graph could not infer a single entry node (found ${s.length}). Provide an explicit entryNode or ensure exactly one node has no incoming edges.`
+    );
+  return s[0];
+}
+export {
+  b as c
+};