@arcgis/ai-components 5.1.0-next.12 → 5.1.0-next.120

package/dist/chunks/orchestrator.js

@@ -0,0 +1,528 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.1/LICENSE.txt */
+import S from "@arcgis/core/identity/IdentityManager.js";
+import b from "@arcgis/core/portal/Portal.js";
+import { p as I, s as l, D as R, q as k, r as M, W as C } from "./generateLayerDescriptions.js";
+import { isGraphInterrupt as A, StateGraph as F, START as L, END as W, MemorySaver as $ } from "@langchain/langgraph/web";
+import { HumanMessage as D, AIMessage as j } from "@langchain/core/messages";
+import * as P from "@arcgis/core/core/reactiveUtils.js";
+import q from "@arcgis/core/layers/FeatureLayer.js";
+import H from "@arcgis/core/request.js";
+const O = async (t) => {
+  const e = await T(), s = await I("default"), n = b.getDefault(), i = (await S.getCredential(`${n.url}/sharing`)).token, a = {
+    type: "generateEmbeddings",
+    webmapEmbeddings: t,
+    auth: { apiUrl: s, token: i }
+  };
+  return e.postMessage(a), await new Promise((c, d) => {
+    const o = (u) => {
+      u.data === "completed" && (e.removeEventListener("message", o), c());
+    }, g = (u) => {
+      e.removeEventListener("message", o), d(u instanceof Error ? u : new Error("Embeddings worker error"));
+    };
+    e.addEventListener("message", o), e.addEventListener("error", g, { once: !0 });
+  }), e;
+}, T = async () => {
+  {
+    const t = (await import("./embeddings.worker.js")).default;
+    return new t();
+  }
+}, U = (t) => {
+  t.currentIntent = "none";
+}, N = async (t, e) => {
+  if (t.agentExecutionContext.userRequest) {
+    const n = new D(t.agentExecutionContext.userRequest.trim());
+    t.agentExecutionContext.messages = [...t.agentExecutionContext.messages, n], U(t);
+  }
+  const s = e?.configurable?.services.agentRegistry.list().map((n) => n.agent.id) ?? [];
+  return await l({ text: `Available agents: ${[...s].join(", ")}` }, e), await l({ text: "Analyzing user input" }, e), t;
+}, G = async (t, e) => (await l({ text: "Exiting..." }, e), t), y = (t) => typeof t == "object" && t !== null && !Array.isArray(t), _ = (t, e) => {
+  if (!y(t)) {
+    t !== void 0 && console.warn(`Agent "${e}" returned invalid sharedStatePatch. Ignoring it.`);
+    return;
+  }
+  const s = {};
+  for (const [n, r] of Object.entries(t)) {
+    if (!y(r) || !("value" in r)) {
+      console.warn(
+        `Agent "${e}" returned invalid sharedStatePatch entry for key "${n}". Ignoring that entry.`
+      );
+      continue;
+    }
+    s[n] = { value: r.value };
+  }
+  return s;
+}, V = (t) => {
+  const { previousSharedState: e, patch: s, agentId: n } = t;
+  if (!s)
+    return e;
+  const r = Date.now(), i = {
+    ...e
+  };
+  for (const [a, c] of Object.entries(s))
+    c?.value !== void 0 && (i[a] = {
+      value: c.value,
+      meta: {
+        updatedByAgentId: n,
+        updatedAt: r
+      }
+    });
+  return i;
+}, w = (t) => {
+  if (typeof t != "string")
+    return;
+  const e = t.trim();
+  return e || void 0;
+}, z = (t) => {
+  switch (t) {
+    case "failed":
+      return "Agent failed without a summary.";
+    case "unknown":
+      return "Agent returned with unknown status.";
+    case "success":
+      return "Agent completed without a summary.";
+    default:
+      return "Agent completed without a summary.";
+  }
+}, Q = (t, e) => {
+  const s = w(e?.outputMessage), n = w(e?.summary), r = e?.status, i = r === "success" || r === "failed" ? r : "unknown";
+  i === "unknown" && console.warn(`Agent "${t}" returned missing/invalid status. Defaulting to "unknown".`);
+  const a = _(e?.sharedStatePatch, t);
+  return {
+    outputMessage: s,
+    summary: n ?? s ?? z(i),
+    status: i,
+    sharedStatePatch: a
+  };
+}, f = 4e3, B = async (t, e) => {
+  const s = e?.configurable, { agentRegistry: n } = s.services, r = n?.get(t.currentIntent);
+  if (!r)
+    return console.warn(`No agent found for intent: ${t.currentIntent}`), t;
+  await l({ text: `Executing registered agent: ${r.agent.name}` }, e);
+  const i = {
+    ...e ?? {},
+    configurable: {
+      ...s ?? {},
+      agentId: r.agent.id,
+      context: r.getContext ? await r.getContext() : void 0
+    }
+  };
+  let a;
+  try {
+    const o = await r.agent.createGraph().compile().invoke(
+      {
+        agentExecutionContext: {
+          ...t.agentExecutionContext,
+          // deep clone on messages did not work in agents, so its a shallow clone here.
+          messages: [...t.agentExecutionContext.messages],
+          // deep clone to prevent accidental mutations by agents
+          priorSteps: structuredClone(t.agentExecutionContext.priorSteps ?? []),
+          sharedState: structuredClone(t.agentExecutionContext.sharedState ?? {})
+        }
+      },
+      i
+    );
+    a = Q(r.agent.name, o), await l({ text: `Finished executing registered agent: ${r.agent.name}` }, e);
+  } catch (o) {
+    if (A(o))
+      throw o;
+    const g = o instanceof Error ? o.message : String(o);
+    console.error(`Agent "${r.agent.name}" failed:`, o), await l({ text: `Registered agent failed: ${r.agent.name}. ${g}` }, e), a = {
+      status: "failed",
+      outputMessage: `Agent execution failed: ${g}`,
+      summary: `Agent execution failed: ${g}`
+    };
+  }
+  const c = a.outputMessage, d = [...t.agentExecutionContext.messages];
+  if (c) {
+    const o = c.length > f ? `${c.slice(0, f - 14)}
+[truncated]` : c;
+    d.push(new j(o));
+  }
+  return {
+    ...t,
+    stepCount: t.stepCount + 1,
+    lastExecutedAgent: r.agent.id,
+    requiresFollowUp: a.status === "failed" ? !0 : t.requiresFollowUp,
+    finalOutputMessage: c ?? "",
+    agentExecutionContext: {
+      ...t.agentExecutionContext,
+      messages: d,
+      priorSteps: [
+        ...t.agentExecutionContext.priorSteps ?? [],
+        {
+          agentId: r.agent.id,
+          assignedTask: t.agentExecutionContext.assignedTask,
+          summary: a?.summary || "No summary provided.",
+          status: a?.status || "unknown"
+        }
+      ],
+      sharedState: V({
+        previousSharedState: t.agentExecutionContext.sharedState,
+        patch: a.sharedStatePatch,
+        agentId: r.agent.id
+      })
+    }
+  };
+}, J = 3, K = () => new F(R).addNode("ingestInput", N).addNode("intentLLM", k).addNode("executeRegisteredAgent", B).addNode("exit", G).addEdge(L, "ingestInput").addEdge("ingestInput", "intentLLM").addConditionalEdges("intentLLM", (e) => e.currentIntent === "none" || e.currentIntent === e.lastExecutedAgent ? "exit" : "executeRegisteredAgent").addConditionalEdges(
+  "executeRegisteredAgent",
+  (e) => e.stepCount >= J || !e.requiresFollowUp ? "exit" : "intentLLM"
+).addEdge("exit", W);
+class X {
+  constructor() {
+    this.agentRegistry = /* @__PURE__ */ new Map();
+  }
+  register(e) {
+    const { agent: s } = e;
+    if (this.agentRegistry.has(s.id))
+      throw new Error(`Duplicate agent id: ${s.id}`);
+    this.agentRegistry.set(s.id, e);
+  }
+  get(e) {
+    return this.agentRegistry.get(e);
+  }
+  list() {
+    return [...this.agentRegistry.values()];
+  }
+}
+class Y {
+  /**
+   * Create a new InterruptHandler tied to a specific compiled graph and config.
+   */
+  constructor(e, s) {
+    this.graph = e, this.config = { ...s };
+  }
+  /**
+   * Returns a promise that resolves when the user provides a HITL response.
+   */
+  async waitForUser() {
+    return await new Promise((e, s) => {
+      this.resolveWait = e, this.rejectWait = s;
+    });
+  }
+  /**
+   * Resume graph execution after the UI responds to an interrupt.
+   */
+  handle(e, s) {
+    try {
+      const n = {
+        agentId: e.agentId,
+        id: e.id,
+        payload: s
+      }, r = this.graph.streamEvents(null, {
+        ...this.config,
+        configurable: {
+          ...this.config.configurable,
+          hitlResponse: n
+        },
+        subgraphs: !0,
+        version: "v2"
+      });
+      this.resolveWait?.(r);
+    } catch (n) {
+      this.rejectWait?.(n);
+    } finally {
+      this.resolveWait = void 0, this.rejectWait = void 0;
+    }
+  }
+  /**
+   * Abort the HITL wait and reject any pending continuation.
+   */
+  cancel() {
+    this.rejectWait && (this.rejectWait(new Error("Request cancelled by user.")), this.resolveWait = void 0, this.rejectWait = void 0);
+  }
+}
+const Z = async (t) => {
+  try {
+    return await (await M()).embedDocuments(t);
+  } catch (e) {
+    throw console.error("Failed to generate embeddings:", e), e;
+  }
+}, E = async (t, e) => {
+  const s = e.get(t);
+  if (s)
+    return s;
+  const n = await Z([t]);
+  return e.set(t, n[0]), n[0];
+};
+async function ee(t, e, s, n) {
+  const r = `req-${Date.now()}`, a = {
+    type: "layerSearch",
+    precomputedEmbedding: n ? await E(t, n) : void 0,
+    requestId: r,
+    minScore: s
+  };
+  return await new Promise((c) => {
+    const d = (o) => {
+      o.data.requestId === r && c(o.data.results);
+    };
+    e.addEventListener("message", d, { once: !0 }), e.postMessage(a);
+  });
+}
+function te(t) {
+  const { worker: e } = t;
+  return {
+    async searchLayers({
+      text: s,
+      minScore: n,
+      embeddingCache: r
+    }) {
+      return await ee(s, e, n, r);
+    }
+  };
+}
+const re = async ({
+  combinedQuery: t,
+  layerIds: e,
+  embeddingsWorker: s,
+  minScore: n,
+  topResults: r,
+  embeddingCache: i
+}) => {
+  const a = `req-${Date.now()}`, c = i ? await E(t, i) : void 0, d = {
+    type: "fieldSearch",
+    layerIdForFieldsSearch: e,
+    precomputedEmbedding: c,
+    requestId: a,
+    minScore: n,
+    topResults: r
+  };
+  return await new Promise((o) => {
+    const g = (u) => {
+      if (u.data.requestId !== a)
+        return;
+      const p = u.data.results.map(({ layerId: m, results: h }) => ({
+        layerId: m,
+        results: h
+      }));
+      o(p);
+    };
+    s.addEventListener("message", g, { once: !0 }), s.postMessage(d);
+  });
+};
+function ne(t) {
+  const { worker: e } = t;
+  return {
+    async searchFields({ text: s, layerIds: n, minScore: r, topResults: i, embeddingCache: a }) {
+      return await re({
+        combinedQuery: s,
+        layerIds: n,
+        embeddingsWorker: e,
+        minScore: r,
+        topResults: i,
+        embeddingCache: a
+      });
+    }
+  };
+}
+const se = (t) => {
+  const e = C.safeParse(t);
+  if (!e.success)
+    throw new Error("Embeddings response validation failed. Regenerate embeddings.");
+  return e.data;
+}, ae = (t, e) => {
+  const s = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Map();
+  if (e.allLayers.forEach((r) => {
+    r instanceof q && n.set(r.id, r);
+  }), t.length !== n.size)
+    throw new Error("Layer count mismatch during registry restoration. Regenerate embeddings.");
+  for (const r of t) {
+    const i = n.get(r.id);
+    if (!i)
+      throw new Error(
+        `Layer with ID ${r.id} not found in the original map during registry restoration. Regenerate embeddings.`
+      );
+    if (r.fields.length !== i.fields.length)
+      throw new Error(
+        `Field count mismatch for layer ID ${r.id} during registry restoration. Regenerate embeddings.`
+      );
+    const a = {
+      name: r.name,
+      title: r.title,
+      description: r.description
+    }, c = /* @__PURE__ */ new Map();
+    for (const d of r.fields) {
+      const o = i.fieldsIndex.get(d.name);
+      if (!o)
+        throw new Error(
+          `Field with name ${d.name} not found in the original layer ${r.id} during registry restoration. Regenerate embeddings.`
+        );
+      c.set(d.name, {
+        name: d.name,
+        alias: i.getFieldAlias(d.name) ?? d.alias,
+        description: d.description,
+        type: o.type || "unknown",
+        valueType: o.valueType || "unknown",
+        domain: i.getFieldDomain(d.name) ?? void 0
+      });
+    }
+    s.set(r.id, {
+      layerItem: a,
+      fieldRegistry: c
+    });
+  }
+  return s;
+}, ie = async (t) => {
+  try {
+    return (await H(t, {
+      responseType: "json"
+    })).data;
+  } catch (e) {
+    throw new Error(`Failed to fetch data from ${t}: ${String(e)}`);
+  }
+}, oe = async (t) => {
+  const e = t.map;
+  if (!e?.portalItem)
+    throw new Error("WebMap portal item is missing.");
+  const { resources: s } = await e.portalItem.fetchResources(), n = s.find((a) => a.resource.path === "embeddings-v01.json");
+  if (!n?.resource.url)
+    throw new Error("Embeddings resource 'embeddings-v01.json' not found in the webmap portal item.");
+  const r = await ie(n.resource.url);
+  return se(r);
+};
+class v {
+  constructor() {
+    this.orchestratorReady = !1, this.chatHistory = [], this.priorSteps = [], this.sharedState = {}, this.threadId = "", this.agentRegistry = new X(), this.streamEpoch = 0;
+  }
+  /**
+   * Creates and returns an AI-ready Orchestrator instance.
+   * @param deps Core dependencies (layer/field registry plus optional map views).
+   * @returns Ready Orchestrator.
+   */
+  static async init(e) {
+    const s = new v();
+    try {
+      if (e.view?.map) {
+        await P.whenOnce(() => e.view.ready);
+        const n = await oe(e.view), r = ae(
+          n.layers,
+          e.view.map
+        );
+        s.layersAndFieldsRegistry = r, s.embeddingsWorker = await O(n);
+      }
+      return e.agents?.forEach((n) => {
+        s.agentRegistry.register(n);
+      }), s.orchestratorReady = !0, s;
+    } catch (n) {
+      throw console.error("Orchestrator initialization failed:", n), n;
+    }
+  }
+  /**
+   * Run a new chat turn through the graph.
+   * Yields structured events for the UI to consume:
+   *  - `trace`: intermediate model output
+   *  - `interrupt`: HITL required, wait for `resumeInterrupt()`
+   *  - `completed`: final result with chat history + layer styling
+   *  - `cancelled`: user aborted the run
+   */
+  async *ask(e) {
+    if (!this.orchestratorReady)
+      throw new Error("Orchestrator is not ready yet.");
+    if (!this.agentRegistry.list().length)
+      throw new Error("Orchestrator has no registered agents.");
+    if (++this.streamEpoch, !e.trim())
+      return;
+    this.threadId = String(Date.now()), this.graph || (this.graph = K().compile({ checkpointer: new $() }));
+    const s = this.embeddingsWorker ? te({ worker: this.embeddingsWorker }) : void 0, n = this.embeddingsWorker ? ne({ worker: this.embeddingsWorker }) : void 0, r = /* @__PURE__ */ new Map(), a = {
+      version: "v2",
+      streamMode: "custom",
+      configurable: {
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        thread_id: this.threadId,
+        hitlResponse: null,
+        services: {
+          layerSearch: s,
+          fieldSearch: n,
+          layersAndFieldsRegistry: this.layersAndFieldsRegistry,
+          agentRegistry: this.agentRegistry,
+          embeddingCache: r
+        }
+      },
+      subgraphs: !0
+    }, c = this.graph?.streamEvents(
+      {
+        agentExecutionContext: {
+          userRequest: e,
+          messages: this.chatHistory,
+          priorSteps: this.priorSteps,
+          sharedState: this.sharedState
+        }
+      },
+      a
+    ), d = ++this.streamEpoch;
+    for (yield* this.pipeStream(c, d); ; ) {
+      const m = (await this.graph.getState(a, { subgraphs: !0 })).tasks.find((h) => h.interrupts.length > 0)?.interrupts[0]?.value;
+      if (!m)
+        break;
+      this.currentInterrupt = m, this.interruptHandler = new Y(this.graph, a), yield { runId: this.threadId, timestamp: Date.now(), type: "interrupt", interrupt: m };
+      try {
+        const h = await this.interruptHandler.waitForUser(), x = ++this.streamEpoch;
+        yield* this.pipeStream(h, x);
+      } catch (h) {
+        if (h) {
+          yield {
+            runId: this.threadId,
+            timestamp: Date.now(),
+            type: "error",
+            error: { message: h?.message }
+          };
+          return;
+        }
+        yield { runId: this.threadId, timestamp: Date.now(), type: "cancelled" };
+        return;
+      }
+    }
+    const g = (await this.graph.getState(a, { subgraphs: !0 })).values;
+    this.chatHistory = g.agentExecutionContext.messages.length ? g.agentExecutionContext.messages : this.chatHistory, this.priorSteps = g.agentExecutionContext.priorSteps?.slice(-5) ?? [], this.sharedState = g.agentExecutionContext.sharedState ?? {}, yield {
+      runId: this.threadId,
+      timestamp: Date.now(),
+      type: "completed",
+      result: { content: g.finalOutputMessage }
+    };
+  }
+  /**
+   * Start a new conversation by clearing chat history, prior steps, and shared state.
+   */
+  newConversation() {
+    this.chatHistory = [], this.priorSteps = [], this.sharedState = {};
+  }
+  /**
+   * Generic resume for any HITL interrupt.
+   * The payload is whatever the UI collected (e.g. "yes", "no", layerId, etc).
+   */
+  resumeInterrupt(e) {
+    if (!this.currentInterrupt || !this.interruptHandler)
+      throw new Error("No pending interrupt to resume.");
+    this.interruptHandler.handle(this.currentInterrupt, e);
+  }
+  /**
+   * Optional: allow UI to cancel the current HITL.
+   */
+  cancelInterrupt() {
+    this.interruptHandler && this.interruptHandler.cancel();
+  }
+  async *pipeStream(e, s) {
+    for await (const n of e) {
+      if (s !== this.streamEpoch) {
+        console.log("Stale stream detected, aborting.");
+        break;
+      }
+      n.event === "on_custom_event" && n.name === "trace_message" ? yield { runId: this.threadId, timestamp: Date.now(), type: "trace", data: n.data } : n.name === "graph_ux_suggestion" && (yield {
+        runId: this.threadId,
+        timestamp: Date.now(),
+        type: "ux-suggestion",
+        suggestion: n.data
+      });
+    }
+  }
+  /**
+   * Disposes this instance by terminating the embeddings worker
+   * and cleaning up all related resources.
+   */
+  dispose() {
+    this.embeddingsWorker && (this.embeddingsWorker.terminate(), this.embeddingsWorker = void 0), this.orchestratorReady = !1;
+  }
+}
+export {
+  v as O,
+  Z as g
+};

