@arcgis/ai-components 5.2.0-next.99 → 6.0.0-next.0

package/dist/chunks/adapter2.js

@@ -0,0 +1,1129 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
+import { Annotation as G, messagesStateReducer as ee } from "@langchain/langgraph/web";
+import { a as te } from "./runtime2.js";
+import y from "zod";
+import { tool as T } from "@langchain/core/tools";
+import { sendTraceMessage as w } from "../orchestrator/signals.js";
+import k from "@arcgis/core/portal/Portal.js";
+import re from "@arcgis/core/WebLinkChart.js";
+import W from "@arcgis/core/rest/knowledgeGraph/GraphQueryStreaming.js";
+import * as ae from "@arcgis/core/core/reactiveUtils.js";
+import { invokeStructuredPrompt as ne } from "../orchestrator/models/prompts.js";
+import { fetchKnowledgeGraph as U, executeQueryStreaming as oe, executeSearchStreaming as se } from "@arcgis/core/rest/knowledgeGraphService.js";
+import { g as D } from "./getPrompt.js";
+import ie from "@arcgis/core/rest/knowledgeGraph/GraphSearchStreaming.js";
+import B from "@arcgis/core/request.js";
+import z from "@arcgis/core/identity/IdentityManager.js";
+import { getBindParametersFromCypherQuery as ce } from "@arcgis/core/applications/KnowledgeStudio/generalSharedKgUtils.js";
+const st = G.Root({
+  ...te(),
+  intent: G({
+    reducer: (e, t) => t
+  }),
+  arcgisKnowledgeMessages: G({
+    reducer: ee,
+    default: () => []
+  }),
+  arcgisKnowledgeToolResult: G({
+    reducer: (e, t) => t,
+    default: () => null
+  })
+});
+function _(e) {
+  const t = e.map?.allLayers.filter((r) => r.type === "knowledge-graph");
+  if (!t || t?.length !== 1)
+    throw new Error("The Knowledge Agent currently only supports maps with exactly one Knowledge Graph Layer.");
+}
+function x(e) {
+  return !!e?.map && "activeLinkChartLayer" in e.map;
+}
+async function E(e) {
+  !x(e) || !e.map.diagramNodesExtent || await e.goTo(e.map.diagramNodesExtent);
+}
+function R(e) {
+  const r = e?.configurable?.context;
+  if (!r || typeof r != "object")
+    throw new Error("ArcgisKnowledgeAgent context missing");
+  if (!("view" in r))
+    throw new Error("View context missing");
+  const a = r.view;
+  return a.map && !("activeLinkChartLayer" in a.map) && _(a), {
+    view: a
+  };
+}
+function it(e) {
+  const r = e?.configurable?.context;
+  if (H(e) === "knowledgeGraph")
+    return "knowledgeGraph";
+  const n = r.view;
+  return x(n) ? "linkChart" : (_(n), "map");
+}
+async function q(e) {
+  const r = e?.configurable?.context;
+  if (H(e) === "knowledgeGraph")
+    return r;
+  {
+    const n = r.view.map;
+    if (n && "activeLinkChartLayer" in n) {
+      const s = n.knowledgeGraph?.url;
+      if (!s)
+        throw new Error("Knowledge graph url missing from link chart.");
+      return {
+        knowledgeGraph: await U(s)
+      };
+    } else {
+      _(r.view);
+      const c = (r.view.map?.allLayers.find(
+        (i) => i.type === "knowledge-graph"
+      )).url;
+      if (!c)
+        throw new Error("Knowledge graph url missing from map.");
+      return {
+        knowledgeGraph: await U(c)
+      };
+    }
+  }
+}
+function H(e) {
+  const r = e?.configurable?.context;
+  if (!r || typeof r != "object")
+    throw new Error("ArcgisKnowledgeAgent context missing");
+  if ("knowledgeGraph" in r && "view" in r)
+    throw new Error("Knowledge Graph context should only have a view or knowledgeGraph, but never both.");
+  if ("knowledgeGraph" in r)
+    return "knowledgeGraph";
+  if ("view" in r)
+    return "view";
+  throw new Error("ArcgisKnowledgeAgent context must have either a view or knowledgeGraph property.");
+}
+class pe {
+  constructor(t) {
+    this.dataModel = t, this.kind = "GraphQueryGenerationRequest", this.explainQuery = !0, this.schemaInformation = O.fromDataModel(t);
+  }
+}
+class O {
+  constructor() {
+    this.schemaType = "ArcgisGraphSchema", this.entityTypes = [], this.relationshipTypes = [], this.identifierInfo = {
+      mappingInfo: {
+        identifierMapsTo: "UniformPropertyIdentifier",
+        identifierPropertyName: "globalid"
+      }
+    };
+  }
+  static fromDataModel(t) {
+    const r = new O();
+    for (const a of t.entityTypes)
+      r.entityTypes.push(N.fromEntityType(a));
+    for (const a of t.relationshipTypes)
+      r.relationshipTypes.push(le.fromRelationshipType(a));
+    return r.identifierInfo = {
+      mappingInfo: {
+        identifierMapsTo: ue(
+          t.identifierInfo.identifierMappingInfo.identifierInfoType
+        ),
+        identifierPropertyName: t.identifierInfo.identifierMappingInfo.uniformPropertyIdentifier.identifierPropertyName
+      }
+    }, r.spatialReference = JSON.parse(JSON.stringify(t.spatialReference)), r;
+  }
+  // Generates a short summary of the types in the data model for LLM consumption.
+  static getDataModelTypesSummary(t) {
+    const r = t.entityTypes.map((n) => n.name).join(", "), a = t.relationshipTypes.map((n) => n.name).join(", ");
+    return `Entity Types: ${r}.
+ Relationship Types: ${a}.`;
+  }
+}
+class N {
+  constructor() {
+    this.name = "", this.properties = [];
+  }
+  static fromEntityType(t) {
+    const r = new N();
+    r.name = t.name, r.alias = t.alias ? t.alias : void 0, r.role = he(t.role);
+    for (const a of t.properties) {
+      const n = {
+        name: a.name,
+        alias: a.alias ? a.alias : void 0,
+        fieldType: a.fieldType,
+        role: de(a.role),
+        geometryDef: a.fieldType === "esriFieldTypeGeometry" ? {
+          geometryType: a.geometryType ?? "esriGeometryAny",
+          hasM: a.hasM ? a.hasM : void 0,
+          hasZ: a.hasZ ? a.hasZ : void 0
+        } : void 0
+      };
+      r.properties.push(n);
+    }
+    return r;
+  }
+}
+class le extends N {
+  constructor() {
+    super(...arguments), this.observedEndPoints = [];
+  }
+  static fromRelationshipType(t) {
+    const r = N.fromEntityType(t);
+    r.observedEndPoints = [];
+    for (const a of t.endPoints)
+      r.observedEndPoints.push({
+        originEntityType: a.originEntityType,
+        destinationEntityType: a.destinationEntityType
+      });
+    return r;
+  }
+}
+const ue = (e) => {
+  switch (e) {
+    case "esriIdentifierInfoTypeUNSPECIFIED":
+      return "UNSPECIFIED";
+    case "esriIdentifierInfoTypeDatabaseNative":
+      return "DatabaseNative";
+    case "esriIdentifierInfoTypeUniformProperty":
+      return "UniformPropertyIdentifier";
+    default:
+      return e;
+  }
+}, he = (e) => {
+  switch (e) {
+    case "Regular":
+      return "esriGraphNamedObjectRegular";
+    case "Provenance":
+      return "esriGraphNamedObjectProvenance";
+    case "Document":
+      return "esriGraphNamedObjectDocument";
+    default:
+      return e;
+  }
+};
+function de(e) {
+  switch (e) {
+    case "esriGraphPropertyRegular":
+      return "Regular";
+    case "esriGraphPropertyDocumentName":
+      return "Document_Name";
+    case "esriGraphPropertyDocumentTitle":
+      return "Document_Title";
+    case "esriGraphPropertyDocumentUrl":
+      return "Document_Url";
+    case "esriGraphPropertyDocumentText":
+      return "Document_Text";
+    case "esriGraphPropertyDocumentKeywords":
+      return "Document_Keywords";
+    case "esriGraphPropertyDocumentContentType":
+      return "Document_ContentType";
+    case "esriGraphPropertyDocumentMetadata":
+      return "Document_Metadata";
+    case "esriGraphPropertyDocumentFileExtension":
+      return "Document_FileExtension";
+    case "esriGraphPropertyProvenanceInstanceId":
+      return "Provenance_InstanceId";
+    case "esriGraphPropertyProvenanceSourceType":
+      return "Provenance_SourceType";
+    case "esriGraphPropertyProvenanceSourceName":
+      return "Provenance_SourceName";
+    case "esriGraphPropertyProvenanceSource":
+      return "Provenance_Source";
+    case "esriGraphPropertyProvenanceComment":
+      return "Provenance_Comment";
+    case "esriGraphPropertyProvenanceTypeName":
+      return "Provenance_TypeName";
+    case "esriGraphPropertyProvenancePropertyName":
+      return "Provenance_PropertyName";
+    default:
+      return "Regular";
+  }
+}
+function M(e) {
+  return e?.signal;
+}
+async function ye(e, t) {
+  const r = await D("arcgis_knowledge_cypher_query_prompt");
+  return t ? `${e} ${r}
+
+Your previous attempt to generate a cypher query failed. See the details below and generate a new cypher query that avoids this error.
+
+Attempt Number: ${t.attemptCount}
+Execution Error: ${t.executionError}
+Failed Query:
+${t.failedGraphQuery}` : `${e} ${r}`;
+}
+async function me(e, t, r, a) {
+  const { graphQuery: n, explanation: s } = await K(e, t, r, a);
+  return { graphQuery: n, explanation: s };
+}
+async function K(e, t, r, a, n) {
+  const s = {
+    message: await ye(e, n),
+    context: new pe(t)
+  }, c = M(a);
+  await w({ text: "Attempting to generate a cypher query from your prompt..." }, a);
+  const o = await B(`${r}/chat`, {
+    method: "post",
+    body: JSON.stringify(s),
+    headers: {
+      "Content-Type": "application/json",
+      "X-Esri-Authorization": `Bearer ${z.findCredential(k.getDefault().url)?.token ?? ""}`
+    },
+    signal: c
+  });
+  if (o.httpStatus !== 200)
+    throw new Error(`Graph query service returned an error: ${o.httpStatus}`, {
+      cause: o.data
+    });
+  let i = !1;
+  const h = Date.now();
+  let p = o.data.sequenceNumber, l = "", u = "", m = 1;
+  for (; !i; ) {
+    await new Promise((g) => setTimeout(g, 1e3)), await w(
+      { text: `Periodically requesting status of job from ArcGIS AI Services${"...".substring(0, m)}` },
+      a
+    ), m = m % 3 + 1;
+    const d = await B(`${r}/chat`, {
+      method: "post",
+      body: JSON.stringify({
+        conversationId: o.data.conversationId,
+        inquiryId: o.data.inquiryId,
+        ackSequenceNumber: p
+      }),
+      headers: {
+        "Content-Type": "application/json",
+        "X-Esri-Authorization": `Bearer ${z.findCredential(k.getDefault().url)?.token ?? ""}`
+      },
+      signal: c
+    });
+    if (d.httpStatus !== 200)
+      throw new Error(`Graph query service polling returned an error: ${d.httpStatus}`, {
+        cause: d.data
+      });
+    if (d.data.context?.kind) {
+      if (d.data.context.kind !== "GraphQueryGenerationResponse")
+        throw new Error(`Unexpected response from graph query service polling. Message: ${d.data.message}`, {
+          cause: d.data
+        });
+      l = d.data.context.graphQuery, u = d.data.message || "", i = !0;
+    } else if (!d.data.hasMore)
+      i = !0;
+    else if (Date.now() - h > 6e4)
+      throw new Error("Graph query service polling timed out after 1 minute.");
+    p = d.data.sequenceNumber;
+  }
+  return { graphQuery: l, explanation: u };
+}
+function ge(e, t) {
+  v(e, (r) => {
+    t.set(`${r.typeName}__${r.id}`, {
+      id: r.id,
+      typeName: r.typeName
+    });
+  });
+}
+function v(e, t) {
+  if (!(!e || typeof e != "object")) {
+    if (we(e))
+      for (const r of e.path)
+        v(r, t);
+    else if (fe(e))
+      t(e);
+    else if (Array.isArray(e))
+      for (const r of e)
+        v(r, t);
+    else if (be(e))
+      for (const r of Object.values(e.properties ?? {}))
+        v(r, t);
+  }
+}
+function fe(e) {
+  return !e || typeof e != "object" || Array.isArray(e) ? !1 : "id" in e && "typeName" in e;
+}
+function we(e) {
+  return !e || typeof e != "object" || Array.isArray(e) ? !1 : e && "path" in e && Array.isArray(e.path);
+}
+function be(e) {
+  return !e || typeof e != "object" || Array.isArray(e) || "id" in e ? !1 : "properties" in e && typeof e.properties == "object";
+}
+function Te(e, t) {
+  const r = [], a = [], n = [
+    [t.dataModel.entityTypes, r],
+    [t.dataModel.relationshipTypes, a]
+  ];
+  for (const [s, c] of n)
+    for (const o of s) {
+      const i = e.getMemberIdsByType(o.name);
+      c.push(...i);
+    }
+  return { entityIds: r, relationshipIds: a };
+}
+function xe(e, t) {
+  const r = { entityIds: new Array(), relationshipIds: new Array() }, a = [], s = e?.allLayers.find((i) => i.type === "knowledge-graph")?.inclusionModeDefinition;
+  if (!s)
+    return { allNamedTypesFullyDynamic: !0, bindParameters: r, nonDynamicTypes: a };
+  const c = [
+    [t.dataModel.entityTypes, r.entityIds],
+    [t.dataModel.relationshipTypes, r.relationshipIds]
+  ];
+  let o = !0;
+  for (const [i, h] of c)
+    for (const p of i) {
+      const l = s.namedTypeDefinitions.get(p.name);
+      if (!l) {
+        o = !1, a.push(p.name);
+        continue;
+      }
+      if (!l.useAllData) {
+        o = !1, a.push(p.name);
+        for (const [u] of l.members || [])
+          h.push(u);
+      }
+    }
+  return { allNamedTypesFullyDynamic: o, bindParameters: r, nonDynamicTypes: a };
+}
+const P = 3;
+function J(e, t = 100) {
+  const r = {};
+  for (const a of Object.entries(e.properties ?? {})) {
+    const [n, s] = a;
+    typeof s == "string" && s.length > t ? r[n] = `${s.slice(0, t)}... (truncated, original length: ${s.length})` : r[n] = s;
+  }
+  return e.properties = r, e;
+}
+function C(e) {
+  return typeof e != "object" || e === null ? String(e) : "details" in e && typeof e.details == "object" && e.details !== null && "errorMessage" in e.details && typeof e.details.errorMessage == "string" ? e.details.errorMessage : "message" in e && typeof e.message == "string" ? e.message : String(e);
+}
+const ve = async ({
+  kg: e,
+  queryParams: t,
+  targetStructure: r,
+  targetStructureReducer: a,
+  requestOptions: n,
+  queryRowLimit: s,
+  queryTimeoutMs: c
+}) => {
+  let o = null, i = r;
+  const h = new AbortController(), p = n?.signal, l = () => {
+    h.abort(p?.reason);
+  };
+  p && (p.aborted ? h.abort(p.reason) : p.addEventListener("abort", l, { once: !0 }));
+  try {
+    const u = await oe(e, t, n);
+    o = u.resultHeader;
+    const m = u.resultRowsStream.getReader();
+    let d = 0;
+    const g = Date.now(), f = !1;
+    for (; ; ) {
+      const { done: b, value: S } = await m.read();
+      if (b)
+        break;
+      if (!f && c && Date.now() - g > c)
+        return h.abort(), { type: "timeout" };
+      for (const Z of S) {
+        if (d++, s && d > s)
+          return h.abort(), { type: "success", rowLimitReached: !0, resultHeader: o, processedResult: i };
+        i = a(i, Z);
+      }
+    }
+  } catch (u) {
+    return h.signal.aborted ? { type: "aborted" } : { type: "error", errorMessage: C(u), error: u };
+  } finally {
+    p?.removeEventListener("abort", l);
+  }
+  return { type: "success", rowLimitReached: !1, resultHeader: o, processedResult: i };
+};
+async function V({
+  prompt: e,
+  bindParameters: t,
+  kg: r,
+  graphQueryServiceUrl: a,
+  targetStructure: n,
+  targetStructureReducer: s,
+  requestOptions: c,
+  queryRowLimit: o,
+  queryTimeoutMs: i,
+  config: h
+}) {
+  let p;
+  for (let l = 1; l <= P; l++) {
+    let u;
+    try {
+      u = await K(e, r.dataModel, a, h, p);
+    } catch (f) {
+      return {
+        type: "generation-error",
+        errorMessage: C(f),
+        error: f
+      };
+    }
+    await w(
+      {
+        text: `Attempting to execute query: ${u.graphQuery.substring(0, 500)}${u.graphQuery.length > 500 ? "..." : ""}`
+      },
+      h
+    );
+    const m = await Pe(u.graphQuery, t), d = await ve({
+      kg: r,
+      queryParams: new W({
+        openCypherQuery: u.graphQuery,
+        bindParameters: m
+      }),
+      targetStructure: n,
+      targetStructureReducer: s,
+      requestOptions: c,
+      queryRowLimit: o,
+      queryTimeoutMs: i
+    }), g = d.type === "aborted" ? "Query execution was aborted." : d.type === "timeout" ? "Query execution timed out." : d.type === "error" ? `Query failed with error: ${d.errorMessage}` : "";
+    if (d.type === "success")
+      return {
+        type: "success",
+        graphQuery: u.graphQuery,
+        explanation: u.explanation,
+        rowLimitReached: d.rowLimitReached,
+        resultHeader: d.resultHeader,
+        processedResult: d.processedResult
+      };
+    if (d.type === "aborted")
+      return {
+        type: "aborted",
+        errorMessage: g,
+        graphQuery: u.graphQuery,
+        explanation: u.explanation
+      };
+    if (l >= P)
+      return d.type === "timeout" ? {
+        type: "timeout",
+        errorMessage: g,
+        graphQuery: u.graphQuery,
+        explanation: u.explanation
+      } : {
+        type: "execution-error",
+        errorMessage: g,
+        error: d.error,
+        graphQuery: u.graphQuery,
+        explanation: u.explanation
+      };
+    p = {
+      failedGraphQuery: u.graphQuery,
+      executionError: g,
+      attemptCount: l
+    }, await w(
+      { text: `Attempt ${l} failed with error: ${g}. Retrying...` },
+      h
+    );
+  }
+  throw new Error(
+    `Failed to execute generated cypher due to an unexpected error after ${P} attempts.`
+  );
+}
+const Pe = async (e, t) => {
+  if (!t)
+    return {};
+  const { bindParameters: r, parseErrors: a } = await ce(e);
+  if (a)
+    return t;
+  const n = {};
+  for (const s of r)
+    s in t && (n[s] = t[s]);
+  return n;
+}, ke = async ({
+  kg: e,
+  searchQuery: t,
+  typeCategoryFilter: r,
+  namedTypesFilter: a,
+  searchResultLimit: n,
+  requestOptions: s
+}) => {
+  const c = [];
+  let o = [r];
+  r === "both" && !e.serviceDefinition.serviceCapabilities.searchCapabilities.searchTypeFilterCapabilities.includes("esriTypeBoth") && (o = ["entity", "relationship"]);
+  const i = n ?? 1 / 0;
+  try {
+    for (const h of o) {
+      const p = i - c.length;
+      if (p <= 0)
+        break;
+      const m = (await se(
+        e,
+        new ie({
+          searchQuery: t,
+          typeCategoryFilter: h,
+          namedTypesFilter: a ?? void 0,
+          num: p
+        }),
+        s
+      )).resultRowsStream.getReader();
+      let d = !1;
+      for (; !d; ) {
+        const { done: g, value: f } = await m.read();
+        if (g) {
+          d = !0;
+          break;
+        }
+        for (const b of f)
+          for (const S of b)
+            c.push(S);
+      }
+    }
+  } catch (h) {
+    const p = C(h);
+    return s?.signal?.aborted ? {
+      type: "aborted",
+      errorMessage: p,
+      error: h
+    } : { type: "error", errorMessage: p, error: h };
+  }
+  return {
+    type: "success",
+    results: c
+  };
+}, X = "IMPORTANT: The generated cypher query must return entire entities and relationships ONLY.";
+async function Y({
+  prompt: e,
+  view: t,
+  knowledgeGraph: r,
+  includeReturnEntityAndRelationshipContext: a = !1
+}) {
+  const n = [e];
+  if (a && n.push(X), x(t)) {
+    const p = await D("arcgis_knowledge_current_lc_context"), l = Te(t.map, r);
+    return n.push(p), {
+      enhancedPrompt: n.join(`
+
+`),
+      bindParameters: l,
+      allNamedTypesFullyDynamic: !1
+    };
+  }
+  const s = t.map, { allNamedTypesFullyDynamic: c, bindParameters: o, nonDynamicTypes: i } = xe(
+    s,
+    r
+  );
+  if (c)
+    return {
+      enhancedPrompt: n.join(`
+
+`),
+      bindParameters: o,
+      allNamedTypesFullyDynamic: !0
+    };
+  const h = (await D("arcgis_knowledge_current_map_context")).replaceAll(
+    "{nonDynamicTypes}",
+    JSON.stringify(i)
+  );
+  return n.push(h), {
+    enhancedPrompt: n.join(`
+
+`),
+    bindParameters: o,
+    allNamedTypesFullyDynamic: c
+  };
+}
+async function Ce(e, t, r, a, n, s) {
+  const { view: c } = n, o = await V({
+    prompt: e,
+    bindParameters: t,
+    kg: r,
+    graphQueryServiceUrl: a,
+    targetStructure: /* @__PURE__ */ new Map(),
+    targetStructureReducer: (u, m) => {
+      for (const d of m)
+        ge(d, u);
+      return u;
+    },
+    requestOptions: {
+      signal: M(s),
+      timeout: s?.timeout
+    },
+    config: s
+  });
+  if (o.type !== "success") {
+    const u = o.type === "generation-error" ? o.errorMessage : `${o.errorMessage} Cypher query: ${o.graphQuery}`;
+    throw new Error(`Failed to add records to the link chart. ${u}`);
+  }
+  const { graphQuery: i, explanation: h, processedResult: p } = o, l = Array.from(p.values());
+  return await w(
+    {
+      text: `Query Results parsed into ${l.length} unique relationships and entities.  Atempting to add to link chart...`
+    },
+    s
+  ), x(c) ? (await c.map.addRecords(l), await E(c), { generatedQuery: i, explanation: h, addedIdTypePairs: l }) : (await c?.map?.allLayers.find(
+    (m) => m.type === "knowledge-graph"
+  )?.addRecords(l), { generatedQuery: i, explanation: h, addedIdTypePairs: l });
+}
+const $ = "addRecords", Se = y.object({
+  prompt: y.string().describe(
+    "The user's inquiry and context required in order to generate a cypher query that will be used to add records to the link chart."
+  )
+}), Ne = async ({ prompt: e }, t) => {
+  const { knowledgeGraph: r } = await q(t), a = R(t), { view: n } = a, c = k.getDefault().helperServices, {
+    enhancedPrompt: o,
+    bindParameters: i,
+    allNamedTypesFullyDynamic: h
+  } = await Y({
+    prompt: e,
+    view: n,
+    knowledgeGraph: r,
+    includeReturnEntityAndRelationshipContext: !0
+  });
+  if (h)
+    return {
+      toolName: $,
+      status: "success",
+      summary: "No records have been added to the map because all data in the knowledge graph is contained in the map.",
+      details: {
+        generatedQuery: "N/A",
+        explanation: "All named types in the knowledge graph are fully dynamic and therefore all data is already contained in the map. No records have been added.",
+        addedIdTypePairs: []
+      }
+    };
+  try {
+    const { generatedQuery: p, explanation: l, addedIdTypePairs: u } = await Ce(
+      o,
+      i,
+      r,
+      `${c.aiAssistantServices.url}${c.aiAssistantServices.graphQueryAssistant}`,
+      a,
+      t
+    );
+    return {
+      toolName: $,
+      status: "success",
+      summary: `Records added successfully. Cypher Query used: ${p}
+
+Number of records added: ${u.length}`,
+      details: {
+        generatedQuery: p,
+        explanation: l,
+        addedIdTypePairs: u
+      }
+    };
+  } catch (p) {
+    const l = C(p);
+    return {
+      toolName: $,
+      status: "error",
+      errorMessage: `Failed to add records to the link chart. ${l}`,
+      error: p
+    };
+  }
+}, ct = T(Ne, {
+  name: $,
+  description: `Adds records (entities or relationships) to the current link chart visualization from an inquiry into the knowledge graph data. The inquiry will retrieve data from the graph database that will serve as the basis for the records to be added to the link chart.  The user should have explicitly requested to add records to the current link chart from their prompt. "add to new link chart" is not a valid prompt for this tool. 
+    
+    example prompts:
+    - "add all suppliers and the parts they produce to the link chart"
+    - "show me the competitors of company x and add them to the link chart"
+    - "add the relationships between company x and company y to the link chart"
+    - "expand all the companies"
+    - "expand company x through all the buildings it owns"
+    - "connect company x and company y"
+    - "connect all buildings on the link chart"
+    `,
+  schema: Se
+});
+async function Re(e, t) {
+  return await t.map?.applyLayout(e), await E(t), { appliedLayout: e };
+}
+const Q = "applyLayout", qe = y.object({
+  layout: y.enum([
+    "organic-standard",
+    "organic-community",
+    "basic-grid",
+    "hierarchical-bottom-to-top",
+    "radial-root-centric",
+    "tree-left-to-right",
+    "geographic-organic-standard",
+    "chronological-mono-timeline",
+    "chronological-multi-timeline"
+  ]).describe(
+    "The layout mode to apply to the link chart.  The value must be one of the following: organic-standard, organic-community, basic-grid, hierarchical-bottom-to-top, radial-root-centric, tree-left-to-right, geographic-organic-standard, chronological-mono-timeline, chronological-multi-timeline"
+  )
+}), Ge = async ({ layout: e }, t) => {
+  const { view: r } = R(t);
+  if (x(r)) {
+    const { appliedLayout: a } = await Re(e, r);
+    return {
+      toolName: Q,
+      status: "success",
+      summary: `Successfully applied layout: ${a}.`,
+      details: {
+        appliedLayout: a
+      }
+    };
+  } else
+    return {
+      toolName: Q,
+      status: "error",
+      errorMessage: "The applyLayout tool can only be used with a LinkChartView.",
+      error: new Error()
+    };
+}, pt = T(Ge, {
+  name: Q,
+  description: "Apply a diagram layout to the link chart",
+  schema: qe
+});
+async function $e(e, t) {
+  return t.map?.changeNonspatialDataDisplay(e), await E(t), { appliedNonspatialDataDisplayMode: e };
+}
+const L = "changeNonspatialVisibility", Ae = y.object({
+  setting: y.enum(["hidden", "visible"]).describe("The setting of nonspatial visibility")
+}), De = async ({ setting: e }, t) => {
+  const { view: r } = R(t);
+  if (x(r)) {
+    const { appliedNonspatialDataDisplayMode: a } = await $e(e, r);
+    return {
+      toolName: L,
+      status: "success",
+      summary: `Successfully applied nonspatial visibility setting: ${a}.`,
+      details: {
+        appliedNonspatialDataDisplayMode: a
+      }
+    };
+  } else
+    return {
+      toolName: L,
+      status: "error",
+      errorMessage: "The changeNonspatialVisibility tool can only be used with a LinkChartView.",
+      error: new Error()
+    };
+}, lt = T(De, {
+  name: L,
+  description: "Change whether or not nonspatial data is visible in the link chart.  The value must be either 'hidden' or 'visible'.",
+  schema: Ae
+});
+async function Ee(e, t, r, a, n) {
+  let s, c = "";
+  for (let o = 1; o <= P; o++) {
+    const { graphQuery: i, explanation: h } = await K(
+      e,
+      t.dataModel,
+      r,
+      n,
+      s
+    );
+    try {
+      await w({ text: `Attempting to create link chart from derived query: ${i}` }, n);
+      const p = await re.fromCypherQuery(
+        t,
+        new W({
+          openCypherQuery: i
+        })
+      );
+      await w({ text: "Link chart created successfully, loading..." }, n), await p.load();
+      const l = a.map;
+      return a.map = p, await a.when(), await ae.whenOnce(() => !a.updating), p.entityCount === 0 && p.relationshipCount === 0 ? (a.map === p && (a.map = l), p.destroy(), {
+        type: "error",
+        errorMessage: `Query returned no results. Cypher Query used to create the link chart: 
+${i}
+
+Explanation: ${h}`
+      }) : (await E(a), {
+        type: "success",
+        graphQuery: i,
+        explanation: h
+      });
+    } catch (p) {
+      const l = C(p);
+      if (o >= P) {
+        c = l;
+        break;
+      }
+      s = {
+        failedGraphQuery: i,
+        executionError: l,
+        attemptCount: o
+      }, await w(
+        { text: `Attempt ${o} to create link chart failed with error: ${l}. Retrying ...` },
+        n
+      );
+    }
+  }
+  return {
+    type: "error",
+    errorMessage: `Failed to create link chart after ${P} attempts. Last error: ${c}`
+  };
+}
+const A = "createLinkChart", Me = y.object({
+  prompt: y.string().describe(
+    "The user's inquiry and context required in order to generate a cypher query that will be used to create a link chart visualization. Only include information relevant to generating a cypher query. Do not suggest entity types, relationship types or properties. Do not include limits  or formatting instructions for the query results unless specifically requested by the user. The prompt should be focused on the data the user wants to see in the link chart, not how to generate it."
+  )
+}), Qe = async ({ prompt: e }, t) => {
+  const { knowledgeGraph: r } = await q(t), { view: a } = R(t);
+  if (x(a)) {
+    const s = k.getDefault().helperServices, c = await Ee(
+      `${e}
+
+${X}`,
+      r,
+      `${s.aiAssistantServices.url}${s.aiAssistantServices.graphQueryAssistant}`,
+      a,
+      t
+    );
+    if (c.type === "error")
+      return {
+        toolName: A,
+        status: "error",
+        errorMessage: c.errorMessage,
+        error: new Error()
+      };
+    const { graphQuery: o, explanation: i } = c;
+    return {
+      toolName: A,
+      status: "success",
+      summary: `Link chart created successfully.  Cypher Query used to create the link chart: 
+${o}
+
+Explanation: ${i}`,
+      details: {
+        generatedQuery: o,
+        explanation: i
+      }
+    };
+  } else
+    return {
+      toolName: A,
+      status: "error",
+      errorMessage: "The createLinkChart tool can only be used with a LinkChartView.",
+      error: new Error()
+    };
+}, ut = T(Qe, {
+  name: A,
+  description: "Creates a new link chart visualization from an inquiry into the knowledge graph data. The inquiry will retrieve data from the graph database that will serve as the basis for the new link chart.  The user should have explicitly requested the creation of a new link chart from their prompt using language like 'create new link chart' or 'add to new link chart'.",
+  schema: Me
+}), I = "queryGraphData", Le = y.object({
+  prompt: y.string().describe(
+    "The user's inquiry into the knowledge graph, from which a cypher query will be generated and executed to answer the inquiry. Only include entity types, relationship types or properties if they are provided in the user prompt or prior steps. Do not suggest entity types, relationship types or properties. Do not include limits, information on what to return, instructions on how to write the query, or formatting instructions for the query results unless specifically requested by the user."
+  )
+}), Ie = async ({ prompt: e }, t) => {
+  const { knowledgeGraph: r } = await q(t), n = k.getDefault().helperServices;
+  let s = e, c = null, o = null;
+  try {
+    ({ view: o } = R(t));
+  } catch {
+  }
+  o && ({ enhancedPrompt: s, bindParameters: c } = await Y({
+    prompt: e,
+    view: o,
+    knowledgeGraph: r,
+    includeReturnEntityAndRelationshipContext: !1
+  }));
+  const i = await V({
+    prompt: s,
+    bindParameters: c,
+    kg: r,
+    graphQueryServiceUrl: `${n.aiAssistantServices.url}${n.aiAssistantServices.graphQueryAssistant}`,
+    targetStructure: new Array(),
+    targetStructureReducer: (f, b) => (f.push(b), f),
+    requestOptions: {
+      signal: M(t),
+      timeout: t?.timeout
+    },
+    config: t
+  });
+  if (i.type !== "success") {
+    const f = i.type === "generation-error" ? i.errorMessage : `${i.errorMessage} Cypher query: ${i.graphQuery}`;
+    return {
+      toolName: I,
+      status: "error",
+      errorMessage: `Failed to query the knowledge graph. ${f}`,
+      error: "error" in i ? i.error : null
+    };
+  }
+  const { graphQuery: h, explanation: p, processedResult: l, resultHeader: u } = i, m = u.headerKeys;
+  for (const f of l)
+    for (const b of f)
+      v(
+        b,
+        (S) => J(S)
+      );
+  const d = 50, g = l.slice(0, d).map((f) => JSON.stringify(f));
+  return {
+    toolName: I,
+    status: "success",
+    summary: `To answer the inquiry, the following cypher query was executed against the knowledge graph:
+
+\`\`\`cypher
+${h}
+\`\`\`
+
+Query Results:
+${g.length} result(s) found.
+
+Column Headers: ${m.join(", ")}
+
+${g.length > d ? `Showing top ${d} results:
+
+` : `Results:
+
+`}${g.join(`
+`)}
+`,
+    details: {
+      generatedQuery: h,
+      explanation: p,
+      resultHeader: {
+        headerKeys: m,
+        exceededTransferLimit: u.exceededTransferLimit,
+        outSpatialReference: u.outSpatialReference
+      },
+      queryResults: l
+    }
+  };
+}, ht = T(Ie, {
+  name: I,
+  description: "Allows users to explore the data in their knowledge graph via cypher query. Generates and executes a cypher query based on the user's inquiry into the knowledge graph, and displays the results in the chat pane without modifying the user's link chart if any. Use this tool when the user is asking an exploratory question about their data as a whole that can be answered via cypher query, for example 'What are the top 5 suppliers by total parts cost?' or 'How many employees do we have in each department?'.",
+  schema: Le
+}), F = "generateCypher", Fe = y.object({
+  prompt: y.string().describe("The user's inquiry into the knowledge graph that needs to be translated into a cypher query.")
+}), je = async ({ prompt: e }, t) => {
+  const { knowledgeGraph: r } = await q(t), n = k.getDefault().helperServices;
+  try {
+    const { graphQuery: s, explanation: c } = await me(
+      e,
+      r.dataModel,
+      `${n.aiAssistantServices.url}${n.aiAssistantServices.graphQueryAssistant}`,
+      t
+    );
+    return {
+      toolName: F,
+      status: "success",
+      summary: `Generated Graph Query: 
+${s}
+
+Explanation: ${c}`,
+      details: {
+        generatedQuery: s,
+        explanation: c
+      }
+    };
+  } catch (s) {
+    const c = C(s);
+    return {
+      toolName: F,
+      status: "error",
+      errorMessage: `Failed to generate Cypher query. ${c}`,
+      error: s
+    };
+  }
+}, dt = T(je, {
+  name: F,
+  description: "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.",
+  schema: Fe
+}), _e = (e) => {
+  const t = e.dataModel, r = /* @__PURE__ */ new Map();
+  for (const o of t.searchIndexes)
+    if (o.supportedCategory !== "esriTypeMetaEntityProvenance")
+      for (const [i, h] of o.searchProperties.entries()) {
+        const p = r.get(i) ?? /* @__PURE__ */ new Set();
+        h.propertyNames.forEach((l) => p.add(l)), r.set(i, p);
+      }
+  const a = t.entityTypes.filter((o) => r.has(o.name)), n = t.relationshipTypes.filter((o) => r.has(o.name)), s = `Entity Types:
+${a.map(({ name: o }) => `${o}: [${Array.from(r.get(o) ?? []).join(", ")}]`).join(`
+`)}`, c = `Relationship Types:
+${n.map(({ name: o }) => `${o}: [${Array.from(r.get(o) ?? []).join(", ")}]`).join(`
+`)}`;
+  return `${s}
+
+${c}`;
+};
+async function Oe(e, t, r) {
+  const a = await D("arcgis_knowledge_lucene_generation_prompt"), n = {
+    inquiry: e,
+    dataModelForSearch: _e(t)
+  }, s = y.enum(["entity", "relationship", "both"]).describe("The graph element category to search against - entity, relationship, or both"), c = y.number().int().positive().nullable().describe(
+    "The maximum number of search results to return. Default to 10 if not specified by the user, or set to null if the user specifically requests no limits or all results."
+  ), o = y.array(
+    y.enum(
+      t.dataModel.entityTypes.map((p) => p.name).concat(t.dataModel.relationshipTypes.map((p) => p.name))
+    )
+  ).min(1), i = y.object({
+    query: y.string().describe("A lucene syntax query string to be executed against the knowledge graph search API"),
+    typeFilters: o.nullable().describe(
+      "Nullable list of entity or relationship types from the graph to limit the search to. If set to null, search will execute against all named types with indexed properties in the graph"
+    ),
+    typeCategoryFilter: s,
+    resultLimit: c
+  });
+  return await ne({
+    promptText: a,
+    inputVariables: n,
+    schema: i,
+    config: r
+  });
+}
+const j = "searchGraphData", Ke = y.object({
+  prompt: y.string().describe(
+    "The user's inquiry into the knowledge graph, from which a lucene search query will be generated and executed against the graph to return relevant results."
+  )
+}), Ue = async ({ prompt: e }, t) => {
+  const { knowledgeGraph: r } = await q(t);
+  await w({ text: "Generating search query for the user inquiry" }, t);
+  const a = await Oe(e, r, t);
+  await w({ text: "Executing graph search with generated search query" }, t);
+  const n = await ke({
+    kg: r,
+    searchQuery: a.query,
+    typeCategoryFilter: a.typeCategoryFilter,
+    namedTypesFilter: a.typeFilters,
+    searchResultLimit: a.resultLimit,
+    requestOptions: {
+      signal: M(t),
+      timeout: t?.timeout
+    }
+  });
+  if (n.type !== "success")
+    return {
+      toolName: j,
+      status: "error",
+      errorMessage: n.errorMessage,
+      error: "error" in n ? n.error : null
+    };
+  for (const o of n.results)
+    v(
+      o,
+      (i) => J(i)
+    );
+  const s = 10, c = n.results.slice(0, s);
+  return {
+    toolName: j,
+    status: "success",
+    summary: `To answer the query, the following lucene query was generated and executed:
+    Query: ${a.query}
+    Type Category Filter: ${a.typeCategoryFilter}
+    Named Type Filters: ${a.typeFilters ? a.typeFilters.join(", ") : "None"}
+    Result Limit: ${a.resultLimit ?? "No limit"}
+
+    Search Results: ${n.results.length} result(s) found. 
+    
+    ${n.results.length > s ? `Showing top ${s} results:
+
+` : ""}${c.map((o) => JSON.stringify(o)).join(`
+`)}`,
+    details: {
+      generatedSearchQuery: a,
+      searchResults: n.results
+    }
+  };
+}, yt = T(Ue, {
+  name: j,
+  description: `
+    Search the knowledge graph using one or more search texts, using lucene search syntax, against indexed string properties defined on their entities and relationships. Use this tool when the user asks a question about their knowledge graph data as a whole, that could be answered via lucene text search of properties stored on graph elements, e.g requiring fuzzy matching. Otherwise if the inquiry is looking for connected records (e.g. paths), data aggregations, etc explore the data via the queryGraphData tool.
+ Example prompts:
+ - "Find 'Bradley'"
+ - "find the person john smith"
+ - "find all people named smith"
+ - "Find all references to 'delayed parts shipment'"
+ - "Find all reports authored by someone with the title of 'Researcher'"
+ - "Find the first 5 reports where summary mentions flood zoning near Sacramento, and the organization name is the City of Sacramento Utilities, and tags containing stormwater".
+ - "Search for all john smiths and show their global ids`,
+  schema: Ke
+});
+export {
+  O as G,
+  pt as a,
+  ut as b,
+  lt as c,
+  ct as d,
+  it as e,
+  q as f,
+  dt as g,
+  st as h,
+  ht as q,
+  yt as s
+};