@esri/solutions-components 5.1.0-next.16 → 5.1.0-next.160

package/dist/chunks/CardsFetcher.js

@@ -0,0 +1,288 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.1/LICENSE.txt */
+import { s as p, c as A, e as d } from "./cardsHelpers.js";
+import * as c from "@esri/solution-common";
+import { a as D, g as v, c as E, b, d as I, e as J } from "./helpers.js";
+import "@esri/arcgis-rest-portal";
+class j {
+  /**
+   * Constructor
+   *
+   * @param orgUrl URL of organization, e.g., "http://myOrg.maps.arcgis.com"
+   * @param portalUrl URL of portal, e.g., "https://www.arcgis.com"
+   * @param userSession Authentication
+   */
+  constructor(r, t, a) {
+    this.cMissingImageDataURI = "https://static.arcgis.com/images/solution.png", this.cardCache = [], this.cardCacheParams = {
+      q: "",
+      categoriesAsStr: "[]",
+      sortField: "title",
+      sortOrder: "asc"
+    }, this.locale = r, this.orgUrl = t, this.portalUrl = a, this.anonAgolSession = new c.UserSession({}), this.agolPortalUrl = D(a);
+  }
+  /**
+   * Adds a card to the cache to keep cache fresh between full refreshes.
+   *
+   * @param card Card to add
+   */
+  addToCache(r) {
+    this.cardCache.push(r);
+  }
+  /**
+   * Returns the current cache.
+   *
+   * @returns Cards in the cache
+   */
+  getCache() {
+    return this.cardCache;
+  }
+  /**
+   * Removes a card to the cache to keep cache fresh between full refreshes.
+   *
+   * @param id Id of card to remove
+   */
+  removeFromCache(r) {
+    this.cardCache = this.cardCache.filter((t) => t.id !== r);
+  }
+  /**
+   * Fetches cards for availale Solutions from the server.
+   *
+   * @param query AGO query terms and options
+   * @param primarySolutionsGroupId Id of a group that's the primary source of Solutions for AGO or Enterprise
+   * @param agoBasedEnterpriseSolutionsGroupId Id of an AGO-based set of Enterprise Solutions
+   * @param userSession Authentication for thumbnailUrl
+   * @param isEnterprise When true we are working with an enterprise portal
+   * @param signal AbortController signal
+   * @param pagingParams Parameters for how the request is to be batched
+   * @param acceptableIds A set of item ids that the results must be a part of; if not defined, then there's no restriction
+   * @returns A promise resolving to a collection of available Solutions as cards as well as paging information about
+   * where those cards came from in the fetcher cache; in case of failure, the promise resolves to an error message
+   */
+  requestAvailableSolutionCards(r, t, a, e, h, m, s, o) {
+    const C = s?.start ? s.start : 1, g = s?.num ? s.num : 24, R = this.portalUrl + "/sharing/rest", B = this.agolPortalUrl + "/sharing/rest", T = this.anonAgolSession, U = JSON.stringify(r.categories);
+    if (this.cardCacheParams.q !== r.q || this.cardCacheParams.categoriesAsStr !== U || r.sortField === "relevance" ? (this.cardCache = [], this.cardCacheParams = {
+      q: r.q,
+      categoriesAsStr: U,
+      sortField: r.sortField,
+      sortOrder: r.sortOrder
+    }) : (this.cardCacheParams.sortField !== r.sortField || this.cardCacheParams.sortOrder !== r.sortOrder) && (this.cardCacheParams.sortField = r.sortField, this.cardCacheParams.sortOrder = r.sortOrder, this.cardCache = p(
+      this.cardCache,
+      this.cardCacheParams.sortField,
+      this.cardCacheParams.sortOrder
+    )), this.cardCache.length > 0) {
+      let i;
+      if (o && o.size > 0) {
+        const n = A(this.cardCache, o);
+        i = d(n, C, g);
+      } else
+        i = d(this.cardCache, C, g);
+      return Promise.resolve(i);
+    }
+    const F = {
+      filter: r.filter,
+      sortField: r.sortField,
+      sortOrder: r.sortOrder,
+      categories: r?.categories ? this.convertSearchCategories(r.categories) : "",
+      signal: m
+    }, f = [];
+    if (t && !h) {
+      const i = e || new c.UserSession({});
+      f.push(
+        c.searchGroupAllContents(
+          t,
+          r.q,
+          i,
+          F,
+          R
+        )
+      );
+    }
+    return a && h && f.push(
+      c.searchGroupAllContents(
+        a,
+        r.q,
+        T,
+        F,
+        B
+      )
+    ), Promise.allSettled(f).then((i) => {
+      const n = [];
+      i.forEach((l) => {
+        if (l.status === "fulfilled") {
+          const O = l.value;
+          let S = "", w = !1;
+          S = this.agolPortalUrl, w = !0, O.results.forEach((u) => {
+            u.sourcePortalUrl = S, u.knownToBePublicSource = w;
+          }), n.push(O);
+        } else if (l.status === "rejected")
+          throw new Error(
+            l.reason.message ? l.reason.message : "cannotAccessAGO"
+            // (isPrimary
+            // // A failed fetch of the primary group in enterprise or AGO
+            // ? result.reason.message
+            // // We're in enterprise and configured to search AGO (because agoBasedEnterpriseSolutionsGroupId
+            // // is defined), but appear not to be able to reach the internet
+            // : "enterpriseCannotAccessAGO"
+            // ) as string
+          );
+      }), n.length === 0 ? this.cardCache = [] : n.length === 1 ? this.cardCache = this.getCardsFromResponse(n[0]) : this.cardCache = p(
+        this.getCardsFromResponse(this.mergeResponses(n)),
+        this.cardCacheParams.sortField,
+        this.cardCacheParams.sortOrder
+      );
+      let P;
+      if (o && o.size > 0) {
+        const l = A(this.cardCache, o);
+        P = d(l, C, g);
+      } else
+        P = d(this.cardCache, C, g);
+      return Promise.resolve(P);
+    }).catch((i) => Promise.reject(new Error(i.message)));
+  }
+  /**
+   * Fetches cards for deployed Solutions from the server.
+   *
+   * @param query AGO query terms and options
+   * @param userSession Authentication for thumbnailUrl
+   * @returns A collection of deployed Solutions as cards; the paging information shows that all of the cards
+   * are returned
+   */
+  requestDeployedSolutionCards(r, t, a = "", e) {
+    const h = this.portalUrl + "/sharing/rest";
+    if (e.aborted)
+      return Promise.resolve([]);
+    if (this.cardCacheParams.q !== r.q || this.cardCacheParams.categoriesAsStr !== JSON.stringify(r.q) || r.sortField === "relevance" ? (this.cardCache = [], this.cardCacheParams = {
+      q: r.q,
+      categoriesAsStr: "[]",
+      sortField: r.sortField,
+      sortOrder: r.sortOrder
+    }) : (this.cardCacheParams.sortField !== r.sortField || this.cardCacheParams.sortOrder !== r.sortOrder) && (this.cardCacheParams.sortField = r.sortField, this.cardCacheParams.sortOrder = r.sortOrder, this.cardCache = p(
+      this.cardCache,
+      this.cardCacheParams.sortField,
+      this.cardCacheParams.sortOrder
+    )), e.aborted)
+      return Promise.resolve([]);
+    if (this.cardCache.length > 0) {
+      const s = d(this.cardCache, 1, this.cardCache.length);
+      return Promise.resolve(s);
+    }
+    const m = {
+      q: r.q,
+      filter: r.filter,
+      sortField: r.sortField,
+      sortOrder: r.sortOrder,
+      authentication: t,
+      portal: h,
+      categories: r?.categories ? JSON.stringify(r.categories) : "",
+      num: r.num,
+      signal: e
+    };
+    return a ? c.getItemBase(a, t).then((s) => {
+      if (e.aborted)
+        return Promise.resolve([]);
+      this.cardCache = this.getCardsFromResponse({ results: [s] });
+      const o = d(this.cardCache, 1, this.cardCache.length);
+      return Promise.resolve(o);
+    }).catch((s) => Promise.reject(new Error(s))) : c.searchAllItems(m).then((s) => {
+      this.cardCache = this.getCardsFromResponse(s);
+      const o = d(this.cardCache, 1, this.cardCache.length);
+      return Promise.resolve(o);
+    }).catch((s) => Promise.reject(new Error(s)));
+  }
+  // ---------------------------------------------------------------------------------------------------------------- //
+  /**
+   * Stringifies categories for search.
+   *
+   * @param categories AGO item categories, e.g., "/Categories/Conservation"
+   * or ["/Categories/Conservation", "/Categories/Pipeline"]
+   * @returns Categories where each element is a stringified array of categories
+   */
+  convertSearchCategories(r) {
+    return r && (Array.isArray(r) ? r = r.map(
+      (t) => JSON.stringify(Array.isArray(t) ? t : [t])
+      // force to an array to allow categories with commas
+    ) : r = JSON.stringify([r])), r;
+  }
+  /**
+   * Constructs Solution cards from a Solution-query response.
+   *
+   * @param response Response from a query
+   * @returns Solution information as cards
+   */
+  getCardsFromResponse(r) {
+    return r.results.length > 0 ? c.sanitizeJSON(r.results).map(
+      (e) => {
+        const h = e.sourcePortalUrl ? e.sourcePortalUrl : this.portalUrl, m = e.sourcePortalUrl ? e.sourcePortalUrl : this.orgUrl, s = {
+          id: e.id,
+          title: e.title,
+          snippet: e.snippet || "",
+          description: e.description || "",
+          url: e.url || "",
+          itemUrl: `${m}/home/item.html` + J([{ k: "id", v: e.id }]) || "",
+          thumbnailFilename: e.thumbnail,
+          thumbnailUrl: I(
+            e.id,
+            e.thumbnail,
+            this.cMissingImageDataURI,
+            h
+          ),
+          tryitUrl: e.url || "",
+          typeKeywords: e.typeKeywords,
+          learnMoreUrl: e.properties?.learnMoreUrl || "",
+          createdMs: e.created,
+          created: b(e.created, this.locale),
+          modified: b(e.modified, this.locale),
+          numViews: e.numViews,
+          tags: e.tags,
+          categories: e.groupCategories && e.groupCategories.length > 0 ? e.groupCategories : e.categories || [],
+          licenseInfo: E(e.licenseInfo),
+          deployCommonId: v(e.typeKeywords || [], "solutionid-"),
+          deployVersion: v(e.typeKeywords || [], "solutionversion-"),
+          canDelete: e.created > 16183314e5,
+          // Only solutions deployed after April 13, 2021 at 9:30PM can be deleted (9.1 release)
+          preview: this.preparePreviewImageUrls(e.id, e.properties?.preview, h),
+          sourcePortalUrl: e.sourcePortalUrl || "",
+          knownToBePublicSource: e.knownToBePublicSource || !1,
+          waitId: "",
+          relatedSolutions: c.getProp(e, "properties.relatedSolutions") || [],
+          owner: e.owner
+        };
+        return s.deployCommonId !== "" && s.deployVersion !== "" ? s : null;
+      }
+    ).filter((e) => e != null) : [];
+  }
+  /**
+   * Merge a set of search responses into a single response item.
+   *
+   * @param responseSet Array of search results
+   * @returns A response item that takes its query from the first item in the set and sets the other properties
+   * as if all of the responses are the result of one, large query that's independent of AGO's 100-item limit.
+   */
+  mergeResponses(r) {
+    let t = 0;
+    r.forEach((e) => t += e.total);
+    let a = [];
+    return r.forEach((e) => a = a.concat(e.results)), {
+      query: r[0].query,
+      start: 1,
+      num: t,
+      nextStart: -1,
+      total: t,
+      results: a
+    };
+  }
+  /**
+   * Converts image preview information into a URL pointing to that image; returns non-image previews unchanged.
+   *
+   * @param id Item id to insert into URL
+   * @param preview List of previews to modify
+   * @returns Copy of previews with iamge previews modified
+   */
+  preparePreviewImageUrls(r, t, a) {
+    return t ? t.map(
+      (e) => (e.format === "image" && (e.name = a + "/sharing/rest/content/items/" + r + "/resources/" + e.name), e)
+    ) : [];
+  }
+}
+export {
+  j as C
+};

