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

package/dist/chunks/dataExplorationGraph.js

@@ -0,0 +1,298 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
+import { StateGraph as b, START as V, END as v } from "@langchain/langgraph/web";
+import { g as T, O as R, P as C, t as N, Q as k, f as h, R as D, r as z, S as $, T as P } from "./adapter.js";
+import "@arcgis/core/identity/IdentityManager.js";
+import "@arcgis/core/portal/Portal.js";
+import { s as c, j as A, h as Q } from "./generateLayerDescriptions.js";
+import { AIMessage as j } from "@langchain/core/messages";
+import "@langchain/openai";
+import "@arcgis/core/core/reactiveUtils.js";
+import "@arcgis/core/layers/FeatureLayer.js";
+import "@arcgis/core/request.js";
+import "@langchain/core/prompts";
+import { h as I } from "./toolCallResponse.js";
+import { ToolNode as O } from "@langchain/langgraph/prebuilt";
+import G from "@arcgis/core/smartMapping/statistics/summaryStatistics.js";
+import U from "@arcgis/core/smartMapping/statistics/uniqueValues.js";
+const W = async (t, e) => (await c({ text: "Exiting Data Exploration agent" }, e), t), B = async (t, e) => {
+  await c({ text: "Requesting LLM for layer filter results" }, e);
+  const d = await T("data_explore_filter_prompt");
+  if (!e?.configurable)
+    throw new Error("config.configurable is required for layer filter tools");
+  const { userTimezone: n, userTimezoneOffset: r } = R(), o = {
+    layerFieldInfo: t.layerFieldInfo,
+    userTimezone: n,
+    userTimezoneOffset: r,
+    queryResponse: t.queryResponse,
+    assignedTask: t.agentExecutionContext.assignedTask,
+    userRequest: t.agentExecutionContext.userRequest,
+    priorSteps: t.agentExecutionContext.priorSteps
+  }, s = await A({
+    promptText: d,
+    modelTier: "advanced",
+    messages: t.dataExplorationMessages,
+    inputVariables: o,
+    tools: C
+  }), i = [...t.dataExplorationMessages, s];
+  if (!((s.tool_calls?.length ?? 0) > 0))
+    return await c({ text: "LLM determined no filter changes needed" }, e), {
+      ...t,
+      dataExplorationMessages: i
+      // Don't overwrite outputMessage if query already set it
+    };
+  const m = [...i, s], p = s.content.toString();
+  return await I(s, e), { ...t, dataExplorationMessages: m, outputMessage: p };
+}, H = async (t, e) => {
+  await c({ text: "Requesting LLM for layer query results" }, e);
+  const d = await T("data_explore_query_prompt");
+  if (!e?.configurable)
+    throw new Error("config.configurable is required for layer query tools");
+  const { userTimezone: n, userTimezoneOffset: r } = R(), s = t.agentExecutionContext.sharedState.lastNavigatedFeatures, i = s && typeof s == "object" && "value" in s ? s.value : s;
+  let l = "none";
+  if (i != null)
+    try {
+      l = JSON.stringify(i);
+    } catch {
+      l = "none";
+    }
+  const m = {
+    layerFieldInfo: t.layerFieldInfo,
+    userTimezone: n,
+    userTimezoneOffset: r,
+    assignedTask: t.agentExecutionContext.assignedTask,
+    userRequest: t.agentExecutionContext.userRequest,
+    priorSteps: t.agentExecutionContext.priorSteps,
+    lastNavigatedFeatures: l
+  }, p = await A({
+    promptText: d,
+    modelTier: "advanced",
+    messages: t.dataExplorationMessages,
+    inputVariables: m,
+    tools: k
+  }), y = p.content.toString();
+  return await I(p, e), {
+    ...t,
+    dataExplorationMessages: [...t.dataExplorationMessages, p],
+    outputMessage: y,
+    status: "success",
+    summary: y ? N(y) : "Query executed."
+  };
+}, J = async (t, e) => {
+  try {
+    await c({ text: "Requesting LLM for summary on query results" }, e);
+    const d = await T("summarize_query_response_prompt"), n = {
+      queryResponse: t.queryResponse,
+      assignedTask: t.agentExecutionContext.assignedTask,
+      userRequest: t.agentExecutionContext.userRequest,
+      priorSteps: t.agentExecutionContext.priorSteps
+    }, r = await Q({
+      promptText: d,
+      modelTier: "fast",
+      messages: t.dataExplorationMessages,
+      inputVariables: n
+    }), o = typeof r == "string" ? r : r.content, s = new j(o);
+    await c({ text: `Received response from LLM: ${o}` }, e);
+    const i = o;
+    return {
+      ...t,
+      outputMessage: i,
+      status: "success",
+      summary: i ? N(i) : "Summary generated.",
+      dataExplorationMessages: [...t.dataExplorationMessages, s]
+    };
+  } catch (a) {
+    throw await c({ text: "Error during filter LLM request" }, e), new Error(`Error during filter LLM request: ${a instanceof Error ? a.message : String(a)}`);
+  }
+};
+async function K(t, e) {
+  const d = await new O(C).invoke(
+    {
+      messages: t.dataExplorationMessages
+    },
+    e
+  );
+  return await c(
+    { text: `Finished executing layer filter tool: ${d.messages.map((n) => n.content).join(", ")}` },
+    e
+  ), { ...t };
+}
+const X = 10, Y = ["string", "small-integer", "integer"], Z = async (t, e, { includeSummaryStatistics: a = !0, includeUniqueValues: d = !0 } = {}) => {
+  let n = null, r = null;
+  try {
+    if (e.type !== "geometry" && e.type !== "oid" && e.type !== "global-id") {
+      a && (n = await G({ layer: t, field: e.name }));
+      const o = e.domain?.type === "coded-value" ? e.domain : null;
+      d && (Y.includes(e.type) || o) && (r = (await U({ layer: t, field: e.name })).uniqueValueInfos.sort((s, i) => i.count - s.count).slice(0, X), o && (r = r.map((s) => ({
+        ...s,
+        value: o.getName(s.value) ?? s.value
+      }))));
+    }
+  } catch (o) {
+    console.error(`Error fetching statistics for field ${e.name}:`, o);
+  }
+  return {
+    summaryStatistics: n,
+    uniqueValues: r
+  };
+};
+function ee(t, e) {
+  return ["string", "small-integer", "integer"].includes(t) || e === "coded-value";
+}
+async function te(t, e, a, d = !0) {
+  const n = [], r = [], o = [];
+  for (const s of t) {
+    let i = function(g) {
+      const u = e.get(g)?.layerItem;
+      return u ? [
+        u.name && `Name: ${u.name}`,
+        u.title && `Title: ${u.title}`,
+        u.description && `Description: ${u.description}`
+      ].filter(Boolean).join(" | ") : g;
+    };
+    const { layerId: l, results: m } = s, p = a.map?.allLayers.find((g) => g.id === l), y = e.get(l)?.fieldRegistry;
+    if (!y)
+      continue;
+    let f = n.find((g) => g.layerId === l);
+    f || (f = {
+      layerId: l,
+      layerSummary: i(l),
+      fieldInfos: []
+    }, n.push(f));
+    for (const g of m) {
+      const u = y.get(g.name);
+      if (!u)
+        continue;
+      const x = u.statistics, E = d && !x?.summaryStatistics, w = ee(u.type, u.domain?.type) && !x?.uniqueValues, q = E || w;
+      if (o.push({
+        layerId: l,
+        fieldName: u.name,
+        didFetchStatistics: q
+      }), q) {
+        const _ = Z(p, u, {
+          includeSummaryStatistics: E,
+          includeUniqueValues: w
+        }).then((F) => {
+          const S = {
+            summaryStatistics: x?.summaryStatistics ?? null,
+            uniqueValues: x?.uniqueValues ?? null
+          };
+          E && (S.summaryStatistics = F.summaryStatistics), w && (S.uniqueValues = F.uniqueValues), y.set(u.name, { ...u, statistics: S }), u.statistics = S;
+        });
+        r.push(_);
+      }
+      f.fieldInfos.push(u);
+    }
+  }
+  return await Promise.all(r), {
+    layerFieldInfo: n,
+    didFetchStatistics: r.length > 0,
+    fieldStatisticsFetchStatus: o
+  };
+}
+const M = /\b(average|avg|mean|median|max(?:imum)?|min(?:imum)?|sum|total|count|std(?:dev|\s*deviation)|variance|null\s*count|missing\s*values?|range)\b/iu;
+function ae(t, e) {
+  return M.test(t) || M.test(e);
+}
+const se = async (t, e) => {
+  try {
+    await c({ text: "Preparing field information for vector search results" }, e);
+    const a = h(e, "layersAndFieldsRegistry"), { mapView: d } = D(e), { assignedTask: n, userRequest: r } = t.agentExecutionContext, o = ae(n, r), { layerFieldInfo: s, didFetchStatistics: i, fieldStatisticsFetchStatus: l } = await te(
+      t.vectorSearchFieldResults,
+      a,
+      d,
+      o
+    );
+    i ? await c({ text: "Statistics fetched" }, e) : await c({ text: "Statistics skipped" }, e);
+    for (const m of l)
+      await c(
+        {
+          text: `  - ${m.fieldName} - stats ${m.didFetchStatistics ? "fetched" : "skipped"}`
+        },
+        e
+      );
+    return await c({ text: "Field information prepared" }, e), { ...t, layerFieldInfo: s };
+  } catch (a) {
+    throw await c({ text: "Error during fetching statistics" }, e), new Error(`Error during fetching statistics: ${a instanceof Error ? a.message : String(a)}`);
+  }
+}, L = 0.7, re = 10, oe = async (t, e) => {
+  try {
+    await c({ text: "Similarity search to find fields" }, e);
+    const a = h(e, "fieldSearch"), d = h(e, "layersAndFieldsRegistry"), n = h(e, "embeddingCache"), r = await a.searchFields({
+      text: t.agentExecutionContext.assignedTask,
+      layerIds: t.vectorSearchLayerIds,
+      minScore: L,
+      topResults: re,
+      embeddingCache: n
+    }), o = r.map(({ layerId: i, results: l }) => {
+      const m = l.map((p) => `  - ${p.name} (${p.score.toFixed(2)})`).join(`
+`);
+      return `${d.get(i)?.layerItem.name ?? i}:
+${m}`;
+    }).join(`
+`);
+    let s;
+    return r.length > 0 ? s = `Vector search completed. Matching layers and fields with scores:
+${o}` : s = `No vector search results found for score over ${L}.`, await c({ text: s }, e), {
+      ...t,
+      vectorSearchFieldResults: r
+    };
+  } catch (a) {
+    throw await c(
+      { text: `Error during vector search: ${a instanceof Error ? a.message : String(a)}` },
+      e
+    ), new Error(`Vector search failed: ${a instanceof Error ? a.message : String(a)}`);
+  }
+}, ie = 0.7, ne = async (t, e) => {
+  try {
+    await c(
+      { text: `Similarity search to find layers: ${t.agentExecutionContext.assignedTask}` },
+      e
+    );
+    const a = h(e, "layerSearch"), d = h(e, "layersAndFieldsRegistry"), n = h(e, "embeddingCache"), r = await a.searchLayers({
+      text: t.agentExecutionContext.assignedTask,
+      minScore: ie,
+      embeddingCache: n
+    }), o = r.map((l) => l.id), s = r.map(({ id: l, score: m }) => `${d.get(l)?.layerItem.name ?? l} (${m.toFixed(2)})`).join(`
+`);
+    let i;
+    return o.length > 0 ? i = `Vector search completed. Matching layers with scores:
+${s}` : i = "Vector search completed. No matching layers found.", await c({ text: i }, e), {
+      ...t,
+      vectorSearchLayerIds: o
+    };
+  } catch (a) {
+    throw await c(
+      { text: `Error during vector search: ${a instanceof Error ? a.message : String(a)}` },
+      e
+    ), new Error(`Vector search failed: ${a instanceof Error ? a.message : String(a)}`);
+  }
+}, le = (t, e) => z(["layerSearch", "fieldSearch", "layersAndFieldsRegistry"], "Data Exploration Agent")(
+  t,
+  e
+), ce = () => new b($).addNode("requireDataExplorationServices", le).addNode("vectorSearchLayers", ne).addNode("vectorSearchFields", oe).addNode("fieldStatistics", se).addNode("queryAgent", H).addNode("queryTools", P).addNode("summarizeQueryResponseLLM", J).addNode("filterAgent", B).addNode("filterTools", K).addNode("earlyExit", W).addEdge(V, "requireDataExplorationServices").addEdge("requireDataExplorationServices", "vectorSearchLayers").addConditionalEdges(
+  "vectorSearchLayers",
+  (e) => e.vectorSearchLayerIds.length ? "vectorSearchFields" : "earlyExit"
+).addConditionalEdges(
+  "vectorSearchFields",
+  (e) => e.vectorSearchFieldResults.length ? "fieldStatistics" : "earlyExit"
+).addEdge("fieldStatistics", "queryAgent").addConditionalEdges("queryAgent", (e) => (e.dataExplorationMessages[e.dataExplorationMessages.length - 1]?.tool_calls?.length ?? 0) > 0 ? "queryTools" : "filterAgent").addConditionalEdges(
+  "queryTools",
+  (e) => e.queryResponse.length ? "summarizeQueryResponseLLM" : "filterAgent"
+).addEdge("summarizeQueryResponseLLM", "filterAgent").addConditionalEdges("filterAgent", (e) => (e.dataExplorationMessages[e.dataExplorationMessages.length - 1]?.tool_calls?.length ?? 0) > 0 ? "filterTools" : v).addEdge("filterTools", v).addEdge("earlyExit", v), de = String.raw`- **data exploration** — User is asking about the feature layer’s data (e.g. counts, summaries, statistics, field values), either for all features, a subset based on a condition, or for a subset based on the current view. And/Or user wants to include or exclude features based on field values, or visually style features differently (e.g., highlight or deemphasize them).
+  The Data Exploration Agent will automatically zoom to the affected features for action taken by this agent. In this case, no need to call navigation tool separately.  
+  _Example: “Only show stations where Brand is Shell”_  
+  _Example: “Make Shell stations stand out on the map”_  
+  _Example: “Gray out all stations that aren’t Shell”_
+  This also includes questions that ask which feature meets a given condition or where a particular feature in the data is located (e.g., “Where is the spring with the highest elevation?”). However, this agent does not handle addresses.
+  _Example: “How many features are there?”_  
+  _Example: “What’s the average population?”_  
+  _Example: “Which values are in the status field?”_`, Me = {
+  id: "dataExploration",
+  name: "Data Exploration Agent",
+  description: de,
+  createGraph: ce,
+  workspace: $
+};
+export {
+  Me as D
+};

