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

package/dist/chunks/arcgisKnowledgeGraph.js

@@ -0,0 +1,229 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.1/LICENSE.txt */
+import { StateGraph as x, START as k, END as c, Command as b } from "@langchain/langgraph/web";
+import { a as K, c as _, b as T, d as A, e as S, s as M, q as v, g as u, h as q, t as g, r as C, i as E, G, j as m } from "./adapter.js";
+import "@arcgis/core/identity/IdentityManager.js";
+import "@arcgis/core/portal/Portal.js";
+import "@arcgis/toolkit/string";
+import { h as N, e as R } from "./generateLayerDescriptions.js";
+import { AIMessage as y } from "@langchain/core/messages";
+import "@langchain/core/callbacks/dispatch/web";
+import "@langchain/openai";
+import "@arcgis/core/config.js";
+import "@arcgis/core/core/reactiveUtils.js";
+import "@arcgis/core/layers/FeatureLayer.js";
+import "@arcgis/core/request.js";
+import { ToolNode as L } from "@langchain/langgraph/prebuilt";
+import { s as p, a as z } from "./index.js";
+import "@langchain/core/prompts";
+const w = [
+  K,
+  _,
+  T,
+  A,
+  S,
+  M,
+  v
+];
+async function D(e, t) {
+  const o = await u("arcgis_knowledge_tool_prompt"), s = q(t), n = {
+    assignedTask: e.agentExecutionContext.assignedTask,
+    userRequest: e.agentExecutionContext.userRequest,
+    priorSteps: e.agentExecutionContext.priorSteps,
+    contextType: s
+  }, r = await N({
+    promptText: o,
+    messages: e.arcgisKnowledgeMessages,
+    inputVariables: n,
+    tools: w,
+    config: t
+  }), l = (r.tool_calls?.length ?? 0) > 0, a = typeof r.text == "string" ? r.text.trim() : "", i = a.length > 0, d = r.content.toString();
+  return !l && (s === "map" || s === "knowledgeGraph") ? {
+    ...e,
+    arcgisKnowledgeMessages: [...e.arcgisKnowledgeMessages, r],
+    outputMessage: s === "map" ? "No tools were found for the current view and prompt. Maps do not support changing nonspatial visibility, layout changes, or generation from queries." : "No tools were found for the current prompt and knowledge graph service. A knowledge graph service only supports search and query.",
+    status: "success"
+  } : {
+    ...e,
+    arcgisKnowledgeMessages: [...e.arcgisKnowledgeMessages, r],
+    outputMessage: l ? d : a,
+    status: l ? e.status : i ? "success" : "failed",
+    summary: d ? g(d) : "ArcGIS Knowledge Agent tool executed."
+  };
+}
+const f = {
+  generateCypher: "generated-cypher-query",
+  queryGraphData: "graph-query-result",
+  searchGraphData: "graph-search-result",
+  addRecords: "added-records",
+  applyLayout: "applied-layout",
+  changeNonspatialVisibility: "changed-nonspatial-visibility",
+  createLinkChart: "created-link-chart"
+};
+function F(e) {
+  return !!e && e.status === "success" && !!f[e.toolName];
+}
+function $(e) {
+  return {
+    type: f[e.toolName],
+    data: e.details
+  };
+}
+async function I(e, t) {
+  const o = new L(w, { handleToolErrors: !1 });
+  try {
+    const s = await o.invoke(
+      {
+        messages: e.arcgisKnowledgeMessages
+      },
+      t
+    ), n = [];
+    for (const a of s.messages) {
+      let i;
+      if (typeof a.content != "string")
+        throw new Error(`Unexpected tool message content type: ${typeof a.content}. Expected string.`);
+      try {
+        i = JSON.parse(a.content);
+      } catch {
+        throw new Error(
+          `Failed to parse tool message content as JSON. Tool: ${a.name ?? "unknown"}.
+
+ Original Content: ${a.content}`
+        );
+      }
+      if (!i || typeof i != "object" || !("toolName" in i))
+        throw new Error(
+          `Parsed tool message content does not have expected structure. Parsed content: ${JSON.stringify(i)}`
+        );
+      n.push(i);
+    }
+    await p(
+      {
+        text: `Finished executing ArcGIS Knowledge Agent tools: ${s.messages.filter((a) => a.name).map((a) => a.name).join(", ")}`
+      },
+      t
+    );
+    const r = n.filter((a) => typeof a != "string").map((a) => `- Called Tool: ${a.toolName}, Status: ${a.status}`), l = n[0];
+    return l && F(l) && await z($(l), t), {
+      ...e,
+      outputMessage: r.join(`
+`),
+      summary: r.length ? g(r.join(`
+`)) : "ArcGIS Knowledge Agent did not execute any tools or return any results.",
+      arcgisKnowledgeMessages: [...e.arcgisKnowledgeMessages, ...s.messages],
+      arcgisKnowledgeToolResult: n
+    };
+  } catch (s) {
+    const n = s instanceof Error ? s.message : String(s);
+    return await p(
+      { text: `ArcGIS Knowledge Agent tool execution failed unexpectedly: ${n}` },
+      t
+    ), {
+      ...e,
+      outputMessage: `ArcGIS Knowledge Agent tool execution failed unexpectedly: ${n}`,
+      status: "failed",
+      summary: g(`ArcGIS Knowledge Agent tool execution failed unexpectedly: ${n}`),
+      arcgisKnowledgeMessages: [...e.arcgisKnowledgeMessages]
+    };
+  }
+}
+const V = (e, t) => (
+  //agent services (ex: embeddingsWorker) would go in the array below, if required.
+  C([], "ArcgisKnowledge Agent")(e, t)
+);
+async function j(e, t) {
+  const s = (e.arcgisKnowledgeToolResult ?? []).map((d) => ({
+    ...d,
+    details: void 0
+    // Remove details to avoid overwhelming the LLM with too much info
+  })), { knowledgeGraph: n } = await E(t), r = G.getDataModelTypesSummary(n.dataModel), l = {
+    assignedTask: e.agentExecutionContext.assignedTask,
+    userRequest: e.agentExecutionContext.userRequest,
+    toolResult: s,
+    dataModelSummary: r
+  }, a = await R({
+    promptText: await u("arcgis_knowledge_summarize_result_prompt"),
+    modelTier: "default",
+    inputVariables: l,
+    config: t
+  }), i = typeof a == "string" ? a : a.content;
+  return {
+    ...e,
+    outputMessage: i,
+    status: "success",
+    summary: g(i),
+    arcgisKnowledgeMessages: [...e.arcgisKnowledgeMessages, new y(i)]
+  };
+}
+async function O(e) {
+  const t = e.arcgisKnowledgeToolResult?.[0], o = t?.status === "success" ? t.summary : "ArcGIS Knowledge Agent tool execution failed.";
+  return {
+    ...e,
+    outputMessage: o,
+    status: "success",
+    summary: g(o),
+    arcgisKnowledgeMessages: [...e.arcgisKnowledgeMessages, new y(o)]
+  };
+}
+function h(e) {
+  return async (t, o) => o?.signal?.aborted ? (await p({ text: "Knowledge Agent execution cancelled" }, o), new b({
+    goto: c,
+    update: {
+      outputMessage: "Knowledge Agent execution cancelled",
+      summary: "Knowledge Agent execution cancelled",
+      status: "failed"
+    }
+  })) : await e(t, o);
+}
+const P = () => new x(m).addNode("requireArcgisKnowledgeServices", V).addNode("agent", h(D)).addNode("tools", h(I)).addNode("summarizationLLM", h(j)).addNode("finalizeToolSummary", h(O)).addEdge(k, "requireArcgisKnowledgeServices").addEdge("requireArcgisKnowledgeServices", "agent").addConditionalEdges("agent", (t) => (t.arcgisKnowledgeMessages[t.arcgisKnowledgeMessages.length - 1]?.tool_calls?.length ?? 0) > 0 ? "tools" : c).addConditionalEdges("tools", (t) => {
+  if (t.status === "failed")
+    return c;
+  const o = t.arcgisKnowledgeToolResult?.[0];
+  return o?.status === "success" && ["applyLayout", "changeNonspatialVisibility"].includes(o.toolName) ? "finalizeToolSummary" : "summarizationLLM";
+}).addEdge("summarizationLLM", c).addEdge("finalizeToolSummary", c), J = String.raw`The purpose of this agent is to work with Knowledge Graph data, a graph database technology that represents and stores data as interconnected entities (nodes) and relationships (edges).
+This agent has two categories of skills: those that work with an active link chart visualization of a subset of the data in the knowledge graph, and those that work with the knowledge graph data more generally against the entire dataset in the service and database.
+For link charts, the agent enables users to interact with a link chart by adding new entities (also called nodes) or relationships (also called edges), removing existing entities or relationships, 
+expanding the graph from particular entities, finding relationships between specified entities on the link chart and adding them to the link chart, finding all relationships 
+that exist out from specified entities and adding those to the link chart, changing whether or not nonspatial data is visible, or changing the layout of the link chart.  
+This agent is designed to handle requests that manipulate the specific link chart.
+For knowledge graph data more generally, the agent can generate Open Cypher queries based on user prompts that represent inquiries into the data of the knowledge service and its graph database,
+and can alternatively use those queries to create a new link chart visualization from the results if requested.
+
+Supported actions:
+- **Change or Apply Layout**: Changes the current layout visualization strategy of the link chart  (e.g., "Change the layout to basic-grid", "Apply hierarchical layout").  Valid layout types include organic-standard, organic-community, basic-grid, hierarchical-bottom-to-top, radial-root-centric, tree-left-to-right, geographic-organic-standard, chronological-mono-timeline.  A best effort should be made to transform the user's request into one of these layout types.
+- **Change Nonspatial Data Visibility**: Changes whether or not nonspatial data is visible on the link chart (e.g., "Show nonspatial data", "Hide nonspatial data").  Valid settings are "hidden" and "visible".  A best effort should be made to transform the user's request into one of these settings.
+- **Generate a cypher query**: Generates an Open Cypher query based on the user's prompt which represents an inquiry into the data of the knowledge service and its graph database, attempting to filter based on certain conditions and traverse specified relationships. The generated query should be syntactically correct and optimized for performance.  The user should explicitly request that a cypher query be returned - if they do not, the purpose of the query is for one of the other tools or skills.
+- **Create a New Link Chart from a user prompt**: Identifies that the users prompt is an inquiry into the data of the knowledge service and its graph database and creates a new link chart from the results.  The user should have requested that a link chart be created or made(or similar term) from their prompt
+- **Add Records (entities or relationships)**: Identifies that the users prompt is an inquiry into the data of the knowledge graph service and its graph database, and that the user wants to take the result of the inquiry and add those entities and/or relationships to the link chart.  The generated query should be syntactically correct and optimized for performance.
+- **Search Graph Data**: Generates and runs a lucene syntax query based on the user's prompt, returning matching entity and relationship records from the knowledge graph.
+- **Query Graph Data**: Generates and executes a cypher query based on the user's prompt, and displays the results in the chat pane, allowing the user to explore the data in their knowledge graph.
+
+_example: "Change the layout to hierarchical-bottom-to-top"_  
+_example: "Apply radial-root-centric layout"_  
+_example: "Show nonspatial data"_  
+_example: "Hide nonspatial data"_
+_example: "Turn off nonspatial visibility"_
+_example: "Generate a cypher query to find all entities connected to 'Entity A' via 'Relationship X' that were created after 2020"_
+_example: "Generate a query to find all employees of Company Esri who joined after 2015 and are located in California"_
+_example: "Tell me how to find all products supplied by Supplier Y that have a price greater than $1000"_
+_example: "Create a new link chart showing all entities related to 'Entity B' through 'Relationship Y'"_
+_example: "Find all people who work for Microsoft and put them on a new link chart"_
+_example: "Add all entities connected to 'Entity C' via 'Relationship Z' to the current link chart"_
+_example: "Add all the people who work for Esri to the current link chart, and all the cars that they drive"_
+_example: "Find all the products supplied by Supplier X and add them to my visualization"_
+_example: "Expand the link chart from 'Entity D' to show its direct connections"_
+_example: "Find all the cars and then add everything up to two hops away from them on the link chart"_
+_example: "Connect Emma and Rob on the link chart if there is a relationship between them"
+_example: "Discover and add all the relationships originating at 'Entity E' to the link chart"_
+_example: "Show me all entities with a name similar to 'Smith' and add them to the link chart"_
+_example: "Find reports in my graph that have a title similar to 'Quarterly Earnings'"_
+_example: "Find John Smith and all people he has made phone calls to in the last year"_
+_example: "What is the average age of all people who work for Esri?"_`, le = {
+  id: "arcgisKnowledge",
+  name: "ArcgisKnowledge Agent",
+  description: J,
+  createGraph: P,
+  workspace: m
+};
+export {
+  le as A
+};