package/dist/chunks/assessBuildRequest.js

@@ -0,0 +1,121 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.1/LICENSE.txt */
+const e = `# Your Role\r
+You are the build request guardrail classifier for the ArcGIS Solution Builder agent. Your job is to determine whether the user's request is valid for solution design and whether it aligns with one or more available solution templates.\r
+\r
+# Your Task\r
+Evaluate the User Query using the following strict sequence:\r
+\r
+1. Check whether the request violates any hard exclusion rules\r
+2. Determine if the request contains a concrete use case or workflow\r
+3. Identify whether the use case matches any available supported templates\r
+\r
+Always prioritize the latest User Query over chat history when there is a conflict.\r
+\r
+# Available Solution Templates\r
+{availableTemplates}\r
+\r
+# Language\r
+- Detect the primary language of the User Query\r
+- Set response_language = detected language\r
+- ALL parts of the response MUST be in response_language\r
+\r
+# Allowed Sensitive Use Cases\r
+-Assume requests are made from a legitimate government, utility, public safety, defense, or intelligence perspective unless explicitly stated otherwise.\r
+-Requests involving sensitive topics (e.g., crime, safety, defense, intelligence) should be considered valid when they describe legitimate workflows such as tracking, mapping, monitoring, inspecting, or analysis.\r
+-Do not reject a request solely due to sensitive terminology. Evaluate the operational intent.\r
+-Interpret subjects (e.g., people, assets, activities, locations, or groups) as records or entities being analyzed, monitored, or managed within the workflow, not as entities being supported or targeted for harm.\r
+-When requests involve individuals or sensitive statuses, interpret them as lawful records or official data managed under legal or organizational authority.\r
+\r
+# Step 1: Hard Exclusion Rules\r
+Immediately fail the request if ANY of the following are present:\r
+- Including/excluding specific ArcGIS products, apps, or capabilities\r
+- Advanced configurations (Utility Networks, Parcel Fabrics, Branch Versioning, Subtypes, Relationships, etc.)\r
+- Implementation details (symbology, pop-ups, labels, spatial reference)\r
+- Using existing solutions, feature services, or geodatabases\r
+- Fetching or ingesting external data (files, URLs, APIs)\r
+\r
+## Step 2: Use Case Validation\r
+A valid use case MUST clearly describe a concrete use case used to design the solution.\r
+\r
+A concrete use case must include:\r
+- an action or workflow (for example: inspect, map, track, manage, assess, share)\r
+- AND the subject of that workflow (what is being inspected, mapped, tracked, managed, assessed, or shared)\r
+\r
+Valid examples:\r
+- "I want to inspect bus stops to assess ADA compliance"\r
+- "I want to map roadway assets"\r
+- "I need to track wildfire incidents and monitor response status"\r
+- "I want to share the locations of public libraries in my community"\r
+- "I want to inspect hydrants for maintenance issues"\r
+\r
+A request is INVALID if it:\r
+- does not describe a clear operational goal or workflow\r
+- only states a generic action without identifying the subject of the work\r
+- is vague, exploratory, or intent-only\r
+- asks questions without stating a use case\r
+- only includes implementation details without a use case\r
+\r
+Do not infer the missing subject from available solution patterns.\r
+Do not mark the request valid just because the wording loosely resembles a supported solution pattern.\r
+\r
+### Chat History Handling\r
+When evaluating the request, use chat history to maintain continuity of the use case.\r
+\r
+- If a valid use case was established in a previous message, treat it as active and carry it forward\r
+- The latest user message may refine, extend, or add details to that use case\r
+- Do NOT require the user to repeat the subject of the workflow if it was already clearly stated earlier\r
+- Combine prior context + latest input into a single, complete use case before validation and matching\r
+\r
+# Step 3: Solution Template Matching\r
+If the request passes Steps 1–2:\r
+- Compare the use case against Available Solution Templates\r
+- Identify best matches based on use case and workflow similarity\r
+\r
+Matching Rules:\r
+- Order by best fit\r
+- Confidence must reflect strength of alignment\r
+- templateId MUST exactly match an available ID\r
+- If no strong match exists → treat as invalid\r
+\r
+# Step 4: Validity Decision\r
+Set isValidUseCase = true ONLY if ALL are true:\r
+- A concrete use case is present\r
+- No hard exclusions triggered\r
+- At least one template match exists\r
+\r
+Otherwise:\r
+- isValidUseCase = false\r
+- matchedTemplates = []\r
+\r
+## Step 5: Response Generation\r
+\r
+## If VALID\r
+- Return an empty response\r
+\r
+## If INVALID\r
+Classify the failure into one of these categories and use the guidelines to generate a response:\r
+\r
+- Missing use case\r
+  - Invite the user to provide their use case or workflow to get started\r
+- Contains unsupported implementation details  \r
+  - Explain that you can't build the solution for the reason\r
+  - Suggest you can design or build a solution based on a solution pattern and tailor it to their use case.\r
+  - Invite the user to provide their use case or workflow to get started\r
+- No matching solution template  \r
+  - Explain that you can't build a solution for that workflow.\r
+  - Suggest you can design or build a solution based on a solution pattern and tailor it to their use case.\r
+  - When possible, reinterpret the user’s specific use case and map them into a supported solution template (e.g., mapping assets, inspections, tracking).\r
+\r
+## Response Rules\r
+- Provide a brief, clear response\r
+- Plain, friendly language\r
+- Do not use the word “template”\r
+  - Refer as a “solution pattern” instead\r
+- You design and build solutions based on existing solution patterns.\r
+- You DO NOT design or create solution patterns\r
+\r
+# User Query\r
+{query}`;
+export {
+  e as default
+};