package/dist/chunks/slottableRequestUtils.js

@@ -0,0 +1,11 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.1/LICENSE.txt */
+function a(e) {
+  return `message-${e}`;
+}
+function o(e, t) {
+  return `block-${e}-${t}`;
+}
+export {
+  o as a,
+  a as g
+};

package/dist/chunks/state.js

@@ -0,0 +1,71 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.1/LICENSE.txt */
+import { Annotation as s } from "@langchain/langgraph/web";
+const c = /* @__PURE__ */ new Set(["agentExecutionContext", "outputMessage", "summary", "status"]);
+function u() {
+  return {
+    assignedTask: "",
+    messages: [],
+    priorSteps: [],
+    sharedState: {},
+    userRequest: ""
+  };
+}
+function i(r) {
+  const n = [...new Set([...r].filter((t) => c.has(t)))];
+  if (n.length !== 0)
+    throw new Error(`ADK custom state cannot define reserved runtime fields: ${n.join(", ")}.`);
+}
+function f(r) {
+  const n = Object.entries(r);
+  return Object.fromEntries(
+    n.map(([t, e]) => [
+      t,
+      s({
+        reducer: (o, a) => a,
+        default: () => e
+      })
+    ])
+  );
+}
+function m(r = {}) {
+  i(Object.keys(r));
+  const n = f(r);
+  return s.Root({
+    ...n,
+    agentExecutionContext: s({
+      reducer: (t, e) => ({
+        ...t,
+        ...e
+      }),
+      default: u
+    }),
+    outputMessage: s({
+      // Preserve the last meaningful user-facing message produced by the graph.
+      reducer: (t = "", e) => typeof e == "string" && e.trim() ? e : t,
+      default: () => ""
+    }),
+    summary: s({
+      // Summary is a compact orchestrator-facing outcome, so replacement semantics are enough.
+      reducer: (t = "", e) => typeof e == "string" ? e : t,
+      default: () => ""
+    }),
+    status: s({
+      // Keep the first meaningful status until a later node explicitly replaces it.
+      reducer: (t, e) => e ?? t,
+      default: () => {
+      }
+    })
+  });
+}
+function l(r) {
+  const n = /* @__PURE__ */ new Set();
+  for (const e of r)
+    for (const o of Object.keys(e.shape ?? {}))
+      n.add(o);
+  const t = Object.fromEntries([...n].map((e) => [e, void 0]));
+  return m(t);
+}
+export {
+  m as a,
+  l as c
+};

