@arcgis/ai-components 5.1.0-next.99 → 5.1.1

package/dist/chunks/generateLayerDescriptions.js

@@ -0,0 +1,453 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.1/LICENSE.txt */
+import { Annotation as m } from "@langchain/langgraph/web";
+import u, { z as r } from "zod";
+import { ChatPromptTemplate as D, SystemMessagePromptTemplate as K } from "@langchain/core/prompts";
+import { s as f } from "./index.js";
+import { AIMessage as B, isAIMessage as W, isToolMessage as X } from "@langchain/core/messages";
+import { createAgent as G, summarizationMiddleware as H, modelCallLimitMiddleware as J } from "langchain";
+import { ChatOpenAI as Q, OpenAIEmbeddings as Y } from "@langchain/openai";
+import q from "@arcgis/core/portal/Portal.js";
+import Z from "@arcgis/core/identity/IdentityManager.js";
+import { generateGuid as ee } from "@arcgis/toolkit/string";
+import te from "@arcgis/core/config.js";
+const F = {
+  advanced: "gpt-5.2",
+  default: "gpt-5-mini",
+  fast: "gpt-5.4-nano"
+}, I = {
+  default: "text-embedding-ada-002"
+}, T = /* @__PURE__ */ new Map();
+let M = null;
+const ne = () => {
+  const t = q.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;
+}, U = async (e) => {
+  const t = ne();
+  T.size === 0 && (M || (M = (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) => T.set(o.name, o));
+    } catch (n) {
+      throw M = null, n;
+    }
+  })()), await M);
+  const s = T.get(e);
+  if (!s)
+    throw new Error(`Model '${e}' is not available in the discovery service.`);
+  return s.endpoint;
+}, se = async (e = "default") => await U(F[e]), ie = async (e = "default") => await U(I[e]), h = (e, t) => t, P = (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: {}
+}), oe = () => ({
+  agentExecutionContext: m({
+    reducer: P,
+    default: j
+  }),
+  outputMessage: m({
+    reducer: _,
+    default: () => ""
+  }),
+  summary: m({
+    reducer: h,
+    default: () => ""
+  }),
+  status: m({
+    reducer: h
+  })
+}), $e = () => ({
+  ...oe(),
+  sharedStatePatch: m({
+    reducer: h
+  })
+}), Ne = m.Root({
+  agentExecutionContext: m({
+    default: j,
+    reducer: P
+  }),
+  currentIntent: m({
+    default: () => "none",
+    reducer: h
+  }),
+  lastExecutedAgent: m({
+    default: () => "",
+    reducer: h
+  }),
+  requiresFollowUp: m({
+    default: () => !0,
+    reducer: h
+  }),
+  stepCount: m({
+    default: () => 0,
+    reducer: (e, t) => t ?? e + 1
+  }),
+  finalOutputMessage: m({
+    default: () => "",
+    reducer: _
+  })
+}), re = (e) => {
+  if (!e || typeof e != "object" || !("services" in e))
+    return !1;
+  const t = e.services;
+  return !!t && typeof t == "object" && "agentRegistry" in t;
+}, ae = (e) => {
+  const t = e?.configurable;
+  return re(t) ? t : void 0;
+}, ce = (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." : ""))));
+  });
+}, k = async (e) => (await ce(/* @__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, le = async (e) => {
+  const { agent: t, messages: s, config: n } = e;
+  return { structuredResponse: (await t.invoke(
+    {
+      messages: s
+    },
+    n
+  )).structuredResponse };
+}, de = (e) => typeof e == "string" && e.length > 0 ? e : void 0, pe = () => ee(), me = (e) => typeof e != "string" || e.trim().length === 0 ? "MapsSDK" : `MapsSDK - ${e.trim()}`, ue = (e) => {
+  const t = e?.configurable;
+  return {
+    conversationId: de(t?.thread_id),
+    abortSignal: e?.signal,
+    requestId: pe(),
+    requestSource: me(te.applicationName)
+  };
+}, $ = async ({ config: e }) => {
+  const t = q.getDefault(), n = (await Z.getCredential(`${t.url}/sharing`))?.token;
+  return async (i, o) => {
+    const { conversationId: a, abortSignal: c, requestId: l, requestSource: p } = ue(e), d = new Headers(o?.headers);
+    d.delete("Authorization"), d.delete("api-key"), n && n.length > 0 && (d.set("X-Esri-Authorization", `Bearer ${n}`), d.set("X-Esri-Request-Source", p)), a && a.length > 0 && d.set("X-Esri-Conversation-Id", a), l.length > 0 && d.set("X-Esri-Request-Id", l);
+    const y = c && o?.signal ? AbortSignal.any([c, o.signal]) : o?.signal ?? c;
+    return await fetch(i, {
+      ...o,
+      headers: d,
+      signal: y
+    });
+  };
+}, v = async (e = {}) => {
+  const { modelTier: t = "default", temperature: s = 0, config: n } = e, i = F[t], o = await se(t);
+  return new Q({
+    modelName: i,
+    apiKey: "dummy-key",
+    // 5-mini does not support temperature parameter
+    ...t !== "default" && { temperature: s },
+    configuration: {
+      baseURL: o,
+      fetch: await $({ config: n })
+    }
+  });
+}, Oe = async (e = {}) => {
+  const { tier: t = "default", config: s } = e, n = I[t], i = await ie(t);
+  return new Y({
+    modelName: n,
+    apiKey: "dummy-key",
+    configuration: {
+      baseURL: i,
+      fetch: await $({ config: s })
+    },
+    batchSize: 2048,
+    maxConcurrency: 10
+  });
+}, ge = r.object({
+  id: r.string().min(1),
+  name: r.string().min(1),
+  description: r.string().min(1)
+});
+r.array(ge);
+const R = (e) => JSON.stringify(e, null, 2), fe = (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()
+  });
+}, Ve = async (e, t) => {
+  const s = ae(t);
+  if (t?.signal?.aborted)
+    return await f({ text: "Run cancelled; skipping intent routing" }, t), {
+      ...e,
+      currentIntent: "none",
+      finalOutputMessage: "Operation cancelled.",
+      requiresFollowUp: !1
+    };
+  try {
+    await f({ text: "Asking LLM to route to an agent" }, t);
+    const i = s.services.agentRegistry?.list() ?? [], o = i.map(({ agent: g }) => ({
+      id: g.id,
+      name: g.name,
+      description: g.description
+    }));
+    if (!o.length)
+      return await f({ text: "No agents registered; skipping intent detection" }, t), {
+        ...e,
+        currentIntent: "none",
+        finalOutputMessage: "No agents registered; skipping intent detection."
+      };
+    const a = await k("intent_prompt"), c = R(o), l = fe(o), p = {
+      registeredAgents: c,
+      priorSteps: R(e.agentExecutionContext.priorSteps),
+      userRequest: e.agentExecutionContext.userRequest
+    }, y = await D.fromTemplate(a).format(p), E = G({
+      model: await v({
+        modelTier: "fast",
+        config: t
+      }),
+      tools: [],
+      systemPrompt: y,
+      responseFormat: l,
+      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.
+        H({
+          model: await v({
+            modelTier: "fast",
+            config: t
+          }),
+          trigger: { tokens: 4e3 },
+          keep: { messages: 6 }
+        }),
+        // Enforce no loop/retry.
+        // 1 usual LLM call and 1 optional summarization call.
+        J({ runLimit: 2 })
+      ]
+    }), { structuredResponse: V } = await le({
+      agent: E,
+      messages: e.agentExecutionContext.messages,
+      config: t
+    }), w = l.parse(
+      V ?? { intent: null, assignedTask: null, requiresFollowUp: !1 }
+    ), x = w.intent ?? "none", z = {
+      ...e,
+      currentIntent: x,
+      requiresFollowUp: w.requiresFollowUp,
+      agentExecutionContext: {
+        ...e.agentExecutionContext,
+        assignedTask: w.assignedTask ?? ""
+      }
+    };
+    if (x === "none") {
+      const g = `I could not find an agent that can handle that request. I have access to the following agents: ${i.map(({ agent: L }) => L.name).join(", ")}.
+
+Please ask a question that can be answered by one of these agents.`;
+      return await f({ text: "LLM did not identify a clear intent." }, t), {
+        ...e,
+        currentIntent: x,
+        requiresFollowUp: !1,
+        finalOutputMessage: g,
+        agentExecutionContext: {
+          ...e.agentExecutionContext,
+          assignedTask: "",
+          messages: [...e.agentExecutionContext.messages, new B(g)],
+          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 f(
+      {
+        text: `Agent picked: ${x}
+Task Assigned: ${w.assignedTask ?? ""}
+Requires Follow-Up: ${w.requiresFollowUp}`
+      },
+      t
+    ), z;
+  } catch (n) {
+    throw await f({ text: "Error during intent detection" }, t), new Error(`Error during intent detection: ${n instanceof Error ? n.message : String(n)}`);
+  }
+}, he = "0.1", b = 1536, ye = "openai", we = I.default, be = `Name: {name}
+Title: {title}
+Description: {description}`, ve = `Name: {name}
+Alias: {alias}
+Description: {description}`, ze = r.object({
+  schemaVersion: r.literal(he),
+  modified: r.number().int().nonnegative(),
+  embeddings: r.object({
+    modelProvider: r.literal(ye),
+    model: r.literal(we),
+    dimensions: r.literal(b),
+    templates: r.object({
+      layer: r.string().default(be),
+      field: r.string().default(ve)
+    })
+  }),
+  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(b, {
+        message: `Layer vector must be exactly ${b} 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(b, {
+            message: `Field vector must be exactly ${b} dimensions`
+          })
+        })
+      )
+    })
+  ).default([])
+}), xe = (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 (X(n)) {
+      const i = n;
+      return t.has(i.tool_call_id);
+    }
+    return !0;
+  });
+}, A = (e, t) => {
+  const s = K.fromTemplate(e);
+  return D.fromMessages([s, ...t]);
+}, Me = async (e) => {
+  const { promptText: t, modelTier: s, temperature: n, messages: i, config: o } = e, a = A(t, i ?? []), c = await v({ modelTier: s, temperature: n, config: o });
+  return a.pipe(c);
+}, Le = async (e) => {
+  const { promptText: t, modelTier: s = "default", temperature: n = 0, messages: i, inputVariables: o, config: a } = e, l = await (await Me({
+    promptText: t,
+    modelTier: s,
+    temperature: n,
+    messages: i,
+    config: a
+  })).invoke(o ?? {}, a);
+  if (typeof l == "string")
+    return l;
+  const p = l.content;
+  return typeof p == "string" ? p : JSON.stringify(p);
+}, N = async (e) => {
+  const { promptText: t, modelTier: s = "default", temperature: n = 0, messages: i, inputVariables: o, schema: a, config: c } = e, l = A(t, i ?? []), d = (await v({ modelTier: s, temperature: n, config: c })).withStructuredOutput(a);
+  return await l.pipe(d).invoke(o ?? {}, c);
+}, Ke = async (e) => {
+  const { promptText: t, modelTier: s = "default", temperature: n = 0, messages: i, inputVariables: o, tools: a, config: c } = e, l = a.length > 0 ? xe(i ?? []) : i ?? [], p = A(t, l), d = await v({ modelTier: s, temperature: n, config: c });
+  return await p.pipe(d.bindTools(a)).invoke(o ?? {}, c);
+}, Te = u.object({
+  name: u.string(),
+  description: u.string(),
+  valueType: u.string(),
+  alias: u.string()
+}), Se = u.object({
+  fields: u.array(Te)
+}), O = (e, t) => e.getFieldAlias(t) ?? void 0, S = (e, t) => O(e, t.name) ?? t.alias ?? "", Ie = (e, t) => {
+  const s = O(e, t.name);
+  return !!(s && s !== (t.alias ?? ""));
+};
+function C(e, t) {
+  const s = /* @__PURE__ */ new Map();
+  for (const n of e.fields) {
+    const i = t.fields.find((l) => l.name === n.name), o = S(e, n), a = Ie(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 Be = async (e) => {
+  const s = await k("field_descriptions_prompt"), n = e.fields.filter((a) => !(S(e, a) && a.description)).map((a) => {
+    const { name: c, type: l, description: p } = a, d = S(e, a);
+    return [`Name: ${c}`, `Type: ${l}`, `Alias: ${d}`, `Description: ${p ?? "N/A"}`].join(", ");
+  }).join(`
+`);
+  if (n.length === 0)
+    return C(e, { fields: [] });
+  const i = {
+    existingItemTitle: e.portalItem?.title,
+    existingItemDescription: e.portalItem?.description,
+    existingLayerTitle: e.title,
+    existingLayerDescription: e.portalItem?.description,
+    fieldInformation: n
+  }, o = await N({
+    promptText: s,
+    schema: Se,
+    inputVariables: i
+  });
+  return C(e, o);
+}, ke = u.object({
+  title: u.string(),
+  description: u.string(),
+  name: u.string().nullable()
+}), We = async (e, t) => {
+  const n = await k("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 N({
+    promptText: n,
+    schema: ke,
+    inputVariables: o
+  }), name: e.title ?? null };
+};
+export {
+  Ne as D,
+  ze as W,
+  We as a,
+  ye as b,
+  v as c,
+  b as d,
+  Le as e,
+  ve as f,
+  Be as g,
+  Ke as h,
+  N as i,
+  oe as j,
+  $e as k,
+  be as l,
+  we as m,
+  ie as n,
+  ae as o,
+  Ve as p,
+  Oe as q,
+  he 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,127 @@
+/* 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 f, f as p, r as x, t as y, H as u } from "./adapter.js";
+import "@arcgis/core/identity/IdentityManager.js";
+import "@arcgis/core/portal/Portal.js";
+import "@arcgis/toolkit/string";
+import { h as S } from "./generateLayerDescriptions.js";
+import "@langchain/core/messages";
+import "@langchain/core/callbacks/dispatch/web";
+import "@langchain/openai";
+import "@arcgis/core/config.js";
+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 { s as m } from "./index.js";
+import "@langchain/core/prompts";
+const c = [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 f("help_prompt"), s = p(t, "layersAndFieldsRegistry"), l = p(t, "agentRegistry");
+  try {
+    const a = await S({
+      promptText: r,
+      modelTier: "fast",
+      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 ? "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) => x(["agentRegistry"], "Help 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: missing helpInternalState.toolCallMessage");
+    const a = (await r.invoke({ messages: [s] }, t)).messages.map((o) => o.text).join(`
+`);
+    return await m({ 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 m({ 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”_
+  
+  If the user asks unrelated queries like "What are the vowels in English alphabet" or "How to cook", call this agent so it can politely refuse and redirect to map-related questions.
+  
+  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 that the requested action is not supported.
+  _Example: "Create a chart"_
+  _Example: "Create a table"_`, V = {
+  id: "help",
+  name: "Help Agent",
+  description: M,
+  createGraph: b,
+  workspace: u
+};
+export {
+  V as H
+};