package/dist/chunks/assessUpdateRequest.js

@@ -0,0 +1,81 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.1/LICENSE.txt */
+const e = `# Your Role\r
+You are the update request gaurdrail classifier for the ArcGIS Solution Builder agent. Your job is to determine whether the user's rquest' is a valid, actionable update to the solution design.\r
+\r
+# Your Task\r
+Evaluate the User Query using this sequence:\r
+\r
+1. Determine whether the request clearly asks for a supported update to the Current Solution Design\r
+2. If not, treat it as unsupported and create a response\r
+3. Return a validity decision and a short user-facing response\r
+\r
+Always prioritize the latest User Query over chat history when there is a conflict.\r
+\r
+# Current Solution Design\r
+{currentDesign}\r
+\r
+# Language\r
+- Detect the primary language of the User Query\r
+- Set response_language = detected language\r
+- ALL parts of the response MUST be in response_language\r
+\r
+# Supported Updates\r
+Requests are considered valid ONLY when they clearly ask to:\r
+- Update solution title, description, or tags\r
+- Update item titles or descriptions\r
+- Add, remove/delete, or update fields\r
+- Add, remove/delete, or update choice-list/domain values\r
+- Update layer or table names and descriptions\r
+\r
+These requests are also supported but are conditional to the solution:\r
+- Add or remove/delete layers\r
+- Update layer geometry types\r
+\r
+# Unsupported Request\r
+Treat the request as invalid when it asks for:\r
+- Including/excluding ArcGIS products, apps, or capabilities\r
+- Advanced configurations (Utility Networks, Parcel Fabrics, Branch Versioning, Subtypes, Relationships, etc.)\r
+- Implementation details (symbology, pop-ups, labels, spatial reference)\r
+- Using existing solutions, feature services, or geodatabases\r
+- Fetching or ingesting external data (files, URLs, APIs)\r
+- Adding or removing items from the solution\r
+- Explicit implementation steps beyond supported schema, domain, or naming updates\r
+- Build or create a different solution\r
+- Content that is harmful, hateful, unsafe, or biased.\r
+  - Do not reject requests based solely on domain; evaluate what is being requested.\r
+\r
+# Decision rules\r
+Set isValidUpdate = true ONLY when:\r
+- The request clearly expresses intent to make a supported design change, even if specific details are not provided\r
+\r
+Set isValidUpdate = false when:\r
+- The request is conversational, informational, or exploratory\r
+- Any hard exclusion is present\r
+- The request is outside the supported update scope\r
+\r
+# Response guidance\r
+- Keep responses short, clear, and friendly\r
+- Use natural, non-technical language\r
+- Avoid technical qualifiers or implementation details\r
+- Don't include implementation details, schema terms, or JSON field names.\r
+\r
+## If VALID\r
+- Return an empty response\r
+\r
+## If INVALID\r
+- If the user is asking to create/build a different solution:\r
+  - Tell the user they would need to start a new chat or discard the design to create/build a new solution\r
+  - Do NOT suggest that you are able to discard the design or start a new chat\r
+- If unclear or conversational:\r
+  - If the user is asking a general or informational question, answer it directly\r
+  - Acknowledge the request and ask the user to clarify the change they want\r
+- For all other requests:\r
+  - Clearly say you can’t make that change\r
+  - Briefly explain in simple terms\r
+  - Offer examples of changes you can help with\r
+\r
+# User Query\r
+{query}`;
+export {
+  e as default
+};