package/dist/chunks/arcgis_knowledge_current_lc_context.js

@@ -0,0 +1,25 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.1/LICENSE.txt */
+const e = `## Membership Bind Parameters
+
+The current link chart contains a subset of entities and relationships from the database. Their membership is available to Cypher queries as lists of string identifiers through these bind parameters:
+
+- $entityIds
+- $relationshipIds
+
+If, and ONLY if, the user is asking for data to be limited by the records already on 'the current link chart', 'my link chart', or similar, the generated Cypher should filter using these parameters.
+
+### START EXAMPLES
+
+User request: 'Add all records that are connected to people on this link chart to the link chart'
+Context: 'Person' entity in data model.
+Expected Result: MATCH (n:Person)-[r]->(m) WHERE id(n) IN $entityIds return r, m
+
+User request: 'Add all the suppliers to the link chart'
+Context: 'Supplier' entity in the data model.
+Expected Result: MATCH (s:Supplier) RETURN s
+
+### END EXAMPLES
+`;
+export {
+  e as default
+};

package/dist/chunks/arcgis_knowledge_current_map_context.js

@@ -0,0 +1,37 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.1/LICENSE.txt */
+const e = `## Membership Bind Parameters
+
+The current map contains a subset of entities and relationships from the database. Their membership is available to Cypher queries as lists of string identifiers through these bind parameters:
+
+- $entityIds
+- $relationshipIds
+
+Included Types:
+{nonDynamicTypes}
+
+Filtering rules:
+
+- Apply membership filtering only when BOTH are true:
+  - The user is asking for data to be limited by the records already on 'the current map', 'my map', 'the knowledge graph layer' or similar.
+  - The variable in the cypher query is a type in Included Types above.
+- IMPORTANT: In all other cases, DO NOT apply membership filtering. DO NOT include membership filters for any type not listed in Included Types above.
+
+### START EXAMPLES
+
+User request: 'Add all records that are connected to people on this map to the map'
+Context: 'Person' entity in data model and included in the bind parameter types above.
+Expected Result: MATCH (n:Person)-[r]->(m) WHERE id(n) IN $entityIds return r, m
+
+User request: 'Add all the suppliers to the map'
+Context: 'Supplier' entity in the data model.
+Expected Result: MATCH (s:Supplier) RETURN s
+
+User request: 'Add all suppliers connected to plants on my map'
+Context: 'Plant' entity in data model but not included in the bind parameter types above.
+Expected Result: MATCH (p:Plant)-[r]->(s:Supplier) return r, s
+
+### END EXAMPLES
+`;
+export {
+  e as default
+};

