@geoscene/ai-components 0.0.0-stage → 5.1.13

package/dist/chunks/converterUtils.js

@@ -0,0 +1,124 @@
+/* COPYRIGHT GeoScene - https://js.geoscene.cn/5.1/LICENSE.txt */
+import g from "@geoscene/geoscene-html-sanitizer";
+import { marked as S } from "marked";
+S.use({
+  gfm: !0,
+  breaks: !0,
+  async: !1
+});
+const C = new g(
+  {
+    whiteList: {
+      // LLMs sometimes return lists like "- 2) Foo". `marked` parses that into a nested ordered list
+      // (`<ol start="2">...`), so we keep `start`/`value` to avoid everything rendering as "1.".
+      ol: ["start"],
+      li: ["value"],
+      "calcite-table": ["caption", "bordered", "striped", "layout", "scale", "class"],
+      "calcite-table-row": ["slot", "class"],
+      "calcite-table-header": ["heading", "alignment", "description", "class"],
+      "calcite-table-cell": ["alignment", "colspan", "rowspan", "class"],
+      // Allow markdown code blocks to render as <pre><code>…</code></pre>.
+      pre: ["class"],
+      code: ["class"]
+    }
+  },
+  !0
+);
+function T(e) {
+  return C.sanitize(e);
+}
+function A(e, t) {
+  const r = e.indexOf("{", t), a = e.indexOf("[", t);
+  return r === -1 ? a : a === -1 ? r : Math.min(r, a);
+}
+function x(e) {
+  if (e.trimStart().startsWith("```"))
+    return null;
+  for (let r = A(e, 0); r !== -1; r = A(e, r + 1)) {
+    let a = 0, c = 0;
+    for (let n = r; n < e.length; n++) {
+      const l = e[n];
+      if (l === "{" ? a++ : l === "}" ? a-- : l === "[" ? c++ : l === "]" && c--, a < 0 || c < 0)
+        break;
+      if (a === 0 && c === 0 && n > r)
+        return e.slice(r, n + 1);
+    }
+  }
+  return null;
+}
+function O(e) {
+  if (!e)
+    return "";
+  let t = e;
+  const r = x(e);
+  if (r)
+    try {
+      const c = JSON.parse(r), l = `
+
+\`\`\`json
+${JSON.stringify(c, null, 2)}
+\`\`\`
+
+`;
+      t = e.replace(r, l);
+    } catch {
+    }
+  const a = E(t);
+  return q(a);
+}
+function q(e) {
+  if (!e)
+    return "";
+  const t = M(e);
+  return T(t);
+}
+function E(e) {
+  return e ? S.parse(e, { async: !1 }) : "";
+}
+function M(e) {
+  if (!e || typeof DOMParser > "u")
+    return e;
+  try {
+    const t = new DOMParser().parseFromString(e, "text/html");
+    return Array.from(t.querySelectorAll("table")).forEach((a, c) => {
+      const n = t.createElement("calcite-table");
+      n.setAttribute("caption", `表格 ${c + 1}`), n.setAttribute("striped", "true");
+      const l = a.querySelector("thead");
+      if (l) {
+        const d = Array.from(l.querySelectorAll("tr"));
+        for (const u of d) {
+          const o = t.createElement("calcite-table-row");
+          o.setAttribute("slot", "table-header");
+          const f = Array.from(u.querySelectorAll("th, td"));
+          for (const h of f) {
+            const s = (h.textContent ?? "").trim(), i = t.createElement("calcite-table-header");
+            i.setAttribute("heading", s), o.appendChild(i);
+          }
+          n.appendChild(o);
+        }
+      }
+      const b = a.querySelector("tbody");
+      (b ? Array.from(b.querySelectorAll("tr")) : Array.from(a.querySelectorAll("tr")).filter((d) => !l?.contains(d))).forEach((d, u) => {
+        const o = t.createElement("calcite-table-row"), f = !l && u === 0 && d.querySelectorAll("th").length > 0;
+        f && o.setAttribute("slot", "table-header");
+        const h = Array.from(d.querySelectorAll("th, td"));
+        for (const s of h) {
+          if (f && s.localName === "th") {
+            const w = (s.textContent ?? "").trim(), y = t.createElement("calcite-table-header");
+            y.setAttribute("heading", w), o.appendChild(y);
+            return;
+          }
+          const i = t.createElement("calcite-table-cell"), p = s.getAttribute("colspan"), m = s.getAttribute("rowspan");
+          p && i.setAttribute("colspan", p), m && i.setAttribute("rowspan", m), i.innerHTML = s.innerHTML, o.appendChild(i);
+        }
+        n.appendChild(o);
+      }), a.replaceWith(n);
+    }), t.body.innerHTML;
+  } catch {
+    return e;
+  }
+}
+export {
+  q as a,
+  O as p
+};

