@arcgis/portal-components 5.2.0-next.7 → 5.2.0-next.71

package/dist/components/arcgis-portal-ai-assistant/customElement.js

@@ -1,375 +1,205 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
-import { c as Z } from "../../chunks/runtime.js";
-import { LitElement as tt, createEvent as et } from "@arcgis/lumina";
-import { css as st, render as at, html as w } from "lit";
-import { createRef as M, ref as T } from "lit/directives/ref.js";
-import { u as rt } from "../../chunks/useT9n.js";
-import { a as P, t as ot } from "../../chunks/functionalities.js";
-import { Annotation as h, StateGraph as $, START as G, END as y, NodeInterrupt as V } from "@langchain/langgraph/web";
-import { sendTraceMessage as g, invokeStructuredPrompt as b, createChatModel as F, sendUXSuggestion as B, createAgentRuntimeStateWithSharedState as E } from "@arcgis/ai-components/utils/index.js";
-import n from "zod";
-import { ChatPromptTemplate as L } from "@langchain/core/prompts";
-import { createAgent as Q } from "langchain";
-import { tool as K } from "@langchain/core/tools";
-import { s as nt, g as it, a as lt, c as ct, q as ut } from "../../chunks/groups.js";
-import mt from "@arcgis/core/identity/IdentityManager.js";
-import k from "@arcgis/core/request.js";
-import { Annotation as dt } from "@langchain/langgraph";
-const x = (s) => {
-  for (let t = s.length - 1; t >= 0; t -= 1) {
-    const e = s[t];
-    if (e.type !== "human")
-      continue;
-    const a = e.content;
-    if (typeof a == "string")
-      return a;
-    if (Array.isArray(a))
-      return a.map(
-        (r) => typeof r == "string" ? r : "text" in r && typeof r.text == "string" ? r.text : ""
-      ).join(" ").trim();
-  }
-  return "";
-}, pt = () => ({ latestItemId: null, memory: {} }), N = (s) => {
-  const t = s?.agentExecutionContext.sharedState.portalItemAnalyticsSummaryMemory?.value;
-  return t ? { latestItemId: t.latestItemId, memory: t.memory } : pt();
-}, gt = n.object({
-  intent: n.enum(["summarize", "followUp", "clarify"]),
-  itemId: n.string().default(""),
-  question: n.string().default("")
-}), ht = n.object({ summary: n.string(), followUpQuestions: n.array(n.string()).default([]) }), ft = n.object({ answer: n.string(), isRelevant: n.boolean() }), yt = async (s, t) => {
-  await g({ text: "Answering follow-up...", agentName: "analytics" }, t);
-  const e = N(s), a = s.analyticsItemId ?? e.latestItemId, r = a ? e.memory[a] : void 0, l = s.analyticsQuestion || x(s.agentExecutionContext.messages);
-  return r ? {
-    status: "success",
-    outputMessage: (await b({
-      promptText: bt,
-      schema: ft,
-      modelTier: "default",
-      inputVariables: {
-        summary: r.summary,
-        question: l,
-        fullContext: JSON.stringify(r.fullContext)
-      }
-    })).answer
-  } : {
-    status: "success",
-    outputMessage: "I don't have enough information yet. Please ask me to summarize the item first using summarize item <item id>."
-  };
-}, bt = `
-You answer follow-up questions about an ArcGIS item.
-
-Ground your answer in the provided item context.
-If the answer is not available from the provided context, state that clearly and suggest what to check next.
-
-Response rules:
-- Reply in concise markdown.
-- Keep the answer focused on the follow-up question.
-- Do not include internal identifiers.
-- Mark isRelevant=false when the question is not about this item or cannot be grounded in this item context.
-
-Item summary:
-{summary}
-
-Item full context
-{fullContext}
-
-Question:
-{question}
-`;
-function I(s) {
-  const { portal: t, user: e } = s ?? {};
-  if (!s || !t || !e)
+import { c as Ue } from "../../chunks/runtime.js";
+import { LitElement as Fe, createEvent as Oe } from "@arcgis/lumina";
+import { css as Ke, render as Ve, html as b } from "lit";
+import { createRef as P, ref as q } from "lit/directives/ref.js";
+import { u as je } from "../../chunks/useT9n.js";
+import { NodeInterrupt as fe, Annotation as h, StateGraph as G, START as A, END as w } from "@langchain/langgraph/web";
+import { sendTraceMessage as m, invokeStructuredPrompt as v, sendUXSuggestion as B, createAgentRuntimeStateWithSharedState as N, createChatModel as Q, getEmbeddings as Le } from "@arcgis/ai-components/utils/index.js";
+import s from "zod";
+import { a as Be, c as Qe, q as We } from "../../chunks/groups.js";
+import Je from "@arcgis/core/identity/IdentityManager.js";
+import Y from "@arcgis/core/request.js";
+import { a as R, t as _e, b as Ye } from "../../chunks/functionalities.js";
+import { ChatPromptTemplate as W } from "@langchain/core/prompts";
+import { tool as ye } from "@langchain/core/tools";
+import { s as He, a as Xe } from "../../chunks/item2.js";
+import { g as Ze, e as et, i as tt, c as at, a as nt } from "../../chunks/groups2.js";
+import rt from "@arcgis/core/portal/Portal.js";
+const we = (e) => {
+  const { portal: t, user: a } = e ?? {};
+  return !!e && !!t && !!a;
+};
+function T(e) {
+  if (!we(e))
     throw new Error("Invalid context: PortalAssistantContext with portal and user is required.");
 }
-const W = K(
-  async ({ itemTitle: s }, t) => {
-    const e = s.trim();
-    if (!e)
-      return null;
-    const a = t?.configurable?.context;
-    I(a);
-    const { result: r, error: l } = await nt(a.portal, e, { num: 1 });
-    return l && console.error("Error searching for portal item by title:", l), r?.results[0]?.id || null;
-  },
-  {
-    name: "resolvePortalItemIdByTitle",
-    description: 'Resolves an ArcGIS Portal item title to the best-match item id. Use this when a user references an item by title (including hash mentions like #title or #"title with spaces") instead of an explicit item id.',
-    schema: n.object({
-      itemTitle: n.string().describe("The portal item title to resolve to an item id.")
-    })
-  }
-), It = async (s, t) => {
-  await g({ text: "Analyzing intent...", agentName: "analytics" }, t);
-  const e = x(s.agentExecutionContext.messages), a = !!N(s).latestItemId, r = await L.fromTemplate(wt).format({
-    userMessage: e,
-    hasSummaryContext: String(a)
-  }), c = await Q({
-    model: await F({ modelTier: "fast" }),
-    tools: [W],
-    systemPrompt: r,
-    responseFormat: gt,
-    checkpointer: !0
-  }).invoke({ messages: s.agentExecutionContext.messages }, t), { intent: i, itemId: o, question: u } = c.structuredResponse, m = i === "clarify" || i === "summarize" && !o || i === "followUp" && !u;
-  return {
-    agentExecutionContext: { ...s.agentExecutionContext },
-    analyticsIntent: m ? "clarify" : i,
-    analyticsItemId: o || null,
-    analyticsQuestion: u || "",
-    status: "success",
-    outputMessage: m ? 'Please clarify with summarize item <item id>, summarize item #<title>, or summarize item #"<title with spaces>".' : ""
-  };
-}, wt = `
-Classify the user analytics request.
+const ot = `
+Write a concise, friendly success message for adding members to a group.
 
 Rules:
-- intent="summarize" only when the user explicitly asks to summarize/overview/recap an item.
-- intent="followUp" for analytical questions about item details, including schema/fields/attributes/layers.
-- intent="clarify" when neither summarize nor follow-up intent is clear.
-- itemId must be the final resolved item id.
-- If request has explicit item id, set itemId directly.
-- If request references item title (for example #title, #"title with spaces", or plain quoted title), call resolvePortalItemIdByTitle and set itemId to the returned value.
-- Never return item titles in output fields.
-- If intent is "followUp", set question to the user's full question/request text.
-- If intent is "summarize", set question="".
-- When user asks to show/list/explain fields, schema, attributes, columns, or layer details, classify as "followUp" unless they explicitly request a summary.
-- If hasSummaryContext is true, prefer "followUp" for detail-oriented requests that do not explicitly ask to summarize.
-
-Examples:
-- "Summarize item 0123456789abcdef0123456789abcdef" => summarize, itemId="0123456789abcdef0123456789abcdef"
-- "Summarize item #california" => summarize, call resolvePortalItemIdByTitle("california") and set itemId to tool result
-- "Summarize item #"california farmland"" => summarize, call resolvePortalItemIdByTitle("california farmland") and set itemId to tool result
-- "Show the layer's available fields" => followUp
-- "List attributes and explain what status means" => followUp
-- "What fields are available?" with hasSummaryContext=true => followUp
-- "Give me an overview of item 0123456789abcdef0123456789abcdef" => summarize
+- Keep it to 1-2 short sentences.
+- Use plain text only.
+- If there is no notAddedMembers, confirm that all requested members were added successfully.
+- If there are notAddedMembers, acknowledge that some members could not be added and list the added and not added members separately then mention why based on the context
+- Make sure to bold the usernames
 
-hasSummaryContext:
-{hasSummaryContext}
+Added members:
+{addedMembers}
 
-User message:
-{userMessage}
-`, xt = async (s, t) => {
-  const e = s.analyticsItemId;
-  if (!e)
-    return {
-      status: "success",
-      outputMessage: 'Please clarify with summarize item <item id>, summarize item #<title>, or summarize item #"<title with spaces>".'
-    };
-  await g({ text: `Summarizing item ${e}...`, agentName: "analytics" }, t);
-  const a = t?.configurable?.context;
-  I(a);
-  const { portal: r, user: l } = a, { result: c, error: i } = await it(l, r, e);
-  if (i || !c)
-    return await g({ text: "Failed to get item context for summarization", agentName: "analytics" }, t), {
-      status: "success",
-      outputMessage: "Unable to retrieve item context for summarization."
-    };
-  const { context: o } = c, u = await b({
-    promptText: vt,
-    schema: ht,
-    modelTier: "default",
-    inputVariables: { context: JSON.stringify(o) }
-  }), { followUpQuestions: d, summary: p } = u, m = N(s), f = {
-    latestItemId: e,
-    memory: {
-      ...m.memory,
-      [e]: { summary: p, followUpQuestions: d, fullContext: o }
-    }
-  };
-  return d.length && await B({ type: "suggested-prompts", data: { prompts: d } }, t), {
-    status: "success",
-    outputMessage: p,
-    sharedStatePatch: { portalItemAnalyticsSummaryMemory: { value: f } }
-  };
-}, vt = `
-You are a item summary tool for ArcGIS. Your job is to summarize an item's info based on the provided context.
-Summary rules:
-- The summary should be concise markdown, make sure to format the output nicely so it's easy to read.
-- Target length: 80-150 words.
-- Provide one short descriptive paragraph.
-- Also propose 3 concise follow-up questions grounded in the item summary.
-- Keep follow-up questions specific and actionable.
-Follow-up questions rules:
-- These questions should be in the format of a prompt that the user can click on.
-- Make sure the questions are relevant to the item summary and that you can answer based solely on the provided context.
-Do not include internal identifiers.
-If the user asks for a detailed summary, you may expand the response up to 300 words.
-Item context:
-{context}
-`, C = (s, t) => t ?? s, O = h.Root({
-  ...E(),
-  // States shared only across nodes in the graph, not between invocations
-  analyticsIntent: h({
-    reducer: C,
-    default: () => "clarify"
-  }),
-  analyticsItemId: h({
-    reducer: C,
-    default: () => null
-  }),
-  analyticsQuestion: h({
-    reducer: C,
-    default: () => ""
-  })
-}), St = () => new $(O).addNode("detectAnalyticsIntent", It).addNode("summarizePortalItem", xt).addNode("answerAnalyticsFollowUp", yt).addEdge(G, "detectAnalyticsIntent").addConditionalEdges("detectAnalyticsIntent", (t) => t.analyticsIntent === "summarize" ? "summarizePortalItem" : t.analyticsIntent === "followUp" ? "answerAnalyticsFollowUp" : y).addEdge("summarizePortalItem", y).addEdge("answerAnalyticsFollowUp", y), Mt = String.raw`- **portal-item-analytics** - Portal item analytics assistant:
-  - summarizes ArcGIS portal items from item context
-  - suggests follow-up prompts grounded in the item
-`, Tt = {
-  id: "portal-item-analytics",
-  name: "Portal Item Analytics",
-  description: Mt,
-  createGraph: St,
-  workspace: O
-}, Pt = (s) => s.map((t) => `"${t}"`).join(", "), At = n.object({
-  successMessage: n.string().default("")
-}), q = "portal-group-creation", D = "approveAddMembers", Ct = async (s, t) => {
-  if (s.intentParams.intent !== "addMembers")
+Not added members:
+{notAddedMembers}
+`, st = (e) => e.map((t) => `"${t}"`).join(", "), it = s.object({
+  successMessage: s.string().default("")
+}), H = "portal-group-creation", X = "approveAddMembers", ut = async (e, t) => {
+  if (e.intentParams.intent !== "addMembers")
     return {
       status: "success",
       outputMessage: "Use @mention usernames for the members you want to add."
     };
-  const e = s.agentExecutionContext.sharedState.createdGroupId?.value;
-  if (!e)
+  const a = e.agentExecutionContext.sharedState.createdGroupId?.value;
+  if (!a)
     return {
       status: "success",
       outputMessage: "Create a group first, then add members using @mention usernames."
     };
-  const a = s.intentParams.memberInfo.memberIdentifiers.map((m) => m.trim()).filter(Boolean);
-  if (!a.length)
+  const n = e.intentParams.memberInfo.memberIdentifiers.map((p) => p.trim()).filter(Boolean);
+  if (!n.length)
     return {
       status: "success",
       outputMessage: "Use @mention usernames for the members you want to add."
     };
-  const l = `The following member(s) will be added to the newly created group:
+  const o = `The following member(s) will be added to the newly created group:
 
-${a.map((m) => `- **@${m}**`).join(`
+${n.map((p) => `- **@${p}**`).join(`
 `)}
 
-Do you want to continue?`, { hitlResponse: c } = t?.configurable ?? {};
-  if (c?.agentId !== q || c.id !== D) {
-    const m = {
-      agentId: q,
-      id: D,
+Do you want to continue?`, { hitlResponse: u } = t?.configurable ?? {};
+  if (u?.agentId !== H || u.id !== X) {
+    const p = {
+      agentId: H,
+      id: X,
       kind: "booleanChoice",
-      message: l,
+      message: o,
       metadata: {
         action: "addMembers",
-        groupId: e,
-        members: [...a]
+        groupId: a,
+        members: [...n]
       }
     };
-    throw new V(m);
+    throw new fe(p);
   }
-  if (c.payload !== !0)
+  if (u.payload !== !0)
     return {
       status: "success",
       outputMessage: "Okay, I cancelled adding members to the group."
     };
-  await g(
-    { text: `Adding members ${Pt(a)}...`, agentName: "group-creation" },
+  await m(
+    { text: `Adding members ${st(n)}...`, agentName: "group-creation" },
     t
   );
   const i = t?.configurable?.context;
-  I(i);
-  const { result: o, error: u } = await lt(i.portal, e, a);
-  if (u || !o)
+  T(i);
+  const { result: l, error: c } = await Be(i.portal, a, n);
+  if (c || !l)
     return {
       status: "success",
       outputMessage: "I could not add members to that group. Please confirm group access and user accounts, then try again."
     };
-  const { addedUsernames: d, notAddedUsers: p } = o;
+  const { addedUsernames: d, notAddedUsers: g } = l;
   try {
-    const f = (await b({
-      promptText: $t,
-      schema: At,
+    const f = (await v({
+      promptText: ot,
+      schema: it,
       modelTier: "fast",
       inputVariables: {
         addedMembers: d.join(", "),
         notAddedMembers: JSON.stringify(
-          p.map((v) => ({ username: v.username, reason: v.error.message }))
+          g.map((y) => ({ username: y.username, reason: y.error.message }))
         )
       }
     })).successMessage;
     if (f)
       return { status: "success", outputMessage: f };
-  } catch (m) {
-    console.error("Error generating add-members success message:", m);
+  } catch (p) {
+    console.error("Error generating add-members success message:", p);
   }
   return {};
-}, $t = `
-Write a concise, friendly success message for adding members to a group.
+}, ct = `
+Write a concise, friendly success message after creating a portal group.
+
+Rules:
+- Mention that the group was created successfully.
+- Mention that the user can add members by using @mention usernames.
+- Keep it to 1-2 short sentences.
+- Make sure to bold the group title in the message.
+
+Group title:
+{groupTitle}
+`, lt = `
+Write a concise, friendly failure message after an attempt to create a portal group.
 
 Rules:
 - Keep it to 1-2 short sentences.
 - Use plain text only.
-- If there is no notAddedMembers, confirm that all requested members were added successfully.
-- If there are notAddedMembers, acknowledge that some members could not be added and list the added and not added members separately then mention why based on the context
-- Make sure to bold the usernames
+- Mention that group creation failed.
+- Include the failure reason in user-friendly language.
+- End with a clear next step the user can try.
 
-Added members:
-{addedMembers}
+Group title:
+{groupTitle}
 
-Not added members:
-{notAddedMembers}
-`, R = "portal-group-creation", U = "approveCreateGroup", Gt = n.object({
-  successMessage: n.string().default("")
-}), Et = n.object({
-  failureMessage: n.string().default("")
-}), Nt = async (s, t) => {
-  if (s.intentParams.intent !== "create")
+Failure reason:
+{failureReason}
+`, Z = "portal-group-creation", ee = "approveCreateGroup", dt = s.object({
+  successMessage: s.string().default("")
+}), pt = s.object({
+  failureMessage: s.string().default("")
+}), mt = async (e, t) => {
+  if (e.intentParams.intent !== "create")
     return {
       status: "success",
       outputMessage: "Tell me the group title you want to use."
     };
-  const e = s.intentParams.title.trim();
-  if (!e)
+  const a = e.intentParams.title.trim();
+  if (!a)
     return {
       status: "success",
       outputMessage: "What title would you like for the new group?"
     };
-  const a = `A group with the title **${e}** will be created. Do you want to continue?`, { hitlResponse: r } = t?.configurable;
-  if (r?.agentId !== R || r.id !== U) {
-    const u = {
-      agentId: R,
-      id: U,
+  const n = `A group with the title **${a}** will be created. Do you want to continue?`, { hitlResponse: r } = t?.configurable;
+  if (r?.agentId !== Z || r.id !== ee) {
+    const c = {
+      agentId: Z,
+      id: ee,
       kind: "booleanChoice",
-      message: a,
+      message: n,
       metadata: {
         action: "createGroup",
-        title: e,
+        title: a,
         access: "private"
       }
     };
-    throw new V(u);
+    throw new fe(c);
   }
   if (r.payload !== !0)
     return {
       status: "success",
-      outputMessage: `Okay, I cancelled creating **${e}**.`
+      outputMessage: `Okay, I cancelled creating **${a}**.`
     };
-  await g({ text: `Creating group "${e}"...`, agentName: "group-creation" }, t);
-  const l = t?.configurable?.context;
-  I(l);
-  const { result: c, error: i } = await ct(l.portal, {
-    title: e,
+  await m({ text: `Creating group "${a}"...`, agentName: "group-creation" }, t);
+  const o = t?.configurable?.context;
+  T(o);
+  const { result: u, error: i } = await Qe(o.portal, {
+    title: a,
     access: "private"
   });
-  if (i || !c) {
-    const u = i?.message?.trim() || "No additional details were provided.";
+  if (i || !u) {
+    const c = i?.message?.trim() || "No additional details were provided.";
     try {
-      const p = (await b({
-        promptText: qt,
-        schema: Et,
+      const g = (await v({
+        promptText: lt,
+        schema: pt,
         modelTier: "fast",
         inputVariables: {
-          groupTitle: e,
-          failureReason: u
+          groupTitle: a,
+          failureReason: c
         }
       })).failureMessage.trim();
-      if (p)
+      if (g)
         return {
           status: "success",
-          outputMessage: p
+          outputMessage: g
         };
     } catch (d) {
       console.error("Error generating create-group failure message:", d);
@@ -379,72 +209,42 @@ Not added members:
       outputMessage: "I could not create that group. Please confirm your permissions and try again with the group title."
     };
   }
-  const o = c.id;
+  const l = u.id;
   try {
-    const d = (await b({
-      promptText: kt,
-      schema: Gt,
+    const d = (await v({
+      promptText: ct,
+      schema: dt,
       modelTier: "fast",
       inputVariables: {
-        groupTitle: e
+        groupTitle: a
       }
     })).successMessage.trim();
     if (d)
       return {
         status: "success",
         outputMessage: d,
-        sharedStatePatch: { createdGroupId: { value: o } },
-        createdGroupId: o
+        sharedStatePatch: { createdGroupId: { value: l } },
+        createdGroupId: l
       };
-  } catch (u) {
-    console.error("Error generating create-group success message:", u);
+  } catch (c) {
+    console.error("Error generating create-group success message:", c);
   }
   return {};
-}, kt = `
-Write a concise, friendly success message after creating a portal group.
-
-Rules:
-- Mention that the group was created successfully.
-- Mention that the user can add members by using @mention usernames.
-- Keep it to 1-2 short sentences.
-- Make sure to bold the group title in the message.
-
-Group title:
-{groupTitle}
-`, qt = `
-Write a concise, friendly failure message after an attempt to create a portal group.
-
-Rules:
-- Keep it to 1-2 short sentences.
-- Use plain text only.
-- Mention that group creation failed.
-- Include the failure reason in user-friendly language.
-- End with a clear next step the user can try.
-
-Group title:
-{groupTitle}
-
-Failure reason:
-{failureReason}
-`, Dt = n.object({
-  intent: n.enum(["clarify", "create", "addMembers"]).default("clarify"),
-  title: n.string().default(""),
-  memberIdentifiers: n.array(n.string()).default([]),
-  clarifyMessage: n.string().default("")
-}), Rt = async (s, t) => {
-  await g({ text: "Thinking about groups...", agentName: "group-creation" }, t);
-  const e = x(s.agentExecutionContext.messages).trim(), a = await b({
-    promptText: Ut,
-    schema: Dt,
-    modelTier: "default",
-    inputVariables: { userMessage: e }
-  }), r = a.title.trim(), l = a.memberIdentifiers.filter(Boolean), c = a.clarifyMessage.trim(), i = a.intent === "create" && !!r, o = a.intent === "addMembers" && l.length > 0;
-  return {
-    intentParams: i ? { intent: "create", title: r } : o ? { intent: "addMembers", memberInfo: { memberIdentifiers: l } } : { intent: "clarify" },
-    status: "success",
-    outputMessage: !i && !o ? c : ""
-  };
-}, Ut = `
+}, I = (e) => {
+  for (let t = e.length - 1; t >= 0; t -= 1) {
+    const a = e[t];
+    if (a.type !== "human")
+      continue;
+    const n = a.content;
+    if (typeof n == "string")
+      return n;
+    if (Array.isArray(n))
+      return n.map(
+        (r) => typeof r == "string" ? r : "text" in r && typeof r.text == "string" ? r.text : ""
+      ).join(" ").trim();
+  }
+  return "";
+}, gt = `
 You classify whether a user is asking to create a new ArcGIS Portal group or add members to an existing group.
 
 Rules:
@@ -470,186 +270,230 @@ Examples:
 
 User message:
 {userMessage}
-`, zt = n.discriminatedUnion("destinationType", [
-  n.object({
-    destinationType: n.literal("portal-content")
-  }),
-  n.object({
-    destinationType: n.literal("portal-groups")
-  }),
-  n.object({
-    destinationType: n.literal("portal-item"),
-    itemId: n.string().trim().min(1)
-  }),
-  n.object({
-    destinationType: n.literal("portal-group"),
-    groupId: n.string().trim().min(1)
-  })
-]);
-function jt(s) {
-  const t = zt.safeParse(s);
-  return t.success ? t.data : void 0;
-}
-const _ = "portal-navigation", J = async (s, t) => {
-  await B({ type: _, data: { ...s } }, t);
-}, Vt = async (s, t) => {
-  const e = s.createdGroupId ?? s.agentExecutionContext.sharedState.createdGroupId?.value;
-  return e ? (await g({ text: "Preparing navigation...", agentName: "group-creation" }, t), await J({ destinationType: "portal-group", groupId: e }, t), {}) : {};
-}, z = (s, t) => t ?? s, Y = h.Root({
-  ...E(),
+`, ht = s.object({
+  intent: s.enum(["clarify", "create", "addMembers"]).default("clarify"),
+  title: s.string().default(""),
+  memberIdentifiers: s.array(s.string()).default([]),
+  clarifyMessage: s.string().default("")
+}), ft = async (e, t) => {
+  await m({ text: "Thinking about groups...", agentName: "group-creation" }, t);
+  const a = I(e.agentExecutionContext.messages).trim(), n = await v({
+    promptText: gt,
+    schema: ht,
+    modelTier: "default",
+    inputVariables: { userMessage: a }
+  }), r = n.title.trim(), o = n.memberIdentifiers.filter(Boolean), u = n.clarifyMessage.trim(), i = n.intent === "create" && !!r, l = n.intent === "addMembers" && o.length > 0;
+  return {
+    intentParams: i ? { intent: "create", title: r } : l ? { intent: "addMembers", memberInfo: { memberIdentifiers: o } } : { intent: "clarify" },
+    status: "success",
+    outputMessage: !i && !l ? u : ""
+  };
+}, yt = ["favorites", "group", "living-atlas", "org"], wt = ["featured", "my", "organization"], bt = ["licenses", "members", "overview", "reports", "settings", "status"], vt = s.object({
+  destinationType: s.literal("portal-content"),
+  hash: s.enum(yt).optional(),
+  t9nKey: s.string().min(1).optional()
+}), It = s.object({
+  destinationType: s.literal("portal-groups"),
+  hash: s.enum(wt).optional(),
+  t9nKey: s.string().min(1).optional()
+}), xt = s.object({
+  destinationType: s.literal("portal-org"),
+  hash: s.enum(bt).optional(),
+  t9nKey: s.string().min(1).optional()
+}), St = s.object({
+  destinationType: s.literal("portal-item"),
+  itemId: s.string().trim().min(1),
+  t9nKey: s.string().min(1).optional()
+}), Tt = s.object({
+  destinationType: s.literal("portal-group"),
+  groupId: s.string().trim().min(1),
+  t9nKey: s.string().min(1).optional()
+}), Mt = s.object({
+  destinationType: s.union([
+    s.literal("portal-gallery"),
+    s.literal("portal-map-viewer"),
+    s.literal("portal-notebooks"),
+    s.literal("portal-scene-viewer")
+  ]),
+  t9nKey: s.string().min(1).optional()
+}), Ct = s.union([
+  vt,
+  It,
+  xt,
+  St,
+  Tt,
+  Mt
+]), be = "portal-navigation", D = async (e, t) => {
+  const a = t?.configurable?.context;
+  !we(a) || !a.navigationTargetMap?.[e.destinationType] || await B({ type: be, data: { ...e } }, t);
+}, Gt = async (e, t) => {
+  const a = e.createdGroupId ?? e.agentExecutionContext.sharedState.createdGroupId?.value;
+  return a ? (await m({ text: "Preparing navigation...", agentName: "group-creation" }, t), await D({ destinationType: "portal-group", groupId: a }, t), {}) : {};
+}, te = (e, t) => t ?? e, ve = h.Root({
+  ...N(),
   // * Shared state between nodes (but not persisted to the agent execution context)
   /** Parameters related to the user's intent for group creation actions */
-  intentParams: h({ reducer: z, default: () => ({ intent: "clarify" }) }),
+  intentParams: h({ reducer: te, default: () => ({ intent: "clarify" }) }),
   /** The ID of the group that was created
    * even though we already have this in the shared state
    * we still need it here to also share between nodes
    */
-  createdGroupId: h({ reducer: z, default: () => "" })
-}), Ft = () => new $(Y).addNode("detectGroupCreationIntent", Rt).addNode("createPortalGroup", Nt).addNode("addMembersToPortalGroup", Ct).addNode("suggestCreatedGroupNavigation", Vt).addEdge(G, "detectGroupCreationIntent").addConditionalEdges("detectGroupCreationIntent", (t) => {
+  createdGroupId: h({ reducer: te, default: () => "" })
+}), At = () => new G(ve).addNode("detectGroupCreationIntent", ft).addNode("createPortalGroup", mt).addNode("addMembersToPortalGroup", ut).addNode("suggestCreatedGroupNavigation", Gt).addEdge(A, "detectGroupCreationIntent").addConditionalEdges("detectGroupCreationIntent", (t) => {
   switch (t.intentParams.intent) {
     case "create":
       return "createPortalGroup";
     case "addMembers":
       return "addMembersToPortalGroup";
     default:
-      return y;
+      return w;
   }
-}).addEdge("createPortalGroup", "suggestCreatedGroupNavigation").addEdge("addMembersToPortalGroup", "suggestCreatedGroupNavigation").addEdge("suggestCreatedGroupNavigation", y), Bt = String.raw`- **portal-group-creation** - Portal group creation assistant:
+}).addEdge("createPortalGroup", "suggestCreatedGroupNavigation").addEdge("addMembersToPortalGroup", "suggestCreatedGroupNavigation").addEdge("suggestCreatedGroupNavigation", w), Nt = String.raw`- **portal-group-creation** - Portal group creation assistant:
   - creates a new ArcGIS Portal group for the signed-in user
   - adds users to the newly created group using @mention usernames
-`, Lt = {
+`, Pt = {
   id: "portal-group-creation",
   name: "Portal Group Creation",
-  description: Bt,
-  createGraph: Ft,
-  workspace: Y
-}, H = "portalDocAssistantMemory", Qt = () => ({ conversationId: "" }), Kt = (s) => {
-  const t = s?.[H]?.value;
+  description: Nt,
+  createGraph: At,
+  workspace: ve
+}, Ie = "portalDocAssistantMemory", qt = () => ({ conversationId: "" }), Et = (e) => {
+  const t = e?.[Ie]?.value;
   if (!t || typeof t != "object")
-    return Qt();
-  const e = t;
+    return qt();
+  const a = t;
+  return {
+    conversationId: typeof a.conversationId == "string" ? a.conversationId : ""
+  };
+}, kt = (e) => ({
+  [Ie]: { value: e }
+}), zt = {
+  pipeline: {
+    follow_up: { allow: !1 }
+  }
+};
+function $t(e) {
   return {
-    conversationId: typeof e.conversationId == "string" ? e.conversationId : ""
+    kind: "DocAIAssistantRequest",
+    filters: {
+      ...zt,
+      persona: { persona: e }
+    }
   };
-}, Wt = (s) => ({
-  [H]: { value: s }
-});
-async function Ot({
-  portal: s,
+}
+async function Rt({
+  portal: e,
   question: t,
-  persona: e,
-  previousConversationId: a,
+  persona: a,
+  previousConversationId: n,
   signal: r,
-  skillId: l
+  skillId: o
 }) {
-  l ??= "doc_ai_assistant";
-  const i = await _t({
-    portal: s,
-    skillId: l,
+  o ??= "doc_ai_assistant";
+  const u = $t(a), i = await Dt({
+    portal: e,
+    skillId: o,
     message: t,
-    options: { context: {
-      kind: "DocAIAssistantRequest",
-      filters: { persona: { persona: e } }
-    }, previousConversationId: a, signal: r }
+    options: { context: u, previousConversationId: n, signal: r }
   });
   return {
-    reply: Jt(i, l),
+    reply: Ut(i, o),
     conversationId: i[0]?.conversationId ?? ""
   };
 }
-async function _t({
-  portal: s,
+async function Dt({
+  portal: e,
   skillId: t,
-  message: e,
-  options: a
+  message: a,
+  options: n
 }) {
-  const l = `${s.helperServices.aiAssistantServices.url}/skills/${t}/chat`, c = {
+  const o = `${e.helperServices.aiAssistantServices.url}/skills/${t}/chat`, u = {
     "Content-Type": "application/json",
-    token: mt.findCredential(s.url)?.token ?? ""
-  }, i = await k(l, {
+    token: Je.findCredential(e.url)?.token ?? ""
+  }, i = await Y(o, {
     method: "post",
     body: JSON.stringify({
-      message: e,
-      context: a.context,
-      conversationId: a.previousConversationId
+      message: a,
+      context: n.context,
+      conversationId: n.previousConversationId
     }),
-    headers: c,
-    signal: a.signal
+    headers: u,
+    signal: n.signal
   });
   if (i.httpStatus !== 200)
     throw new Error(`Doc assistant chat failed (${i.httpStatus})`, {
       cause: i.data
     });
-  const o = i.data, u = [o], { conversationId: d, inquiryId: p } = o, m = async (f, v) => {
-    if (!v)
+  const l = i.data, c = [l], { conversationId: d, inquiryId: g } = l, p = async (f, y) => {
+    if (!y)
       return;
-    await ot(1e3);
-    const S = await k(l, {
+    await _e(500);
+    const x = await Y(o, {
       method: "post",
-      body: JSON.stringify({ conversationId: d, inquiryId: p, ackSequenceNumber: f }),
-      headers: c,
-      signal: a.signal
+      body: JSON.stringify({ conversationId: d, inquiryId: g, ackSequenceNumber: f }),
+      headers: u,
+      signal: n.signal
     });
-    if (S.httpStatus !== 200)
-      throw new Error(`Doc assistant poll failed (${S.httpStatus})`, {
-        cause: S.data
+    if (x.httpStatus !== 200)
+      throw new Error(`Doc assistant poll failed (${x.httpStatus})`, {
+        cause: x.data
       });
-    const A = S.data;
-    u.push(A), await m(A.sequenceNumber, A.hasMore);
+    const M = x.data;
+    c.push(M), await p(M.sequenceNumber, M.hasMore);
   };
-  return o.hasMore && await m(o.sequenceNumber, o.hasMore), u;
+  return l.hasMore && await p(l.sequenceNumber, l.hasMore), c;
 }
-function Jt(s, t) {
+function Ut(e, t) {
   switch (t) {
     case "doc_chat":
-      return s.find((e) => e.message != null)?.message ?? "";
+      return e.find((a) => a.message != null)?.message ?? "";
     case "doc_ai_assistant":
-      for (let e = s.length - 1; e >= 0; e -= 1) {
-        const a = s[e];
-        if (a.context?.kind === "DocAIAssistantContext") {
-          const r = a.context.results?.[0]?.reply;
+      for (let a = e.length - 1; a >= 0; a -= 1) {
+        const n = e[a];
+        if (n.context?.kind === "DocAIAssistantContext") {
+          const r = n.context.results?.[0]?.reply;
           if (r)
             return r;
         }
       }
       return "";
     default:
-      return P(t);
+      return R(t);
   }
 }
-const Yt = async (s, t) => {
-  await g({ text: "Asking documentation assistant...", agentName: "doc-assistant" }, t);
-  const e = x(s.agentExecutionContext.messages).trim();
-  if (!e)
+const Ft = async (e, t) => {
+  await m({ text: "Asking documentation assistant...", agentName: "doc-assistant" }, t);
+  const a = I(e.agentExecutionContext.messages).trim();
+  if (!a)
     return {
       status: "success",
       outputMessage: "Please share your question and I can help with ArcGIS and Portal documentation."
     };
-  const a = t?.configurable?.context;
-  I(a);
-  const r = Kt(s.agentExecutionContext.sharedState), { reply: l, conversationId: c } = await Ot({
-    portal: a.portal,
-    question: e,
+  const n = t?.configurable?.context;
+  T(n);
+  const r = Et(e.agentExecutionContext.sharedState), { reply: o, conversationId: u } = await Rt({
+    portal: n.portal,
+    question: a,
     previousConversationId: r.conversationId || void 0,
     skillId: "doc_ai_assistant",
-    persona: "developers"
+    persona: "doc-online"
   });
   return {
     status: "success",
-    outputMessage: l.trim() || "I could not retrieve a response from the documentation assistant.",
-    sharedStatePatch: Wt({
-      conversationId: c || r.conversationId
+    outputMessage: o.trim() || "I could not retrieve a response from the documentation assistant.",
+    sharedStatePatch: kt({
+      conversationId: u || r.conversationId
     })
   };
-}, Ht = K(
-  async ({ groupTitle: s }, t) => {
-    const e = s.trim();
-    if (!e)
+}, xe = ye(
+  async ({ groupTitle: e }, t) => {
+    const a = e.trim();
+    if (!a)
       return null;
-    const a = t?.configurable?.context;
-    I(a);
+    const n = t?.configurable?.context;
+    T(n);
     try {
-      return (await ut(a.portal, { query: `title:${e}`, num: 1 }))?.results[0]?.id || null;
+      return (await We(n.portal, { query: `title:${a}`, num: 1 }))?.results[0]?.id || null;
     } catch (r) {
       return console.error("Error searching for portal group by title:", r), null;
     }
@@ -657,198 +501,1530 @@ const Yt = async (s, t) => {
   {
     name: "resolvePortalGroupIdByTitle",
     description: "Resolves an ArcGIS Portal group title to the best-match group id. Use this when a user references a group by title instead of an explicit group id.",
-    schema: n.object({
-      groupTitle: n.string().describe("The portal group title to resolve to a group id.")
+    schema: s.object({
+      groupTitle: s.string().describe("The portal group title to resolve to a group id.")
     })
   }
-), j = n.object({
-  shouldSuggestNavigation: n.boolean().default(!1),
-  destinationType: n.enum(["none", "portal-content", "portal-item", "portal-groups", "portal-group"]).default("none"),
-  itemId: n.string().default(""),
-  groupId: n.string().default("")
-}), Xt = async (s, t) => {
-  await g({ text: "Extracting navigation intent...", agentName: "doc-assistant" }, t);
-  const e = s.outputMessage.trim();
-  if (!e)
-    return {};
-  const a = x(s.agentExecutionContext.messages).trim(), r = await L.fromTemplate(te).format({
-    question: a,
-    response: e
-  }), c = await Q({
-    model: await F({ modelTier: "default" }),
-    tools: [W, Ht],
-    systemPrompt: r,
-    responseFormat: j,
-    checkpointer: !0
-  }).invoke({ messages: s.agentExecutionContext.messages }, t), i = j.parse(c.structuredResponse ?? {});
-  if (!i.shouldSuggestNavigation || i.destinationType === "none")
-    return {};
-  const o = Zt(i);
-  return o ? (await J(o, t), {}) : {};
-};
-function Zt({
-  destinationType: s,
-  itemId: t,
-  groupId: e
-}) {
-  switch (s) {
-    case "portal-content":
-      return { destinationType: "portal-content" };
-    case "portal-groups":
-      return { destinationType: "portal-groups" };
-    case "portal-item":
-      return t ? { destinationType: "portal-item", itemId: t } : null;
-    case "portal-group":
-      return e ? { destinationType: "portal-group", groupId: e } : null;
-    case "none":
+), Se = ye(
+  async ({ itemTitle: e }, t) => {
+    const a = e.trim();
+    if (!a)
       return null;
-    default:
-      return P(s);
+    const n = t?.configurable?.context;
+    T(n);
+    const { result: r, error: o } = await He(n.portal, a, { num: 1 });
+    return o && console.error("Error searching for portal item by title:", o), r?.results[0]?.id || null;
+  },
+  {
+    name: "resolvePortalItemIdByTitle",
+    description: 'Resolves an ArcGIS Portal item title to the best-match item id. Use this when a user references an item by title (including hash mentions like #title or #"title with spaces") instead of an explicit item id.',
+    schema: s.object({
+      itemTitle: s.string().describe("The portal item title to resolve to an item id.")
+    })
   }
+);
+function C(e, t = "#") {
+  const a = e.match(new RegExp(`\\${t}"([^"]+)"`, "u"));
+  if (a?.[1])
+    return a[1].trim();
+  const n = e.match(new RegExp(`\\${t}([^\\s"']+)`, "u"));
+  return n?.[1] ? n[1].trim() : null;
 }
-const te = `
+const Te = {
+  "portal-content": {
+    description: "The main content page of the portal.",
+    hints: ["My content", "Content"]
+  },
+  "portal-content-favorites": {
+    description: "The Favorites view under Content in the portal.",
+    hints: ["My favorites", "Favorites", "Content favorites"]
+  },
+  "portal-content-group": {
+    description: "The Groups view under Content in the portal.",
+    hints: ["Content groups", "Group content", "My groups content"]
+  },
+  "portal-content-living-atlas": {
+    description: "The Living Atlas view under Content in the portal.",
+    hints: ["Living Atlas", "Content living atlas"]
+  },
+  "portal-content-organization": {
+    description: "The Organization view under Content in the portal.",
+    hints: ["Organization content", "Content organization", "My organization content"]
+  },
+  "portal-gallery": {
+    description: "The gallery page of the portal.",
+    hints: ["Gallery", "Featured content", "Maps and apps"]
+  },
+  "portal-group": {
+    description: "A specific group page in the portal.",
+    hints: ["Group", "group page"]
+  },
+  "portal-groups": {
+    description: "The groups listing page of the portal.",
+    hints: ["Groups", "Browse groups"]
+  },
+  "portal-groups-featured": {
+    description: "The Featured groups view under Groups in the portal.",
+    hints: ["Featured groups", "Groups featured"]
+  },
+  "portal-groups-my": {
+    description: "The My groups view under Groups in the portal.",
+    hints: ["My groups", "Groups my"]
+  },
+  "portal-groups-organization": {
+    description: "The Organization groups view under Groups in the portal.",
+    hints: ["Organization groups", "Groups organization", "My organization groups"]
+  },
+  "portal-item": {
+    description: "A specific item page in the portal.",
+    hints: ["Item", "item page"]
+  },
+  "portal-map-viewer": {
+    description: "The Map Viewer app of the portal.",
+    hints: ["Map Viewer", "Map", "Open map"]
+  },
+  "portal-notebooks": {
+    description: "The Notebooks home page of the portal.",
+    hints: ["Notebooks", "Notebook home", "My notebooks"]
+  },
+  "portal-scene-viewer": {
+    description: "The Scene Viewer app of the portal.",
+    hints: ["Scene Viewer", "Scene", "3D scene"]
+  },
+  "portal-org-security": {
+    description: "The Organization > Settings > Security page of the portal.",
+    hints: ["Organization settings", "Security", "Organization > Settings > Security"]
+  }
+}, Ot = Ye(Te), Kt = Object.entries(Te).map(([e, { description: t, hints: a }]) => `  - ${e}: ${t} (hints: ${a.join(", ")})`).join(`
+`), Vt = `
 You decide whether the assistant response should include a navigation action to ArcGIS Portal.
 
 Given the user question and assistant response:
 - Decide if a navigation action would help the user complete the task.
-- If yes, choose one destination type:
-  - portal-content: portal content page
-  - portal-groups: groups listing page
-  - portal-item: specific item page (requires itemId)
-  - portal-group: specific group page (requires groupId)
+- If yes, choose one destinationType:
+${Kt}
 
 Rules:
+- Only suggest navigation when you are highly confident the destination will help complete the user's task.
+- If confidence is below 0.85, set shouldSuggestNavigation=false and destinationType=none.
+- If there is no clear destination from the allowed types, set shouldSuggestNavigation=false and destinationType=none.
 - If no navigation is useful, set shouldSuggestNavigation=false and destinationType=none.
-- If destinationType is portal-item and user references an item by title (for example #title, #"title with spaces", or plain quoted title), call resolvePortalItemIdByTitle and set itemId from the tool result.
-- If destinationType is portal-group and user references a group by title (for example $title, $"title with spaces", or plain quoted group title), call resolvePortalGroupIdByTitle and set groupId from the tool result.
-- Do not invent itemId.
-- Do not invent groupId.
-- Prefer destinationType=portal-content for generic "go to content" guidance.
+- Prefer the most specific destination that is clearly supported by the question and response.
+- Use entity-level destinations over collection/root destinations when both could apply and the entity target is explicit.
+- Use collection/root destinations only for generic browsing intent with no specific entity target.
+- If a chosen destination requires parameters, include all required parameters.
+- If required parameters are missing or uncertain, set shouldSuggestNavigation=false and destinationType=none.
+- Do not invent required parameters.
+- Always include a confidence score from 0 to 1 in the output.
+- Confidence means confidence that a navigation suggestion should be shown to the user.
+- If shouldSuggestNavigation=false or destinationType=none, confidence must be <= 0.5.
+- Use confidence >= 0.85 only when shouldSuggestNavigation=true and destinationType is not none.
 
 User question:
 {question}
 
 Assistant response:
 {response}
-`, X = dt.Root({
-  ...E()
-}), ee = () => new $(X).addNode("answerDocQuestion", Yt).addNode("extractNavigationIntent", Xt).addEdge(G, "answerDocQuestion").addEdge("answerDocQuestion", "extractNavigationIntent").addEdge("extractNavigationIntent", y), se = String.raw`- **portal-doc-assistant** - General ArcGIS documentation and Portal help assistant:
-  - answers general ArcGIS, Portal, Enterprise, and JavaScript SDK questions
-  - acts as a fallback when specialized agents are not applicable
-`, ae = {
-  id: "portal-doc-assistant",
-  name: "Portal Doc Assistant",
-  description: se,
-  createGraph: ee,
-  workspace: X
-}, re = st`:host{height:100%;border-width:1px;border-style:solid;border-color:var(--calcite-color-border-3);display:block;width:100%;--tw-shadow: 0 1px 6px -1px rgba(0, 0, 0, .16), 0 1px 2px -1px rgba(0, 0, 0, .08);--tw-shadow-colored: 0 1px 6px -1px var(--tw-shadow-color), 0 1px 2px -1px var(--tw-shadow-color);box-shadow:var(--tw-ring-offset-shadow, 0 0 #0000),var(--tw-ring-shadow, 0 0 #0000),var(--tw-shadow)}.chat-entry{display:flex;flex-direction:column;gap:.75rem;width:100%}.chat-actions{display:flex;justify-content:flex-end;gap:.5rem}.header-actions{display:flex;gap:.5rem;padding-inline-start:.75rem}.navigation-block{display:flex;flex-direction:column;align-items:stretch;gap:.35rem;margin-top:.5rem}.navigation-button{width:100%;margin-block:.25rem}.navigation-block-description{font-size:.75rem;color:var(--calcite-color-text-3)}`, oe = (s, t) => {
-  const { destinationType: e } = s, a = `${t.url}/home`;
-  switch (e) {
-    case "portal-content":
-      return `${a}/content.html`;
-    case "portal-groups":
-      return `${a}/groups.html`;
-    case "portal-item":
-      return `${a}/item.html?id=${s.itemId}`;
+`, ae = s.object({
+  shouldSuggestNavigation: s.boolean().default(!1),
+  destinationType: s.enum(["none", ...Ot]).default("none"),
+  itemId: s.string().default(""),
+  groupId: s.string().default(""),
+  confidence: s.number().min(0).max(1).default(0)
+}), jt = async (e, t) => {
+  await m({ text: "Extracting navigation intent...", agentName: "doc-assistant" }, t);
+  const a = e.outputMessage.trim();
+  if (!a)
+    return {};
+  const n = I(e.agentExecutionContext.messages).trim(), r = await W.fromTemplate(Vt).format({
+    question: n,
+    response: a
+  }), u = (await Q({ modelTier: "fast" })).withStructuredOutput(ae), i = ae.parse(await u.invoke(r));
+  if (!i.shouldSuggestNavigation || i.destinationType === "none")
+    return {};
+  if (i.destinationType === "portal-item" && !i.itemId) {
+    const c = C(n, "#");
+    c && (i.itemId = await Se.invoke({ itemTitle: c }, t) ?? "");
+  }
+  if (i.destinationType === "portal-group" && !i.groupId) {
+    const c = C(n, "$") ?? C(n, "#");
+    c && (i.groupId = await xe.invoke({ groupTitle: c }, t) ?? "");
+  }
+  const l = Lt(i);
+  return l ? (await D(l, t), {}) : {};
+};
+function Lt({
+  destinationType: e,
+  itemId: t,
+  groupId: a
+}) {
+  switch (e) {
+    case "portal-content":
+    case "portal-gallery":
+    case "portal-groups":
+    case "portal-map-viewer":
+    case "portal-notebooks":
+    case "portal-scene-viewer":
+      return { destinationType: e };
+    case "portal-org-security":
+      return { destinationType: "portal-org", hash: "settings" };
+    case "portal-content-favorites":
+      return { destinationType: "portal-content", hash: "favorites" };
+    case "portal-content-group":
+      return { destinationType: "portal-content", hash: "group" };
+    case "portal-content-living-atlas":
+      return { destinationType: "portal-content", hash: "living-atlas" };
+    case "portal-content-organization":
+      return { destinationType: "portal-content", hash: "org" };
+    case "portal-groups-featured":
+      return { destinationType: "portal-groups", hash: "featured" };
+    case "portal-groups-my":
+      return { destinationType: "portal-groups", hash: "my" };
+    case "portal-groups-organization":
+      return { destinationType: "portal-groups", hash: "organization" };
+    case "portal-item":
+      return t ? { destinationType: e, itemId: t } : null;
+    case "portal-group":
+      return a ? { destinationType: e, groupId: a } : null;
+    case "none":
+      return null;
+    default:
+      return R(e);
+  }
+}
+const Me = h.Root({
+  ...N()
+}), Bt = () => new G(Me).addNode("answerDocQuestion", Ft).addNode("extractNavigationIntent", jt).addEdge(A, "answerDocQuestion").addEdge("answerDocQuestion", "extractNavigationIntent").addEdge("extractNavigationIntent", w), Qt = String.raw`- **portal-doc-assistant** - General ArcGIS documentation and Portal help assistant:
+  - answers general ArcGIS, Portal, Enterprise, and JavaScript SDK questions
+  - acts as a fallback when specialized agents are not applicable
+`, Wt = {
+  id: "portal-doc-assistant",
+  name: "Portal Doc Assistant",
+  description: Qt,
+  createGraph: Bt,
+  workspace: Me
+}, Jt = () => ({ latestGroupId: null, memory: {} }), U = (e) => {
+  const t = e?.agentExecutionContext.sharedState.portalGroupSummaryMemory?.value;
+  return t ? { latestGroupId: t.latestGroupId, memory: t.memory } : Jt();
+}, Ce = `
+Shared markdown formatting rules:
+- Use clear markdown headings (##) to separate sections.
+- Use concise bullet points for lists of facts, counts, or signals.
+- Emphasize key metrics with bold labels (for example: **Recent items:** 4).
+- Keep wording direct and analytical; avoid filler language but make sure the language is friendly.
+- Do not include raw internal IDs unless explicitly requested.
+`, _t = `
+You answer follow-up questions about ArcGIS group analytics.
+
+${Ce}
+
+Ground your answer in the provided group analytics summary and context.
+If the answer is not available from the provided context, state that clearly and suggest what to check next.
+
+Response rules:
+- Reply in concise markdown with this section structure:
+  1) ## Answer
+  2) ## Evidence
+  3) ## Gaps (only when data is missing)
+- Keep the answer focused on the follow-up question.
+- Do not include internal identifiers.
+- Mark isRelevant=false when the question is not about this group or cannot be grounded in this group context.
+
+Group analytics summary:
+{summary}
+
+Group full context:
+{fullContext}
+
+Question:
+{question}
+`, Yt = async (e, t) => {
+  await m({ text: "Answering group follow-up...", agentName: "group-analytics" }, t);
+  const a = U(e), n = e.groupSummaryGroupId ?? a.latestGroupId, r = n ? a.memory[n] : void 0, o = e.groupSummaryQuestion || I(e.agentExecutionContext.messages);
+  return r ? {
+    status: "success",
+    outputMessage: (await v({
+      promptText: _t,
+      schema: Ht,
+      modelTier: "default",
+      inputVariables: {
+        summary: r.summary,
+        question: o,
+        fullContext: JSON.stringify(r.fullContext)
+      }
+    })).answer
+  } : {
+    status: "success",
+    outputMessage: "I do not have group analytics context yet. Ask me to analyze a group first with analyze group <group id>."
+  };
+}, Ht = s.object({
+  answer: s.string(),
+  isRelevant: s.boolean()
+}), Xt = `
+Classify the user's request for ArcGIS Portal group analytics.
+
+Rules:
+- intent="summarize" only when the user explicitly asks to summarize, analyze, overview, or recap a group.
+- intent="followUp" for follow-up questions about a previously analyzed group.
+- intent="navigation" when the user asks to open, go to, navigate to, or view the group page.
+- intent="clarify" when intent or required group target is missing.
+- groupId must be the final resolved group id.
+- If request has explicit group id, set groupId directly.
+- If request references group title (for example $title, $"title with spaces", or plain quoted group title), call resolvePortalGroupIdByTitle and set groupId to the tool result.
+- Never return group titles in output fields.
+- If intent is "followUp", set question to the user's full question/request text.
+- If intent is "navigation", set question="".
+- If intent is "summarize", set question="".
+- If intent is "navigation" and no group is specified, leave groupId empty so the system can navigate to the groups listing page.
+- If hasAnalyticsContext is true and the user asks about the same group context without an explicit summarize/analyze command, prefer "followUp".
+
+Examples:
+- "Analyze group 0123456789abcdef0123456789abcdef" => summarize, groupId="0123456789abcdef0123456789abcdef"
+- "Analyze group $living atlas" => summarize, call resolvePortalGroupIdByTitle("living atlas") and set groupId to tool result
+- "Analyze group $"living atlas basemaps"" => summarize, call resolvePortalGroupIdByTitle("living atlas basemaps") and set groupId to tool result
+- "Is this group active?" with hasAnalyticsContext=true => followUp
+
+hasAnalyticsContext:
+{hasAnalyticsContext}
+
+User message:
+{userMessage}
+`, Zt = async (e, t) => {
+  await m({ text: "Analyzing group-analytics intent...", agentName: "group-analytics" }, t);
+  const a = I(e.agentExecutionContext.messages), n = !!U(e).latestGroupId, r = await W.fromTemplate(Xt).format({
+    userMessage: a,
+    hasAnalyticsContext: String(n)
+  }), u = (await Q({ modelTier: "fast" })).withStructuredOutput(ne), i = ne.parse(await u.invoke(r));
+  let l = i.groupId;
+  if ((i.intent === "summarize" || i.intent === "navigation") && !l) {
+    const y = C(a, "$");
+    y && (l = await xe.invoke({ groupTitle: y }, t) ?? "");
+  }
+  const { intent: c, question: d } = i, g = c === "summarize" && !l, p = c === "followUp" && !(d ?? "").trim(), f = c === "clarify" || g || p;
+  return {
+    groupSummaryIntent: f ? "clarify" : c,
+    groupSummaryGroupId: l || null,
+    groupSummaryQuestion: d || "",
+    status: "success",
+    outputMessage: f ? "Please clarify with a group id or title" : ""
+  };
+}, ne = s.object({
+  intent: s.enum(["summarize", "followUp", "navigation", "clarify"]),
+  groupId: s.string().default(""),
+  question: s.string().default("")
+}), ea = async (e, t) => {
+  const a = U(e), n = e.groupSummaryGroupId ?? a.latestGroupId;
+  return await m({ text: "Preparing navigation...", agentName: "group-analytics" }, t), await D(
+    n ? { destinationType: "portal-group", groupId: n } : { destinationType: "portal-groups" },
+    t
+  ), { status: "success" };
+};
+function Ge({ timestamp: e, now: t, windowMs: a }) {
+  return e ? t - e <= a : !1;
+}
+const ta = 720 * 60 * 60 * 1e3;
+function aa(e) {
+  const t = Ze(e);
+  return {
+    id: e.id ?? "",
+    title: e.title ?? "",
+    description: e.description ?? "",
+    snippet: e.snippet ?? "",
+    access: e.access ?? null,
+    owner: e.owner ?? "",
+    tags: e.tags ?? [],
+    created: e.created?.getTime(),
+    modified: e.modified?.getTime(),
+    isInvitationOnly: e.isInvitationOnly,
+    sourceSignals: {
+      capabilities: nt(e),
+      membershipAccess: at(e),
+      isOpenData: tt(e),
+      isDistributedCollaborationGroup: et(e),
+      orgId: t.orgId,
+      hiddenMembers: t.hiddenMembers,
+      isViewOnly: t.isViewOnly,
+      isReadOnly: t.isReadOnly,
+      leavingDisallowed: t.leavingDisallowed
+    }
+  };
+}
+async function na(e) {
+  const t = { owner: e.owner ?? "", admins: [], users: [] };
+  try {
+    return await e.fetchMembers();
+  } catch (a) {
+    return console.warn("Unable to fetch group members for analytics context", a), t;
+  }
+}
+function ra(e) {
+  return e.map((t) => ({
+    id: t.id ?? "",
+    title: t.title ?? "Untitled",
+    type: t.type ?? "Unknown",
+    owner: t.owner ?? "",
+    created: t.created?.getTime(),
+    modified: t.modified?.getTime()
+  }));
+}
+function oa(e, t) {
+  return e.filter(
+    (a) => a.modified ? Ge({ timestamp: a.modified, now: t, windowMs: ta }) : !1
+  );
+}
+function sa(e) {
+  const t = /* @__PURE__ */ new Map();
+  for (const a of e)
+    t.set(a.type, (t.get(a.type) ?? 0) + 1);
+  return [...t.entries()].sort((a, n) => n[1] - a[1] || a[0].localeCompare(n[0])).slice(0, 6).map(([a, n]) => ({ type: a, count: n }));
+}
+async function ia(e) {
+  const t = await e.queryItems({ num: 20, sortField: "modified", sortOrder: "desc" }), a = ra(t.results), n = Date.now();
+  return {
+    total: t.total,
+    topItems: a,
+    recentlyModifiedItems: oa(a, n),
+    topItemTypes: sa(a)
+  };
+}
+async function ua(e, t) {
+  if (!t)
+    return { error: { code: "missingGroupId", message: "Group id is required." } };
+  try {
+    const n = (await e.queryGroups({ query: `id:${t}`, num: 1 })).results[0];
+    if (!n)
+      return { error: { code: "groupNotFound", message: `No group found for id: ${t}` } };
+    const r = aa(n), o = await na(n), u = await ia(n);
+    return { result: { group: r, members: o, items: u } };
+  } catch (a) {
+    return console.error("Error fetching portal group analytics context:", a), { error: { code: "unhandledError" } };
+  }
+}
+const ca = `
+You summarize ArcGIS Portal groups based on structured context and deterministic activity signals.
+
+${Ce}
+
+Output format requirements:
+- Return concise markdown with clear sections in this order:
+  1) Overview
+  2) Activity
+  3) Members
+  4) Content Theme
+  5) Contribution Model
+  6) Unknowns / Data Gaps
+- Keep total response about 180-280 words unless the user asked for extra detail.
+- Avoid internal-only implementation details and do not expose raw IDs unless user explicitly asks.
+
+Reasoning rules:
+- Use deterministicSignals as the source of truth for active/recent status.
+- If group description/snippet are empty, infer purpose from tags, item title patterns, and item type distribution.
+- For members, report owner/admin/user counts when available; if unavailable due to permission scope, explicitly say so.
+- For contribution model, use membershipAccess, capabilities, and sourceJSON flags to characterize collaboration vs distribution behavior.
+- Be explicit when signals are heuristic or unavailable.
+
+Follow-up prompt rules:
+- Generate exactly 3 follow-up prompts.
+- Write them as direct first-person user chat prompts that can be clicked and sent as-is.
+- Do not write meta-questions such as "Would you like..." or "Do you want me to...".
+- Keep each prompt short, specific, and actionable.
+- Every prompt must be answerable using only the provided group context and deterministic signals.
+- Do not require external data, navigation, or additional fetches.
+- Tailor each prompt to this specific group's available signals (content mix, activity, members, and contribution model).
+- Avoid repeating phrasing from prior prompts or using generic template wording.
+- If a signal is unavailable (for example members), do not ask follow-ups that depend on that missing signal.
+
+Group context:
+{context}
+
+Deterministic signals:
+{deterministicSignals}
+`, la = 2160 * 60 * 60 * 1e3, da = async (e, t) => {
+  const a = e.groupSummaryGroupId;
+  if (!a)
+    return {
+      status: "success",
+      outputMessage: 'Please clarify with analyze group <group id>, analyze group $<title>, or analyze group $"<title with spaces>".'
+    };
+  await m({ text: `Analyzing group ${a}...`, agentName: "group-analytics" }, t);
+  const n = t?.configurable?.context;
+  T(n);
+  const { result: r, error: o } = await ua(n.portal, a);
+  if (o || !r)
+    return await m({ text: "Failed to fetch group context", agentName: "group-analytics" }, t), {
+      status: "success",
+      outputMessage: "Unable to retrieve group context for analytics."
+    };
+  const { group: u, items: i } = r, l = Date.now(), c = u.modified, d = c ? Ge({ timestamp: c, now: l, windowMs: la }) : !1, g = i.recentlyModifiedItems.length, p = g > 0, f = d || p, y = await v({
+    promptText: ca,
+    schema: pa,
+    modelTier: "default",
+    inputVariables: {
+      context: JSON.stringify(r),
+      deterministicSignals: JSON.stringify({
+        isGroupActive: f,
+        isGroupRecentlyModified: d,
+        hasRecentlyAddedOrUpdatedContent: p,
+        recentItemCount: g
+      })
+    }
+  }), { followUpQuestions: x, summary: M } = y, Re = U(e), De = {
+    latestGroupId: a,
+    memory: {
+      ...Re.memory,
+      [a]: { summary: M, followUpQuestions: x, fullContext: r }
+    }
+  };
+  return x.length && await B({ type: "suggested-prompts", data: { prompts: x } }, t), {
+    status: "success",
+    outputMessage: M,
+    sharedStatePatch: { portalGroupSummaryMemory: { value: De } }
+  };
+}, pa = s.object({
+  summary: s.string(),
+  followUpQuestions: s.array(s.string()).default([])
+}), F = (e, t) => t ?? e, Ae = h.Root({
+  ...N(),
+  groupSummaryIntent: h({
+    reducer: F,
+    default: () => "clarify"
+  }),
+  groupSummaryGroupId: h({
+    reducer: F,
+    default: () => null
+  }),
+  groupSummaryQuestion: h({
+    reducer: F,
+    default: () => ""
+  })
+}), ma = () => new G(Ae).addNode("detectGroupSummaryIntent", Zt).addNode("summarizePortalGroup", da).addNode("answerGroupSummaryFollowUp", Yt).addNode("suggestGroupSummaryNavigation", ea).addEdge(A, "detectGroupSummaryIntent").addConditionalEdges("detectGroupSummaryIntent", (t) => t.groupSummaryIntent === "summarize" ? "summarizePortalGroup" : t.groupSummaryIntent === "followUp" ? "answerGroupSummaryFollowUp" : t.groupSummaryIntent === "navigation" ? "suggestGroupSummaryNavigation" : w).addEdge("summarizePortalGroup", w).addEdge("answerGroupSummaryFollowUp", w).addEdge("suggestGroupSummaryNavigation", w), ga = String.raw`- **portal-group-analytics** - Portal group analytics assistant:
+  - summarizes ArcGIS portal groups from group context and sourceJSON details
+  - answers follow-up questions grounded in the summarized group
+  - suggests navigation to groups when relevant
+`, ha = {
+  id: "portal-group-analytics",
+  name: "Portal Group Analytics",
+  description: ga,
+  createGraph: ma,
+  workspace: Ae
+}, fa = () => ({ latestItemId: null, memory: {} }), J = (e) => {
+  const t = e?.agentExecutionContext.sharedState.portalItemAnalyticsSummaryMemory?.value;
+  return t ? { latestItemId: t.latestItemId, memory: t.memory } : fa();
+}, re = s.object({
+  intent: s.enum(["summarize", "followUp", "clarify"]),
+  itemId: s.string().default(""),
+  question: s.string().default("")
+}), ya = s.object({ summary: s.string(), followUpQuestions: s.array(s.string()).default([]) }), wa = s.object({ answer: s.string(), isRelevant: s.boolean() }), ba = `
+You answer follow-up questions about an ArcGIS item.
+
+Ground your answer in the provided item context.
+If the answer is not available from the provided context, state that clearly and suggest what to check next.
+
+Response rules:
+- Reply in concise markdown.
+- Keep the answer focused on the follow-up question.
+- Do not include internal identifiers.
+- Mark isRelevant=false when the question is not about this item or cannot be grounded in this item context.
+
+Item summary:
+{summary}
+
+Item full context
+{fullContext}
+
+Question:
+{question}
+`, va = async (e, t) => {
+  await m({ text: "Answering follow-up...", agentName: "analytics" }, t);
+  const a = J(e), n = e.analyticsItemId ?? a.latestItemId, r = n ? a.memory[n] : void 0, o = e.analyticsQuestion || I(e.agentExecutionContext.messages);
+  return r ? {
+    status: "success",
+    outputMessage: (await v({
+      promptText: ba,
+      schema: wa,
+      modelTier: "default",
+      inputVariables: {
+        summary: r.summary,
+        question: o,
+        fullContext: JSON.stringify(r.fullContext)
+      }
+    })).answer
+  } : {
+    status: "success",
+    outputMessage: "I don't have enough information yet. Please ask me to summarize the item first using summarize item <item id>."
+  };
+}, Ia = `
+Classify the user analytics request.
+
+Rules:
+- intent="summarize" only when the user explicitly asks to summarize/overview/recap an item.
+- intent="followUp" for analytical questions about item details, including schema/fields/attributes/layers.
+- intent="clarify" when neither summarize nor follow-up intent is clear.
+- itemId must be the final resolved item id.
+- If request has explicit item id, set itemId directly.
+- If request references item title (for example #title, #"title with spaces", or plain quoted title), call resolvePortalItemIdByTitle and set itemId to the returned value.
+- Never return item titles in output fields.
+- If intent is "followUp", set question to the user's full question/request text.
+- If intent is "summarize", set question="".
+- When user asks to show/list/explain fields, schema, attributes, columns, or layer details, classify as "followUp" unless they explicitly request a summary.
+- If hasSummaryContext is true, prefer "followUp" for detail-oriented requests that do not explicitly ask to summarize.
+
+Examples:
+- "Summarize item 0123456789abcdef0123456789abcdef" => summarize, itemId="0123456789abcdef0123456789abcdef"
+- "Summarize item #california" => summarize, call resolvePortalItemIdByTitle("california") and set itemId to tool result
+- "Summarize item #"california farmland"" => summarize, call resolvePortalItemIdByTitle("california farmland") and set itemId to tool result
+- "Show the layer's available fields" => followUp
+- "List attributes and explain what status means" => followUp
+- "What fields are available?" with hasSummaryContext=true => followUp
+- "Give me an overview of item 0123456789abcdef0123456789abcdef" => summarize
+
+hasSummaryContext:
+{hasSummaryContext}
+
+User message:
+{userMessage}
+`, xa = async (e, t) => {
+  await m({ text: "Analyzing intent...", agentName: "analytics" }, t);
+  const a = I(e.agentExecutionContext.messages), n = !!J(e).latestItemId, r = await W.fromTemplate(Ia).format({
+    userMessage: a,
+    hasSummaryContext: String(n)
+  }), u = (await Q({ modelTier: "fast" })).withStructuredOutput(re), i = re.parse(await u.invoke(r));
+  let l = i.itemId;
+  if (i.intent === "summarize" && !l) {
+    const y = C(a, "#");
+    y && (l = await Se.invoke({ itemTitle: y }, t) ?? "");
+  }
+  const { intent: c, question: d } = i, f = c === "clarify" || c === "summarize" && !l || c === "followUp" && !d;
+  return {
+    agentExecutionContext: { ...e.agentExecutionContext },
+    analyticsIntent: f ? "clarify" : c,
+    analyticsItemId: l || null,
+    analyticsQuestion: d || "",
+    status: "success",
+    outputMessage: f ? 'Please clarify with summarize item <item id>, summarize item #<title>, or summarize item #"<title with spaces>".' : ""
+  };
+}, Sa = `
+You are a item summary tool for ArcGIS. Your job is to summarize an item's info based on the provided context.
+Summary rules:
+- The summary should be concise markdown, make sure to format the output nicely so it's easy to read.
+- Target length: 80-150 words.
+- Provide one short descriptive paragraph.
+- Also propose 3 concise follow-up questions grounded in the item summary.
+- Keep follow-up questions specific and actionable.
+Follow-up questions rules:
+- These questions should be in the format of a prompt that the user can click on.
+- Make sure the questions are relevant to the item summary and that you can answer based solely on the provided context.
+Do not include internal identifiers.
+If the user asks for a detailed summary, you may expand the response up to 300 words.
+Item context:
+{context}
+`, Ta = async (e, t) => {
+  const a = e.analyticsItemId;
+  if (!a)
+    return {
+      status: "success",
+      outputMessage: 'Please clarify with summarize item <item id>, summarize item #<title>, or summarize item #"<title with spaces>".'
+    };
+  await m({ text: `Summarizing item ${a}...`, agentName: "analytics" }, t);
+  const n = t?.configurable?.context;
+  T(n);
+  const { portal: r, user: o } = n, { result: u, error: i } = await Xe(o, r, a);
+  if (i || !u)
+    return await m({ text: "Failed to get item context for summarization", agentName: "analytics" }, t), {
+      status: "success",
+      outputMessage: "Unable to retrieve item context for summarization."
+    };
+  const { context: l } = u, c = await v({
+    promptText: Sa,
+    schema: ya,
+    modelTier: "default",
+    inputVariables: { context: JSON.stringify(l) }
+  }), { followUpQuestions: d, summary: g } = c, p = J(e), f = {
+    latestItemId: a,
+    memory: {
+      ...p.memory,
+      [a]: { summary: g, followUpQuestions: d, fullContext: l }
+    }
+  };
+  return d.length && await B({ type: "suggested-prompts", data: { prompts: d } }, t), {
+    status: "success",
+    outputMessage: g,
+    sharedStatePatch: { portalItemAnalyticsSummaryMemory: { value: f } }
+  };
+}, O = (e, t) => t ?? e, Ne = h.Root({
+  ...N(),
+  // States shared only across nodes in the graph, not between invocations
+  analyticsIntent: h({
+    reducer: O,
+    default: () => "clarify"
+  }),
+  analyticsItemId: h({
+    reducer: O,
+    default: () => null
+  }),
+  analyticsQuestion: h({
+    reducer: O,
+    default: () => ""
+  })
+}), Ma = () => new G(Ne).addNode("detectAnalyticsIntent", xa).addNode("summarizePortalItem", Ta).addNode("answerAnalyticsFollowUp", va).addEdge(A, "detectAnalyticsIntent").addConditionalEdges("detectAnalyticsIntent", (t) => t.analyticsIntent === "summarize" ? "summarizePortalItem" : t.analyticsIntent === "followUp" ? "answerAnalyticsFollowUp" : w).addEdge("summarizePortalItem", w).addEdge("answerAnalyticsFollowUp", w), Ca = String.raw`- **portal-item-analytics** - Portal item analytics assistant:
+  - answers questions about one specific ArcGIS portal item when item context is present
+  - summarizes item details, metadata, and context grounded in that item
+  - suggests follow-up prompts grounded in the same item
+  - use for item-specific requests, not for gallery browsing, featured content, or opening Map Viewer
+`, Ga = {
+  id: "portal-item-analytics",
+  name: "Portal Item Analytics",
+  description: Ca,
+  createGraph: Ma,
+  workspace: Ne
+}, Aa = {
+  schemaVersion: "1.0",
+  capabilities: [
+    {
+      id: "my-content",
+      title: "My content",
+      description: "Browse, discover, search, and filter ArcGIS content—including maps, apps, datasets, and other items—that you own or can access.",
+      hints: ["view my content", "show my content", "my content"],
+      platforms: ["online", "enterprise"],
+      resolutions: {
+        navigate: {
+          routeKey: "content"
+        }
+      }
+    },
+    {
+      id: "create-feature-layer",
+      title: "Create feature layer",
+      description: "Generate an editable feature layer by copying fields from templates or existing layers.",
+      hints: ["add a feature layer", "make a feature layer", "generate a feature layer"],
+      platforms: ["online", "enterprise"],
+      resolutions: {
+        navigate: {
+          routeKey: "content"
+        }
+      }
+    },
+    {
+      id: "create-folder",
+      title: "Create folder",
+      description: "Create a new folder in your ArcGIS content to organize your items.",
+      hints: ["create a folder", "make a folder", "set up a folder", "new folder"],
+      platforms: ["online", "enterprise"],
+      resolutions: {
+        navigate: {
+          routeKey: "content"
+        }
+      }
+    }
+  ]
+}, Na = {
+  schemaVersion: "1.0",
+  capabilities: [
+    {
+      id: "my groups",
+      title: "My groups",
+      description: "Browse, discover, search, and filter ArcGIS content collections—including maps, apps, datasets, and other items—that you own, belong to, or can access.",
+      hints: ["view my groups", "show my groups", "my groups"],
+      platforms: ["online", "enterprise"],
+      resolutions: {
+        navigate: {
+          routeKey: "groups"
+        }
+      }
+    },
+    {
+      id: "create-group",
+      title: "Create group",
+      description: "Create a new ArcGIS Portal group owned by the signed-in user.",
+      hints: ["create a group", "make a group", "set up a group", "new group"],
+      platforms: ["online", "enterprise"],
+      resolutions: {
+        navigate: {
+          routeKey: "groups"
+        }
+      }
+    },
+    {
+      id: "featured-groups",
+      title: "Featured groups",
+      description: "Browse, discover, search, and filter ArcGIS content collections—including maps, apps, datasets, and other items—that organization administrators choose to highlight in ArcGIS.",
+      hints: ["view featured groups", "show featured groups", "highlighted groups", "top groups"],
+      platforms: ["online", "enterprise"],
+      resolutions: {
+        navigate: {
+          routeKey: "groups",
+          hash: "featured"
+        }
+      }
+    },
+    {
+      id: "organization-groups",
+      title: "Organization groups",
+      description: "Browse, discover, search, and filter ArcGIS content collections—including maps, apps, datasets, and other items—that are specific to your organization in ArcGIS.",
+      hints: ["view organization groups", "show organization groups"],
+      platforms: ["online", "enterprise"],
+      resolutions: {
+        navigate: {
+          routeKey: "groups",
+          hash: "organization"
+        }
+      }
+    }
+  ]
+}, Pa = {
+  schemaVersion: "1.0",
+  capabilities: [
+    {
+      id: "org-config-mfa",
+      title: "Multifactor Authentication (MFA)",
+      description: "Configure organization-level multifactor authentication (MFA) settings. Administrators can enable MFA for ArcGIS logins, allow recovery codes for members, view MFA adoption status, enforce MFA requirements for all members, manage the MFA exemption list, and designate administrators who can troubleshoot MFA issues.",
+      hints: ["config MFA", "set up MFA"],
+      platforms: ["online", "enterprise"],
+      resolutions: {
+        navigate: {
+          routeKey: "organization",
+          queryParams: {
+            tab: "security"
+          },
+          hash: "settings"
+        }
+      }
+    }
+  ]
+}, qa = {
+  "contentRouteRegistry.ts": Aa,
+  "groupsRouteRegistry.ts": Na,
+  "orgSettingsRouteRegistry.ts": Pa
+};
+function oe(e) {
+  const t = [], a = /* @__PURE__ */ new Set();
+  for (const [n, r] of Object.entries(e))
+    for (const o of r.capabilities) {
+      if (a.has(o.id))
+        throw new Error(`${n}: duplicate capability id "${o.id}" across registries`);
+      a.add(o.id), t.push(o);
+    }
+  return t;
+}
+let E;
+function S(e) {
+  return e ? E = oe({ customCapabilities: e }) : E || (E = oe(qa)), E;
+}
+const Ea = /^(?:take me to|navigate to|go to|show me|open)\s+(?:the\s+)?/u;
+function $(e) {
+  return e.toLowerCase().replace(/[^a-z0-9]+/gu, " ").trim().replace(Ea, "").trim();
+}
+const ka = s.object({
+  capabilityIds: s.array(s.string()).default([]),
+  confidence: s.number().min(0).max(1).default(0),
+  reason: s.string().default("")
+}), se = 0.8, za = String.raw`You select Portal navigation capabilities for a user's request.
+
+Select only capability IDs from the supplied candidates. Return an empty array when none fit.
+A named surface is required: do not select a capability on another Portal surface.
+Retrieval scores are hints only, not ground truth.
+
+User request:
+{userRequest}
+
+Candidates:
+{candidates}`, $a = async (e, t) => {
+  if (e.outputMessage || e.targets.length === 0)
+    return {};
+  const a = I(e.agentExecutionContext.messages).trim(), n = Ra(a, e);
+  if (n.length === 1)
+    return console.info("[arcgis-portal-ai-assistant] navigation capability selection:", {
+      method: "exact-match",
+      request: a,
+      selectedCapabilityIds: n
+    }), { chosenCapabilityIds: n };
+  await m({ text: "Choosing a navigation destination...", agentName: "navigation" }, t);
+  const r = JSON.stringify(
+    e.targets.map(({ capability: o, keywordScore: u, semanticScore: i }) => ({
+      id: o.id,
+      title: o.title,
+      description: o.description,
+      route: o.resolutions.navigate,
+      keywordScore: u,
+      semanticScore: i
+    }))
+  );
+  try {
+    const o = await v({
+      promptText: za,
+      schema: ka,
+      modelTier: "fast",
+      inputVariables: { candidates: r, userRequest: a }
+    }), u = new Set(e.targets.map(({ capability: l }) => l.id)), i = o.capabilityIds.filter((l) => u.has(l));
+    return console.info("[arcgis-portal-ai-assistant] navigation capability selection:", {
+      confidence: o.confidence,
+      method: "structured-model",
+      reason: o.reason,
+      request: a,
+      selectedCapabilityIds: i
+    }), o.confidence < se ? {
+      chosenCapabilityIds: [],
+      status: "failed",
+      summary: `Navigation selection confidence ${o.confidence} is below the required ${se}; defer to the Portal Doc Assistant.`
+    } : { chosenCapabilityIds: i };
+  } catch {
+    return console.info("[arcgis-portal-ai-assistant] navigation capability selection:", {
+      method: "structured-model-unavailable",
+      request: a,
+      selectedCapabilityIds: []
+    }), { chosenCapabilityIds: [] };
+  }
+};
+function Ra(e, t) {
+  const a = $(e);
+  return t.targets.filter(
+    ({ capability: n }) => [n.title, ...n.hints].some(
+      (r) => $(r) === a
+    )
+  ).map(({ capability: n }) => n.id);
+}
+const Pe = /* @__PURE__ */ new Set(["1d", "7d", "14d", "30d", "3m", "6m"]), Da = s.object({
+  period: s.string(),
+  startTime: s.string(),
+  endTime: s.string()
+}), Ua = String.raw`Extract temporal filters for an ArcGIS storage-credits query.
+
+Return JSON only with these optional string fields:
+- period
+- startTime
+- endTime
+
+Rules:
+- period must use <integer><unit> with unit in d,w,m (examples: 7d, 2w, 3m).
+- If the request is a relative range and period can be determined, always include period.
+- For "last quarter" or "previous quarter", use calendar-quarter boundaries and include period as 3m with both startTime and endTime.
+- For "last quarter" or "previous quarter", endTime must be the UTC end of the previous quarter, not "now".
+- If period matches one of these supported periods and the range ends today, period alone is sufficient:
+  1d, 7d, 14d, 30d, 3m, 6m.
+- If the request implies a range not supported as period (for example 2m or 10d), include startTime and endTime.
+- For custom date ranges (for example "last december"), provide startTime and endTime.
+- startTime and endTime must be epoch milliseconds as strings.
+- If the end of range is "now", set endTime to {nowEpochMs}.
+- If temporal intent is unclear, return empty strings for all fields.
+
+Now UTC:
+- ISO: {nowIso}
+- Epoch ms: {nowEpochMs}
+
+User request:
+{userRequest}`;
+async function Fa(e, t = /* @__PURE__ */ new Date()) {
+  const a = e.trim();
+  if (!a)
+    return {};
+  try {
+    const n = await v({
+      promptText: Ua,
+      schema: Da,
+      modelTier: "fast",
+      inputVariables: {
+        nowEpochMs: String(t.getTime()),
+        nowIso: t.toISOString(),
+        userRequest: a
+      }
+    });
+    return Oa(n, t);
+  } catch (n) {
+    return console.error(n), {};
+  }
+}
+function Oa(e, t = /* @__PURE__ */ new Date()) {
+  const a = ie(e.startTime), n = ie(e.endTime), r = Ka(e.period);
+  if (r) {
+    if (a !== void 0 && n !== void 0 && a < n)
+      return { period: r, startTime: String(a), endTime: String(n) };
+    const o = Pe.has(r);
+    if (!o || n !== void 0 && !ja(n, t.getTime())) {
+      const i = n ?? t.getTime(), l = Va(r, new Date(i));
+      if (l !== void 0)
+        return {
+          period: r,
+          startTime: String(l),
+          endTime: String(i)
+        };
+    }
+    return o ? {
+      period: r,
+      ...a !== void 0 ? { startTime: String(a) } : {},
+      ...n !== void 0 ? { endTime: String(n) } : {}
+    } : { period: r };
+  }
+  return a !== void 0 && n !== void 0 && a < n ? { startTime: String(a), endTime: String(n) } : a !== void 0 ? { startTime: String(a), endTime: String(t.getTime()) } : {};
+}
+function Ka(e) {
+  const t = e?.trim().match(/^(\d+)\s*([dwm])$/iu);
+  if (!t)
+    return;
+  const a = Number.parseInt(t[1], 10);
+  if (!Number.isFinite(a) || a <= 0)
+    return;
+  const n = t[2].toLowerCase();
+  if (n === "w") {
+    const r = a * 7;
+    if (Pe.has(`${r}d`))
+      return `${r}d`;
+  }
+  return `${a}${n}`;
+}
+function Va(e, t) {
+  const a = e.match(/^(\d+)([dwm])$/u);
+  if (!a)
+    return;
+  const n = Number.parseInt(a[1], 10);
+  if (!Number.isFinite(n) || n <= 0)
+    return;
+  const r = a[2];
+  if (r === "d")
+    return t.getTime() - n * 24 * 60 * 60 * 1e3;
+  if (r === "w")
+    return t.getTime() - n * 7 * 24 * 60 * 60 * 1e3;
+  const o = new Date(t.getTime());
+  return o.setUTCMonth(o.getUTCMonth() - n), o.getTime();
+}
+function ie(e) {
+  if (!e)
+    return;
+  const t = Number.parseInt(e, 10);
+  if (!(!Number.isFinite(t) || t <= 0))
+    return t;
+}
+function ja(e, t) {
+  const a = new Date(e), n = new Date(t);
+  return a.getUTCFullYear() === n.getUTCFullYear() && a.getUTCMonth() === n.getUTCMonth() && a.getUTCDate() === n.getUTCDate();
+}
+async function La(e, t, a) {
+  const n = S().find((o) => o.id === e);
+  if (!n)
+    return;
+  const r = await Qa(Ba(n), a);
+  return r && Ja(r, t) ? { capability: n, target: r } : void 0;
+}
+function Ba(e) {
+  const { hash: t, queryParams: a, routeKey: n } = e.resolutions.navigate;
+  switch (n) {
+    case "content":
+      switch (e.id) {
+        case "my-content":
+          return { destinationType: "portal-content", t9nKey: "myContent" };
+        case "create-feature-layer":
+          return { destinationType: "portal-content", t9nKey: "createFeatureLayer" };
+        case "create-folder":
+          return { destinationType: "portal-content", t9nKey: "createFolder" };
+        default:
+          return { destinationType: "portal-content" };
+      }
+    case "groups":
+      if (t === "featured")
+        return { destinationType: "portal-groups", hash: "featured", t9nKey: "featuredGroups" };
+      if (t === "organization")
+        return { destinationType: "portal-groups", hash: "organization", t9nKey: "organizationGroups" };
+      switch (e.id) {
+        case "my groups":
+          return { destinationType: "portal-groups", hash: "my", t9nKey: "myGroups" };
+        case "create-group":
+          return { destinationType: "portal-groups", t9nKey: "createGroup" };
+        default:
+          return { destinationType: "portal-groups" };
+      }
+    case "organization":
+      return {
+        destinationType: "portal-org",
+        hash: t,
+        queryParams: a,
+        buttonLabel: e.buttonLabel
+      };
+    default:
+      return;
+  }
+}
+async function Qa(e, t) {
+  if (!e || !t || !Wa(e))
+    return e;
+  const a = await Fa(t);
+  if (!a.period && !a.startTime && !a.endTime)
+    return e;
+  const n = {
+    ...e.queryParams,
+    ...a.period ? { period: a.period } : {},
+    ...a.startTime ? { startTime: a.startTime } : {},
+    ...a.endTime ? { endTime: a.endTime } : {}
+  };
+  return { ...e, queryParams: n };
+}
+function Wa(e) {
+  return e.destinationType === "portal-org" && e.hash === "status";
+}
+function Ja(e, t) {
+  return !t || !!t[e.destinationType];
+}
+const _a = async (e, t) => {
+  if (e.outputMessage || e.status === "failed")
+    return {};
+  const a = e.targets.find(({ capability: o }) => e.chosenCapabilityIds.includes(o.id)) ?? e.targets[0];
+  if (!a)
+    return {
+      outputMessage: "I couldn't find a matching Portal page. Try asking to open your content, groups, or organization settings.",
+      sharedStatePatch: { navLastAnsweredRequest: { value: ue(e) } },
+      status: "success",
+      summary: "Navigation could not find a matching capability; route another agent if appropriate."
+    };
+  const n = ue(e), r = await La(a.capability.id, void 0, n);
+  return r ? (await m({ text: "Preparing navigation...", agentName: "navigation" }, t), await D(r.target, t), {
+    outputMessage: e.chosenCapabilityIds.length ? a.capability.description : `The closest place to start is ${a.capability.title}. Click the button below to open it.`,
+    status: "success",
+    summary: `Navigation suggested ${a.capability.id}${e.retrievalDegraded ? " using keyword-only retrieval" : ""}.`,
+    sharedStatePatch: { navLastAnsweredRequest: { value: n } }
+  }) : (console.warn(`Navigation capability ${a.capability.id} was not found in the resolver.`), {
+    outputMessage: "I found a possible destination, but couldn't resolve a valid Portal navigation target. Try asking to open your content, groups, or organization settings.",
+    status: "success",
+    summary: `Navigation resolver could not map ${a.capability.id}.`,
+    sharedStatePatch: { navLastAnsweredRequest: { value: n } }
+  });
+};
+function ue(e) {
+  return I(e.agentExecutionContext.messages) || e.agentExecutionContext.userRequest;
+}
+async function qe(e) {
+  return e.length === 0 ? [] : (await rt.getDefault().load(), await Le(e));
+}
+const Ya = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  generateEmbeddings: qe
+}, Symbol.toStringTag, { value: "Module" }));
+function Ha(e) {
+  const t = [], a = `${e.title}. ${e.description}`;
+  a.trim().length > 0 && t.push({ field: "summary", text: a });
+  const n = e.hints;
+  if (Array.isArray(n))
+    for (const r of n)
+      typeof r == "string" && r.trim().length > 0 && t.push({ field: "hint", text: r });
+  return t;
+}
+let k, _, z = 0;
+async function Xa(e = {}) {
+  const t = z;
+  return k ??= en(e.embed ?? tn).then((a) => (t === z && (_ = a), a)).catch((a) => {
+    throw t === z && (k = void 0), a;
+  }), await k;
+}
+function Za() {
+  return _;
+}
+function ce() {
+  z += 1, _ = void 0, k = void 0;
+}
+async function en(e) {
+  const t = an(), a = await e(t.map((n) => n.text));
+  if (a.length !== t.length)
+    throw new Error(`Expected ${t.length} vectors, got ${a.length}`);
+  return t.map((n, r) => ({
+    ...n,
+    vector: a[r]
+  }));
+}
+async function tn(e) {
+  const { generateEmbeddings: t } = await Promise.resolve().then(() => Ya);
+  return await t(e);
+}
+function an() {
+  return S().flatMap(
+    (e) => Ha(e).map(({ field: t, text: a }) => ({
+      capabilityId: e.id,
+      field: t,
+      text: a
+    }))
+  );
+}
+const le = 1.2, de = 0.75, nn = 60, rn = 0.65, K = {
+  description: 1,
+  hint: 2,
+  title: 3
+};
+let L;
+function on() {
+  L = void 0;
+}
+async function sn(e, t = {}) {
+  const a = dn(Ee(e));
+  let n = [], r = !1, o;
+  if (e.trim()) {
+    const u = t.loadEmbeddings, i = Za();
+    if (!u && !i)
+      r = !0, o = "Capability embeddings are still loading.";
+    else
+      try {
+        if (u) {
+          const [l, c] = await Promise.all([
+            (t.embedQuery ?? me)(e),
+            u()
+          ]);
+          n = pe(l, c);
+        } else if (i) {
+          const l = await (t.embedQuery ?? me)(e);
+          n = pe(l, i);
+        }
+      } catch {
+        r = !0, o = "Semantic search is unavailable.";
+      }
+  }
+  return {
+    degraded: r,
+    ...o ? { degradedReason: o } : {},
+    // RRF combines ranks rather than raw scores because BM25 and cosine
+    // similarity are on different scales.
+    matches: mn(a, n, t.topN ?? 5)
+  };
+}
+function un() {
+  return L ??= cn(S()), L;
+}
+function cn(e) {
+  const t = /* @__PURE__ */ new Map(), a = e.map((n) => {
+    const r = /* @__PURE__ */ new Map();
+    V(r, n.title, K.title), V(r, n.description, K.description);
+    for (const o of n.hints)
+      V(r, o, K.hint);
+    for (const o of r.keys())
+      t.set(o, (t.get(o) ?? 0) + 1);
+    return {
+      capability: n,
+      length: ln(r),
+      termFrequencies: r
+    };
+  });
+  return {
+    averageDocumentLength: a.length ? a.reduce((n, r) => n + r.length, 0) / a.length : 0,
+    documentFrequency: t,
+    documents: a
+  };
+}
+function V(e, t, a) {
+  for (const n of Ee(t))
+    e.set(n, (e.get(n) ?? 0) + a);
+}
+function ln(e) {
+  return [...e.values()].reduce((t, a) => t + a, 0);
+}
+function Ee(e) {
+  return e.toLowerCase().split(/[^a-z0-9]+/u).filter(Boolean);
+}
+function dn(e) {
+  const t = un(), a = new Set(e), n = t.documents.length;
+  return t.documents.map(({ capability: r, length: o, termFrequencies: u }) => {
+    let i = 0;
+    for (const l of a) {
+      const c = u.get(l), d = t.documentFrequency.get(l);
+      if (!c || !d)
+        continue;
+      const g = Math.log(1 + (n - d + 0.5) / (d + 0.5)), p = le * (1 - de + de * (o / t.averageDocumentLength));
+      i += g * (c * (le + 1) / (c + p));
+    }
+    return { capability: r, score: i };
+  }).filter(({ score: r }) => r > 0).sort(ke);
+}
+function pe(e, t) {
+  const a = /* @__PURE__ */ new Map();
+  for (const r of t) {
+    const o = pn(e, r.vector);
+    if (o === void 0)
+      continue;
+    const u = a.get(r.capabilityId);
+    (u === void 0 || o > u) && a.set(r.capabilityId, o);
+  }
+  const n = new Map(S().map((r) => [r.id, r]));
+  return [...a.entries()].flatMap(([r, o]) => {
+    const u = n.get(r);
+    return u && o >= rn ? [{ capability: u, score: o }] : [];
+  }).sort(ke);
+}
+function pn(e, t) {
+  if (e.length === 0 || e.length !== t.length)
+    return;
+  let a = 0, n = 0, r = 0;
+  for (let u = 0; u < e.length; u += 1)
+    a += e[u] * t[u], n += e[u] ** 2, r += t[u] ** 2;
+  const o = Math.sqrt(n) * Math.sqrt(r);
+  return o === 0 ? void 0 : a / o;
+}
+async function me(e) {
+  const [t] = await qe([e]);
+  if (!t)
+    throw new Error("Expected one query embedding.");
+  return t;
+}
+function mn(e, t, a) {
+  const n = /* @__PURE__ */ new Map();
+  return ge(n, e, "keyword"), ge(n, t, "semantic"), [...n.values()].sort((r, o) => o.score !== r.score ? o.score - r.score : (o.semanticScore ?? 0) !== (r.semanticScore ?? 0) ? (o.semanticScore ?? 0) - (r.semanticScore ?? 0) : (o.keywordScore ?? 0) !== (r.keywordScore ?? 0) ? (o.keywordScore ?? 0) - (r.keywordScore ?? 0) : r.capability.id.localeCompare(o.capability.id)).slice(0, Math.max(0, a));
+}
+function ge(e, t, a) {
+  for (const [n, { capability: r, score: o }] of t.entries()) {
+    const u = n + 1, i = e.get(r.id) ?? { capability: r, score: 0 };
+    i.score += 1 / (nn + u), a === "keyword" ? (i.keywordRank = u, i.keywordScore = o) : (i.semanticRank = u, i.semanticScore = o), e.set(r.id, i);
+  }
+}
+function ke(e, t) {
+  return t.score - e.score || e.capability.id.localeCompare(t.capability.id);
+}
+const gn = async (e, t) => {
+  await m({ text: "Finding a place to navigate...", agentName: "navigation" }, t);
+  const a = I(e.agentExecutionContext.messages).trim();
+  try {
+    const n = await sn(a, { topN: 5 });
+    return console.table(
+      n.matches.map(({ capability: r, keywordRank: o, keywordScore: u, semanticRank: i, semanticScore: l, score: c }) => ({
+        capability: r.title,
+        fusedScore: c,
+        keywordRank: o,
+        keywordScore: u,
+        semanticRank: i,
+        semanticScore: l
+      }))
+    ), n.degradedReason && console.info("[arcgis-portal-ai-assistant] navigation semantic search:", n.degradedReason), {
+      chosenCapabilityIds: [],
+      retrievalDegraded: n.degradedReason ?? "",
+      targets: hn(a, n.matches)
+    };
+  } catch {
+    return {
+      chosenCapabilityIds: [],
+      outputMessage: "I couldn't look up a Portal page right now. Please try again.",
+      status: "failed",
+      targets: []
+    };
+  }
+};
+function hn(e, t) {
+  const a = $(e), n = t.filter(
+    ({ capability: o }) => [o.title, ...o.hints].some(
+      (u) => $(u) === a
+    )
+  );
+  if (n.length !== 1)
+    return t;
+  const [r] = n;
+  return [r, ...t.filter((o) => o !== r)];
+}
+const j = (e, t) => t ?? e, ze = h.Root({
+  ...N(),
+  chosenCapabilityIds: h({ reducer: j, default: () => [] }),
+  // Empty when hybrid keyword-and-semantic retrieval succeeds; otherwise
+  // contains the semantic-search failure reason for response diagnostics.
+  retrievalDegraded: h({ reducer: j, default: () => "" }),
+  targets: h({ reducer: j, default: () => [] })
+}), fn = () => new G(ze).addNode("retrieveNavigationTargets", gn).addNode("chooseNavigationTargets", $a).addNode("respondWithNavigation", _a).addEdge(A, "retrieveNavigationTargets").addEdge("retrieveNavigationTargets", "chooseNavigationTargets").addEdge("chooseNavigationTargets", "respondWithNavigation").addEdge("respondWithNavigation", w);
+function yn() {
+  const e = S().map(({ hints: t, title: a }) => t[0] ?? a).join(", ");
+  return String.raw`- **portal-navigation** - Portal page navigation assistant:
+  - routes requests to open, show, or navigate to a Portal page, including creation-flow pages
+  - falls back to the closest Portal page where a workflow starts when another agent cannot perform the action
+  - handles short navigation follow-ups after asking the user to open a page
+  - capability examples: ${e}
+  - do not use for general "how do I" questions unless the user explicitly asks to reach a page
+`;
+}
+const wn = {
+  id: "navigation",
+  name: "Portal Navigation",
+  get description() {
+    return yn();
+  },
+  createGraph: fn,
+  workspace: ze
+}, bn = Ke`:host{height:100%;border-width:1px;border-style:solid;border-color:var(--calcite-color-border-3);display:block;width:100%;--tw-shadow: 0 1px 6px -1px rgba(0, 0, 0, .16), 0 1px 2px -1px rgba(0, 0, 0, .08);--tw-shadow-colored: 0 1px 6px -1px var(--tw-shadow-color), 0 1px 2px -1px var(--tw-shadow-color);box-shadow:var(--tw-ring-offset-shadow, 0 0 #0000),var(--tw-ring-shadow, 0 0 #0000),var(--tw-shadow)}.chat-entry{display:flex;flex-direction:column;gap:.75rem;width:100%}.chat-actions{display:flex;justify-content:flex-end;gap:.5rem}.header-actions{display:flex;gap:.5rem;padding-inline-start:.75rem}.navigation-block{display:flex;flex-direction:column;align-items:stretch;gap:.35rem;margin-top:.5rem}.navigation-button{width:100%;margin-block:.25rem}.navigation-block-description{font-size:.75rem;color:var(--calcite-color-text-3)}`;
+function vn(e, t) {
+  if (!t)
+    return;
+  const { destinationType: a } = e;
+  switch (a) {
+    case "portal-content":
+      return t[a]?.(e.hash);
+    case "portal-groups":
+      return t[a]?.(e.hash);
+    case "portal-org":
+      return t[a]?.(e.hash, e.queryParams);
+    case "portal-gallery":
+      return t[a];
+    case "portal-map-viewer":
+    case "portal-notebooks":
+    case "portal-scene-viewer":
+      return t[a];
+    case "portal-item":
+      return t[a]?.(e.itemId);
     case "portal-group":
-      return `${a}/group.html?id=${s.groupId}`;
+      return t[a]?.(e.groupId);
     default:
-      return P(e);
+      return R(a);
   }
+}
+function In(e) {
+  const t = Ct.safeParse(e);
+  return t.success ? t.data : void 0;
+}
+const xn = { myContent: "My content", createFeatureLayer: "Create feature layer", createFolder: "Create folder", myGroups: "My groups", createGroup: "Create group", featuredGroups: "Featured groups", organizationGroups: "Organization groups", configureMultifactorAuthentication: "Configure multifactor authentication" }, $e = {
+  navigationTargets: xn
 };
-class ne extends tt {
+function Sn(e, t) {
+  const a = he(e.t9nKey, t.navigationTargets) ?? he(e.t9nKey, $e.navigationTargets);
+  if (a)
+    return a;
+  const n = t.navigation;
+  switch (e.destinationType) {
+    case "portal-content":
+      switch (e.hash) {
+        case "favorites":
+          return n.openContentFavorites;
+        case "group":
+          return n.openContentGroup;
+        case "living-atlas":
+          return n.openContentLivingAtlas;
+        case "org":
+          return n.openContentOrganization;
+        default:
+          return n.openContent;
+      }
+    case "portal-gallery":
+      return n.openGallery;
+    case "portal-groups":
+      switch (e.hash) {
+        case "featured":
+          return n.openGroupsFeatured;
+        case "my":
+          return n.openGroupsMy;
+        case "organization":
+          return n.openGroupsOrganization;
+        default:
+          return n.openGroups;
+      }
+    case "portal-map-viewer":
+      return n.openMapViewer;
+    case "portal-notebooks":
+      return n.openNotebooks;
+    case "portal-scene-viewer":
+      return n.openSceneViewer;
+    case "portal-org":
+      return n.openOrgSettings;
+    case "portal-item":
+      return n.openItem;
+    case "portal-group":
+      return n.openGroup;
+    default:
+      return R(e);
+  }
+}
+function he(e, t) {
+  if (!(!e || !t || !Tn(e)))
+    return t[e];
+}
+function Tn(e) {
+  return e in $e.navigationTargets;
+}
+class Mn extends Fe {
   constructor() {
-    super(...arguments), this.t9n = rt({ blocking: !0 }), this.assistantEl = M(), this.formEl = M(), this.voiceInputEl = M(), this.inputEl = M(), this.navigationSlotElements = /* @__PURE__ */ new Map(), this.handleSlottableRequest = (t) => {
-      const e = t.detail, a = e.data?.block;
-      if (!a)
+    super(), this.t9n = je({ blocking: !0 }), this.assistantEl = P(), this.formEl = P(), this.voiceInputEl = P(), this.inputEl = P(), this.navigationSlotElements = /* @__PURE__ */ new Map(), this.handleSlottableRequest = (t) => {
+      const a = t.detail, n = a.data?.block;
+      if (!n)
         return;
-      const r = this.getNavigationAction(a);
-      r && this.upsertNavigationSlotElement(e.slotName, r);
-    }, this.inputText = "", this.showVoiceInput = !0, this.isListening = !1, this.isVoiceInputDisabled = !1, this.interrupt = null, this.autoDestroyDisabled = !1, this.defaultClosed = !1, this.arcgisPortalNavigationRequest = et();
+      const r = this.getNavigationAction(n);
+      r && this.upsertNavigationSlotElement(a.slotName, r);
+    }, this.inputText = "", this.showVoiceInput = !0, this.isListening = !1, this.isVoiceInputDisabled = !1, this.interrupt = null, this.autoDestroyDisabled = !1, this.defaultClosed = !1, this.arcgisPortalNavigationRequest = Oe(), S();
   }
   static {
-    this.properties = { inputText: 16, showVoiceInput: 16, isListening: 16, isVoiceInputDisabled: 16, interrupt: 16, autoDestroyDisabled: 5, portal: 0, user: 0, config: 0, defaultClosed: 5 };
+    this.properties = { inputText: 16, showVoiceInput: 16, isListening: 16, isVoiceInputDisabled: 16, interrupt: 16, autoDestroyDisabled: 5, portal: 0, user: 0, config: 0, navigationTargetMap: 0, disabledAgents: 0, defaultClosed: 5, navigationCapabilities: 0 };
   }
   static {
-    this.styles = re;
+    this.styles = bn;
+  }
+  async load() {
+    await this.refreshCapabilityEmbeddings();
+  }
+  willUpdate(t) {
+    !this.hasUpdated || !t.has("navigationCapabilities") || this.refreshCapabilityEmbeddings();
+  }
+  async clearEmbeddingsCache() {
+    ce();
+  }
+  isAgentEnabled(t) {
+    return !this.disabledAgents?.[t];
+  }
+  async refreshCapabilityEmbeddings() {
+    try {
+      S(this.navigationCapabilities), on(), ce(), await Xa();
+    } catch (t) {
+      console.warn("[arcgis-portal-ai-assistant] embeddings warm-up failed:", t);
+    }
   }
   getNavigationAction(t) {
-    if (t?.type !== _)
+    if (t?.type !== be)
       return;
-    const e = jt(t.data);
-    if (!e)
+    const a = t.data, n = In(a);
+    if (!n)
       return;
-    const a = oe(e, this.portal);
-    if (a)
-      return { href: a, targetDetail: e, label: this.getNavigationText(e.destinationType) };
+    const r = vn(a, this.navigationTargetMap);
+    if (r)
+      return {
+        href: r,
+        targetDetail: a,
+        label: a?.buttonLabel || Sn(n, this.t9n)
+      };
   }
-  upsertNavigationSlotElement(t, e) {
-    const a = this.assistantEl.value;
-    if (!a)
+  upsertNavigationSlotElement(t, a) {
+    const n = this.assistantEl.value;
+    if (!n)
       return;
-    let r = this.navigationSlotElements.get(t);
-    r || (r = document.createElement("div"), r.slot = t, this.navigationSlotElements.set(t, r), a.append(r)), at(w`<div><calcite-button class="navigation-button" appearance=outline width=full .href=${e.href} icon-end=launch @click=${(l) => {
-      l.preventDefault(), this.arcgisPortalNavigationRequest.emit({
-        href: e.href,
-        targetDetail: e.targetDetail
+    const r = `navigation:${t}`;
+    let o = this.navigationSlotElements.get(r);
+    o || (o = document.createElement("div"), o.slot = t, this.navigationSlotElements.set(r, o), n.append(o)), Ve(b`<div><calcite-button class="navigation-button" appearance=outline width=full .href=${a.href} icon-end=launch @click=${(u) => {
+      u.preventDefault(), this.arcgisPortalNavigationRequest.emit({
+        href: a.href,
+        targetDetail: a.targetDetail
       });
-    }}>${e.label}</calcite-button>${e.description ? w`<div class="navigation-block-description">${e.description}</div>` : null}</div>`, r);
-  }
-  getNavigationText(t) {
-    const e = this.t9n.navigation;
-    switch (t) {
-      case "portal-content":
-        return e.openContent;
-      case "portal-groups":
-        return e.openGroups;
-      case "portal-item":
-        return e.openItem;
-      case "portal-group":
-        return e.openGroup;
-      default:
-        return P(t);
-    }
+    }}>${a.label}</calcite-button>${a.description ? b`<div class="navigation-block-description">${a.description}</div>` : null}</div>`, o);
   }
   render() {
-    const { t9n: t, inputText: e, portal: a, user: r, showVoiceInput: l, isListening: c, isVoiceInputDisabled: i } = this;
-    return w`<arcgis-assistant log-enabled keep-suggested-prompts .heading=${t.heading} .entryMessage=${t.entryMessage} @arcgisSlottableRequest=${this.handleSlottableRequest} @arcgisInterrupt=${({ detail: o }) => {
-      this.interrupt = o;
+    const { t9n: t, inputText: a, portal: n, user: r, navigationTargetMap: o, showVoiceInput: u, isListening: i, isVoiceInputDisabled: l } = this;
+    return b`<arcgis-assistant log-enabled keep-suggested-prompts .heading=${t.heading} .entryMessage=${t.entryMessage} @arcgisSlottableRequest=${this.handleSlottableRequest} @arcgisInterrupt=${({ detail: c }) => {
+      this.interrupt = c;
     }} @arcgisInterruptCancel=${() => {
       this.interrupt = null;
     }} @arcgisInterruptSubmit=${() => {
       this.interrupt = null;
-    }} @arcgisPromptSelect=${({ detail: o }) => {
-      this.inputText = o.prompt, requestAnimationFrame(() => {
+    }} @arcgisPromptSelect=${({ detail: c }) => {
+      this.inputText = c.prompt, requestAnimationFrame(() => {
         this.inputEl.value?.focusTextArea();
       });
-    }} ${T(this.assistantEl)}><div slot=header-actions-start class="header-actions"><calcite-icon icon=effects></calcite-icon></div><form slot=chat-entry class="chat-entry" @submit=${(o) => {
-      o.preventDefault();
-      const u = e.trim();
-      u && (this.assistantEl.value?.submitMessage(u), this.inputText = "");
-    }} ${T(this.formEl)}><arcgis-portal-mentionable-text-area .portal=${a} .user=${r} rows=3 .popoverListLabel=${t.mentionEntities} .placeholder=${t.placeholder} .value=${e} @arcgisUserMentionableTextAreaKeyDown=${({ detail: o }) => {
-      o.key === "Enter" && !o.shiftKey && (o.preventDefault(), this.formEl.value?.requestSubmit());
-    }} @arcgisUserMentionableTextAreaChange=${({ detail: o }) => {
-      this.inputText = o ?? "";
-    }} ${T(this.inputEl)}></arcgis-portal-mentionable-text-area><div class="chat-actions"><arcgis-portal-voice-input @arcgisVoiceInputStart=${() => {
+    }} ${q(this.assistantEl)}><div slot=header-actions-start class="header-actions"><calcite-icon icon=effects></calcite-icon></div><form slot=chat-entry class="chat-entry" @submit=${(c) => {
+      c.preventDefault();
+      const d = a.trim();
+      d && (this.assistantEl.value?.submitMessage(d), this.inputText = "");
+    }} ${q(this.formEl)}><arcgis-portal-mentionable-text-area .portal=${n} .user=${r} rows=3 .popoverListLabel=${t.mentionEntities} .placeholder=${t.placeholder} .value=${a} @arcgisUserMentionableTextAreaKeyDown=${({ detail: c }) => {
+      c.key === "Enter" && !c.shiftKey && (c.preventDefault(), this.formEl.value?.requestSubmit());
+    }} @arcgisUserMentionableTextAreaChange=${({ detail: c }) => {
+      this.inputText = c ?? "";
+    }} ${q(this.inputEl)}></arcgis-portal-mentionable-text-area><div class="chat-actions"><arcgis-portal-voice-input @arcgisVoiceInputStart=${() => {
       this.isListening = !0, this.isVoiceInputDisabled = !1;
     }} @arcgisVoiceInputStop=${() => {
       this.isListening = !1, this.isVoiceInputDisabled = !1;
-    }} @arcgisVoiceInputError=${(o) => {
-      o.detail.errorCode === "not-supported" && (this.showVoiceInput = !1);
-    }} @arcgisVoiceInputInterimTranscription=${(o) => {
-      this.inputText = o.detail.text;
-    }} ${T(this.voiceInputEl)}></arcgis-portal-voice-input>${l && w`<calcite-button icon-start=microphone .label=${t.voiceInput} round .disabled=${i} .appearance=${c ? "solid" : "outline-fill"} @click=${async () => {
+    }} @arcgisVoiceInputError=${(c) => {
+      c.detail.errorCode === "not-supported" && (this.showVoiceInput = !1);
+    }} @arcgisVoiceInputInterimTranscription=${(c) => {
+      this.inputText = c.detail.text;
+    }} ${q(this.voiceInputEl)}></arcgis-portal-voice-input>${u && b`<calcite-button icon-start=microphone .label=${t.voiceInput} round .disabled=${l} .appearance=${i ? "solid" : "outline-fill"} @click=${async () => {
       this.isVoiceInputDisabled = !0;
-      const o = this.voiceInputEl.value;
-      c ? await o?.stopListening() : await o?.startListening();
-    }}></calcite-button>` || ""}<calcite-button type=submit icon-start=send round .disabled=${!e.trim()} .label=${t.send}>${t.send}</calcite-button></div></form><arcgis-assistant-agent .agent=${Tt} .context=${{ portal: a, user: r }}></arcgis-assistant-agent><arcgis-assistant-agent .agent=${Lt} .context=${{ portal: a, user: r }}></arcgis-assistant-agent><arcgis-assistant-agent .agent=${ae} .context=${{ portal: a, user: r }}></arcgis-assistant-agent>${this.interrupt && w`<arcgis-portal-ai-assistant-interrupt slot=interrupt .type=${this.interrupt.type} .message=${this.interrupt.message} .options=${this.interrupt.options} @arcgisSubmit=${({ detail: o }) => {
-      this.assistantEl.value?.submitInterrupt(o);
+      const c = this.voiceInputEl.value;
+      i ? await c?.stopListening() : await c?.startListening();
+    }}></calcite-button>` || ""}<calcite-button type=submit icon-start=send round .disabled=${!a.trim()} .label=${t.send}>${t.send}</calcite-button></div></form>${this.isAgentEnabled("itemAnalytics") && b`<arcgis-assistant-agent .agent=${Ga} .context=${{ portal: n, user: r, navigationTargetMap: o }}></arcgis-assistant-agent>` || ""}${this.isAgentEnabled("groupCreation") && b`<arcgis-assistant-agent .agent=${Pt} .context=${{ portal: n, user: r, navigationTargetMap: o }}></arcgis-assistant-agent>` || ""}${this.isAgentEnabled("docAssistant") && b`<arcgis-assistant-agent .agent=${Wt} .context=${{ portal: n, user: r, navigationTargetMap: o }}></arcgis-assistant-agent>` || ""}${this.isAgentEnabled("groupAnalytics") && b`<arcgis-assistant-agent .agent=${ha} .context=${{ portal: n, user: r, navigationTargetMap: o }}></arcgis-assistant-agent>` || ""}${this.isAgentEnabled("navigation") && b`<arcgis-assistant-agent .agent=${wn} .context=${{ portal: n, user: r, navigationTargetMap: o }}></arcgis-assistant-agent>` || ""}${this.interrupt && b`<arcgis-portal-ai-assistant-interrupt slot=interrupt .type=${this.interrupt.type} .message=${this.interrupt.message} .options=${this.interrupt.options} @arcgisSubmit=${({ detail: c }) => {
+      this.assistantEl.value?.submitInterrupt(c);
     }} @arcgisCancel=${() => {
       this.assistantEl.value?.cancelInterrupt();
     }}></arcgis-portal-ai-assistant-interrupt>` || ""}</arcgis-assistant>`;
   }
 }
-Z("arcgis-portal-ai-assistant", ne);
+Ue("arcgis-portal-ai-assistant", Mn);
 export {
-  ne as ArcgisPortalAiAssistant
+  Mn as ArcgisPortalAiAssistant
 };