package/dist/chunks/arcgis_knowledge_cypher_query_prompt.js

@@ -0,0 +1,102 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.1/LICENSE.txt */
+const e = `# ArcGIS Knowledge Graph Cypher Rules
+
+## GOAL
+
+Generate a Cypher query that answers the user’s request and conforms to the data model.
+
+---
+
+## 1. USER OVERRIDES (HIGHEST PRIORITY)
+
+If the user specifies any of the following, ALWAYS follow their instructions over defaults:
+
+- LIMIT (or no limit)
+- Output columns / data model
+- Inclusion/exclusion of globalid
+- Ordering, grouping, filtering, projection
+
+---
+
+## 2. DATA MODEL CONFORMANCE (NON-NEGOTIABLE)
+
+Use ONLY valid data model elements.
+
+### Required
+
+- Use only valid entity types, relationship types, and properties
+- Ensure relationships connect valid entity types
+- infer direction from user prompt. if not clear use the least restrictive valid form supported by the model.
+
+### VALIDATION RULES (STRICT)
+
+- Enforce exact schema match: all entities, relationships, and properties must exist exactly in the data model
+- Validate relationship integrity: types, source→target pairing, and direction must match schema
+- Enforce field correctness: properties and filters must exist on the referenced type and use valid data types
+- Ensure alias consistency: each alias maps to one type only and cannot change meaning
+- Apply strict failure: if any component is invalid, do NOT generate the query and do NOT infer or repair
+
+## 4. PATH RESOLUTION
+
+- First attempt a direct relationship
+- If none exists → use a valid multi-hop path
+- Each hop MUST be valid in the data model
+- Max path length: 3 (unless user requests more)
+
+### Path selection
+
+- Prefer shortest valid path
+- If multiple valid paths exist → choose best match to user intent
+- If no valid path exists → do not speculate
+
+---
+
+## 5. PERFORMANCE
+
+- Use the minimal number of entities and relationships
+- Prefer shortest valid path
+- Avoid unnecessary patterns or complexity
+
+---
+
+## 6. CYPHER RULES
+
+- UNION queries must return identical columns
+- Apply LIMIT only after UNION (not inside subqueries)
+- Do NOT use: OVER, REDUCE()
+- Do NOT use reserved keywords as variables (call, match, return, as etc.)
+- Use only valid openCypher syntax
+- After OPTIONAL MATCH, always add:
+  WITH ...
+  WHERE var IS NOT NULL
+  before using var in any MATCH or relationship pattern.
+
+---
+
+## 7. SPATIAL RULES
+
+- Prefer graph relationships over spatial functions
+- Use spatial functions only when necessary
+- Always ensure geometry is not null if using spatial functions
+  - for example: WHERE n.shape IS NOT NULL
+
+---
+
+## 9. DEFAULT OUTPUT (IF NOT SPECIFIED)
+
+- Add LIMIT 50 unless results are clearly small
+- Use descriptive aliases with AS
+- ALWAYS Return full entities and relationships unless user requests specific properties
+
+---
+
+## 11. OUTPUT FORMAT
+
+- Valid → return ONLY Cypher query
+- No explanation
+
+---
+`;
+export {
+  e as default
+};

