@geoscene/ai-components 0.0.0-stage → 5.1.13

package/dist/chunks/graph.js

@@ -0,0 +1,86 @@
+/* COPYRIGHT GeoScene - https://js.geoscene.cn/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("图至少需要一个节点。");
+  if (c.length === 0)
+    throw new Error("图至少需要一条边。");
+  if (l.length > 0 && !h)
+    throw new Error("图中间件需要 Agent 元数据。");
+  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(`图的边引用了未知起点：${a}`);
+      if (!n.has(f))
+        throw new Error(`图的边引用了未知终点：${f}`);
+      r.addEdge(a, f);
+    } else {
+      const a = e.from;
+      if (!n.has(a))
+        throw new Error(`图的条件边引用了未知起点：${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(`图的条件边返回了未知节点：${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(`图的入口引用了未知节点：${o}`);
+    return o;
+  }
+  const s = [...t].filter((h) => (c.get(h) ?? 0) === 0);
+  if (s.length !== 1)
+    throw new Error(
+      `无法推断唯一入口节点，找到 ${s.length} 个。请显式指定 entryNode，或保证只有一个没有入边的节点。`
+    );
+  return s[0];
+}
+export {
+  b as c
+};

package/dist/chunks/helpGraph.js

@@ -0,0 +1,117 @@
+/* COPYRIGHT GeoScene - https://js.geoscene.cn/5.1/LICENSE.txt */
+import { StateGraph as d, START as g, END as i } from "@langchain/langgraph/web";
+import { l as h, g as f, f as p, r as x, t as y, H as m } from "./adapter.js";
+import "@geoscene/core/identity/IdentityManager.js";
+import "@geoscene/core/portal/Portal.js";
+import "@geoscene/toolkit/string";
+import { h as S } from "./generateLayerDescriptions.js";
+import "@langchain/core/messages";
+import "@langchain/core/callbacks/dispatch/web";
+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 { ToolNode as E } from "@langchain/langgraph/prebuilt";
+import { s as u } from "./index.js";
+import "@langchain/core/prompts";
+const c = [h], v = (e) => {
+  if (!e || e.size === 0)
+    return "当前地图没有可用图层。";
+  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 ? `（另有 ${s.size - 10} 个）` : "";
+    return `${l + 1}. "${r.title}”。说明：${r.description}
+   字段：${a}${o}`;
+  }).join(`
+
+`);
+  return `当前地图包含 ${e.size} 个图层：
+
+${t}`;
+}, T = (e) => {
+  const t = e?.list() ?? [];
+  return t.length ? t.map((r) => `- ${r.agent.name}: ${r.agent.description}`).join(`
+`) : "当前没有可用 Agent。";
+};
+async function _(e, t) {
+  const r = await f("help_prompt"), s = p(t, "layersAndFieldsRegistry"), l = p(t, "agentRegistry");
+  try {
+    const a = await S({
+      promptText: r,
+      modelTier: "default",
+      config: t,
+      tools: c,
+      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 ? "已根据分配的任务准备帮助工具调用。" : "已根据分配的任务提供地图相关帮助。",
+      status: o ? e.status : "success"
+    };
+  } catch (a) {
+    const o = a instanceof Error ? a.message : String(a);
+    return {
+      ...e,
+      outputMessage: `调用帮助 Agent 出错：${o}`,
+      summary: "帮助 Agent 执行失败。",
+      status: "failed"
+    };
+  }
+}
+const C = (e, t) => x(["agentRegistry"], "帮助 Agent")(e, t);
+async function H(e, t) {
+  const r = new E(c, { handleToolErrors: !1 });
+  try {
+    const s = e.helpInternalState.toolCallMessage;
+    if (!s)
+      throw new Error("helpToolCalling：缺少 helpInternalState.toolCallMessage");
+    const a = (await r.invoke({ messages: [s] }, t)).messages.map((o) => o.text).join(`
+`);
+    return await u({ text: `帮助工具执行完成：${a}` }, t), {
+      ...e,
+      outputMessage: a,
+      status: "success",
+      summary: a ? y(a) : "帮助已执行。",
+      helpInternalState: {
+        ...e.helpInternalState,
+        toolCallMessage: void 0
+      }
+    };
+  } catch (s) {
+    const l = s instanceof Error ? s.message : String(s);
+    return await u({ text: `帮助工具执行失败：${l}` }, t), {
+      ...e,
+      outputMessage: `帮助工具执行失败：${l}`,
+      status: "failed",
+      summary: `帮助工具执行失败：${l}`,
+      helpInternalState: {
+        ...e.helpInternalState,
+        toolCallMessage: void 0
+      }
+    };
+  }
+}
+const b = () => new d(m).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**——回答地图、图层、字段和助手能力相关问题。
+示例：“介绍当前地图”“列出地图全部图层”“列出保护区图层字段”“有哪些 Agent”“你能做什么”“我能问什么”。
+用户询问英文字母元音、烹饪等无关问题时，调用此 Agent 礼貌说明范围并引导回地图问题。
+用户要求其他 Agent 均不支持的地图操作时，也调用此 Agent 告知暂不支持，例如“创建图表”“创建表格”。`, V = {
+  id: "help",
+  name: "帮助 Agent",
+  description: M,
+  createGraph: b,
+  workspace: m
+};
+export {
+  V as H
+};

package/dist/chunks/help_prompt.js

@@ -0,0 +1,68 @@
+/* COPYRIGHT GeoScene - https://js.geoscene.cn/5.1/LICENSE.txt */
+const n = `## 你的身份
+
+你是嵌入 GIS 应用的地图助手。你不了解历史、科学、人物、事件、烹饪等与当前地图及数据无关的信息，只知道下面“地图上下文”中描述的内容。
+
+对于超出上下文的问题，应自然说明没有相关信息，并使用地图中具体的图层名和字段名，引导用户提出你能帮助的问题。
+
+示例：“我没有这方面的信息，我只了解当前地图。你可以让我列出地图中的图层，或介绍地图助手的功能。”
+
+---
+
+## 你的能力
+
+- 列出当前地图的图层。
+- 列出指定图层的字段，此时使用工具。
+- 使用真实图层名和字段名建议具体查询。
+- 概括地图内容及可执行的操作。
+- 告知用户某些地图操作暂不支持，例如图表、表格，并说明将来可能提供。
+
+---
+
+## 输入
+
+分配的任务：
+{assignedTask}
+
+用户最新请求：
+{userRequest}
+
+之前的步骤：
+{priorSteps}
+
+以分配的任务作为主要指令，这里不会再次重复问题。
+将用户最新请求作为辅助上下文。
+之前的步骤仅用于解释已有结果、失败原因或可能的后续操作。
+
+---
+
+## 地图上下文
+
+{layerSummary}
+
+## 可用 Agent 及能力
+
+{agents}
+
+### 回答要求
+
+建议用户可以问什么时，使用具体的真实图层名：
+- “显示高程超过500的水源。”
+- “按保护级别筛选巴拿马保护区。”
+- “缩放到流域边界。”
+
+回答“我能问什么”时，结合上下文字段提供3至5个具体查询示例。
+对于无关问题，可以回答：“我只能帮助处理当前地图。你可以让我按 [FieldName] 筛选 [LayerName]，或定位到某个位置。”
+
+---
+
+## 格式
+
+- 回答简洁。
+- 列表使用项目符号。
+- 使用换行（\\n）和适当格式。
+- 所有建议使用地图上下文中真实的图层名和字段名。
+`;
+export {
+  n as default
+};

package/dist/chunks/index.js

@@ -0,0 +1,11 @@
+/* COPYRIGHT GeoScene - https://js.geoscene.cn/5.1/LICENSE.txt */
+import { dispatchCustomEvent as e } from "@langchain/core/callbacks/dispatch/web";
+const n = async (s, a) => {
+  await e("trace_message", s, a);
+}, o = async (s, a) => {
+  await e("graph_ux_suggestion", s, a);
+};
+export {
+  o as a,
+  n as s
+};

package/dist/chunks/intent_prompt.js

@@ -0,0 +1,124 @@
+/* COPYRIGHT GeoScene - https://js.geoscene.cn/5.1/LICENSE.txt */
+const e = `## GIS Agent 编排器
+
+你负责 GeoScene Maps SDK for JavaScript 系统的任务编排。
+你的职责是决定当前步骤下一步最适合执行的唯一 Agent。
+
+---
+
+## 输入
+
+你会得到：
+- 用户最新请求。
+- 相关聊天历史。
+- 已注册 Agent 列表。
+- 可选的 Agent 先前执行步骤。
+
+---
+
+## 输出
+
+返回以下两种结果之一：
+- 一个决定，包含：
+  1. \`agentId\`：下一步执行的 Agent。
+  2. \`assignedTask\`：交给该 Agent 的明确、可执行任务。
+  3. \`requiresFollowUp\`：该 Agent 成功后，是否可能还需要另一步编排。
+- 如果没有适用的已注册 Agent，返回 \`null\`。
+
+---
+
+## 重要要求
+
+- 只有请求明确超出所有已注册 Agent 的范围时，才返回 \`null\`。
+- 只要有 Agent 能执行下一项有用操作，就选择最合适的 Agent。
+
+---
+
+## 上下文
+
+### 用户最新请求
+{userRequest}
+
+### 已注册 Agent
+
+格式：
+{{id: string, name: string, description: string}}[]
+
+{registeredAgents}
+
+### 之前的步骤
+
+每个步骤包含：
+- \`agentId: string\`
+- \`assignedTask: string\`
+- \`summary: string\`
+- \`status: "success" | "failed" | "unknown"\`
+
+利用之前的步骤：
+- 避免重复已经成功完成的工作。
+- 必要时重试或调整失败的步骤。
+
+{priorSteps}
+
+---
+
+## 规则
+
+- 主要关注用户最新请求。
+- 只有最新请求明确依赖之前上下文时，才使用相关聊天历史，否则忽略。
+- 根据之前的步骤判断哪些操作已经尝试或完成。
+- 不要预先规划整个流程，只决定下一项最合适的步骤。
+- 优先选择能直接完成用户请求的 Agent。
+- 只有必要时才拆分为多个步骤。
+- 多个 Agent 均可处理时，选择最合适的，而不是返回 \`null\`。
+- 根据已注册 Agent 的能力说明选择，不要求用户使用精确关键词。
+- 如果没有 Agent 能完整完成请求，但有 Agent 能执行下一项有用操作，就选择它。
+- 除非用户当前请求明确要求，否则不要复用之前步骤的限制条件。
+- 每个步骤都必须准确反映当前请求。
+
+---
+
+## 条件理解
+
+准确理解用户措辞：
+- 不要用一种条件替换另一种，例如距离与包含、范围与精确匹配。
+- 用户明确给出的条件必须原样遵守。
+- 用户未指定的条件不要自行假设或推断。
+不要把请求重新解释成其他问题。
+
+---
+
+## 追问中的指代解析
+
+当最新请求使用“这些”“那些”“它们”“那组”“之前的结果”“这个”“它”“那个”“这个地块”“这个位置”“那个要素”等指代表达时，说明它依赖之前上下文。
+其他语言中的等价指代表达同样适用。
+
+根据最近相关的聊天历史或成功步骤解析指代。
+此时 \`assignedTask\` 应可独立理解，保留所引用的先前条件，并仅增加最新请求中的新条件或问题。
+如果可从上下文确定对象，不要在 \`assignedTask\` 中保留模糊指代。
+
+---
+
+## 分配任务的要求（重要）
+
+- \`assignedTask\` 的含义必须与用户请求完全一致。
+- 不要增加、移除或转换条件。
+- 不要用一种条件替换另一种。
+- 没有明确条件时，不要自行假设。
+- 任务应简短、具体、可直接执行。
+- 尽量保留用户原话，只做必要转换。
+- 解析追问时，只把模糊指代替换成已确定的上下文，其余措辞尽量保持。
+- 只使用用户请求或已提供上下文中明确存在的信息。
+- 如果需要多个步骤，\`assignedTask\` 可以只代表用户请求的一部分。
+
+---
+
+## requiresFollowUp 的要求
+
+- \`requiresFollowUp\` 表示是否可能需要下一步 Agent 操作，不表示对当前请求的不确定性。
+- 只有该 Agent 成功后仍可能需要另一步编排时，才设为 \`true\`。
+- 如果该 Agent 成功后即可完成用户可见的任务，则设为 \`false\`。
+`;
+export {
+  e as default
+};

package/dist/chunks/layerStylingGraph.js

@@ -0,0 +1,190 @@
+/* COPYRIGHT GeoScene - https://js.geoscene.cn/5.1/LICENSE.txt */
+import { NodeInterrupt as E, StateGraph as L, START as w, END as m } from "@langchain/langgraph/web";
+import "@geoscene/core/identity/IdentityManager.js";
+import "@geoscene/core/portal/Portal.js";
+import "@geoscene/toolkit/string";
+import { h as I } from "./generateLayerDescriptions.js";
+import "@langchain/core/messages";
+import { s as i } 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 { f as g, z as v, A as T, B as R, C as F, D as C, E as A, F as $, I as N, J as b, K as q, L as M, g as _, r as k, M as S } from "./adapter.js";
+import { h as V } from "./toolCallResponse.js";
+import { ToolNode as j } from "@langchain/langgraph/prebuilt";
+const h = 0.5, z = 10, D = async (t, e) => {
+  try {
+    await i({ text: "正在通过相似度搜索字段" }, e);
+    const r = g(e, "fieldSearch"), a = g(e, "layersAndFieldsRegistry"), o = g(e, "embeddingCache"), n = await r.searchFields({
+      text: t.agentExecutionContext.assignedTask,
+      layerIds: t.vectorSearchLayerIds,
+      minScore: h,
+      topResults: z,
+      embeddingCache: o
+    }), c = n.map(({ layerId: d, results: p }) => {
+      const y = p.map((s) => `  - ${s.name} (${s.score.toFixed(2)})`).join(`
+`);
+      return `${a.get(d)?.layerItem.name ?? d}:
+${y}`;
+    }).join(`
+`);
+    let l;
+    return n.length > 0 ? l = `向量搜索完成，匹配的图层、字段及得分：
+${c}` : l = `未找到得分超过以下阈值的向量搜索结果：${h}.`, await i({ text: l }, e), {
+      ...t,
+      vectorSearchFieldResults: n
+    };
+  } catch (r) {
+    throw await i(
+      { text: `向量搜索出错：${r instanceof Error ? r.message : String(r)}` },
+      e
+    ), new Error(`向量搜索失败：${r instanceof Error ? r.message : String(r)}`);
+  }
+}, P = 0.5, H = async (t, e) => {
+  try {
+    await i(
+      { text: `正在通过相似度搜索图层：${t.agentExecutionContext.assignedTask}` },
+      e
+    );
+    const r = g(e, "layerSearch"), a = g(e, "layersAndFieldsRegistry"), o = await r.searchLayers({
+      text: t.agentExecutionContext.assignedTask,
+      minScore: P
+    }), n = o.map((d) => d.id), c = o.map(({ id: d, score: p }) => `${a.get(d)?.layerItem.name ?? d} (${p.toFixed(2)})`).join(`
+`);
+    let l;
+    return n.length > 0 ? l = `向量搜索完成，匹配的图层及得分：
+${c}` : l = "向量搜索完成，未找到匹配图层。", await i({ text: l }, e), {
+      ...t,
+      vectorSearchLayerIds: n
+    };
+  } catch (r) {
+    throw await i(
+      { text: `向量搜索出错：${r instanceof Error ? r.message : String(r)}` },
+      e
+    ), new Error(`向量搜索失败：${r instanceof Error ? r.message : String(r)}`);
+  }
+}, f = [
+  v,
+  T,
+  R,
+  F,
+  C,
+  A,
+  $,
+  N,
+  b,
+  q,
+  M
+], x = (t, e = 3) => {
+  const r = t.map((o, n) => o.type === "human" ? n : -1).filter((o) => o !== -1);
+  if (r.length === 0)
+    return [];
+  const a = r.length > e ? r[r.length - e] : r[0];
+  return t.slice(a);
+}, G = async (t, e) => {
+  await i({ text: "正在请求模型规划图层查询" }, e);
+  const r = await _("navigation_intent_prompt");
+  if (!e?.configurable)
+    throw new Error("图层查询工具需要 config.configurable");
+  const a = {
+    layerFieldInfo: t.layerFieldInfo
+  }, o = await I({
+    promptText: r,
+    modelTier: "advanced",
+    config: e,
+    messages: x(t.agentExecutionContext.messages),
+    inputVariables: a,
+    tools: f
+  });
+  return await V(o, e), {
+    ...t,
+    agentExecutionContext: {
+      ...t.agentExecutionContext,
+      messages: [...t.agentExecutionContext.messages, o]
+    }
+  };
+};
+async function B(t, e) {
+  const a = await new j(f, { handleToolErrors: !1 }).invoke(
+    {
+      messages: x(t.agentExecutionContext.messages)
+    },
+    e
+  ), o = a.messages.map((c) => c.text).join(`
+`);
+  await i({ text: `图层过滤工具执行完成：${o}` }, e);
+  const n = a.messages.map((c) => c.text).join(`
+`);
+  return { ...t, outputMessage: n };
+}
+const U = async (t, e) => (await i({ text: "退出图层样式 Agent" }, e), t), J = async (t, e) => {
+  try {
+    await i({ text: "正在填充图层和字段信息" }, e);
+    const r = [];
+    for (const a of t.vectorSearchFieldResults) {
+      let o = function(y) {
+        const s = l.get(y)?.layerItem;
+        return s ? [
+          s.name && `名称：${s.name}`,
+          s.title && `标题：${s.title}`,
+          s.description && `说明：${s.description}`
+        ].filter(Boolean).join(" | ") : y;
+      };
+      const { layerId: n, results: c } = a, l = g(e, "layersAndFieldsRegistry"), d = l.get(n)?.fieldRegistry;
+      if (!d)
+        continue;
+      let p = r.find((y) => y.layerId === n);
+      p || (p = {
+        layerId: n,
+        layerSummary: o(n),
+        fieldInfos: []
+      }, r.push(p));
+      for (const y of c) {
+        const s = d.get(y.name);
+        s && p.fieldInfos.push(s);
+      }
+    }
+    return await i({ text: "layerFieldInfo 已填充" }, e), { ...t, layerFieldInfo: r };
+  } catch (r) {
+    throw await i({ text: "填充 layerFieldInfo 出错" }, e), new Error(`填充 layerFieldInfo 出错：${r instanceof Error ? r.message : String(r)}`);
+  }
+}, K = (t, e) => {
+  const r = t.vectorSearchLayerIds ?? [];
+  if (r.length <= 1)
+    return { ...t, selectedLayerId: t.vectorSearchLayerIds[0] };
+  const { hitlResponse: a } = e.configurable;
+  if (a?.agentId !== u.id || a.id !== "reviewLayerSelection") {
+    const n = {
+      agentId: u.id,
+      id: "reviewLayerSelection",
+      kind: "singleSelection",
+      message: "请选择要应用样式的图层。",
+      metadata: [...r]
+    };
+    throw new E(n);
+  }
+  let o = null;
+  return Array.isArray(a.payload) && a.payload.length > 0 && (o = a.payload[0]), {
+    ...t,
+    selectedLayerId: o ?? t.vectorSearchLayerIds[0]
+  };
+}, O = (t, e) => k(["layerSearch", "fieldSearch", "layersAndFieldsRegistry"], "图层样式 Agent")(t, e), Q = () => new L(S).addNode("requireLayerStylingServices", O).addNode("vectorSearchLayers", H).addNode("layerSelectionHITL", K).addNode("vectorSearchFields", D).addNode("populateLayerFieldInfo", J).addNode("agent", G).addNode("tools", B).addNode("earlyExit", U).addEdge(w, "requireLayerStylingServices").addEdge("requireLayerStylingServices", "vectorSearchLayers").addConditionalEdges(
+  "layerSelectionHITL",
+  (e) => e.vectorSearchLayerIds.length ? "vectorSearchFields" : "earlyExit"
+).addConditionalEdges(
+  "vectorSearchFields",
+  (e) => e.vectorSearchFieldResults.length ? "populateLayerFieldInfo" : "earlyExit"
+).addEdge("populateLayerFieldInfo", "agent").addEdge("agent", "tools").addEdge("tools", m).addEdge("earlyExit", m), W = String.raw`- **layerStyling**——按数据改变地图上要素的绘制方式，例如根据字段值设置颜色、大小、透明度、符号或图表。
+示例：“按销售额给点着色”“用颜色渐变显示人口密度”“创建高度与深度的关系图”“按人口改变圆大小”。`, u = {
+  id: "layerStyling",
+  name: "图层样式 Agent",
+  description: W,
+  createGraph: Q,
+  workspace: S
+};
+export {
+  u as L
+};

package/dist/chunks/layer_descriptions_prompt.js

@@ -0,0 +1,55 @@
+/* COPYRIGHT GeoScene - https://js.geoscene.cn/5.1/LICENSE.txt */
+const e = `该要素图层属于一个要素服务，包含多个具有名称、类型和说明的字段。
+要素图层是一组表示真实世界实体的地理要素，每个要素的属性提供附加信息。根据数据类型，图层可能包含点、线或面几何。
+本图层的几何类型为 {layerGeometryType}。
+
+以下是各字段的 name、alias、type、valueType 和 description，可帮助理解图层的数据。
+
+字段说明：
+{fieldInformation}
+
+你的任务：
+- 分析字段说明，理解图层表示的数据。
+- 为图层生成：
+  - 标题：简洁、准确表达要素服务的内容与用途。
+  - 说明：详细介绍要素图层。
+
+说明应考虑：
+- 图层用途。
+- 数据类型和几何实体。
+- 信息来源和覆盖的地理区域。
+- 在 GIS 中的潜在应用和价值。
+
+不适用的内容可以略过。不要陈述该图层“不是什么”或“不具有什么”，避免罗列字段名、类型等技术细节。
+
+生成标题的要求：
+- 避免特殊字符。
+- 避免使用“图层”（layer）一词。
+- 英文标题避免全大写，使用标题式大小写。
+- 不要过长。
+
+以下是要素图层已有的标题和说明。
+
+## 人工填写的现有图层信息
+
+{existingLayerTitle}
+{existingLayerSnippet}
+{existingLayerDescription}
+
+## 如何使用人工填写的信息
+
+人工填写者可能掌握字段和图层说明之外的更多信息。
+- 只有有助于理解资源时才使用这些信息。
+- 只有能改善标题和说明时才使用这些信息。
+- 用这些信息补充字段和图层说明中遗漏的重要内容。
+
+## 避免的做法
+
+- 不要直接把这些信息作为答案。
+- 不要把这些信息视为最终版本。
+- 不要未经分析就据此作答。
+- 不要逐字照抄。
+`;
+export {
+  e as default
+};