package/dist/chunks/data_explore_filter_prompt.js

@@ -0,0 +1,125 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
+const e = `# ArcGIS Online Map Viewer — Layer Filter Tool Calling Assistant
+
+You are an assistant that helps manage layer filters and visual effects for **ArcGIS Online Map Viewer** by selecting and calling the appropriate tool.
+
+You may make **zero or one** tool call based on the assigned task.
+
+## You are given:
+
+Assigned task:
+{assignedTask}
+
+Latest user request:
+{userRequest}
+
+Prior steps:
+{priorSteps}
+
+Use the assigned task as the primary instruction for the current query.
+Use the latest user request as supporting context when needed.
+Use prior steps only when the assigned task clearly depends on earlier results.
+
+A list of layers, with layerId, layerSummary and each with associated field information
+{layerFieldInfo}
+
+FieldInfo:
+
+- \`name\`: the actual field name used in layer filter expressions
+- \`type\`: one of \`string\`, \`number\`, \`date\`, etc.
+- \`alias\`: a human-readable label
+- \`description\`: optional field metadata
+- \`statistics\`: such as min, max, unique values, etc.
+
+This is what the query tool returned:
+{queryResponse}
+
+## Your task
+
+1. Decide whether a tool call is needed (see "When to call a tool" below).
+2. If needed, determine \`targetLayer\` using the priority rules below.
+3. Select the most appropriate tool.
+
+## How to determine targetLayer (follow in order)
+
+Use the FIRST rule that matches:
+
+1. **queryResponse includes \`objectIds\` and \`objectIdField\`** → pass them as \`targetLayer.objectIds\` array and set \`where\` to \`"1=1"\`. Do NOT construct a WHERE clause with IN(...).
+
+2. **queryResponse includes a \`where\` clause** → copy that exact \`where\` string and the \`layerId\` into \`targetLayer\`. Do NOT regenerate, rephrase, or simplify it.
+
+3. **Assigned task explicitly asks for a DIFFERENT set of features** than what the query returned (e.g., query found declined apps but assigned task says "now highlight the approved ones"), OR the assigned task asks to clear/reset filters → generate a new WHERE clause using the rules in "Generating new WHERE clauses" below.
+
+### Also forward geometryFilter and useCurrentExtent
+
+If the query tool call in the message history used a \`geometryFilter\` (spatial/proximity query) or \`useCurrentExtent: true\`, include the same parameters in your tool call. Without them, the filter would apply to the entire layer instead of just the spatially scoped features.
+
+## When to call a tool
+
+ALWAYS call a tool when:
+
+- The assigned task asked to "show", "find", "locate", or "where is" something
+- The assigned task asked a question that identifies specific features (e.g., "which has the highest...?", "find all X that are Y")
+- The assigned task wants to clear or reset filters of the map
+
+### No tool call
+
+Make no tool call when:
+
+- The query returned zero features
+- The assigned task asked a pure aggregate/statistical question (e.g., "what is the average?", "how many total?")
+- No meaningful filter can be generated
+- The assigned task was fully answered by the query step with no need for map interaction
+- Even if objectIds are available in the query response, do not highlight features unless the assigned task explicitly asked to see, show, highlight or emphasize them
+
+## Generating new WHERE clauses (exception case only)
+
+Only use these rules when rule 3 above applies — i.e., the assigned task explicitly asked for a different feature set.
+
+- Use only the field's **\`name\`** in the expression — not the alias.
+- Use field \`type\` to choose operators:
+  - **String** → \`LIKE '%value%'\`, \`=\`, \`IN (...)\`
+  - **Number/Date** → \`=\`, \`<\`, \`>\`, \`BETWEEN\`, etc.
+- **Coded-value domain fields** → use the numeric/string **code**, never the domain name.
+- **Range domain fields** → use the listed min/max as valid bounds.
+- DO NOT use subqueries or \`SELECT\`.
+- Combine conditions with \`AND\`, \`OR\`, or \`NOT\` as appropriate.
+
+## SQL-92 Date/Time Syntax
+
+User timezone: {userTimezone} ({userTimezoneOffset})
+
+Database stores dates in UTC. Convert user's local time to UTC.
+
+To convert: if offset is \`-08:00\`, add 8 hours. If \`-05:00\`, add 5 hours.
+
+Format: \`TIMESTAMP 'YYYY-MM-DD HH:MM:SS'\`
+
+## Geometry and Spatial Queries (for setFeatureEffect)
+
+When dealing with geometry and proximity and spatial queries:
+
+1. TARGET LAYER = What you want to FIND/RETURN in results
+2. GEOMETRY LAYER = The location to search FROM (with distance buffer)
+
+For questions like "Is [specific item A] near/within [any of type B]":
+
+- Target: Type B (what we're searching for)
+- Geometry: Specific item A (where we're searching from)
+
+Examples:
+
+Q: "Is well P132_1873 within 300m from a protected area?"
+Target: Protected Areas (what we want to find)
+Geometry: Well (where="ID = 'P132_1873'" - single point)
+
+Q: "Find roads within 500m of park X"
+Target: Roads (what we want to find)
+Geometry: Park X (specific location)
+
+Key principle: The geometry layer should be the SIMPLER geometry (ideally a single feature or small set),
+not a large collection that requires union operations.
+`;
+export {
+  e as default
+};