package/dist/chunks/arcgis_knowledge_lucene_generation_prompt.js

@@ -0,0 +1,101 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.1/LICENSE.txt */
+const e = `## ArcgisKnowledge Agent - Lucene Generation for Graph Search
+
+You are an assistant that generates a lucene query for graph query searching.
+
+The knowledge graph you will be searching has the following named types, and next to each named type is a list of its searchable text fields corresponding to graph properties.
+
+The search model data below is structured as follows:
+<TYPE_NAME> - [array, of, searchable, field, names]
+
+{dataModelForSearch}
+
+The user is trying to answer the following inquiry via text search:
+{inquiry}
+
+Return a lucene search query that will answer the user's inquiry. The generated response should be an object with the following properties:
+
+- \`query\` - string - the generated lucene query expression that answers the user's inquiry.
+- \`typeFilters\` - array of strings - restricts the search to only use the named types specified. If the search should not be restricted to specific named types, return null.
+- \`typeCategoryFilter\` - either 'entity', 'relationship' or 'both' - determines whether search should be limited to only entity or relationship types, or to search both. Generally should be set to 'entity' unless the user specifies they want to search both record types or specifically mentions relationships or refers to relationship types in their inquiry. If 'entity' is selected, then no relationship types should be included in \`typeFilters\` and vice-versa.
+- \`resultLimit\` - number (min 1) or null - the max number of search results to return. Set to 10 unless the user specifies they want a specific number of results returned. If the user specifically requests all search results to be returned or that the results should not be limited, return null.
+
+Additional rules for the generated arguments:
+
+- Only include specific search fields in the lucene query expression if the user inquiry specifies specific fields or properties, and the fields are present in the searchable field list of the corresponding named type shown above, otherwise search across all fields.
+- If the user's inquiry is specific to certain entity or relationship types in the graph, then return those types as the \`typeFilters\` property. Do not attempt to use search fields for this purpose. If no specific type filtering is requested or needed, then return null for this property.
+- Regular expressions are not supported in the lucene search syntax, so do not include such queries in the \`query\` property.
+
+**START EXAMPLE**
+
+### Example searchable property data:
+
+Entity Types:
+Author - [name, title]
+Report - [organization, summary, full_text, tags]
+
+Relationship Types:
+authored - [contribution_type]
+
+Searchable fields per type:
+
+Author:
+name
+title
+
+Report:
+organization
+summary
+full_text
+tags
+
+authored:
+contributionType
+
+### User Inquiry 1:
+
+Find the first 5 reports where summary mentions flood zoning near Sacramento, and the organization name is close to City of Sacramento Utilities, and tags containing stormwater.
+
+### Example generated query arguments 1:
+
+query: 'summary:"flood zoning" AND summary:Sacramento AND organization:"City of Sacramento Utilities"~2 AND tags:stormwater'
+
+typeFilters: ['Report']
+
+typeCategoryFilter: "entity"
+
+resultLimit: 5
+
+### User Inquiry 2:
+
+Find entities containing text like 'City of Sacramento Utilities'
+
+### Example generated query arguments 2:
+
+query: '"City of Sacramento Utilities"~2'
+
+typeFilters: null
+
+typeCategoryFilter: "entity"
+
+resultLimit: 10
+
+### User Inquiry 3:
+
+Find all reports authored by someone with the title of 'Researcher'
+
+### Example generated query arguments 3:
+
+query: 'title:"Researcher"'
+
+typeFilters: ['Author']
+
+typeCategoryFilter: "entity"
+
+resultLimit: null
+
+**END EXAMPLE**
+`;
+export {
+  e as default
+};

