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

package/dist/chunks/generateLayerDescriptions.js

@@ -0,0 +1,413 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.1/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.1/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
+};

package/dist/chunks/helpGraph.js

@@ -0,0 +1,123 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.1/LICENSE.txt */
+import { StateGraph as d, START as g, END as i } from "@langchain/langgraph/web";
+import { l as h, g as x, f as p, r as f, t as y, H as u } from "./adapter.js";
+import "@arcgis/core/identity/IdentityManager.js";
+import "@arcgis/core/portal/Portal.js";
+import { j as S, s as c } from "./generateLayerDescriptions.js";
+import "@langchain/core/messages";
+import "@langchain/core/callbacks/dispatch/web";
+import "@langchain/openai";
+import "@arcgis/core/core/reactiveUtils.js";
+import "@arcgis/core/layers/FeatureLayer.js";
+import "@arcgis/core/request.js";
+import { ToolNode as E } from "@langchain/langgraph/prebuilt";
+import "@langchain/core/prompts";
+const m = [h], v = (e) => {
+  if (!e || e.size === 0)
+    return "No layers available in this map.";
+  const t = Array.from(e.values()).map(({ layerItem: r, fieldRegistry: s }, l) => {
+    const a = Array.from(s.values()).map((n) => n.name).slice(0, 10).join(", "), o = s.size > 10 ? ` (and ${s.size - 10} more)` : "";
+    return `${l + 1}. "${r.title}". Description: ${r.description}
+   Fields: ${a}${o}`;
+  }).join(`
+
+`);
+  return `This map contains ${e.size} layer(s):
+
+${t}`;
+}, T = (e) => {
+  const t = e?.list() ?? [];
+  return t.length ? t.map((r) => `- ${r.agent.name}: ${r.agent.description}`).join(`
+`) : "No agents currently available.";
+};
+async function _(e, t) {
+  const r = await x("help_prompt"), s = p(t, "layersAndFieldsRegistry"), l = p(t, "agentRegistry");
+  try {
+    const a = await S({
+      promptText: r,
+      modelTier: "fast",
+      tools: m,
+      inputVariables: {
+        layerSummary: v(s),
+        agents: T(l),
+        assignedTask: e.agentExecutionContext.assignedTask,
+        userRequest: e.agentExecutionContext.userRequest,
+        priorSteps: e.agentExecutionContext.priorSteps
+      }
+    }), o = (a.tool_calls?.length ?? 0) > 0, n = typeof a.text == "string" ? a.text.trim() : "";
+    return {
+      ...e,
+      helpInternalState: {
+        ...e.helpInternalState,
+        toolCallMessage: o ? a : void 0
+      },
+      outputMessage: o ? e.outputMessage : n,
+      summary: o ? "Prepared help tool call from assigned task." : "Provided map-related help based on the assigned task.",
+      status: o ? e.status : "success"
+    };
+  } catch (a) {
+    const o = a instanceof Error ? a.message : String(a);
+    return {
+      ...e,
+      outputMessage: `Error invoking help agent: ${o}`,
+      summary: "Help agent execution failed.",
+      status: "failed"
+    };
+  }
+}
+const C = (e, t) => f(["agentRegistry"], "Help Agent")(e, t);
+async function H(e, t) {
+  const r = new E(m);
+  try {
+    const s = e.helpInternalState.toolCallMessage;
+    if (!s)
+      throw new Error("helpToolCalling: missing helpInternalState.toolCallMessage");
+    const a = (await r.invoke({ messages: [s] }, t)).messages.map((o) => o.text).join(`
+`);
+    return await c({ text: `Finished executing help tool: ${a}` }, t), {
+      ...e,
+      outputMessage: a,
+      status: "success",
+      summary: a ? y(a) : "Help executed.",
+      helpInternalState: {
+        ...e.helpInternalState,
+        toolCallMessage: void 0
+      }
+    };
+  } catch (s) {
+    const l = s instanceof Error ? s.message : String(s);
+    return await c({ text: `Help tool execution failed: ${l}` }, t), {
+      ...e,
+      outputMessage: `Help tool execution failed: ${l}`,
+      status: "failed",
+      summary: `Help tool execution failed: ${l}`,
+      helpInternalState: {
+        ...e.helpInternalState,
+        toolCallMessage: void 0
+      }
+    };
+  }
+}
+const b = () => new d(u).addNode("requireHelpServices", C).addNode("agent", _).addNode("tools", H).addEdge(g, "requireHelpServices").addEdge("requireHelpServices", "agent").addConditionalEdges("agent", (t) => t.helpInternalState.toolCallMessage ? "tools" : i).addEdge("tools", i), M = String.raw`- **help** — Enables users to ask questions about the map, layers, fields, and it's capabilities.
+
+  _Example: “Tell me about this map”_  
+  _Example: “List all layers in this map”_  
+  _Example: “List fields in protected areas layer”_  
+  _Example: “What agents are available to me?”_  
+  _Example: “What can you do?”_  
+  _Example: “What can I ask”_
+  
+  Even if the user asks unrelated queries like "What are the vowels in English alphabet" or "How to cook", call this agent.
+  
+  IF the user asks map related queries, but those that are not performed by any of the agents, call this agent so we can respond accordingly.
+  _Example: "Create a chart"_
+  _Example: "Create a table"_`, D = {
+  id: "help",
+  name: "Help Agent",
+  description: M,
+  createGraph: b,
+  workspace: u
+};
+export {
+  D as H
+};

package/dist/chunks/help_prompt.js

@@ -0,0 +1,57 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.1/LICENSE.txt */
+const e = `## Map Query Gate
+
+### Input
+
+Assigned task:
+{assignedTask}
+
+Latest user request:
+{userRequest}
+
+Prior steps:
+{priorSteps}
+
+Use the assigned task as the primary instruction for the current query. The question will **not** be restated again here.
+Use the latest user request as supporting context when needed.
+Use prior steps only when needed to explain a previous result, failure, or likely next action.
+
+### Map Context
+
+{layerSummary}
+
+## Available agents (capabilities)
+
+{agents}
+
+### Rules
+
+- "What layers are in this map?" → List the layer names
+- "What fields are in this layer?" → Call the tool to list the field names for that layer
+- "What can you do?" / "What can I ask?" → Suggest specific queries using EXACT layer and field names from the context above
+- "Tell me about this map" → Summarize layers and capabilities
+- "Create a chart of all wells ans their depth" → If a question is map related but not supported by available capabilities, say so. Add that support for this might be added in the future.
+- Questions completely unrelated to maps/GIS → Politely explain you only help with the map |
+
+### Response Guidelines
+
+When suggesting what users can ask, be SPECIFIC using actual layer names:
+
+- "Show me water sources with elevation above 500"
+- "Filter Protected Areas in Panama by protection level"
+- "Zoom to Watershed Boundaries"
+
+For "what can I ask" responses, provide 3-5 specific example queries using fields from the context.
+
+For off-topic questions:
+"I can only help with this map. Try asking me to filter [LayerName] by [FieldName], or zoom to a location."
+
+Rules:
+
+- Keep responses concise
+- Use bullet points for lists
+- Use new lines (\\n) and appropriate formatting in your response
+`;
+export {
+  e as default
+};