package/dist/chunks/dataExplorationGraph.js

@@ -0,0 +1,319 @@
+/* COPYRIGHT GeoScene - https://js.geoscene.cn/5.1/LICENSE.txt */
+import { StateGraph as I, START as k, END as v } from "@langchain/langgraph/web";
+import { g as T, O as R, P as C, t as N, Q as V, f, R as D, r as z, S as b, T as P } from "./adapter.js";
+import "@geoscene/core/identity/IdentityManager.js";
+import "@geoscene/core/portal/Portal.js";
+import "@geoscene/toolkit/string";
+import { h as _, e as Q } from "./generateLayerDescriptions.js";
+import { AIMessage as O } from "@langchain/core/messages";
+import { s as n } from "./index.js";
+import "@langchain/openai";
+import "@geoscene/core/config.js";
+import "@geoscene/core/core/reactiveUtils.js";
+import "@geoscene/core/layers/FeatureLayer.js";
+import "@geoscene/core/request.js";
+import "@langchain/core/prompts";
+import { h as $ } from "./toolCallResponse.js";
+import { ToolNode as j } from "@langchain/langgraph/prebuilt";
+import G from "@geoscene/core/smartMapping/statistics/summaryStatistics.js";
+import U from "@geoscene/core/smartMapping/statistics/uniqueValues.js";
+const W = async (t, e) => (await n({ text: "退出数据探索 Agent" }, e), t), B = async (t, e) => {
+  await n({ text: "正在请求模型生成图层过滤操作" }, e);
+  const d = await T("data_explore_filter_prompt");
+  if (!e?.configurable)
+    throw new Error("图层过滤工具需要 config.configurable");
+  const { userTimezone: l, userTimezoneOffset: s } = R(), r = {
+    layerFieldInfo: t.layerFieldInfo,
+    userTimezone: l,
+    userTimezoneOffset: s,
+    queryResponse: t.queryResponse,
+    assignedTask: t.agentExecutionContext.assignedTask,
+    userRequest: t.agentExecutionContext.userRequest,
+    priorSteps: t.agentExecutionContext.priorSteps
+  }, o = await _({
+    promptText: d,
+    modelTier: "advanced",
+    config: e,
+    messages: t.dataExplorationMessages,
+    inputVariables: r,
+    tools: C
+  }), i = [...t.dataExplorationMessages, o];
+  if (!((o.tool_calls?.length ?? 0) > 0))
+    return await n({ text: "模型判断无需修改过滤条件" }, e), {
+      ...t,
+      dataExplorationMessages: i
+      // Don't overwrite outputMessage if query already set it
+    };
+  const m = i, g = o.content.toString();
+  return await $(o, e), { ...t, dataExplorationMessages: m, outputMessage: g };
+}, H = async (t, e) => {
+  await n({ text: "正在请求模型规划图层查询" }, e);
+  const d = await T("data_explore_query_prompt");
+  if (!e?.configurable)
+    throw new Error("图层查询工具需要 config.configurable");
+  const { userTimezone: l, userTimezoneOffset: s } = R(), r = t.agentExecutionContext.sharedState, o = r.lastNavigatedFeatures?.value, i = r.lastResolvedLocation?.value;
+  let c = "none";
+  if (o != null)
+    try {
+      c = JSON.stringify(o);
+    } catch {
+      c = "none";
+    }
+  let m = "none";
+  if (i != null)
+    try {
+      m = JSON.stringify({
+        address: i.address,
+        location: i.location
+      });
+    } catch {
+      m = "none";
+    }
+  const g = {
+    layerFieldInfo: t.layerFieldInfo,
+    userTimezone: l,
+    userTimezoneOffset: s,
+    assignedTask: t.agentExecutionContext.assignedTask,
+    userRequest: t.agentExecutionContext.userRequest,
+    priorSteps: t.agentExecutionContext.priorSteps,
+    lastNavigatedFeatures: c,
+    lastResolvedLocation: m
+  }, y = await _({
+    promptText: d,
+    modelTier: "advanced",
+    config: e,
+    messages: t.dataExplorationMessages,
+    inputVariables: g,
+    tools: V
+  }), h = (y.tool_calls?.length ?? 0) > 0, p = y.content.toString();
+  return await $(y, e), {
+    ...t,
+    dataExplorationMessages: [...t.dataExplorationMessages, y],
+    // Only emit output here when no tools are being called.
+    // For tool-calling flows, downstream summarizer nodes provide the final user-facing message.
+    ...h ? {} : { outputMessage: p },
+    status: "success",
+    summary: p && !h ? N(p) : "查询规划完成。"
+  };
+}, J = async (t, e) => {
+  try {
+    await n({ text: "正在请求模型汇总查询结果" }, e);
+    const d = await T("summarize_query_response_prompt"), l = {
+      queryResponse: t.queryResponse,
+      assignedTask: t.agentExecutionContext.assignedTask,
+      userRequest: t.agentExecutionContext.userRequest,
+      priorSteps: t.agentExecutionContext.priorSteps
+    }, s = await Q({
+      promptText: d,
+      modelTier: "fast",
+      config: e,
+      messages: t.dataExplorationMessages,
+      inputVariables: l
+    }), r = typeof s == "string" ? s : s.content, o = new O(r);
+    await n({ text: `收到模型响应：${r}` }, e);
+    const i = r;
+    return {
+      ...t,
+      outputMessage: i,
+      status: "success",
+      summary: i ? N(i) : "摘要已生成。",
+      dataExplorationMessages: [...t.dataExplorationMessages, o]
+    };
+  } catch (a) {
+    throw await n({ text: "请求过滤模型时出错" }, e), new Error(`请求过滤模型时出错：${a instanceof Error ? a.message : String(a)}`);
+  }
+};
+async function K(t, e) {
+  if ((t.queryResponse ?? []).some((s) => {
+    const r = s.details;
+    return typeof r == "object" && r !== null && "error" in r;
+  }))
+    return await n({ text: "查询结果包含错误，跳过图层过滤工具。" }, e), { ...t };
+  const l = await new j(C, { handleToolErrors: !1 }).invoke(
+    {
+      messages: t.dataExplorationMessages
+    },
+    e
+  );
+  return await n(
+    { text: `图层过滤工具执行完成：${l.messages.map((s) => s.content).join(", ")}` },
+    e
+  ), { ...t };
+}
+const X = 10, Y = ["string", "small-integer", "integer"], Z = async (t, e, { includeSummaryStatistics: a = !0, includeUniqueValues: d = !0 } = {}) => {
+  let l = null, s = null;
+  try {
+    if (e.type !== "geometry" && e.type !== "oid" && e.type !== "global-id") {
+      a && (l = await G({ layer: t, field: e.name }));
+      const r = e.domain?.type === "coded-value" ? e.domain : null;
+      d && (Y.includes(e.type) || r) && (s = (await U({ layer: t, field: e.name })).uniqueValueInfos.sort((o, i) => i.count - o.count).slice(0, X), r && (s = s.map((o) => ({
+        ...o,
+        value: r.getName(o.value) ?? o.value
+      }))));
+    }
+  } catch (r) {
+    console.error(`获取字段统计信息失败，字段：${e.name}:`, r);
+  }
+  return {
+    summaryStatistics: l,
+    uniqueValues: s
+  };
+};
+function ee(t, e) {
+  return ["string", "small-integer", "integer"].includes(t) || e === "coded-value";
+}
+async function te(t, e, a, d = !0) {
+  const l = [], s = [], r = [];
+  for (const o of t) {
+    let i = function(p) {
+      const u = e.get(p)?.layerItem;
+      return u ? [
+        u.name && `名称：${u.name}`,
+        u.title && `标题：${u.title}`,
+        u.description && `说明：${u.description}`
+      ].filter(Boolean).join(" | ") : p;
+    };
+    const { layerId: c, results: m } = o, g = a.map?.allLayers.find((p) => p.id === c), y = e.get(c)?.fieldRegistry;
+    if (!y)
+      continue;
+    let h = l.find((p) => p.layerId === c);
+    h || (h = {
+      layerId: c,
+      layerSummary: i(c),
+      fieldInfos: []
+    }, l.push(h));
+    for (const p of m) {
+      const u = y.get(p.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 (r.push({
+        layerId: c,
+        fieldName: u.name,
+        didFetchStatistics: q
+      }), q) {
+        const A = Z(g, 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;
+        });
+        s.push(A);
+      }
+      h.fieldInfos.push(u);
+    }
+  }
+  return await Promise.all(s), {
+    layerFieldInfo: l,
+    didFetchStatistics: s.length > 0,
+    fieldStatisticsFetchStatus: r
+  };
+}
+const L = /\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 L.test(t) || L.test(e);
+}
+const se = async (t, e) => {
+  try {
+    await n({ text: "正在为向量搜索结果准备字段信息" }, e);
+    const a = f(e, "layersAndFieldsRegistry"), { mapView: d } = D(e), { assignedTask: l, userRequest: s } = t.agentExecutionContext, r = ae(l, s), { layerFieldInfo: o, didFetchStatistics: i, fieldStatisticsFetchStatus: c } = await te(
+      t.vectorSearchFieldResults,
+      a,
+      d,
+      r
+    );
+    i ? await n({ text: "已获取统计信息" }, e) : await n({ text: "跳过统计" }, e);
+    for (const m of c)
+      await n(
+        {
+          text: `  - ${m.fieldName}——统计状态：${m.didFetchStatistics ? "已获取" : "已跳过"}`
+        },
+        e
+      );
+    return await n({ text: "字段信息准备完成" }, e), { ...t, layerFieldInfo: o };
+  } catch (a) {
+    throw await n({ text: "获取统计信息失败" }, e), new Error(`获取统计信息失败：${a instanceof Error ? a.message : String(a)}`);
+  }
+}, M = 0.5, re = 10, oe = async (t, e) => {
+  try {
+    await n({ text: "正在通过相似度搜索字段" }, e);
+    const a = f(e, "fieldSearch"), d = f(e, "layersAndFieldsRegistry"), l = f(e, "embeddingCache"), s = await a.searchFields({
+      text: t.agentExecutionContext.assignedTask,
+      layerIds: t.vectorSearchLayerIds,
+      minScore: M,
+      topResults: re,
+      embeddingCache: l
+    }), r = s.map(({ layerId: i, results: c }) => {
+      const m = c.map((g) => `  - ${g.name} (${g.score.toFixed(2)})`).join(`
+`);
+      return `${d.get(i)?.layerItem.name ?? i}:
+${m}`;
+    }).join(`
+`);
+    let o;
+    return s.length > 0 ? o = `向量搜索完成，匹配的图层、字段及得分：
+${r}` : o = `未找到得分超过以下阈值的向量搜索结果：${M}.`, await n({ text: o }, e), {
+      ...t,
+      vectorSearchFieldResults: s
+    };
+  } catch (a) {
+    throw await n(
+      { text: `向量搜索出错：${a instanceof Error ? a.message : String(a)}` },
+      e
+    ), new Error(`向量搜索失败：${a instanceof Error ? a.message : String(a)}`);
+  }
+}, ie = 0.5, ne = async (t, e) => {
+  try {
+    await n(
+      { text: `正在通过相似度搜索图层：${t.agentExecutionContext.assignedTask}` },
+      e
+    );
+    const a = f(e, "layerSearch"), d = f(e, "layersAndFieldsRegistry"), l = f(e, "embeddingCache"), s = await a.searchLayers({
+      text: t.agentExecutionContext.assignedTask,
+      minScore: ie,
+      embeddingCache: l
+    }), r = s.map((c) => c.id), o = s.map(({ id: c, score: m }) => `${d.get(c)?.layerItem.name ?? c} (${m.toFixed(2)})`).join(`
+`);
+    let i;
+    return r.length > 0 ? i = `向量搜索完成，匹配的图层及得分：
+${o}` : i = "向量搜索完成，未找到匹配图层。", await n({ text: i }, e), {
+      ...t,
+      vectorSearchLayerIds: r
+    };
+  } catch (a) {
+    throw await n(
+      { text: `向量搜索出错：${a instanceof Error ? a.message : String(a)}` },
+      e
+    ), new Error(`向量搜索失败：${a instanceof Error ? a.message : String(a)}`);
+  }
+}, le = (t, e) => z(["layerSearch", "fieldSearch", "layersAndFieldsRegistry"], "数据探索 Agent")(
+  t,
+  e
+), ce = () => new I(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(k, "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**——处理要素图层的数据问题，包括全部要素、满足条件的子集或当前视图中的子集的数量、汇总、统计和字段值；也处理按字段包含或排除要素，以及高亮、弱化等显示效果。
+该 Agent 会自动缩放到操作影响的要素，无需另行调用导航工具。
+示例：“只显示 Brand 为 Shell 的站点”“在地图上突出 Shell 站点”“将非 Shell 站点灰显”。
+也处理识别符合条件的具体要素及其位置，例如“高程最高的泉在哪里”，但不处理地址。
+示例：“有多少要素”“平均人口是多少”“status 字段有哪些值”。
+不处理帮助或元数据请求，例如列出图层、列出图层字段或列、属性，以及功能介绍。`, Ce = {
+  id: "dataExploration",
+  name: "数据探索 Agent",
+  description: de,
+  createGraph: ce,
+  workspace: b
+};
+export {
+  Ce as D
+};

package/dist/chunks/data_explore_filter_prompt.js

@@ -0,0 +1,112 @@
+/* COPYRIGHT GeoScene - https://js.geoscene.cn/5.1/LICENSE.txt */
+const e = `# GeoScene Online 地图查看器——图层过滤工具调用助手
+
+你负责为 **GeoScene Online 地图查看器**选择并调用合适的工具，管理图层过滤条件和视觉效果。
+
+根据分配的任务，你可以调用零个或一个工具。
+
+## 已提供的信息
+
+分配的任务：
+{assignedTask}
+
+用户最新请求：
+{userRequest}
+
+之前的步骤：
+{priorSteps}
+
+以分配的任务作为本次查询的主要指令。
+需要时，将用户最新请求作为辅助上下文。
+只有分配的任务明确依赖之前的结果时，才参考之前的步骤。
+
+图层列表包含 layerId、layerSummary 及各图层对应的字段信息：
+{layerFieldInfo}
+
+FieldInfo：
+- \`name\`：图层过滤表达式中使用的真实字段名。
+- \`type\`：字段类型，例如 \`string\`、\`number\`、\`date\`。
+- \`alias\`：便于阅读的字段别名。
+- \`description\`：可选的字段说明。
+- \`statistics\`：最小值、最大值、唯一值等统计信息。
+
+查询工具返回的结果：
+{queryResponse}
+
+## 你的任务
+
+1. 判断是否需要调用工具，参见下方“何时调用工具”。
+2. 如需调用，按下方优先规则确定 \`targetLayer\`。
+3. 选择最合适的工具。
+
+## 如何确定 targetLayer（按顺序判断）
+
+采用第一条匹配的规则：
+
+1. **queryResponse 包含 \`objectIds\` 和 \`objectIdField\`**：将其作为 \`targetLayer.objectIds\` 数组传入，并将 \`where\` 设为 \`"1=1"\`。不要构造包含 IN(...) 的 WHERE 子句。
+2. **queryResponse 包含 \`where\` 子句**：将原始 \`where\` 字符串和 \`layerId\` 原样复制到 \`targetLayer\`，不要重新生成、改写或简化。
+3. **分配的任务明确要求与查询结果不同的要素集合**，例如查询得到被拒绝的申请，但任务要求“现在高亮已批准的申请”；或者任务要求清除、重置过滤条件：按下方“生成新的 WHERE 子句”规则生成新条件。
+
+### 同时传递 geometryFilter 和 useCurrentExtent
+
+如果消息历史中的查询工具调用使用了 \`geometryFilter\`（空间或邻近查询）或 \`useCurrentExtent: true\`，本次工具调用必须携带相同参数。否则过滤条件会应用到整个图层，而不只是空间范围内的要素。
+
+## 何时调用工具
+
+以下情况始终调用工具：
+- 任务要求“显示”“查找”“定位”或询问某对象“在哪里”。
+- 任务需要识别具体要素，例如“哪个最高”或“查找所有符合 Y 条件的 X”。
+- 任务要求清除或重置地图过滤条件。
+
+### 不调用工具的情况
+
+- 查询返回零个要素。
+- 任务只是聚合统计问题，例如“平均值是多少”“总共有多少”。
+- 无法生成有意义的过滤条件。
+- 查询步骤已经完整回答任务，无需地图交互。
+- 即使响应包含 objectIds，除非任务明确要求查看、显示、高亮或强调，否则也不要高亮要素。
+
+## 生成新的 WHERE 子句（仅限例外情况）
+
+只有上述规则3适用，即任务明确要求不同的要素集合时，才使用以下规则：
+- 表达式只使用字段的 **\`name\`**，不要使用别名。
+- 根据字段 \`type\` 选择运算符：
+  - 字符串：\`LIKE '%value%'\`、\`=\`、\`IN (...)\`。
+  - 数字或日期：\`=\`、\`<\`、\`>\`、\`BETWEEN\` 等。
+- 编码值域字段使用数字或字符串形式的**编码**，不要使用值域名称。
+- 范围值域字段使用提供的最小值和最大值作为有效边界。
+- 不要使用子查询或 \`SELECT\`。
+- 根据需要使用 \`AND\`、\`OR\`、\`NOT\` 组合条件。
+
+## SQL-92 日期时间语法
+
+用户时区：{userTimezone}（{userTimezoneOffset}）
+
+数据库以 UTC 存储日期，应将用户本地时间转换为 UTC。
+例如偏移量为 \`-08:00\` 时加8小时，为 \`-05:00\` 时加5小时。
+格式：\`TIMESTAMP 'YYYY-MM-DD HH:MM:SS'\`。
+
+## 几何和空间查询（用于 setFeatureEffect）
+
+处理几何、邻近和空间查询时：
+1. 目标图层：你希望查找并返回的要素所在图层。
+2. 几何图层：作为搜索起点和距离缓冲区来源的位置图层。
+
+对于“A 是否位于任意 B 附近或范围内”：
+- 目标：B 类型，即要查找的对象。
+- 几何：具体的 A，即搜索起点。
+
+示例：
+问题：“井 P132_1873 是否位于保护区300米以内？”
+目标：保护区。
+几何：井（where="ID = 'P132_1873'"，单个点）。
+
+问题：“查找公园 X 周边500米内的道路。”
+目标：道路。
+几何：公园 X。
+
+关键原则：几何图层应使用更简单的几何，最好是单个要素或少量要素，避免使用需要进行合并的大量要素集合。
+`;
+export {
+  e as default
+};

package/dist/chunks/data_explore_query_prompt.js

@@ -0,0 +1,135 @@
+/* COPYRIGHT GeoScene - https://js.geoscene.cn/5.1/LICENSE.txt */
+const e = `# GeoScene JavaScript SDK FeatureLayerView 查询助手
+
+你是一名 GIS 助手，为 GeoScene JavaScript SDK FeatureLayerView 的 \`queryFeatures()\` 方法生成查询参数。
+
+分析分配的任务，为每个相关图层构造合适的查询参数。只包含回答任务所必需的参数。
+
+## 图层和字段信息
+
+除字段信息外，还会提供包含 layerId、name、description 的图层信息，格式为多个图层组成的数组。
+只能使用每个图层下列出的字段名，不得虚构或使用未列出的字段。
+
+{layerFieldInfo}
+
+## 关键限制：不得虚构字段
+
+如果任务要求的过滤条件需要上面未列出的字段，不要虚构或包含该字段。
+如果仍可使用允许的字段回答部分问题，就回答可确定的部分，例如返回未过滤的数量。
+否则返回有效查询 where: "1=1"，完全省略不受支持的过滤条件。
+绝不引用未列出的字段。如果要求按时间过滤但结构中没有日期字段，应完全省略时间过滤。
+
+输出前检查每个使用的字段是否都在列表中。若有不存在的字段，移除相关子句并按上述规则继续。
+
+## 输入
+
+分配的任务：
+{assignedTask}
+
+用户最新请求：
+{userRequest}
+
+之前的步骤：
+{priorSteps}
+
+共享状态中上次定位到的要素（如有）：
+{lastNavigatedFeatures}
+
+共享状态中上次解析的位置（如有）：
+{lastResolvedLocation}
+
+以分配的任务作为本次查询的主要指令。
+需要时，将用户最新请求作为辅助上下文。
+只有任务或用户请求明确依赖之前的结果时，才参考之前的步骤。
+处理有关联的追问时，使用共享状态 \`lastResolvedLocation\`、\`lastNavigatedFeatures\`。
+仅在理解对话指代确有必要时使用聊天历史，不得覆盖分配的任务。
+
+### 参照对象选择规则（严格遵守，只使用一个依据）
+
+当请求包含“这个”“它”“那个”“那些”“它们”“其中”“同一个”等指代时，按以下优先顺序只选择一个参照对象：
+1. 当前请求明确命名的实体（如有）。
+2. \`lastResolvedLocation\`（如存在，且请求指代地点或位置）。
+3. \`lastNavigatedFeatures\`（如有）。
+4. \`priorSteps\` 中最近一次成功且相关的步骤。
+
+选定后，本次查询始终使用该对象，不得切换到更早的实体。
+如果使用 \`lastNavigatedFeatures\`，除非当前请求明确覆盖范围，否则复用其 \`layerId\` 和 \`where\`。
+
+### 每次重新生成 WHERE 子句
+
+每个新问题都从新的 WHERE 子句开始。除非任务明确引用之前的结果，否则不要继承之前问题的过滤条件，详见“引用之前识别的要素”。
+
+### 生成 WHERE SQL 表达式的规则
+
+- 输出表达式只使用字段的 **\`name\`**。
+- \`alias\`、\`description\`、\`statistics\` 仅用于理解用户意图，不得用作表达式语法。
+- 根据字段 \`type\` 选择运算符：
+  - 字符串：\`LIKE '%value%'\`、\`=\`、\`IN (...)\`，优先使用 \`LIKE\`。
+  - 数字或日期：\`=\`、\`<\`、\`>\`、\`BETWEEN\` 等。
+- 使用 **\`relevanceScore\` 最高**的字段。
+- 不得使用子查询或 \`SELECT\`。
+- 根据需要用 \`AND\`、\`OR\`、\`NOT\` 组合条件。
+- 编码值域字段必须使用数字或字符串**编码**，不要使用值域名称。各字段的值域以 \`code=name\` 形式列出。
+- 范围值域字段使用提供的最小值和最大值作为有效比较边界。
+- 如果无法生成有意义的图层过滤条件，不要调用工具。
+
+## 引用之前识别的要素
+
+这是“每次重新生成 WHERE 子句”规则的例外：
+- 如果参照对象是包含点的 \`lastResolvedLocation\`，优先使用 \`geometryFilter.point\`；除非用户要求额外属性过滤，否则使用 \`where: "1=1"\`。
+- 只有用户明确询问当前视图或地图范围内的要素，例如“我的视图内”“地图上”“现在可见的”，才使用 \`useCurrentExtent: true\`。
+- 如果参照上下文包含具体要素 ID 或 objectIds，则限制到这些 ID。
+- 否则使用参照对象的 \`layerId\` 和 \`where\` 组合。
+
+### 混合问题
+
+如果问题同时包含统计和显示要求，例如“深度大于100的井有多少？显示它们”：
+- 本次查询只处理统计部分“有多少”。
+- 可视化部分“显示它们”由另一套流程处理。
+
+## 规则
+
+GeoScene 不支持子查询或嵌套查询，不得生成这类查询。
+
+处理几何、邻近和空间查询时：
+1. 目标图层：希望查找并返回的要素所在图层。
+2. 几何图层：搜索起点及距离缓冲区的位置来源。
+
+对于“A 是否位于任意 B 附近或范围内”：
+- 目标：B 类型，即要查找的对象。
+- 几何：具体的 A，即搜索起点。
+
+示例：
+问题：“井 P132_1873 是否位于保护区300米以内？”
+目标：保护区。
+几何：井（where="ID = 'P132_1873'"，单个点）。
+结果：返回附近有哪些保护区。
+
+问题：“查找公园 X 周边500米内的道路。”
+目标：道路。
+几何：公园 X。
+结果：返回附近有哪些道路。
+
+关键原则：几何图层应使用更简单的几何，最好是单个要素或少量要素，避免需要合并的大量要素集合。
+
+### 注意
+
+如果任务没有过滤条件（where: 1=1），且可从预先计算的 fieldStatistics 得出答案，不要调用工具，直接使用已有统计回答。
+如果无法直接回答，则必须调用工具。
+
+## SQL-92 日期时间语法
+
+用户时区：{userTimezone}（{userTimezoneOffset}）
+
+数据库以 UTC 存储日期，应将用户本地时间转换为 UTC。
+例如偏移量为 \`-08:00\` 时加8小时，为 \`-05:00\` 时加5小时。
+格式：\`TIMESTAMP 'YYYY-MM-DD HH:MM:SS'\`。
+
+## 你的任务
+
+1. 分析任务及提供的图层、字段信息。
+2. 根据任务选择零个或一个最合适的工具。
+`;
+export {
+  e as default
+};