package/dist/chunks/data_explore_query_prompt.js

@@ -0,0 +1,144 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
+const e = `# ArcGIS JavaScript SDK FeatureLayerView Query Assistant
+
+You are a GIS assistant that generates query parameters for the ArcGIS JavaScript SDK FeatureLayerView \`queryFeatures()\` method.
+
+Analyze the assigned task and construct appropriate query parameters for each relevant layer. Only include parameters that are necessary to answer the assigned task.
+
+## Layer and Field Information
+
+In addition to field info, layer info with layerId, name, and description will also be provided.
+It will be an array of multiple layers.
+
+You are only allowed to use the field names listed under each layer. Do not invent or use any fields not listed.
+
+{layerFieldInfo}
+
+## Critical Guard — Do NOT Hallucinate Fields
+
+If the assigned task asks for a filter that requires a field not present in the list above, do not invent the field and do not include it.
+
+Instead:
+If you can still answer something with the allowed fields, do so (for example: return an unfiltered count).
+Otherwise, return a valid query with where: "1=1" and omit any unsupported filters entirely.
+Never reference fields beyond those listed. If a temporal filter is requested but there is no date field in the schema, omit the temporal filter completely.
+
+Validator: Before producing output, verify every field used exists in the listed fields. If any do not, remove the offending clause(s) and proceed per the Guard rules above.
+
+## Input
+
+Assigned task:
+{assignedTask}
+
+Latest user request:
+{userRequest}
+
+Prior steps:
+{priorSteps}
+
+Last navigated features from shared state (if available):
+{lastNavigatedFeatures}
+
+Use the assigned task as the primary instruction for the current query.
+Use the latest user request as supporting context when needed.
+Use prior steps only when the assigned task or user request clearly depends on earlier results.
+Use lastNavigatedFeatures as authoritative context for map-navigation references when present.
+Use chat history only when necessary to understand conversational references, and do not override the assigned task.
+
+### Anchor selection rule (strict, single source of truth)
+
+When the request is referential (for example: "this", "it", "that", "those", "them", "of those", "the same one(s)"), choose exactly one anchor using this priority order:
+
+1. Explicit entity named in the current request (if present)
+2. \`lastNavigatedFeatures\` (if present)
+3. The immediately previous successful relevant step from \`priorSteps\`
+
+After selecting the anchor, keep that anchor for this query and do not switch to an older entity.
+If \`lastNavigatedFeatures\` is used as the anchor, reuse its \`layerId\` and \`where\` for query scope unless the current request explicitly overrides it.
+
+### Fresh WHERE clause rule
+
+Start with a fresh WHERE clause for each new question. Do not inherit filters from previous questions UNLESS the assigned task explicitly references previous results (see "Referencing Previously Identified Features" below).
+
+### Rules for generating WHERE clause SQL expressions:
+
+- Use only the field's **\`name\`** in the output expression.
+- Use metadata (\`alias\`, \`description\`, \`statistics\`) only to help understand the user's meaning — not in the syntax.
+- Use field \`type\` to choose appropriate operators:
+  - **String** → \`LIKE '%value%'\`, \`=\`, \`IN (...)\` (prefer \`LIKE\` over \`=\`)
+  - **Number/Date** → \`=\`, \`<\`, \`>\`, \`BETWEEN\`, etc.
+- Use fields with the **highest \`relevanceScore\`**.
+- DO NOT use subqueries or \`SELECT\` keyword.
+- Combine conditions with \`AND\`, \`OR\`, or \`NOT\` as appropriate.
+- **Coded-value domain fields** → Always use the numeric/string **code** in WHERE clauses, never the domain name. Domain values are listed under each field as \`code=name\` pairs
+- **Range domain fields** → Use the listed min/max as valid bounds for comparisons.
+- If no meaningful layer filter can be generated, do not call a tool.
+
+## Referencing Previously Identified Features
+
+This is an exception to the "fresh WHERE clause" rule above.
+
+- If the anchored context indicates \`useCurrentExtent: true\`, use \`useCurrentExtent: true\` with \`where: "1=1"\`.
+- If the anchored context includes specific feature IDs/objectIds, scope to those IDs.
+- Otherwise, use the anchored \`layerId\` + \`where\` combination.
+
+### Mixed Questions
+
+If a question has both aggregate and display components (e.g., "How many wells have depth > 100? Show them"):
+
+- Focus ONLY on the aggregate part ("how many") for this query
+- The visualization part ("show them") is handled by a separate system
+
+## RULES
+
+DO NOT generate sub queries or nested queries as they are not supported by ArcGIS.
+
+When dealing with geometry and proximity and spatial queries:
+
+1. TARGET LAYER = What you want to FIND/RETURN in results
+2. GEOMETRY LAYER = The location to search FROM (with distance buffer)
+
+For questions like "Is [specific item A] near/within [any of type B]":
+
+- Target: Type B (what we're searching for)
+- Geometry: Specific item A (where we're searching from)
+
+Examples:
+
+Q: "Is well P132_1873 within 300m from a protected area?"
+Target: Protected Areas (what we want to find)
+Geometry: Well (where="ID = 'P132_1873'" - single point)
+Result: Returns which protected areas are nearby
+
+Q: "Find roads within 500m of park X"
+Target: Roads (what we want to find)
+Geometry: Park X (specific location)
+Result: Returns which roads are nearby
+
+Key principle: The geometry layer should be the SIMPLER geometry (ideally a single feature or small set),
+not a large collection that requires union operations.
+
+### NOTE:
+
+If the assigned task includes no filter (where: 1=1) and the answer can be derived from precomputed fieldStatistics, do NOT call a tool. Instead, respond directly using the provided statistics.
+
+If you cannot answer directly, you MUST call a tool.
+
+## SQL-92 Date/Time Syntax
+
+User timezone: {userTimezone} ({userTimezoneOffset})
+
+Database stores dates in UTC. Convert user's local time to UTC.
+
+To convert: if offset is \`-08:00\`, add 8 hours. If \`-05:00\`, add 5 hours.
+
+Format: \`TIMESTAMP 'YYYY-MM-DD HH:MM:SS'\`
+
+## Your Task
+
+1. Analyze the assigned task and the provided layer and field information.
+2. Select zero or one most appropriate tool to call based on the assigned task.
+`;
+export {
+  e as default
+};

package/dist/chunks/embeddings.worker.js

@@ -0,0 +1,25 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
+const o = `(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)}})()})})();
+`, s = typeof self < "u" && self.Blob && new Blob(["(self.URL || self.webkitURL).revokeObjectURL(self.location.href);", o], { type: "text/javascript;charset=utf-8" });
+function a(r) {
+  let e;
+  try {
+    if (e = s && (self.URL || self.webkitURL).createObjectURL(s), !e) throw "";
+    const t = new Worker(e, {
+      name: r?.name
+    });
+    return t.addEventListener("error", () => {
+      (self.URL || self.webkitURL).revokeObjectURL(e);
+    }), t;
+  } catch {
+    return new Worker(
+      "data:text/javascript;charset=utf-8," + encodeURIComponent(o),
+      {
+        name: r?.name
+      }
+    );
+  }
+}
+export {
+  a as default
+};