package/dist/chunks/summarize_query_response_prompt.js

@@ -0,0 +1,77 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.1/LICENSE.txt */
+const e = `## Task: Summarize Geographic Features
+
+You are given features from ArcGIS Feature layer for multiple layers:  
+{queryResponse}
+
+## Input
+
+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.
+Use chat history only when necessary to understand conversational references, and do not override the assigned task.
+
+### Your goal:
+
+1. If the assigned task is about a **specific calculation** (e.g., average, total, count, min, max), return only the **direct numeric answer** — short and clear.
+   - Example: “The average price is $4.00.”
+   - When a value is already present in \`queryResponse\` (for example in \`details.value\` or \`summary\`), copy that value **verbatim**.
+   - Do NOT reformat values (including numbers, dates, and times):
+     - Do not add/remove grouping commas.
+     - Do not change decimals, round values, or change numeric type/text.
+     - Do not change date/time format, timezone notation, separators, or precision.
+
+2. If the question is more general or there are **multiple features with varying attributes**, write a **brief summary** (2–3 sentences max) that highlights key patterns or insights.
+
+3. The response can be per layer, or summarize based on the question.
+
+4. DO NOT ramble.
+
+5. If a \`geometryFilter\` is used, do NOT assume the feature referenced in that geometry (e.g., "ApplicationNumber = 'XYZ'") must appear in the results. It may only be used as a spatial anchor.
+
+Only describe what _was_ found — not what was _used to search_.
+
+6. If no feature \`attributes\` are returned but \`totalCount\` is present, assume the spatial filter was applied correctly. There is no need to say the subset was not returned — just summarize based on the count and available context.
+
+7. Do not give suggestions like exporting the results as the tools are not capable to do that.
+
+8. Format all responses using **Markdown** suitable for chat display.
+
+- Use bullet points for lists and use new lines (\\n) and appropriate formatting in your response.
+- Use Markdown emphasis (for example, **bold**) only when it improves clarity; keep formatting minimal and readable.
+- If results are best presented in rows/columns (for example, multiple features sharing the same fields), format them as a **Markdown table**.
+- The table must be valid Markdown with a header row and separator row (e.g., \`| Column |\` and \`| --- |\`).
+- Do not use plain aligned text, CSV-like output, or code fences for tabular data.
+
+9. Do NOT say things like "I can't change the map", "I can't highlight features", or suggest WHERE clauses for the user to run manually. A separate system handles map visualization automatically after this step. Your job is ONLY to summarize the data returned by the query.
+
+In all cases:
+
+- Focus on **notable attribute values**, **commonalities or differences**, and **interesting trends**.
+- If the feature list is empty or not meaningful, state that clearly.
+
+### STRICT OUTPUT RULES
+
+- Do NOT ask follow-up questions.
+- Do NOT offer additional actions or suggestions.
+- Do NOT explain what you can do next.
+- Do NOT add conversational phrases.
+- Do NOT add any text beyond the requested summary or numeric answer.
+- End the response immediately after the summary.
+- Do NOT include introductory phrases (e.g., "Found", "Here are", "The results show").
+- Do NOT restate the assigned task or user’s question.
+- Use Markdown formatting for the response.
+- When presenting tabular data, output a valid Markdown table.
+`;
+export {
+  e as default
+};