@arcgis/ai-components 5.2.0-next.24 → 5.2.0-next.26

package/dist/chunks/arcgisKnowledgeGraph.js

@@ -1,11 +1,11 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
-import { StateGraph as f, START as x, END as h, Command as k } from "@langchain/langgraph/web";
-import { a as b, c as _, b as K, d as A, e as T, s as v, q, g as u, h as M, t as c, r as S, i as C, G as E, j as m } from "./adapter.js";
+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 G, e as N } from "./generateLayerDescriptions.js";
-import { AIMessage as R } from "@langchain/core/messages";
+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";
@@ -13,43 +13,44 @@ 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 D } from "./index.js";
+import { s as p, a as z } from "./index.js";
 import "@langchain/core/prompts";
 const w = [
-  b,
-  _,
   K,
-  A,
+  _,
   T,
-  v,
-  q
+  A,
+  S,
+  M,
+  v
 ];
-async function z(e, a) {
-  const i = await u("arcgis_knowledge_tool_prompt"), o = M(a), n = {
+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: o
-  }, s = await G({
-    promptText: i,
+    contextType: s
+  }, r = await N({
+    promptText: o,
     messages: e.arcgisKnowledgeMessages,
     inputVariables: n,
-    tools: w
-  }), l = (s.tool_calls?.length ?? 0) > 0, t = typeof s.text == "string" ? s.text.trim() : "", r = t.length > 0, d = s.content.toString();
-  return !l && (o === "map" || o === "knowledgeGraph") ? {
+    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, s],
-    outputMessage: o === "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.",
+    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, s],
-    outputMessage: l ? d : t,
-    status: l ? e.status : r ? "success" : "failed",
-    summary: d ? c(d) : "ArcGIS Knowledge Agent tool executed."
+    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 y = {
+const f = {
   generateCypher: "generated-cypher-query",
   queryGraphData: "graph-query-result",
   searchGraphData: "graph-search-result",
@@ -59,110 +60,126 @@ const y = {
   createLinkChart: "created-link-chart"
 };
 function F(e) {
-  return !!e && e.status === "success" && !!y[e.toolName];
+  return !!e && e.status === "success" && !!f[e.toolName];
 }
 function $(e) {
   return {
-    type: y[e.toolName],
+    type: f[e.toolName],
     data: e.details
   };
 }
-async function I(e, a) {
-  const i = new L(w, { handleToolErrors: !1 });
+async function I(e, t) {
+  const o = new L(w, { handleToolErrors: !1 });
   try {
-    const o = await i.invoke(
+    const s = await o.invoke(
       {
         messages: e.arcgisKnowledgeMessages
       },
-      a
+      t
     ), n = [];
-    for (const t of o.messages) {
-      let r;
-      if (typeof t.content != "string")
-        throw new Error(`Unexpected tool message content type: ${typeof t.content}. Expected string.`);
+    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 {
-        r = JSON.parse(t.content);
+        i = JSON.parse(a.content);
       } catch {
         throw new Error(
-          `Failed to parse tool message content as JSON. Tool: ${t.name ?? "unknown"}.
+          `Failed to parse tool message content as JSON. Tool: ${a.name ?? "unknown"}.
 
- Original Content: ${t.content}`
+ Original Content: ${a.content}`
         );
       }
-      if (!r || typeof r != "object" || !("toolName" in r))
+      if (!i || typeof i != "object" || !("toolName" in i))
         throw new Error(
-          `Parsed tool message content does not have expected structure. Parsed content: ${JSON.stringify(r)}`
+          `Parsed tool message content does not have expected structure. Parsed content: ${JSON.stringify(i)}`
         );
-      n.push(r);
+      n.push(i);
     }
     await p(
       {
-        text: `Finished executing ArcGIS Knowledge Agent tools: ${o.messages.filter((t) => t.name).map((t) => t.name).join(", ")}`
+        text: `Finished executing ArcGIS Knowledge Agent tools: ${s.messages.filter((a) => a.name).map((a) => a.name).join(", ")}`
       },
-      a
+      t
     );
-    const s = n.filter((t) => typeof t != "string").map((t) => `- Called Tool: ${t.toolName}, Status: ${t.status}`), l = n[0];
-    return l && F(l) && await D($(l), a), {
+    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: s.join(`
+      outputMessage: r.join(`
 `),
-      summary: s.length ? c(s.join(`
+      summary: r.length ? g(r.join(`
 `)) : "ArcGIS Knowledge Agent did not execute any tools or return any results.",
-      arcgisKnowledgeMessages: [...e.arcgisKnowledgeMessages, ...o.messages],
+      arcgisKnowledgeMessages: [...e.arcgisKnowledgeMessages, ...s.messages],
       arcgisKnowledgeToolResult: n
     };
-  } catch (o) {
-    const n = o instanceof Error ? o.message : String(o);
+  } catch (s) {
+    const n = s instanceof Error ? s.message : String(s);
     return await p(
       { text: `ArcGIS Knowledge Agent tool execution failed unexpectedly: ${n}` },
-      a
+      t
     ), {
       ...e,
       outputMessage: `ArcGIS Knowledge Agent tool execution failed unexpectedly: ${n}`,
       status: "failed",
-      summary: c(`ArcGIS Knowledge Agent tool execution failed unexpectedly: ${n}`),
+      summary: g(`ArcGIS Knowledge Agent tool execution failed unexpectedly: ${n}`),
       arcgisKnowledgeMessages: [...e.arcgisKnowledgeMessages]
     };
   }
 }
-const V = (e, a) => (
+const V = (e, t) => (
   //agent services (ex: embeddingsWorker) would go in the array below, if required.
-  S([], "ArcgisKnowledge Agent")(e, a)
+  C([], "ArcgisKnowledge Agent")(e, t)
 );
-async function j(e, a) {
-  const o = (e.arcgisKnowledgeToolResult ?? []).map((d) => ({
+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 C(a), s = E.getDataModelTypesSummary(n.dataModel), l = {
+  })), { knowledgeGraph: n } = await E(t), r = G.getDataModelTypesSummary(n.dataModel), l = {
     assignedTask: e.agentExecutionContext.assignedTask,
     userRequest: e.agentExecutionContext.userRequest,
-    toolResult: o,
-    dataModelSummary: s
-  }, t = await N({
+    toolResult: s,
+    dataModelSummary: r
+  }, a = await R({
     promptText: await u("arcgis_knowledge_summarize_result_prompt"),
     modelTier: "default",
-    inputVariables: l
-  }), r = typeof t == "string" ? t : t.content;
+    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: r,
+    outputMessage: o,
     status: "success",
-    summary: c(r),
-    arcgisKnowledgeMessages: [...e.arcgisKnowledgeMessages, new R(r)]
+    summary: g(o),
+    arcgisKnowledgeMessages: [...e.arcgisKnowledgeMessages, new y(o)]
   };
 }
-function g(e) {
-  return async (a, i) => i?.signal?.aborted ? (await p({ text: "Knowledge Agent execution cancelled" }, i), new k({
-    goto: h,
+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(a, i);
+  })) : await e(t, o);
 }
-const O = () => new f(m).addNode("requireArcgisKnowledgeServices", V).addNode("agent", g(z)).addNode("tools", g(I)).addNode("summarizationLLM", g(j)).addEdge(x, "requireArcgisKnowledgeServices").addEdge("requireArcgisKnowledgeServices", "agent").addConditionalEdges("agent", (a) => (a.arcgisKnowledgeMessages[a.arcgisKnowledgeMessages.length - 1]?.tool_calls?.length ?? 0) > 0 ? "tools" : h).addConditionalEdges("tools", (a) => a.status === "failed" ? h : "summarizationLLM").addEdge("summarizationLLM", h), P = 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).
+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 
@@ -200,13 +217,13 @@ _example: "Discover and add all the relationships originating at 'Entity E' to t
 _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?"_`, ie = {
+_example: "What is the average age of all people who work for Esri?"_`, le = {
   id: "arcgisKnowledge",
   name: "ArcgisKnowledge Agent",
-  description: P,
-  createGraph: O,
+  description: J,
+  createGraph: P,
   workspace: m
 };
 export {
-  ie as A
+  le as A
 };

package/dist/chunks/arcgis_knowledge_current_lc_context.js

@@ -1,7 +1,24 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
-const e = `## Additional System Context
+const e = `## Membership Bind Parameters
 
-In addition to the user's inquiry prompt that precedes this system context, the current link chart has entities and relationships on it already, in the format of an array of objects containing identifiers and typeNames, in case this is needed for query generation (for example 'Add all records that are connected to people on this link chart to the link chart'). If the user is asking for a query that acts on 'the current link chart', 'my link chart', or similar then the cypher query should be filtered by the ids. For example, 'Match (n:Person)-[\\r]->(m) WHERE id(n) IN [\\'identifier1','identifier2'] return r, m. Curly braces (the '{' and '}' characters) are often part of identifier strings and should not be stripped out - the process of filtering by ids should not be altering the id strings. The entities and relationships that are on the current link chart are as follows:
+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

@@ -1,7 +1,36 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
-const e = `## Additional System Context
+const e = `## Membership Bind Parameters
 
-In addition to the user's inquiry prompt that precedes this system context, the current map has entities and relationships on it already, in the format of an array of objects containing identifiers and typeNames or type names that contain all entities or relationships of that type, in case this is needed for query generation (for example 'Add all records that are connected to people on this map to the map'). If the user is asking for a query that acts on 'the current map', 'my map', or similar then the cypher query should be filtered by the ids. For example, 'Match (n:Person)-[\\r]->(m) WHERE id(n) IN [\\'identifier1','identifier2'] return r, m. Curly braces (the '{' and '}' characters) are often part of identifier strings and should not be stripped out - the process of filtering by ids should not be altering the id strings. The entities and relationships that are on the current map are as follows:
+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.2/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_summarize_result_prompt.js

@@ -1,48 +1,137 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
-const e = `## ArcgisKnowledge Agent - Action Summary
+const n = `# ArcGIS Knowledge Agent — Action Summary
 
-You are a helpful Knowledge Graph assistant agent that has received a user inquiry and performed some tool call actions to answer their question or perform the desired operation.
+You are a Knowledge Graph assistant that has executed tool calls to answer a user request.
 
-The knowledge graph you are working with has the following data model:
+## Context
 
+**Data model**
 {dataModelSummary}
 
-## User Input:
-
-Assigned task:
+**Assigned task**
 {assignedTask}
 
-Latest user request:
+**User request**
 {userRequest}
 
-## Tool Call Result:
-
+**Tool result**
 {toolResult}
 
-## Your Goal:
+---
+
+## 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
+
+---
 
-Based on the user request and tool call result above, generate a concise response that answers their question fully.
+## Internal Processing (Do NOT output)
 
-If the above tool calls do not provide the information required to answer the users question, state this, and do not speculate.
+Classify results into:
 
-The general format for the summary should be (paragraphs of content separated by new lines, not bullet points):
+- SEARCH_HITS, ENTITIES, RELATIONSHIPS, PATHS
 
-- A short, easy to read summary of the results and answer to the users inquiry, in the form of a concise 1-3 sentence summary. This can include the tool called and a brief summary of its settings. For multiple or complex settings (e.g. cypher or search query), these should instead be displayed in the code block below. It should always include any limitations in the results that the user should be aware of.
-- _Optional_ - Code block containing tool settings / query or search used etc for tool calls with multiple or complex settings
-- _Optional_ - Markdown table of query or search results preview if these tools were used, and this is appropriate to answer the user's question. Ensure long property values are truncated to short lengths (20 chars) in the table if not directly relevant to the user's query. Do not re-order data in the table. If a query or search of graph data was done, this should be displayed.
-- _Important_ If the summary or markdown table was generated based on data where only a limited preview of the full results of e.g. a search/query was available, indicate this at the end of the summary in a separate paragraph in italics, along the lines of 'NOTE: This summary was generated from a limited preview of the search / query results, and may not be accurate.'
+## Failure Handling
 
-### STRICT OUTPUT RULES
+- If data is insufficient → clearly state limitation
+- Never infer or fabricate missing information
 
-- Do NOT ask follow-up questions.
-- Do NOT offer additional actions or suggestions.
-- Do NOT explain what you can do next.
-- End the response immediately after the summary.
-- Do NOT include introductory phrases (e.g., "Found", "Here are", "The results show").
-- Do NOT restate the assigned task or user’s question.
-- Use Markdown formatting for the response, formatting in a way that makes the summary easy to read.
-- When presenting tabular data, output a valid Markdown table.
+---
 `;
 export {
-  e as default
+  n as default
 };