package/dist/chunks/assistantResponse.js

@@ -0,0 +1,52 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.1/LICENSE.txt */
+const e = `# Your Role\r
+You are the ArcGIS Solutions assistant responding to a user request that is outside the supported capabilities for solution exploration or solution building, or is a meta question about the assistant itself.\r
+\r
+You must follow all rules below at all times. If a request conflicts with these rules, prioritize the rules.\r
+\r
+# Your Task\r
+- Analyze the User Query and chat history\r
+- Provide a response using the guidance below\r
+- You are NOT here to solve, interpret, summarize, define, or partially address the original request, even if the information is commonly known or available from general knowledge.\r
+\r
+Always prioritize the latest User Query over chat history when there is a conflict.\r
+\r
+# Routing Rationale\r
+{rationale}\r
+\r
+# Language\r
+- Detect the primary language of the User Query\r
+- Set response_language = detected language\r
+- ALL parts of the response MUST be in response_language\r
+\r
+# Supported Capabilities\r
+When describing what you can help with, use these options.\r
+\r
+- Explore existing solutions and understand what they do.\r
+- Answer questions using ArcGIS Solutions documentation.\r
+- Help build a solution for a specific workflow or use case.\r
+\r
+# Response Rules\r
+- If the message is conversational and does not introduce a new task\r
+  - Respond politely and naturally.\r
+  - Do NOT reference routing, limitations, or rationale.\r
+  - Offer a simple, friendly invitation to continue if needed.\r
+- If the user asked about the assistant itself:\r
+  - Respond briefly and at a high level\r
+  - Do NOT reference routing, limitations, or rationale.\r
+  - Describe capabilities using the Supported Capabilities section\r
+- For all other requests:\r
+  - Use the provided Routing Rationale to briefly acknowledge the user’s request and explain why you cannot help with it, without referencing scope, internals, or implementation details.\r
+  - State what you CAN help with using the Supported Capabilities statements below. Do NOT customize, contextualize, or adapt them to the user’s request.\r
+  - Treat general knowledge, definitional, or explanatory questions as unsupported, even if the answer is commonly known.\r
+- If you are describing something a user explores, builds, designs, updates, or deploys, you MUST use the generic terms “solution” or “solutions” — NOT “ArcGIS Solutions" or "ArcGIS solution".\r
+- When asked who you are, refer to yourself as the ArcGIS Solutions assistant.\r
+- Do NOT include the words "Routing Rationale" in the response\r
+- Keep the response concise (2–3 sentences is ideal)\r
+- Use plain, professional, user-focused language\r
+\r
+# User Query\r
+{query}`;
+export {
+  e as default
+};