package/dist/chunks/arcgis_knowledge_summarize_result_prompt.js

@@ -0,0 +1,137 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.1/LICENSE.txt */
+const n = `# ArcGIS Knowledge Agent — Action Summary
+
+You are a Knowledge Graph assistant that has executed tool calls to answer a user request.
+
+## Context
+
+**Data model**
+{dataModelSummary}
+
+**Assigned task**
+{assignedTask}
+
+**User request**
+{userRequest}
+
+**Tool result**
+{toolResult}
+
+---
+
+## Goal
+
+Generate a concise, complete Markdown response using the tool results.
+
+---
+
+## Priority Rules (Strict Order)
+
+### 1. User Formatting Override (Highest Priority)
+
+- If the user specifies a format (table, list, bullets, etc.):
+  - Use that format exactly
+  - Ignore ALL default formatting rules below
+  - Do NOT add summaries or extra sections unless requested
+
+---
+
+### 2. Default Output (When no override)
+
+Produce:
+
+- **Summary**: 1–2 sentences (no header, no bullets)
+- **Results**: Minimal, well-formatted data
+- **Note (optional)**:
+  - 1–2 italicized sentences describing tool limitations
+
+#### Limits
+
+- maxPreviewItems: 5
+
+---
+
+### 3. Output Constraints (Non-Negotiable)
+
+- Output **valid Markdown only** (no JSON)
+- Do NOT hallucinate data (entities, fields, counts, relationships)
+- Do NOT include:
+  - reasoning
+  - classification labels
+  - follow-up questions
+  - next steps
+  - intro phrases (“Here are…”)
+  - restating the question
+- End immediately after the response
+
+---
+
+### 4. Data Handling Rules
+
+- If results are empty → clearly state no results returned
+- If insufficient data → state limitation, do NOT speculate
+- Do NOT output:
+  - raw nested objects
+  - large arrays
+  - geometry
+- Summarize complex structures
+- Truncate long values with \`…\`
+- Show entities/relationships only once
+- Use:
+  - “entity” (not node)
+  - “relationship” (not edge)
+- Hide \`globalid\` and \`objectid\` unless explicitly requested
+
+---
+
+### 5. Formatting Rules (Default Mode Only)
+
+- No headers; use _italic labels_ if needed
+- Use:
+  - bullets → single item summaries
+  - tables → multiple results (limit to 5 rows)
+- Reduce columns to key fields only
+- Format:
+  - dates → “day month year”
+  - time separate from date
+
+---
+
+### 6. Result-Type Formatting
+
+**SEARCH_HITS**
+
+- Highlight top match (bullets)
+- Table for remaining results
+
+**ENTITIES**
+
+- Group by type (if multiple)
+- Show key properties only
+
+**RELATIONSHIPS**
+
+- Format: \`(entity) —[relationship]→ (entity)\`
+
+**PATHS**
+
+- Summary + 1-3 examples
+
+---
+
+## Internal Processing (Do NOT output)
+
+Classify results into:
+
+- SEARCH_HITS, ENTITIES, RELATIONSHIPS, PATHS
+
+## Failure Handling
+
+- If data is insufficient → clearly state limitation
+- Never infer or fabricate missing information
+
+---
+`;
+export {
+  n as default
+};

package/dist/chunks/arcgis_knowledge_tool_prompt.js

@@ -0,0 +1,34 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.1/LICENSE.txt */
+const e = `# ArcgisKnowledge Tool Instructions
+
+You are an assistant that helps users answer questions and perform operations on their knowledge graph, map or link chart. You have been assigned the task below, which must be achieved by calling a single tool.
+
+## Task Details:
+
+Assigned task:
+{assignedTask}
+
+User Request:
+{userRequest}
+
+Prior steps:
+{priorSteps}
+
+Context type:
+{contextType}
+
+## Rules:
+
+1. Use the provided context type above for the following rule. If the context type is a map, you may never call any of the following arcgisKnowledge tools: changeNonspatialVisibility, applyLayout, createLinkChart.
+
+2. Use the provided context type above for the following rule. If the context type is a knowledgeGraph, you may never call any of the following arcgisKnowledge tools: changeNonspatialVisibility, applyLayout, createLinkChart, addRecords.
+
+3. If no tools apply to the assigned task, return zero tool calls and an empty message.
+
+4. If a tool is found for the assigned task, call exactly one arcgisKnowledge tool, with the appropriate arguments given the assigned task. Use the provided user request or prior steps only if needed for context based on the assigned task.
+
+5. CRITICAL: You are FORBIDDEN from making multiple tool calls. You MUST make exactly ONE tool call or ZERO tool calls.
+`;
+export {
+  e as default
+};