@graphty/graphty-element 2.3.0 → 2.3.1

package/dist/chunks/{AiManager-Bd_r1Hei.js → AiManager-BBmGJbH4.js}

@@ -1,17 +1,17 @@
-import { l as _ } from "./VoiceInputAdapter-DszYl6Ha.js";
-import { G as K } from "./GraphtyLogger-5KEttFUo.js";
-import W from "jmespath";
-import { z as m } from "zod";
-import { e as G } from "./Algorithm-RQ629NLb.js";
-import { N as H, c as B, C as X } from "./cameras-ii4vngYY.js";
-import { inferSchema as C } from "@jsonhero/schema-infer";
-import { i as Z } from "./GraphtyError-BwcnblTH.js";
-import { createAnthropic as Y } from "@ai-sdk/anthropic";
-import { createGoogleGenerativeAI as J } from "@ai-sdk/google";
-import { createOpenAI as Q } from "@ai-sdk/openai";
-import { generateText as ee, streamText as te } from "ai";
-import { A as se } from "./ApiKeyManager-C0ac91dE.js";
-class I {
+import { l as Y } from "./VoiceInputAdapter-Dr9Gcmds.js";
+import { G as J } from "./GraphtyLogger-5KEttFUo.js";
+import { z as c } from "zod";
+import { k as Q, A as x, B as P } from "./optionsFromZod-17lkrAJs.js";
+import { N as ee, e as te, C as se, d as re } from "./algorithms-CpX56sUB.js";
+import ae from "jmespath";
+import { inferSchema as A } from "@jsonhero/schema-infer";
+import { i as oe } from "./GraphtyError-BwcnblTH.js";
+import { createAnthropic as ne } from "@ai-sdk/anthropic";
+import { createGoogleGenerativeAI as ie } from "@ai-sdk/google";
+import { createOpenAI as le } from "@ai-sdk/openai";
+import { generateText as ce, streamText as ue } from "ai";
+import { A as de } from "./ApiKeyManager-C0ac91dE.js";
+class F {
   /**
    * Creates a new AiStatusManager instance.
    */
@@ -111,18 +111,18 @@ class I {
    * @param status - New status for the tool call
    * @param result - Optional result data
    */
-  updateToolCallStatus(e, t, r) {
-    const { toolCalls: a } = this.status;
-    if (!a)
+  updateToolCallStatus(e, t, s) {
+    const { toolCalls: r } = this.status;
+    if (!r)
       return;
-    const o = a.findIndex((l) => l.name === e);
+    const o = r.findIndex((l) => l.name === e);
     if (o === -1)
       return;
-    const n = [...a];
+    const n = [...r];
     n[o] = {
       ...n[o],
       status: t,
-      result: r
+      result: s
     }, this.status = {
       ...this.status,
       toolCalls: n
@@ -186,14 +186,14 @@ class I {
     };
   }
 }
-const f = K.getLogger(["graphty", "ai"]);
-class re {
+const f = J.getLogger(["graphty", "ai"]);
+class me {
   /**
    * Creates a new AiController instance.
    * @param options - Configuration options for the controller
    */
   constructor(e) {
-    this.abortController = null, this.disposed = !1, this.currentInput = null, this.startTime = null, this.lastInput = null, this.lastError = null, this.provider = e.provider, this.commandRegistry = e.commandRegistry, this.graph = e.graph, this.statusManager = new I(), this.schemaManager = e.schemaManager ?? null, this.emitEvent = e.emitEvent, this.statusManager.subscribe((t) => {
+    this.abortController = null, this.disposed = !1, this.currentInput = null, this.startTime = null, this.lastInput = null, this.lastError = null, this.provider = e.provider, this.commandRegistry = e.commandRegistry, this.graph = e.graph, this.statusManager = new F(), this.schemaManager = e.schemaManager ?? null, this.emitEvent = e.emitEvent, this.statusManager.subscribe((t) => {
       this.emitAiEvent({
         type: "ai-status-change",
         status: t
@@ -224,22 +224,22 @@ class re {
       timestamp: this.startTime
     }), this.statusManager.submit();
     try {
-      const t = this.buildMessages(e), r = this.commandRegistry.toToolDefinitions();
-      f.debug("Request", { messages: t, tools: r.map((n) => n.name) }), this.statusManager.startStreaming();
-      const a = await this.provider.generate(t, r, { signal: this.abortController.signal });
+      const t = this.buildMessages(e), s = this.commandRegistry.toToolDefinitions();
+      f.debug("Request", { messages: t, tools: s.map((n) => n.name) }), this.statusManager.startStreaming();
+      const r = await this.provider.generate(t, s, { signal: this.abortController.signal });
       if (f.debug("Response", {
-        text: a.text || "(no text)",
-        toolCalls: a.toolCalls.map((n) => ({ name: n.name, arguments: n.arguments }))
-      }), a.text && (this.statusManager.appendStreamedText(a.text), this.emitAiEvent({
+        text: r.text || "(no text)",
+        toolCalls: r.toolCalls.map((n) => ({ name: n.name, arguments: n.arguments }))
+      }), r.text && (this.statusManager.appendStreamedText(r.text), this.emitAiEvent({
         type: "ai-stream-chunk",
-        text: a.text,
-        accumulated: a.text
-      })), a.toolCalls.length === 0) {
+        text: r.text,
+        accumulated: r.text
+      })), r.toolCalls.length === 0) {
         this.statusManager.complete();
         const n = {
           success: !0,
-          message: a.text || "No response from AI",
-          llmText: a.text
+          message: r.text || "No response from AI",
+          llmText: r.text
         };
         return this.emitAiEvent({
           type: "ai-command-complete",
@@ -248,22 +248,22 @@ class re {
         }), n;
       }
       this.statusManager.startExecuting();
-      const o = await this.executeToolCalls(a.toolCalls, a.text);
+      const o = await this.executeToolCalls(r.toolCalls, r.text);
       return this.statusManager.complete(), this.emitAiEvent({
         type: "ai-command-complete",
         result: o,
         duration: Date.now() - this.startTime
       }), o;
     } catch (t) {
-      const r = t instanceof Error ? t.message : String(t), a = t instanceof Error ? t : new Error(r);
-      return this.lastError = a, this.statusManager.setError(a, !0), this.emitAiEvent({
+      const s = t instanceof Error ? t.message : String(t), r = t instanceof Error ? t : new Error(s);
+      return this.lastError = r, this.statusManager.setError(r, !0), this.emitAiEvent({
         type: "ai-command-error",
-        error: a,
+        error: r,
         input: e,
         canRetry: !0
       }), {
         success: !1,
-        message: `Error: ${r}`
+        message: `Error: ${s}`
       };
     } finally {
       this.abortController = null, this.currentInput = null;
@@ -327,22 +327,22 @@ ${this.schemaManager.getFormattedSchema()}
    * @returns Combined execution result
    */
   async executeToolCalls(e, t) {
-    const r = [];
-    for (const a of e) {
-      this.statusManager.addToolCall(a.name), this.statusManager.updateToolCallStatus(a.name, "executing"), this.emitAiEvent({
+    const s = [];
+    for (const r of e) {
+      this.statusManager.addToolCall(r.name), this.statusManager.updateToolCallStatus(r.name, "executing"), this.emitAiEvent({
         type: "ai-stream-tool-call",
-        name: a.name,
-        params: a.arguments
+        name: r.name,
+        params: r.arguments
       });
       try {
-        const o = await this.executeToolCall(a);
-        if (r.push(o), this.statusManager.updateToolCallStatus(
-          a.name,
+        const o = await this.executeToolCall(r);
+        if (s.push(o), this.statusManager.updateToolCallStatus(
+          r.name,
           o.success ? "complete" : "error",
           o.data ?? { message: o.message }
         ), this.emitAiEvent({
           type: "ai-stream-tool-result",
-          name: a.name,
+          name: r.name,
           result: o.data ?? { message: o.message },
           success: o.success
         }), !o.success)
@@ -350,18 +350,18 @@ ${this.schemaManager.getFormattedSchema()}
       } catch (o) {
         const n = o instanceof Error ? o.message : String(o), l = {
           success: !1,
-          message: `Error executing ${a.name}: ${n}`
+          message: `Error executing ${r.name}: ${n}`
         };
-        r.push(l), this.statusManager.updateToolCallStatus(a.name, "error", { error: n }), this.emitAiEvent({
+        s.push(l), this.statusManager.updateToolCallStatus(r.name, "error", { error: n }), this.emitAiEvent({
           type: "ai-stream-tool-result",
-          name: a.name,
+          name: r.name,
           result: { error: n },
           success: !1
         });
         break;
       }
     }
-    return this.combineResults(r, t);
+    return this.combineResults(s, t);
   }
   /**
    * Execute a single tool call.
@@ -376,9 +376,9 @@ ${this.schemaManager.getFormattedSchema()}
         success: !1,
         message: `Unknown command: ${e.name}. Command not found in registry.`
       };
-    let r;
+    let s;
     try {
-      r = t.parameters.parse(e.arguments), f.debug("Validated arguments", { arguments: r });
+      s = t.parameters.parse(e.arguments), f.debug("Validated arguments", { arguments: s });
     } catch (n) {
       const l = n instanceof Error ? n.message : String(n);
       return f.debug("Command result: FAILED - Invalid arguments", { error: l }), {
@@ -386,7 +386,7 @@ ${this.schemaManager.getFormattedSchema()}
         message: `Invalid arguments for ${e.name}: ${l}`
       };
     }
-    const a = {
+    const r = {
       graph: this.graph,
       abortSignal: this.abortController?.signal ?? new AbortController().signal,
       emitEvent: (n, l) => {
@@ -395,7 +395,7 @@ ${this.schemaManager.getFormattedSchema()}
       updateStatus: (n) => {
         n.stageMessage && this.statusManager.setStage("executing", n.stageMessage);
       }
-    }, o = await t.execute(this.graph, r, a);
+    }, o = await t.execute(this.graph, s, r);
     return f.debug("Command result", {
       success: o.success,
       message: o.message,
@@ -415,12 +415,12 @@ ${this.schemaManager.getFormattedSchema()}
         message: t ?? "No commands executed",
         llmText: t
       };
-    const r = e.every((i) => i.success), a = e.map((i) => i.message);
-    t && a.unshift(t);
-    const o = e.flatMap((i) => i.affectedNodes ?? []).filter((i, u, c) => c.indexOf(i) === u), n = e.flatMap((i) => i.affectedEdges ?? []).filter((i, u, c) => c.indexOf(i) === u), l = e.filter((i) => i.success).pop() ?? e[e.length - 1];
+    const s = e.every((i) => i.success), r = e.map((i) => i.message);
+    t && r.unshift(t);
+    const o = [...new Set(e.flatMap((i) => i.affectedNodes ?? []))], n = [...new Set(e.flatMap((i) => i.affectedEdges ?? []))], l = e.filter((i) => i.success).pop() ?? e[e.length - 1];
     return {
-      success: r,
-      message: a.join(`
+      success: s,
+      message: r.join(`
 `),
       data: l.data,
       affectedNodes: o.length > 0 ? o : void 0,
@@ -460,7 +460,7 @@ ${this.schemaManager.getFormattedSchema()}
     this.disposed = !0, this.cancel(), this.statusManager.reset();
   }
 }
-class ae {
+class pe {
   constructor() {
     this.commands = /* @__PURE__ */ new Map();
   }
@@ -529,7 +529,7 @@ class ae {
     }));
   }
 }
-const oe = {
+const he = {
   maxSampleSize: 1e3,
   maxDepth: 3,
   enumMaxAbsoluteUnique: 10,
@@ -537,7 +537,7 @@ const oe = {
   enumMaxStringLength: 64,
   enumMinSampleSize: 25
 };
-class ne {
+class ge {
   constructor(e) {
     this.values = /* @__PURE__ */ new Map(), this.options = e;
   }
@@ -548,8 +548,8 @@ class ne {
    */
   trackValue(e, t) {
     this.values.has(e) || this.values.set(e, []);
-    const r = this.values.get(e);
-    r && r.push(t);
+    const s = this.values.get(e);
+    s && s.push(t);
   }
   /**
    * Recursively track string values from an object.
@@ -557,13 +557,13 @@ class ne {
    * @param prefix - Property path prefix
    * @param depth - Current recursion depth
    */
-  trackObject(e, t = "", r = 0) {
-    if (!(r >= this.options.maxDepth))
-      for (const [a, o] of Object.entries(e)) {
-        if (t === "" && a === "id")
+  trackObject(e, t = "", s = 0) {
+    if (!(s >= this.options.maxDepth))
+      for (const [r, o] of Object.entries(e)) {
+        if (t === "" && r === "id")
           continue;
-        const n = t ? `${t}.${a}` : a;
-        typeof o == "string" ? this.trackValue(n, o) : o !== null && typeof o == "object" && !Array.isArray(o) && this.trackObject(o, n, r + 1);
+        const n = t ? `${t}.${r}` : r;
+        typeof o == "string" ? this.trackValue(n, o) : o !== null && typeof o == "object" && !Array.isArray(o) && this.trackObject(o, n, s + 1);
       }
   }
   /**
@@ -581,30 +581,30 @@ class ne {
     const t = this.values.get(e);
     if (!t || t.length < this.options.enumMinSampleSize)
       return { isEnum: !1 };
-    const r = [...new Set(t)], a = r.length / t.length, o = r.length <= this.options.enumMaxAbsoluteUnique || a <= this.options.enumMaxUniqueRatio, n = r.every((l) => l.length <= this.options.enumMaxStringLength);
-    return o && n ? { isEnum: !0, values: r.sort() } : { isEnum: !1 };
+    const s = [...new Set(t)], r = s.length / t.length, o = s.length <= this.options.enumMaxAbsoluteUnique || r <= this.options.enumMaxUniqueRatio, n = s.every((l) => l.length <= this.options.enumMaxStringLength);
+    return o && n ? { isEnum: !0, values: s.sort() } : { isEnum: !1 };
   }
 }
-class D {
+class O {
   /**
    * Creates a new SchemaExtractor instance.
    * @param graph - The graph to extract schema from
    * @param options - Optional extraction options
    */
   constructor(e, t = {}) {
-    this.graph = e, this.options = { ...oe, ...t };
+    this.graph = e, this.options = { ...he, ...t };
   }
   /**
    * Extract schema from the graph.
    * @returns SchemaSummary with node and edge property information
    */
   extract() {
-    const e = this.graph.getDataManager(), t = this.graph.getNodeCount(), r = this.graph.getEdgeCount(), a = Array.from(e.nodes.values()).map((n) => n.data).filter((n) => n !== void 0), o = Array.from(e.edges.values()).map((n) => n.data).filter((n) => n !== void 0);
+    const e = this.graph.getDataManager(), t = this.graph.getNodeCount(), s = this.graph.getEdgeCount(), r = Array.from(e.nodes.values()).map((n) => n.data).filter((n) => n !== void 0), o = Array.from(e.edges.values()).map((n) => n.data).filter((n) => n !== void 0);
     return {
-      nodeProperties: this.extractFromCollection(a),
+      nodeProperties: this.extractFromCollection(r),
       edgeProperties: this.extractFromCollection(o),
       nodeCount: t,
-      edgeCount: r
+      edgeCount: s
     };
   }
   /**
@@ -615,14 +615,14 @@ class D {
   extractFromCollection(e) {
     if (e.length === 0)
       return [];
-    const t = e.length <= this.options.maxSampleSize ? e : this.sampleEvenly(e, this.options.maxSampleSize), [r, ...a] = t;
-    let o = C(r);
-    for (const i of a)
-      o = C(
+    const t = e.length <= this.options.maxSampleSize ? e : this.sampleEvenly(e, this.options.maxSampleSize), [s, ...r] = t;
+    let o = A(s);
+    for (const i of r)
+      o = A(
         i,
         o
       );
-    const n = o.toSnapshot(), l = new ne(this.options);
+    const n = o.toSnapshot(), l = new ge(this.options);
     for (const i of t)
       l.trackObject(i, "", 0);
     return this.mergeResults(n, l);
@@ -634,14 +634,14 @@ class D {
    * @returns Array of merged property summaries
    */
   mergeResults(e, t) {
-    const r = [];
+    const s = [];
     if (e.type === "object" && e.properties) {
-      for (const [a, o] of Object.entries(e.properties.required))
-        this.extractProperties(a, o, t, "", !1, r);
-      for (const [a, o] of Object.entries(e.properties.optional))
-        this.extractProperties(a, o, t, "", !0, r);
+      for (const [r, o] of Object.entries(e.properties.required))
+        this.extractProperties(r, o, t, "", !1, s);
+      for (const [r, o] of Object.entries(e.properties.optional))
+        this.extractProperties(r, o, t, "", !0, s);
     }
-    return r.sort((a, o) => a.name.localeCompare(o.name));
+    return s.sort((r, o) => r.name.localeCompare(o.name));
   }
   /**
    * Recursively extract properties, handling nested objects with dot notation.
@@ -653,19 +653,19 @@ class D {
    * @param properties - Array to accumulate property summaries
    * @param depth - Current recursion depth
    */
-  extractProperties(e, t, r, a, o, n, l = 0) {
-    const i = a ? `${a}.${e}` : e;
-    if (a === "" && e === "id" || l >= this.options.maxDepth)
+  extractProperties(e, t, s, r, o, n, l = 0) {
+    const i = r ? `${r}.${e}` : e;
+    if (r === "" && e === "id" || l >= this.options.maxDepth)
       return;
-    let u = o, c = t;
-    if (t.type === "nullable" && t.schema && (u = !0, c = t.schema), c.type === "object" && c.properties) {
-      for (const [d, h] of Object.entries(c.properties.required))
-        this.extractProperties(d, h, r, i, !1, n, l + 1);
-      for (const [d, h] of Object.entries(c.properties.optional))
-        this.extractProperties(d, h, r, i, !0, n, l + 1);
+    let u = o, d = t;
+    if (t.type === "nullable" && t.schema && (u = !0, d = t.schema), d.type === "object" && d.properties) {
+      for (const [m, h] of Object.entries(d.properties.required))
+        this.extractProperties(m, h, s, i, !1, n, l + 1);
+      for (const [m, h] of Object.entries(d.properties.optional))
+        this.extractProperties(m, h, s, i, !0, n, l + 1);
       return;
     }
-    const p = this.schemaToSummary(i, c, r, u);
+    const p = this.schemaToSummary(i, d, s, u);
     p && n.push(p);
   }
   /**
@@ -676,16 +676,16 @@ class D {
    * @param nullable - Whether the property can be null
    * @returns Property summary or null if not convertible
    */
-  schemaToSummary(e, t, r, a) {
+  schemaToSummary(e, t, s, r) {
     const o = {
       name: e,
       type: this.inferredTypeToPropertyType(t),
-      nullable: a
+      nullable: r
     };
     switch (t.type) {
       case "string": {
         t.format?.name && (o.format = t.format.name);
-        const n = r.getEnumAnalysis(e);
+        const n = s.getEnumAnalysis(e);
         n.isEnum && n.values && (o.enumValues = n.values);
         break;
       }
@@ -735,19 +735,19 @@ class D {
    * @returns Array of evenly distributed samples
    */
   sampleEvenly(e, t) {
-    const r = [], a = e.length / t;
+    const s = [], r = e.length / t;
     for (let o = 0; o < t; o++) {
-      const n = Math.floor(o * a);
-      r.push(e[n]);
+      const n = Math.floor(o * r);
+      s.push(e[n]);
     }
-    return r;
+    return s;
   }
 }
-const ie = m.enum(["nodeCount", "edgeCount", "currentLayout", "all", "summary"]).describe("Type of information to query about the graph"), le = {
+const fe = c.enum(["nodeCount", "edgeCount", "currentLayout", "all", "summary"]).describe("Type of information to query about the graph"), ye = {
   name: "queryGraph",
   description: "Query information about the graph structure, including node count, edge count, current layout, and overall statistics.",
-  parameters: m.object({
-    query: ie
+  parameters: c.object({
+    query: fe
   }),
   examples: [
     { input: "How many nodes are there?", params: { query: "nodeCount" } },
@@ -756,106 +756,106 @@ const ie = m.enum(["nodeCount", "edgeCount", "currentLayout", "all", "summary"])
     { input: "Show me the graph summary", params: { query: "summary" } },
     { input: "Give me all the graph stats", params: { query: "all" } }
   ],
-  execute(s, e) {
+  execute(a, e) {
     const { query: t } = e;
     try {
       switch (t) {
         case "nodeCount": {
-          const r = s.getNodeCount();
+          const s = a.getNodeCount();
           return Promise.resolve({
             success: !0,
-            message: `The graph has ${r} node${r !== 1 ? "s" : ""}.`,
-            data: { nodeCount: r }
+            message: `The graph has ${s} node${s !== 1 ? "s" : ""}.`,
+            data: { nodeCount: s }
           });
         }
         case "edgeCount": {
-          const r = s.getEdgeCount();
+          const s = a.getEdgeCount();
           return Promise.resolve({
             success: !0,
-            message: `The graph has ${r} edge${r !== 1 ? "s" : ""}.`,
-            data: { edgeCount: r }
+            message: `The graph has ${s} edge${s !== 1 ? "s" : ""}.`,
+            data: { edgeCount: s }
           });
         }
         case "currentLayout": {
-          const a = s.getLayoutManager().layoutEngine?.type ?? "unknown";
+          const r = a.getLayoutManager().layoutEngine?.type ?? "unknown";
           return Promise.resolve({
             success: !0,
-            message: `The current layout is "${a}".`,
-            data: { layout: a }
+            message: `The current layout is "${r}".`,
+            data: { layout: r }
           });
         }
         case "all":
         case "summary": {
-          const r = s.getNodeCount(), a = s.getEdgeCount(), n = s.getLayoutManager().layoutEngine?.type ?? "unknown", l = s.getViewMode() === "2d";
+          const s = a.getNodeCount(), r = a.getEdgeCount(), n = a.getLayoutManager().layoutEngine?.type ?? "unknown", l = a.getViewMode() === "2d";
           return Promise.resolve({
             success: !0,
             message: `Graph Summary:
-- Nodes: ${r}
-- Edges: ${a}
+- Nodes: ${s}
+- Edges: ${r}
 - Layout: ${n}
 - Mode: ${l ? "2D" : "3D"}`,
             data: {
-              nodeCount: r,
-              edgeCount: a,
+              nodeCount: s,
+              edgeCount: r,
               layout: n,
               is2D: l
             }
           });
         }
         default: {
-          const r = s.getNodeCount(), a = s.getEdgeCount();
+          const s = a.getNodeCount(), r = a.getEdgeCount();
           return Promise.resolve({
             success: !0,
-            message: `Unknown query type "${String(t)}". The graph has ${r} nodes and ${a} edges.`,
-            data: { nodeCount: r, edgeCount: a }
+            message: `Unknown query type "${String(t)}". The graph has ${s} nodes and ${r} edges.`,
+            data: { nodeCount: s, edgeCount: r }
           });
         }
       }
-    } catch (r) {
+    } catch (s) {
       return Promise.resolve({
         success: !1,
-        message: `Failed to query graph: ${r.message}`
+        message: `Failed to query graph: ${s.message}`
       });
     }
   }
-}, ce = {
+}, ve = 50, be = {
   name: "findNodes",
-  description: "Find nodes in the graph that match specific criteria. Returns matching node IDs and counts. Note: selectors search within node data directly, so use 'type' not 'data.type'.",
-  parameters: m.object({
-    selector: m.string().describe(
+  description: "Find nodes in the graph that match specific criteria. Returns the total number of matches and at most `limit` matching node IDs (50 when no limit is given), with `truncated` true when the list was cut. Note: selectors search within node data directly, so use 'type' not 'data.type'.",
+  parameters: c.object({
+    selector: c.string().describe(
       `Simple selector to match nodes (e.g., 'type == "server"'). Search is performed on node data directly, so use property names like 'type' not 'data.type'.`
     ),
-    limit: m.number().optional().describe("Maximum number of results to return")
+    limit: c.number().optional().describe("Maximum number of node IDs to return (default 50)")
   }),
   examples: [
     { input: "Find all server nodes", params: { selector: "type == 'server'" } },
     { input: "Find nodes with high degree", params: { selector: "degree > 5" } },
     { input: "Get first 10 nodes", params: { selector: "", limit: 10 } }
   ],
-  execute(s, e) {
-    const { selector: t, limit: r } = e;
+  execute(a, e) {
+    const { selector: t, limit: s } = e;
     try {
-      const a = s.getDataManager(), o = Array.from(a.nodes.values());
+      const r = a.getDataManager(), o = Array.from(r.nodes.values());
       let n;
-      !t || t === "" || t === "*" ? n = o : n = o.filter((i) => {
+      !t || t === "" || t === "*" ? n = o : n = o.filter((p) => {
         try {
-          const u = /^(\w+)\s*==\s*['"](.+)['"]$/.exec(t);
-          if (u) {
-            const [, p, d] = u, h = i.data[p];
-            return typeof h == "boolean" ? h === (d === "true") : h === d;
+          const m = /^(\w+)\s*==\s*['"](.+)['"]$/.exec(t);
+          if (m) {
+            const [, g, b] = m, v = p.data[g];
+            return typeof v == "boolean" ? v === (b === "true") : v === b;
           }
-          const c = /^(\w+)\s*(>|<|>=|<=)\s*(\d+)$/.exec(t);
-          if (c) {
-            const [, p, d, h] = c, g = Number(i.data[p]), v = Number(h);
-            switch (d) {
+          const h = /^(\w+)\s*(>|<|>=|<=)\s*(\d+)$/.exec(t);
+          if (h) {
+            const [, g, b, v] = h, w = Number(p.data[g]), S = Number(v);
+            switch (b) {
               case ">":
-                return g > v;
+                return w > S;
               case "<":
-                return g < v;
+                return w < S;
               case ">=":
-                return g >= v;
+                return w >= S;
               case "<=":
-                return g <= v;
+                return w <= S;
               default:
                 return !1;
             }
@@ -864,29 +864,32 @@ const ie = m.enum(["nodeCount", "edgeCount", "currentLayout", "all", "summary"])
         } catch {
           return !1;
         }
-      }), r !== void 0 && r > 0 && (n = n.slice(0, r));
-      const l = n.map((i) => String(i.id));
+      });
+      const l = n.length, i = n.slice(0, s !== void 0 && s > 0 ? s : ve).map((p) => String(p.id)), u = i.length, d = l > u;
       return Promise.resolve({
         success: !0,
-        message: `Found ${l.length} matching node${l.length !== 1 ? "s" : ""}.`,
+        message: `Found ${l} matching node${l !== 1 ? "s" : ""}${d ? ` (showing ${u})` : ""}.`,
         data: {
-          count: l.length,
-          nodeIds: l
+          total: l,
+          returned: u,
+          count: u,
+          truncated: d,
+          nodeIds: i
         },
-        affectedNodes: l
+        affectedNodes: i
       });
-    } catch (a) {
+    } catch (r) {
       return Promise.resolve({
         success: !1,
-        message: `Failed to find nodes: ${a.message}`
+        message: `Failed to find nodes: ${r.message}`
       });
     }
   }
-}, ue = m.enum(["nodeTypes", "edgeTypes", "nodeProperties", "edgeProperties", "all"]).describe("Type of schema information to retrieve"), de = {
+}, we = c.enum(["nodeTypes", "edgeTypes", "nodeProperties", "edgeProperties", "all"]).describe("Type of schema information to retrieve"), Se = {
   name: "getSchema",
   description: "Get schema information about the graph data including node types, edge types, and available properties. Use this to discover what types of nodes exist or what properties are available for filtering.",
-  parameters: m.object({
-    query: ue
+  parameters: c.object({
+    query: we
   }),
   examples: [
     { input: "What types of nodes are there?", params: { query: "nodeTypes" } },
@@ -895,21 +898,21 @@ const ie = m.enum(["nodeCount", "edgeCount", "currentLayout", "all", "summary"])
     { input: "What edge properties are available?", params: { query: "edgeProperties" } },
     { input: "Show me the data schema", params: { query: "all" } }
   ],
-  execute(s, e) {
+  execute(a, e) {
     const { query: t } = e;
     try {
-      const a = new D(s).extract(), o = s.getDataManager(), n = (l, i, u = 20) => {
-        const c = /* @__PURE__ */ new Set();
+      const r = new O(a).extract(), o = a.getDataManager(), n = (l, i, u = 20) => {
+        const d = /* @__PURE__ */ new Set();
         for (const p of l) {
-          const d = p.data?.[i];
-          if (typeof d == "string" && (c.add(d), c.size > u))
+          const m = p.data?.[i];
+          if (typeof m == "string" && (d.add(m), d.size > u))
             return [];
         }
-        return Array.from(c).sort();
+        return Array.from(d).sort();
       };
       switch (t) {
         case "nodeTypes": {
-          let i = a.nodeProperties.find((u) => u.name === "type")?.enumValues ?? [];
+          let i = r.nodeProperties.find((u) => u.name === "type")?.enumValues ?? [];
           return i.length === 0 && (i = n(o.nodes.values(), "type")), i.length === 0 ? Promise.resolve({
             success: !0,
             message: "No distinct node types found. Nodes may not have a 'type' property, or there are too many unique values to categorize.",
@@ -921,7 +924,7 @@ const ie = m.enum(["nodeCount", "edgeCount", "currentLayout", "all", "summary"])
           });
         }
         case "edgeTypes": {
-          let i = a.edgeProperties.find((u) => u.name === "type")?.enumValues ?? [];
+          let i = r.edgeProperties.find((u) => u.name === "type")?.enumValues ?? [];
           return i.length === 0 && (i = n(o.edges.values(), "type")), i.length === 0 ? Promise.resolve({
             success: !0,
             message: "No distinct edge types found. Edges may not have a 'type' property, or there are too many unique values to categorize.",
@@ -933,7 +936,7 @@ const ie = m.enum(["nodeCount", "edgeCount", "currentLayout", "all", "summary"])
           });
         }
         case "nodeProperties": {
-          const l = a.nodeProperties.map((i) => {
+          const l = r.nodeProperties.map((i) => {
             let u = `${i.name}: ${i.type}`;
             return i.enumValues && i.enumValues.length > 0 && (u += ` (values: ${i.enumValues.join(", ")})`), i.range && (u += ` (range: ${i.range.min}-${i.range.max})`), u;
           });
@@ -942,11 +945,11 @@ const ie = m.enum(["nodeCount", "edgeCount", "currentLayout", "all", "summary"])
             message: `Node properties:
 ${l.map((i) => `- ${i}`).join(`
 `)}`,
-            data: { nodeProperties: a.nodeProperties }
+            data: { nodeProperties: r.nodeProperties }
           });
         }
         case "edgeProperties": {
-          const l = a.edgeProperties.map((i) => {
+          const l = r.edgeProperties.map((i) => {
             let u = `${i.name}: ${i.type}`;
             return i.enumValues && i.enumValues.length > 0 && (u += ` (values: ${i.enumValues.join(", ")})`), i.range && (u += ` (range: ${i.range.min}-${i.range.max})`), u;
           });
@@ -959,36 +962,36 @@ ${l.map((i) => `- ${i}`).join(`
             message: `Edge properties:
 ${l.map((i) => `- ${i}`).join(`
 `)}`,
-            data: { edgeProperties: a.edgeProperties }
+            data: { edgeProperties: r.edgeProperties }
           });
         }
         case "all": {
-          let i = a.nodeProperties.find((g) => g.name === "type")?.enumValues ?? [];
+          let i = r.nodeProperties.find((g) => g.name === "type")?.enumValues ?? [];
           i.length === 0 && (i = n(o.nodes.values(), "type"));
-          let c = a.edgeProperties.find((g) => g.name === "type")?.enumValues ?? [];
-          c.length === 0 && (c = n(o.edges.values(), "type"));
-          const p = a.nodeProperties.map((g) => g.name), d = a.edgeProperties.map((g) => g.name);
+          let d = r.edgeProperties.find((g) => g.name === "type")?.enumValues ?? [];
+          d.length === 0 && (d = n(o.edges.values(), "type"));
+          const p = r.nodeProperties.map((g) => g.name), m = r.edgeProperties.map((g) => g.name);
           let h = `Graph Schema Summary:
-- ${a.nodeCount} nodes with ${a.nodeProperties.length} properties
-- ${a.edgeCount} edges with ${a.edgeProperties.length} properties`;
+- ${r.nodeCount} nodes with ${r.nodeProperties.length} properties
+- ${r.edgeCount} edges with ${r.edgeProperties.length} properties`;
           return i.length > 0 && (h += `
 
-Node types: ${i.join(", ")}`), c.length > 0 && (h += `
+Node types: ${i.join(", ")}`), d.length > 0 && (h += `
 
-Edge types: ${c.join(", ")}`), p.length > 0 && (h += `
+Edge types: ${d.join(", ")}`), p.length > 0 && (h += `
 
-Node properties: ${p.join(", ")}`), d.length > 0 && (h += `
+Node properties: ${p.join(", ")}`), m.length > 0 && (h += `
 
-Edge properties: ${d.join(", ")}`), Promise.resolve({
+Edge properties: ${m.join(", ")}`), Promise.resolve({
             success: !0,
             message: h,
             data: {
-              nodeCount: a.nodeCount,
-              edgeCount: a.edgeCount,
+              nodeCount: r.nodeCount,
+              edgeCount: r.edgeCount,
               nodeTypes: i,
-              edgeTypes: c,
-              nodeProperties: a.nodeProperties,
-              edgeProperties: a.edgeProperties
+              edgeTypes: d,
+              nodeProperties: r.nodeProperties,
+              edgeProperties: r.edgeProperties
             }
           });
         }
@@ -998,19 +1001,19 @@ Edge properties: ${d.join(", ")}`), Promise.resolve({
             message: `Unknown schema query type: ${String(t)}`
           });
       }
-    } catch (r) {
+    } catch (s) {
       return Promise.resolve({
         success: !1,
-        message: `Failed to get schema: ${r.message}`
+        message: `Failed to get schema: ${s.message}`
       });
     }
   }
-}, me = m.string().describe("Layout algorithm type (e.g., 'circular', 'ngraph', 'random', 'spiral', 'd3')"), pe = m.enum(["2d", "3d"]).describe("Dimension mode: '2d' or '3d'"), he = {
+}, Ce = c.string().describe("Layout algorithm type (e.g., 'circular', 'ngraph', 'random', 'spiral', 'd3')"), $e = c.enum(["2d", "3d"]).describe("Dimension mode: '2d' or '3d'"), xe = {
   name: "setLayout",
   description: "Change the graph layout algorithm. Common layouts include 'circular' (nodes in a circle), 'ngraph' (force-directed physics), 'random', 'spiral', 'shell', 'd3' (D3 force simulation), 'spring', 'planar', 'spectral', and 'forceatlas2'.",
-  parameters: m.object({
-    type: me,
-    options: m.record(m.unknown()).optional().describe("Additional layout-specific options")
+  parameters: c.object({
+    type: Ce,
+    options: c.record(c.unknown()).optional().describe("Additional layout-specific options")
   }),
   examples: [
     { input: "Use circular layout", params: { type: "circular" } },
@@ -1020,16 +1023,16 @@ Edge properties: ${d.join(", ")}`), Promise.resolve({
     { input: "Use D3 force layout", params: { type: "d3" } },
     { input: "Shell layout", params: { type: "shell" } }
   ],
-  async execute(s, e) {
-    const { type: t, options: r = {} } = e;
+  async execute(a, e) {
+    const { type: t, options: s = {} } = e;
     try {
-      return await s.setLayout(t, r), {
+      return await a.setLayout(t, s), {
         success: !0,
         message: `Layout changed to "${t}". The graph is now being rearranged.`,
         data: { layoutType: t }
       };
-    } catch (a) {
-      const o = a.message;
+    } catch (r) {
+      const o = r.message;
       return o.includes("not found") || o.includes("unknown") || o.includes("invalid") ? {
         success: !1,
         message: `Invalid layout type "${t}". Try 'circular', 'ngraph', 'random', 'spiral', 'shell', or 'd3'.`
@@ -1039,11 +1042,11 @@ Edge properties: ${d.join(", ")}`), Promise.resolve({
       };
     }
   }
-}, ge = {
+}, Me = {
   name: "setDimension",
   description: "Switch between 2D and 3D graph visualization modes. In 2D mode, nodes are arranged on a flat plane. In 3D mode, nodes can be positioned in three-dimensional space.",
-  parameters: m.object({
-    dimension: pe
+  parameters: c.object({
+    dimension: $e
   }),
   examples: [
     { input: "Switch to 2D view", params: { dimension: "2d" } },
@@ -1051,27 +1054,27 @@ Edge properties: ${d.join(", ")}`), Promise.resolve({
     { input: "Make it flat", params: { dimension: "2d" } },
     { input: "Enable 3D mode", params: { dimension: "3d" } }
   ],
-  async execute(s, e) {
+  async execute(a, e) {
     const { dimension: t } = e;
     try {
-      const r = t === "2d", a = r ? "2D" : "3D";
-      return await s.setViewMode(r ? "2d" : "3d"), {
+      const s = t === "2d", r = s ? "2D" : "3D";
+      return await a.setViewMode(s ? "2d" : "3d"), {
         success: !0,
-        message: `Switched to ${a} mode. The graph will now be displayed ${r ? "on a flat plane" : "in three-dimensional space"}.`,
-        data: { dimension: a, is2D: r }
+        message: `Switched to ${r} mode. The graph will now be displayed ${s ? "on a flat plane" : "in three-dimensional space"}.`,
+        data: { dimension: r, is2D: s }
       };
-    } catch (r) {
+    } catch (s) {
       return {
         success: !1,
-        message: `Failed to change dimension: ${r.message}`
+        message: `Failed to change dimension: ${s.message}`
       };
     }
   }
-}, fe = m.enum(["vr", "ar", "exit"]).describe("VR for virtual reality, AR for augmented reality, exit to return to normal view"), ye = {
+}, Pe = c.enum(["vr", "ar", "exit"]).describe("VR for virtual reality, AR for augmented reality, exit to return to normal view"), Ae = {
   name: "setImmersiveMode",
   description: "Enter or exit VR/AR immersive modes using WebXR. Use 'vr' for virtual reality (headset), 'ar' for augmented reality (pass-through or mobile AR), or 'exit' to return to normal desktop view.",
-  parameters: m.object({
-    mode: fe
+  parameters: c.object({
+    mode: Pe
   }),
   examples: [
     { input: "Enter VR mode", params: { mode: "vr" } },
@@ -1082,25 +1085,25 @@ Edge properties: ${d.join(", ")}`), Promise.resolve({
     { input: "Show augmented reality view", params: { mode: "ar" } },
     { input: "Go back to normal view", params: { mode: "exit" } }
   ],
-  async execute(s, e) {
+  async execute(a, e) {
     const { mode: t } = e;
     try {
       if (t === "exit") {
-        const n = s.exitImmersiveMode;
-        return n && await n.call(s), {
+        const n = a.exitImmersiveMode;
+        return n && await n.call(a), {
           success: !0,
           message: "Exited immersive mode, returned to normal view."
         };
       }
-      const { getXRHelper: r } = s, a = r?.call(s);
-      if (!a)
+      const { getXRHelper: s } = a, r = s?.call(a);
+      if (!r)
         return {
           success: !1,
           message: `WebXR is not available. ${t.toUpperCase()} mode requires a WebXR-capable browser and device.`
         };
       if (t === "vr") {
-        const { enterVR: n } = a;
-        return n ? (await n.call(a), {
+        const { enterVR: n } = r;
+        return n ? (await n.call(r), {
           success: !0,
           message: "Entering VR mode. Put on your headset to view the graph in virtual reality."
         }) : {
@@ -1108,96 +1111,96 @@ Edge properties: ${d.join(", ")}`), Promise.resolve({
           message: "VR mode is not supported on this device or browser."
         };
       }
-      const { enterAR: o } = a;
-      return o ? (await o.call(a), {
+      const { enterAR: o } = r;
+      return o ? (await o.call(r), {
         success: !0,
         message: "Entering AR mode. Point your device to see the graph in augmented reality."
       }) : {
         success: !1,
         message: "AR mode is not supported on this device or browser."
       };
-    } catch (r) {
+    } catch (s) {
       return {
         success: !1,
-        message: `Failed to enter ${t.toUpperCase()} mode: ${r.message}`
+        message: `Failed to enter ${t.toUpperCase()} mode: ${s.message}`
       };
     }
   }
-}, ve = m.object({
-  color: m.string().optional().describe("Color for the node (e.g., '#ff0000', 'red')"),
-  size: m.number().positive().optional().describe("Size of the node (default is 1)"),
-  shape: m.string().optional().describe("Shape type (e.g., 'sphere', 'box', 'cylinder')"),
-  glowColor: m.string().optional().describe("Glow effect color"),
-  glowStrength: m.number().positive().optional().describe("Glow effect strength. One strength is drawn at a time for the whole scene"),
-  outlineColor: m.string().optional().describe("Outline color"),
-  outlineWidth: m.number().positive().optional().describe(
+}, Ee = c.object({
+  color: c.string().optional().describe("Color for the node (e.g., '#ff0000', 'red')"),
+  size: c.number().positive().optional().describe("Size of the node (default is 1)"),
+  shape: c.string().optional().describe("Shape type (e.g., 'sphere', 'box', 'cylinder')"),
+  glowColor: c.string().optional().describe("Glow effect color"),
+  glowStrength: c.number().positive().optional().describe("Glow effect strength. One strength is drawn at a time for the whole scene"),
+  outlineColor: c.string().optional().describe("Outline color"),
+  outlineWidth: c.number().positive().optional().describe(
     "Outline width. Not drawn: every outline in the scene is stroked at one width, so asking for this is answered with the reason rather than applied"
   ),
-  enabled: m.boolean().optional().describe("Whether the node is visible")
-}).describe("Style properties for nodes"), be = m.object({
-  color: m.string().optional().describe("Color for the edge line (e.g., '#00ff00', 'green')"),
-  width: m.number().positive().optional().describe("Width of the edge line"),
-  lineType: m.string().optional().describe("Line pattern (e.g., 'solid', 'dash', 'dot')"),
-  arrowColor: m.string().optional().describe("Color for the arrow head"),
-  arrowSize: m.number().positive().optional().describe("Size of the arrow head"),
-  arrowOpacity: m.number().min(0).max(1).optional().describe("Opacity of the arrow head, 0 to 1"),
-  enabled: m.boolean().optional().describe("Whether the edge is visible")
-}).describe("Style properties for edges"), we = { by: "plugin", name: "graphty-ai" };
-function Se(s) {
+  enabled: c.boolean().optional().describe("Whether the node is visible")
+}).describe("Style properties for nodes"), Te = c.object({
+  color: c.string().optional().describe("Color for the edge line (e.g., '#00ff00', 'green')"),
+  width: c.number().positive().optional().describe("Width of the edge line"),
+  lineType: c.string().optional().describe("Line pattern (e.g., 'solid', 'dash', 'dot')"),
+  arrowColor: c.string().optional().describe("Color for the arrow head"),
+  arrowSize: c.number().positive().optional().describe("Size of the arrow head"),
+  arrowOpacity: c.number().min(0).max(1).optional().describe("Opacity of the arrow head, 0 to 1"),
+  enabled: c.boolean().optional().describe("Whether the edge is visible")
+}).describe("Style properties for edges"), Ne = { by: "plugin", name: "graphty-ai" };
+function ke(a) {
   const e = {}, t = [];
-  return s.color !== void 0 && (e["node.color"] = s.color), s.size !== void 0 && (e["node.size"] = s.size), s.shape !== void 0 && (e["node.shape"] = s.shape), s.glowColor !== void 0 && (e["node.glow"] = s.glowColor), s.glowStrength !== void 0 && (e["node.glowStrength"] = s.glowStrength), s.outlineColor !== void 0 && (e["node.outline"] = s.outlineColor), s.enabled === !1 && (e["node.opacity"] = 0), s.outlineWidth !== void 0 && t.push({ property: "outlineWidth", reason: H }), { set: e, unsupported: t };
+  return a.color !== void 0 && (e["node.color"] = a.color), a.size !== void 0 && (e["node.size"] = a.size), a.shape !== void 0 && (e["node.shape"] = a.shape), a.glowColor !== void 0 && (e["node.glow"] = a.glowColor), a.glowStrength !== void 0 && (e["node.glowStrength"] = a.glowStrength), a.outlineColor !== void 0 && (e["node.outline"] = a.outlineColor), a.enabled === !1 && (e["node.opacity"] = 0), a.outlineWidth !== void 0 && t.push({ property: "outlineWidth", reason: ee }), { set: e, unsupported: t };
 }
-function Ce(s) {
+function Ie(a) {
   const e = {};
-  return s.color !== void 0 && (e["edge.color"] = s.color), s.width !== void 0 && (e["edge.width"] = s.width), s.lineType !== void 0 && (e["edge.style"] = s.lineType), s.enabled === !1 && (e["edge.opacity"] = 0), s.arrowColor !== void 0 && (e["edge.arrowHeadColor"] = s.arrowColor), s.arrowSize !== void 0 && (e["edge.arrowHeadSize"] = s.arrowSize), s.arrowOpacity !== void 0 && (e["edge.arrowHeadOpacity"] = s.arrowOpacity), { set: e, unsupported: [] };
+  return a.color !== void 0 && (e["edge.color"] = a.color), a.width !== void 0 && (e["edge.width"] = a.width), a.lineType !== void 0 && (e["edge.style"] = a.lineType), a.enabled === !1 && (e["edge.opacity"] = 0), a.arrowColor !== void 0 && (e["edge.arrowHeadColor"] = a.arrowColor), a.arrowSize !== void 0 && (e["edge.arrowHeadSize"] = a.arrowSize), a.arrowOpacity !== void 0 && (e["edge.arrowHeadOpacity"] = a.arrowOpacity), { set: e, unsupported: [] };
 }
-const xe = /* @__PURE__ */ new Set(["", "*", "all", "*.*", "true"]);
-function $e(s) {
-  return !s || xe.has(s.toLowerCase().trim());
+const Re = /* @__PURE__ */ new Set(["", "*", "all", "*.*", "true"]);
+function De(a) {
+  return !a || Re.has(a.toLowerCase().trim());
 }
-function L(s, e, t, r) {
+function _(a, e, t, s) {
   return {
-    name: s,
+    name: a,
     target: e,
     kind: "custom",
-    source: we,
-    selector: $e(t) ? { match: "everything" } : { match: "expression", where: t.replace(/"/g, "'") },
-    set: r
+    source: Ne,
+    selector: De(t) ? { match: "everything" } : { match: "expression", where: t.replace(/"/g, "'") },
+    set: s
   };
 }
-function z(s) {
-  return Z(s) ? `${s.message} (${s.code})` : s instanceof Error ? s.message : String(s);
+function K(a) {
+  return oe(a) ? `${a.message} (${a.code})` : a instanceof Error ? a.message : String(a);
 }
-async function j(s, e, t, r) {
-  const { styles: a } = s.getSession(), o = a.validate(e);
+async function W(a, e, t, s) {
+  const { styles: r } = a.getSession(), o = r.validate(e);
   if (!o.ok)
     return {
       success: !1,
-      message: `That ${r} style could not be applied: ${o.errors.map((n) => n.message).join(" ")}`
+      message: `That ${s} style could not be applied: ${o.errors.map((n) => n.message).join(" ")}`
     };
   try {
-    const n = await a.add(e), l = t.map(({ property: u, reason: c }) => ` ${u} was not applied: ${c}`).join(""), i = o.unresolvedPaths.length === 0 ? "" : ` Nothing in this graph answers ${o.unresolvedPaths.join(", ")} yet, so the layer may paint nothing until it does.`;
+    const n = await r.add(e), l = t.map(({ property: u, reason: d }) => ` ${u} was not applied: ${d}`).join(""), i = o.unresolvedPaths.length === 0 ? "" : ` Nothing in this graph answers ${o.unresolvedPaths.join(", ")} yet, so the layer may paint nothing until it does.`;
     return {
       success: !0,
-      message: `Added the ${r} style layer "${n.name}".${l}${i}`,
+      message: `Added the ${s} style layer "${n.name}".${l}${i}`,
       data: { layerId: n.id, layerName: n.name }
     };
   } catch (n) {
     return {
       success: !1,
-      message: `That ${r} style could not be applied: ${z(n)}`
+      message: `That ${s} style could not be applied: ${K(n)}`
     };
   }
 }
-const Me = {
+const Le = {
   name: "findAndStyleNodes",
   description: `Style the nodes matching a selector by adding a style layer. Use an empty selector to match every node. A node's own fields are published under 'data.', so write 'data.type == "server"'. Styles include color, size, shape, glow color and outline color.`,
-  parameters: m.object({
-    selector: m.string().describe(
+  parameters: c.object({
+    selector: c.string().describe(
       `Expression matching nodes (empty string matches all). A record's own fields live under 'data.', so write 'data.type == "server"'.`
     ),
-    style: ve,
-    layerName: m.string().optional().describe("Name for this style layer (for later removal)")
+    style: Ee,
+    layerName: c.string().optional().describe("Name for this style layer (for later removal)")
   }),
   examples: [
     {
@@ -1221,23 +1224,23 @@ const Me = {
       params: { selector: "", style: { shape: "box" }, layerName: "box-shapes" }
     }
   ],
-  async execute(s, e) {
+  async execute(a, e) {
     const {
       selector: t,
-      style: r,
-      layerName: a = `ai-node-style-${Date.now()}`
-    } = e, { set: o, unsupported: n } = Se(r);
-    return j(s, L(a, "node", t, o), n, "node");
+      style: s,
+      layerName: r = `ai-node-style-${Date.now()}`
+    } = e, { set: o, unsupported: n } = ke(s);
+    return W(a, _(r, "node", t, o), n, "node");
   }
-}, Pe = {
+}, je = {
   name: "findAndStyleEdges",
   description: "Style the edges matching a selector by adding a style layer. Use an empty selector to match every edge. An edge's own fields are published under 'data.', so write 'data.weight > `0.5`'. Styles include color, width and line pattern.",
-  parameters: m.object({
-    selector: m.string().describe(
+  parameters: c.object({
+    selector: c.string().describe(
       "Expression matching edges (empty string matches all). A record's own fields live under 'data.', so write 'data.weight > `0.5`'."
     ),
-    style: be,
-    layerName: m.string().optional().describe("Name for this style layer (for later removal)")
+    style: Te,
+    layerName: c.string().optional().describe("Name for this style layer (for later removal)")
   }),
   examples: [
     {
@@ -1257,29 +1260,29 @@ const Me = {
       params: { selector: "", style: { lineType: "dash" }, layerName: "dashed" }
     }
   ],
-  async execute(s, e) {
+  async execute(a, e) {
     const {
       selector: t,
-      style: r,
-      layerName: a = `ai-edge-style-${Date.now()}`
-    } = e, { set: o, unsupported: n } = Ce(r);
-    return j(s, L(a, "edge", t, o), n, "edge");
+      style: s,
+      layerName: r = `ai-edge-style-${Date.now()}`
+    } = e, { set: o, unsupported: n } = Ie(s);
+    return W(a, _(r, "edge", t, o), n, "edge");
   }
-}, Ee = {
+}, ze = {
   name: "clearStyles",
   description: "Clear styles added by AI commands. Specify a layerName to clear a specific style, or leave empty to clear all AI-added styles.",
-  parameters: m.object({
-    layerName: m.string().optional().describe("Name of the style layer to clear (clears all if not specified)")
+  parameters: c.object({
+    layerName: c.string().optional().describe("Name of the style layer to clear (clears all if not specified)")
   }),
   examples: [
     { input: "Clear all styling", params: {} },
     { input: "Remove red node styling", params: { layerName: "red-nodes" } }
   ],
-  async execute(s, e) {
-    const { layerName: t } = e, { styles: r } = s.getSession();
+  async execute(a, e) {
+    const { layerName: t } = e, { styles: s } = a.getSession();
     try {
       if (t === void 0) {
-        const o = await r.removeBySource(
+        const o = await s.removeBySource(
           (n) => n.by === "plugin" && n.name === "graphty-ai"
         );
         return {
@@ -1288,42 +1291,42 @@ const Me = {
           data: { clearedCount: o.length }
         };
       }
-      const a = r.list().filter(
+      const r = s.list().filter(
         (o) => o.name === t && o.source.by === "plugin" && o.source.name === "graphty-ai"
       );
-      if (a.length === 0)
+      if (r.length === 0)
         return {
           success: !0,
           message: `Style layer "${t}" not found (may already be cleared).`
         };
-      for (const o of a)
-        await r.remove(o.id);
+      for (const o of r)
+        await s.remove(o.id);
       return {
         success: !0,
         message: `Cleared style layer "${t}".`,
-        data: { clearedCount: a.length }
+        data: { clearedCount: r.length }
       };
-    } catch (a) {
+    } catch (r) {
       return {
         success: !1,
-        message: `Failed to clear styles: ${z(a)}`
+        message: `Failed to clear styles: ${K(r)}`
       };
     }
   }
 };
-function x() {
+function E() {
   return [
-    ...X.map((s) => s.id),
-    ...G().map((s) => s.id)
+    ...se.map((a) => a.id),
+    ...Q().map((a) => a.id)
   ];
 }
-const Te = m.string().describe(
+const qe = c.string().describe(
   "Named camera view. The element ships 'fitToGraph', 'topView', 'sideView', 'frontView' and 'isometric'; an application may have registered others."
-), $ = m.object({
-  x: m.number(),
-  y: m.number(),
-  z: m.number()
-}).describe("3D position coordinates"), Ae = {
+), T = c.object({
+  x: c.number(),
+  y: c.number(),
+  z: c.number()
+}).describe("3D position coordinates"), Ue = {
   name: "setCameraPosition",
   /*
    * READ AT PROMPT TIME, NOT AT IMPORT TIME. The description is what the system prompt shows
@@ -1334,13 +1337,13 @@ const Te = m.string().describe(
    * registered.
    */
   get description() {
-    return `Set the camera position using a preset (${x().join(", ")}) or specific coordinates. Presets automatically calculate the best view for the current graph. Animation can be enabled for smooth transitions.`;
+    return `Set the camera position using a preset (${E().join(", ")}) or specific coordinates. Presets automatically calculate the best view for the current graph. Animation can be enabled for smooth transitions.`;
   },
-  parameters: m.object({
-    preset: Te.optional().describe("Named camera preset to apply"),
-    position: $.optional().describe("Custom camera position (3D only)"),
-    target: $.optional().describe("Point the camera should look at (3D only)"),
-    animate: m.boolean().optional().describe("Whether to animate the camera transition (default: true)")
+  parameters: c.object({
+    preset: qe.optional().describe("Named camera preset to apply"),
+    position: T.optional().describe("Custom camera position (3D only)"),
+    target: T.optional().describe("Point the camera should look at (3D only)"),
+    animate: c.boolean().optional().describe("Whether to animate the camera transition (default: true)")
   }),
   examples: [
     { input: "Show from top", params: { preset: "topView", animate: !0 } },
@@ -1353,37 +1356,37 @@ const Te = m.string().describe(
       params: { position: { x: 10, y: 20, z: 30 }, target: { x: 0, y: 0, z: 0 } }
     }
   ],
-  async execute(s, e) {
+  async execute(a, e) {
     const {
       preset: t,
-      position: r,
-      target: a,
+      position: s,
+      target: r,
       animate: o = !0
     } = e;
     try {
-      if (!t && !r)
+      if (!t && !s)
         return {
           success: !1,
           message: "Either 'preset' or 'position' must be provided."
         };
       if (t)
-        return B(t) ? (await s.setCameraState({ preset: t }, { animate: o, description: `Setting camera to ${t} view` }), {
+        return te(t) ? (await a.setCameraState({ preset: t }, { animate: o, description: `Setting camera to ${t} view` }), {
           success: !0,
           message: `Camera moved to ${t} view${o ? " (animated)" : ""}.`,
           data: { preset: t, animated: o }
         }) : {
           success: !1,
-          message: `Unknown camera view "${t}". Available views: ${x().join(", ")}.`
+          message: `Unknown camera view "${t}". Available views: ${E().join(", ")}.`
         };
-      if (r) {
-        const n = { position: r };
-        return a && (n.target = a), await s.setCameraState(n, {
+      if (s) {
+        const n = { position: s };
+        return r && (n.target = r), await a.setCameraState(n, {
           animate: o,
           description: "Moving camera to specified position"
         }), {
           success: !0,
-          message: `Camera moved to position (${r.x}, ${r.y}, ${r.z})${o ? " (animated)" : ""}.`,
-          data: { position: r, target: a, animated: o }
+          message: `Camera moved to position (${s.x}, ${s.y}, ${s.z})${o ? " (animated)" : ""}.`,
+          data: { position: s, target: r, animated: o }
         };
       }
       return {
@@ -1398,227 +1401,361 @@ const Te = m.string().describe(
     }
   }
 };
-function Ne(s, e) {
-  const t = s.getDataManager(), { nodes: r } = t, a = [];
+function Ve(a, e) {
+  const t = a.getDataManager(), { nodes: s } = t, r = [];
   if (!e || e.length === 0) {
-    for (const [o] of r)
-      a.push(String(o));
-    return a;
+    for (const [o] of s)
+      r.push(String(o));
+    return r;
   }
   try {
     const n = `[?${e.replace(/"/g, "'")}]`;
-    for (const [l, i] of r) {
-      const { data: u } = i, c = W.search([u], n);
-      Array.isArray(c) && c.length > 0 && a.push(String(l));
+    for (const [l, i] of s) {
+      const { data: u } = i, d = ae.search([u], n);
+      Array.isArray(d) && d.length > 0 && r.push(String(l));
     }
   } catch {
     return [];
   }
-  return a;
+  return r;
 }
-const ke = {
+const Fe = {
   name: "zoomToNodes",
   description: "Zoom the camera to fit specific nodes in view. Use a JMESPath selector to choose which nodes to focus on, or leave empty to fit all nodes. Optionally add padding around the nodes.",
-  parameters: m.object({
-    selector: m.string().optional().describe("JMESPath expression to match nodes (empty matches all)"),
-    animate: m.boolean().optional().describe("Whether to animate the zoom (default: true)"),
-    padding: m.number().optional().describe("Extra padding around nodes (default: 1.2 = 20% padding)")
+  parameters: c.object({
+    selector: c.string().optional().describe("JMESPath expression to match nodes (empty matches all)"),
+    animate: c.boolean().optional().describe("Whether to animate the zoom (default: true)"),
+    padding: c.number().optional().describe("Extra padding around nodes (default: 1.2 = 20% padding)")
   }),
   examples: [
     { input: "Zoom to fit all nodes", params: { selector: "" } },
     { input: "Zoom to server nodes", params: { selector: "type == 'server'" } },
     { input: "Fit graph with more padding", params: { selector: "", padding: 1.5 } }
   ],
-  async execute(s, e) {
-    const { selector: t = "", animate: r = !0 } = e;
+  async execute(a, e) {
+    const { selector: t = "", animate: s = !0 } = e;
     try {
-      const a = Ne(s, t);
-      if (a.length === 0 && t && t.length > 0)
+      const r = Ve(a, t);
+      if (r.length === 0 && t && t.length > 0)
         return {
           success: !0,
           message: `No nodes matched the selector "${t}".`,
           affectedNodes: []
         };
-      await s.applyCameraView("fitToGraph", {
-        ...t && t.length > 0 ? { scope: { nodes: a } } : {},
-        animate: r,
+      await a.applyCameraView("fitToGraph", {
+        ...t && t.length > 0 ? { scope: { nodes: r } } : {},
+        animate: s,
         description: `Zooming to fit ${t ? "matching nodes" : "all nodes"}`
       });
-      const o = t ? a.length : s.getNodeCount();
+      const o = t ? r.length : a.getNodeCount();
       return {
         success: !0,
         message: `Zoomed to fit ${o} node(s)${t ? ` matching "${t}"` : ""}.`,
-        affectedNodes: a,
-        data: { nodeCount: o, animated: r }
+        affectedNodes: r,
+        data: { nodeCount: o, animated: s }
+      };
+    } catch (r) {
+      return {
+        success: !1,
+        message: `Failed to zoom to nodes: ${r.message}`
+      };
+    }
+  }
+}, N = c.object({
+  namespace: c.string().describe("The namespace of the algorithm (e.g., 'graphty')"),
+  type: c.string().describe("The type of algorithm to run (e.g., 'degree', 'pagerank')"),
+  options: c.record(c.string(), c.unknown()).optional().describe(
+    "The algorithm's options, by name (e.g., { source: 'a', target: 'b' } for dijkstra, { dampingFactor: 0.9 } for pagerank). An unknown name or an out-of-range value is refused."
+  )
+}), k = 50, I = c.object({
+  namespace: c.string().optional().describe("Optional namespace to filter algorithms by")
+}), Oe = {
+  name: "runAlgorithm",
+  description: "Run a graph algorithm to analyze the graph structure, optionally with options such as a source and target. Returns a bounded summary: the top 10 elements and the value range for a metric, the group sizes for a partition, the route for a path, plus any graph-level values.",
+  parameters: N,
+  examples: [
+    {
+      input: "Calculate the degree of each node",
+      params: { namespace: "graphty", type: "degree" }
+    },
+    {
+      input: "Run pagerank algorithm",
+      params: { namespace: "graphty", type: "pagerank" }
+    },
+    {
+      input: "Compute centrality metrics",
+      params: { namespace: "graphty", type: "degree" }
+    },
+    {
+      input: "Find the shortest path from node A to node B",
+      params: { namespace: "graphty", type: "dijkstra", options: { source: "A", target: "B" } }
+    }
+  ],
+  async execute(a, e) {
+    const t = N.safeParse(e);
+    if (!t.success)
+      return {
+        success: !1,
+        message: `Invalid parameters: ${t.error.message}`
+      };
+    const { namespace: s, type: r, options: o } = t.data;
+    try {
+      if (!x.get(a, s, r)) {
+        const m = x.getRegisteredAlgorithms(s), h = m.length > 0 ? `Available in namespace '${s}': ${m.map((g) => g.split(":")[1]).join(", ")}` : `No algorithms found in namespace '${s}'. Use listAlgorithms to see available options.`;
+        return {
+          success: !1,
+          message: `Algorithm not found: ${s}:${r}. ${h}`
+        };
+      }
+      const l = (s === "graphty" ? re(r) : void 0) ?? P(`${s}:${r}`) ?? P(r);
+      if (l === void 0)
+        return await a.runAlgorithm(s, r, { algorithmOptions: o }), {
+          success: !0,
+          message: `Successfully ran ${s}:${r} algorithm. Results are now available in node data.`,
+          data: { namespace: s, type: r, nodeCount: a.getNodeCount() }
+        };
+      const i = "params" in l ? l.params : {}, u = await a.run(l.descriptor.key, { ...i, ...o }), d = {
+        namespace: s,
+        type: r,
+        algorithm: l.descriptor.key,
+        shape: u.shape,
+        summary: u.summary(),
+        graph: u.graph
       };
-    } catch (a) {
+      let p;
+      if (u.shape === "path") {
+        const m = u.ranking("order").map((h) => String(h.id)).reverse();
+        p = m.slice(0, k), d.path = {
+          nodeIds: p,
+          total: m.length,
+          truncated: m.length > k
+        };
+      }
+      return {
+        success: !0,
+        message: `Successfully ran ${s}:${r} algorithm. ${u.reading()}`,
+        data: d,
+        ...p === void 0 ? {} : { affectedNodes: p }
+      };
+    } catch (n) {
+      return {
+        success: !1,
+        message: `Failed to run algorithm ${s}:${r}: ${n instanceof Error ? n.message : String(n)}`
+      };
+    }
+  }
+}, _e = {
+  name: "listAlgorithms",
+  description: "List all available graph algorithms that can be run on the graph. Optionally filter by namespace.",
+  parameters: I,
+  examples: [
+    {
+      input: "What algorithms are available?",
+      params: {}
+    },
+    {
+      input: "List graphty algorithms",
+      params: { namespace: "graphty" }
+    },
+    {
+      input: "Show me the available analysis tools",
+      params: {}
+    }
+  ],
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async execute(a, e) {
+    const t = I.safeParse(e);
+    if (!t.success)
+      return {
+        success: !1,
+        message: `Invalid parameters: ${t.error.message}`
+      };
+    const { namespace: s } = t.data;
+    try {
+      const r = x.getRegisteredAlgorithms(s);
+      return r.length === 0 ? {
+        success: !0,
+        message: s ? `No algorithms found in namespace '${s}'.` : "No algorithms are currently registered.",
+        data: {
+          algorithms: [],
+          count: 0
+        }
+      } : {
+        success: !0,
+        message: s ? `Found ${r.length} algorithm(s) in namespace '${s}': ${r.join(", ")}` : `Found ${r.length} available algorithm(s): ${r.join(", ")}`,
+        data: {
+          algorithms: r,
+          count: r.length
+        }
+      };
+    } catch (r) {
       return {
         success: !1,
-        message: `Failed to zoom to nodes: ${a.message}`
+        message: `Failed to list algorithms: ${r instanceof Error ? r.message : String(r)}`
       };
     }
   }
 };
-function Re(s, e = 100) {
-  return s.length <= e ? s : `${s.slice(0, e)}...`;
+function Ke(a, e = 100) {
+  return a.length <= e ? a : `${a.slice(0, e)}...`;
 }
-function S(s, e) {
-  if (s == null)
+function M(a, e) {
+  if (a == null)
     return;
   const t = e.split(".");
-  let r = s;
-  for (const a of t) {
-    if (r == null || typeof r != "object")
+  let s = a;
+  for (const r of t) {
+    if (s == null || typeof s != "object")
       return;
-    r = r[a];
+    s = s[r];
   }
-  return r;
+  return s;
 }
-function b(s, e = 100) {
-  if (s == null)
-    return s;
-  if (typeof s == "string")
-    return Re(s, e);
-  if (Array.isArray(s))
-    return s.map((t) => b(t, e));
-  if (typeof s == "object") {
+function C(a, e = 100) {
+  if (a == null)
+    return a;
+  if (typeof a == "string")
+    return Ke(a, e);
+  if (Array.isArray(a))
+    return a.map((t) => C(t, e));
+  if (typeof a == "object") {
     const t = {};
-    for (const [r, a] of Object.entries(s))
-      t[r] = b(a, e);
+    for (const [s, r] of Object.entries(a))
+      t[s] = C(r, e);
     return t;
   }
-  return s;
+  return a;
 }
-function q(s) {
-  if (s.length === 0)
+function G(a) {
+  if (a.length === 0)
     return { min: 0, max: 0, avg: 0, median: 0, count: 0 };
-  const e = [...s].sort((i, u) => i - u), t = s.reduce((i, u) => i + u, 0), r = e[0], a = e[e.length - 1], o = t / s.length, n = Math.floor(e.length / 2), l = e.length % 2 === 0 ? (e[n - 1] + e[n]) / 2 : e[n];
-  return { min: r, max: a, avg: o, median: l, count: s.length };
+  const e = [...a].sort((i, u) => i - u), t = a.reduce((i, u) => i + u, 0), s = e[0], r = e[e.length - 1], o = t / a.length, n = Math.floor(e.length / 2), l = e.length % 2 === 0 ? (e[n - 1] + e[n]) / 2 : e[n];
+  return { min: s, max: r, avg: o, median: l, count: a.length };
 }
-function Ie(s, e = 5) {
-  if (s.length === 0)
+function We(a, e = 5) {
+  if (a.length === 0)
     return [];
-  const t = Math.min(...s), r = Math.max(...s);
-  if (t === r)
+  const t = Math.min(...a), s = Math.max(...a);
+  if (t === s)
     return [
       {
-        range: M(t, r),
-        count: s.length,
+        range: R(t, s),
+        count: a.length,
         min: t,
-        max: r
+        max: s
       }
     ];
-  const a = (r - t) / e, o = [];
+  const r = (s - t) / e, o = [];
   for (let n = 0; n < e; n++) {
-    const l = t + n * a, i = n === e - 1 ? r : t + (n + 1) * a;
+    const l = t + n * r, i = n === e - 1 ? s : t + (n + 1) * r;
     o.push({
-      range: M(l, i),
+      range: R(l, i),
       count: 0,
       min: l,
       max: i
     });
   }
-  for (const n of s) {
-    let l = Math.floor((n - t) / a);
+  for (const n of a) {
+    let l = Math.floor((n - t) / r);
     l >= e && (l = e - 1), o[l].count++;
   }
   return o;
 }
-function M(s, e) {
-  const t = (r) => Number.isInteger(r) ? r.toString() : r.toFixed(2);
-  return `${t(s)} - ${t(e)}`;
+function R(a, e) {
+  const t = (s) => Number.isInteger(s) ? s.toString() : s.toFixed(2);
+  return `${t(a)} - ${t(e)}`;
 }
-function De(s) {
-  if (s == null)
+function Ge(a) {
+  if (a == null)
     return "null";
-  if (Array.isArray(s))
+  if (Array.isArray(a))
     return "array";
-  const e = typeof s;
+  const e = typeof a;
   return e === "string" || e === "number" || e === "boolean" ? e : e === "object" ? "object" : "null";
 }
-function Le(s, e) {
+function He(a, e) {
   const t = [];
-  let r = 0;
-  for (const a of s) {
-    const o = S(a.data, e);
-    o == null ? r++ : t.push(o);
+  let s = 0;
+  for (const r of a) {
+    const o = M(r.data, e);
+    o == null ? s++ : t.push(o);
   }
-  return { values: t, nullCount: r };
+  return { values: t, nullCount: s };
 }
-function V(s) {
-  if (s.length === 0)
+function H(a) {
+  if (a.length === 0)
     return "null";
   const e = /* @__PURE__ */ new Map();
-  for (const t of s) {
-    const r = De(t);
-    e.set(r, (e.get(r) ?? 0) + 1);
+  for (const t of a) {
+    const s = Ge(t);
+    e.set(s, (e.get(s) ?? 0) + 1);
   }
   return e.delete("null"), e.size === 0 ? "null" : e.size > 1 ? "mixed" : e.keys().next().value;
 }
-function ze(s, e = 3) {
+function Be(a, e = 3) {
   const t = /* @__PURE__ */ new Set();
-  for (const r of s)
-    U(r.data, "", t, 0, e);
+  for (const s of a)
+    B(s.data, "", t, 0, e);
   return Array.from(t).sort();
 }
-function U(s, e, t, r, a) {
-  if (!(r >= a || s === null || s === void 0 || typeof s != "object" || Array.isArray(s)))
-    for (const o of Object.keys(s)) {
+function B(a, e, t, s, r) {
+  if (!(s >= r || a === null || a === void 0 || typeof a != "object" || Array.isArray(a)))
+    for (const o of Object.keys(a)) {
       const n = e ? `${e}.${o}` : o;
       t.add(n);
-      const l = s[o];
-      l !== null && typeof l == "object" && !Array.isArray(l) && U(l, n, t, r + 1, a);
+      const l = a[o];
+      l !== null && typeof l == "object" && !Array.isArray(l) && B(l, n, t, s + 1, r);
     }
 }
-const je = m.enum(["nodes", "edges", "both"]).optional().describe("What to sample: 'nodes', 'edges', or 'both' (default)"), P = 3, E = 10, T = 100;
-function y(s, e) {
-  if (s.length <= e)
-    return [...s];
-  const t = [...s];
-  for (let r = 0; r < e; r++) {
-    const a = r + Math.floor(Math.random() * (t.length - r));
-    [t[r], t[a]] = [t[a], t[r]];
+const Xe = c.enum(["nodes", "edges", "both"]).optional().describe("What to sample: 'nodes', 'edges', or 'both' (default)"), D = 3, L = 10, j = 100;
+function y(a, e) {
+  if (a.length <= e)
+    return [...a];
+  const t = [...a];
+  for (let s = 0; s < e; s++) {
+    const r = s + Math.floor(Math.random() * (t.length - s));
+    [t[s], t[r]] = [t[r], t[s]];
   }
   return t.slice(0, e);
 }
-function A(s, e, t) {
-  if (s.length <= e)
-    return [...s];
-  const r = /* @__PURE__ */ new Map(), a = [];
-  for (const i of s) {
+function z(a, e, t) {
+  if (a.length <= e)
+    return [...a];
+  const s = /* @__PURE__ */ new Map(), r = [];
+  for (const i of a) {
     const u = t(i);
     if (u === void 0)
-      a.push(i);
+      r.push(i);
     else {
-      const c = r.get(u) ?? [];
-      c.push(i), r.set(u, c);
+      const d = s.get(u) ?? [];
+      d.push(i), s.set(u, d);
     }
   }
-  const o = r.size + (a.length > 0 ? 1 : 0);
+  const o = s.size + (r.length > 0 ? 1 : 0);
   if (o === 0)
-    return y(s, e);
+    return y(a, e);
   const n = Math.max(1, Math.floor(e / o)), l = [];
-  for (const i of r.values()) {
+  for (const i of s.values()) {
     const u = y(i, n);
     l.push(...u);
   }
-  if (a.length > 0) {
-    const i = y(a, n);
+  if (r.length > 0) {
+    const i = y(r, n);
     l.push(...i);
   }
   if (l.length < e) {
-    const i = s.filter((c) => !l.includes(c)), u = y(i, e - l.length);
+    const i = a.filter((d) => !l.includes(d)), u = y(i, e - l.length);
     l.push(...u);
   }
   return l.slice(0, e);
 }
-const qe = {
+const Ze = {
   name: "sampleData",
   description: "Get sample nodes and/or edges from the graph to inspect actual data structures. Useful for understanding what properties exist and what values they contain before writing selectors.",
-  parameters: m.object({
-    target: je,
-    count: m.number().min(1).max(E).optional().describe(`Number of samples to return per type (1-${E}, default ${P})`),
-    stratifyBy: m.string().optional().describe("Property path to stratify sampling by (e.g., 'data.type' to sample from each type)")
+  parameters: c.object({
+    target: Xe,
+    count: c.number().min(1).max(L).optional().describe(`Number of samples to return per type (1-${L}, default ${D})`),
+    stratifyBy: c.string().optional().describe("Property path to stratify sampling by (e.g., 'data.type' to sample from each type)")
   }),
   examples: [
     { input: "Show me some example nodes", params: { target: "nodes" } },
@@ -1629,36 +1766,36 @@ const qe = {
       params: { target: "nodes", count: 6, stratifyBy: "data.type" }
     }
   ],
-  execute(s, e) {
+  execute(a, e) {
     const {
       target: t = "both",
-      count: r = P,
-      stratifyBy: a
+      count: s = D,
+      stratifyBy: r
     } = e;
     try {
-      const o = s.getDataManager(), n = {};
+      const o = a.getDataManager(), n = {};
       if (t === "nodes" || t === "both") {
         const i = Array.from(o.nodes.values());
         let u;
-        a ? u = A(i, r, (c) => {
-          const p = S(c.data, a);
+        r ? u = z(i, s, (d) => {
+          const p = M(d.data, r);
           return typeof p == "string" ? p : void 0;
-        }) : u = y(i, r), n.nodes = u.map((c) => ({
-          id: String(c.id),
-          data: b(c.data, T)
+        }) : u = y(i, s), n.nodes = u.map((d) => ({
+          id: String(d.id),
+          data: C(d.data, j)
         }));
       }
       if (t === "edges" || t === "both") {
         const i = Array.from(o.edges.values());
         let u;
-        a ? u = A(i, r, (c) => {
-          const p = S(c.data, a);
+        r ? u = z(i, s, (d) => {
+          const p = M(d.data, r);
           return typeof p == "string" ? p : void 0;
-        }) : u = y(i, r), n.edges = u.map((c) => ({
-          id: c.id,
-          source: String(c.srcId),
-          target: String(c.dstId),
-          data: b(c.data, T)
+        }) : u = y(i, s), n.edges = u.map((d) => ({
+          id: d.id,
+          source: String(d.srcId),
+          target: String(d.dstId),
+          data: C(d.data, j)
         }));
       }
       const l = [];
@@ -1674,36 +1811,36 @@ const qe = {
       });
     }
   }
-}, N = 20, k = 50, Ve = 5;
-function Ue(s, e, t, r, a) {
+}, q = 20, U = 50, Ye = 5;
+function Je(a, e, t, s, r) {
   const o = t.filter((p) => typeof p == "string"), n = /* @__PURE__ */ new Map();
   for (const p of o)
     n.set(p, (n.get(p) ?? 0) + 1);
-  const l = Array.from(n.entries()).sort((p, d) => d[1] - p[1]), i = l.length > a, u = l.slice(0, a), c = {};
-  for (const [p, d] of u)
-    c[p] = {
-      count: d,
-      percentage: d / o.length * 100
+  const l = Array.from(n.entries()).sort((p, m) => m[1] - p[1]), i = l.length > r, u = l.slice(0, r), d = {};
+  for (const [p, m] of u)
+    d[p] = {
+      count: m,
+      percentage: m / o.length * 100
     };
   return {
-    property: s,
+    property: a,
     target: e,
     type: "string",
-    totalCount: o.length + r,
-    nullCount: r,
+    totalCount: o.length + s,
+    nullCount: s,
     uniqueCount: n.size,
-    distribution: c,
+    distribution: d,
     truncated: i
   };
 }
-function Oe(s, e, t, r) {
-  const a = t.filter((l) => typeof l == "number"), o = q(a), n = Ie(a, Ve);
+function Qe(a, e, t, s) {
+  const r = t.filter((l) => typeof l == "number"), o = G(r), n = We(r, Ye);
   return {
-    property: s,
+    property: a,
     target: e,
     type: "number",
-    totalCount: a.length + r,
-    nullCount: r,
+    totalCount: r.length + s,
+    nullCount: s,
     statistics: {
       min: o.min,
       max: o.max,
@@ -1716,73 +1853,73 @@ function Oe(s, e, t, r) {
     }))
   };
 }
-function Fe(s, e, t, r) {
-  const a = t.filter((l) => typeof l == "boolean"), o = a.filter((l) => l).length, n = a.length - o;
+function et(a, e, t, s) {
+  const r = t.filter((l) => typeof l == "boolean"), o = r.filter((l) => l).length, n = r.length - o;
   return {
-    property: s,
+    property: a,
     target: e,
     type: "boolean",
-    totalCount: a.length + r,
-    nullCount: r,
+    totalCount: r.length + s,
+    nullCount: s,
     distribution: {
       true: {
         count: o,
-        percentage: a.length > 0 ? o / a.length * 100 : 0
+        percentage: r.length > 0 ? o / r.length * 100 : 0
       },
       false: {
         count: n,
-        percentage: a.length > 0 ? n / a.length * 100 : 0
+        percentage: r.length > 0 ? n / r.length * 100 : 0
       }
     }
   };
 }
-function _e(s, e, t, r, a) {
+function tt(a, e, t, s, r) {
   const o = t.filter((h) => Array.isArray(h)), n = [], l = [];
   for (const h of o)
     l.push(h.length), n.push(...h);
-  const i = V(n), u = /* @__PURE__ */ new Set();
+  const i = H(n), u = /* @__PURE__ */ new Set();
   for (const h of n)
     typeof h == "string" ? u.add(h) : typeof h == "number" || typeof h == "boolean" ? u.add(String(h)) : h != null && u.add(JSON.stringify(h));
-  const c = Array.from(u), p = c.length > a, d = q(l);
+  const d = Array.from(u), p = d.length > r, m = G(l);
   return {
-    property: s,
+    property: a,
     target: e,
     type: "array",
-    totalCount: o.length + r,
-    nullCount: r,
+    totalCount: o.length + s,
+    nullCount: s,
     itemType: i,
-    uniqueItems: c.slice(0, a),
-    uniqueItemCount: c.length,
+    uniqueItems: d.slice(0, r),
+    uniqueItemCount: d.length,
     lengthStatistics: {
-      min: d.min,
-      max: d.max,
-      avg: d.avg
+      min: m.min,
+      max: m.max,
+      avg: m.avg
     },
     truncated: p
   };
 }
-function Ke(s, e, t, r) {
-  const a = {};
+function st(a, e, t, s) {
+  const r = {};
   for (const o of t) {
     const n = typeof o;
-    Array.isArray(o) ? a.array = (a.array || 0) + 1 : n === "object" && o !== null ? a.object = (a.object || 0) + 1 : (n === "string" || n === "number" || n === "boolean") && (a[n] = (a[n] || 0) + 1);
+    Array.isArray(o) ? r.array = (r.array || 0) + 1 : n === "object" && o !== null ? r.object = (r.object || 0) + 1 : (n === "string" || n === "number" || n === "boolean") && (r[n] = (r[n] || 0) + 1);
   }
   return {
-    property: s,
+    property: a,
     target: e,
     type: "mixed",
-    totalCount: t.length + r,
-    nullCount: r,
-    typeCounts: a
+    totalCount: t.length + s,
+    nullCount: s,
+    typeCounts: r
   };
 }
-const We = {
+const rt = {
   name: "describeProperty",
   description: "Get detailed information about a specific property in node or edge data. Returns value distributions for strings, statistics for numbers, counts for booleans, and unique items for arrays.",
-  parameters: m.object({
-    property: m.string().describe("Property path to analyze (e.g., 'type', 'data.category', 'weight')"),
-    target: m.enum(["nodes", "edges"]).optional().describe("Whether to analyze node or edge properties (default: 'nodes')"),
-    limit: m.number().min(1).max(k).optional().describe(`Maximum number of unique values to show (1-${k}, default ${N})`)
+  parameters: c.object({
+    property: c.string().describe("Property path to analyze (e.g., 'type', 'data.category', 'weight')"),
+    target: c.enum(["nodes", "edges"]).optional().describe("Whether to analyze node or edge properties (default: 'nodes')"),
+    limit: c.number().min(1).max(U).optional().describe(`Maximum number of unique values to show (1-${U}, default ${q})`)
   }),
   examples: [
     { input: "Describe the type property on nodes", params: { property: "type", target: "nodes" } },
@@ -1793,47 +1930,47 @@ const We = {
     { input: "Show me the distribution of data.category", params: { property: "data.category" } },
     { input: "Analyze the tags property", params: { property: "tags", limit: 10 } }
   ],
-  execute(s, e) {
+  execute(a, e) {
     const {
       property: t,
-      target: r = "nodes",
-      limit: a = N
+      target: s = "nodes",
+      limit: r = q
     } = e;
     try {
-      const o = s.getDataManager(), n = Array.from(r === "nodes" ? o.nodes.values() : o.edges.values());
+      const o = a.getDataManager(), n = Array.from(s === "nodes" ? o.nodes.values() : o.edges.values());
       if (n.length === 0)
         return Promise.resolve({
           success: !1,
-          message: `No ${r} found in the graph.`
+          message: `No ${s} found in the graph.`
         });
-      const { values: l, nullCount: i } = Le(n, t);
+      const { values: l, nullCount: i } = He(n, t);
       if (l.length === 0 && i === n.length) {
-        const d = ze(n);
+        const m = Be(n);
         return Promise.resolve({
           success: !1,
-          message: `Property "${t}" not found on ${r}. Available properties: ${d.slice(0, 10).join(", ")}${d.length > 10 ? "..." : ""}`,
+          message: `Property "${t}" not found on ${s}. Available properties: ${m.slice(0, 10).join(", ")}${m.length > 10 ? "..." : ""}`,
           data: {
-            availableProperties: d.slice(0, 20)
+            availableProperties: m.slice(0, 20)
           }
         });
       }
-      const u = V(l);
-      let c;
+      const u = H(l);
+      let d;
       switch (u) {
         case "string":
-          c = Ue(t, r, l, i, a);
+          d = Je(t, s, l, i, r);
           break;
         case "number":
-          c = Oe(t, r, l, i);
+          d = Qe(t, s, l, i);
           break;
         case "boolean":
-          c = Fe(t, r, l, i);
+          d = et(t, s, l, i);
           break;
         case "array":
-          c = _e(t, r, l, i, a);
+          d = tt(t, s, l, i, r);
           break;
         case "mixed":
-          c = Ke(t, r, l, i);
+          d = st(t, s, l, i);
           break;
         default:
           return Promise.resolve({
@@ -1844,27 +1981,27 @@ const We = {
       let p;
       switch (u) {
         case "string": {
-          const d = c;
-          p = `Property "${t}" is a string with ${d.uniqueCount} unique value${d.uniqueCount !== 1 ? "s" : ""}.`;
+          const m = d;
+          p = `Property "${t}" is a string with ${m.uniqueCount} unique value${m.uniqueCount !== 1 ? "s" : ""}.`;
           break;
         }
         case "number": {
-          const d = c;
-          p = `Property "${t}" is a number (min: ${d.statistics.min.toFixed(2)}, max: ${d.statistics.max.toFixed(2)}, avg: ${d.statistics.avg.toFixed(2)}).`;
+          const m = d;
+          p = `Property "${t}" is a number (min: ${m.statistics.min.toFixed(2)}, max: ${m.statistics.max.toFixed(2)}, avg: ${m.statistics.avg.toFixed(2)}).`;
           break;
         }
         case "boolean": {
-          const d = c;
-          p = `Property "${t}" is a boolean (true: ${d.distribution.true.percentage.toFixed(1)}%, false: ${d.distribution.false.percentage.toFixed(1)}%).`;
+          const m = d;
+          p = `Property "${t}" is a boolean (true: ${m.distribution.true.percentage.toFixed(1)}%, false: ${m.distribution.false.percentage.toFixed(1)}%).`;
           break;
         }
         case "array": {
-          const d = c;
-          p = `Property "${t}" is an array of ${d.itemType} values with ${d.uniqueItemCount} unique item${d.uniqueItemCount !== 1 ? "s" : ""}.`;
+          const m = d;
+          p = `Property "${t}" is an array of ${m.itemType} values with ${m.uniqueItemCount} unique item${m.uniqueItemCount !== 1 ? "s" : ""}.`;
           break;
         }
         case "mixed": {
-          const h = Object.keys(c.typeCounts).join(", ");
+          const h = Object.keys(d.typeCounts).join(", ");
           p = `Property "${t}" has mixed types: ${h}.`;
           break;
         }
@@ -1874,7 +2011,7 @@ const We = {
       return Promise.resolve({
         success: !0,
         message: p,
-        data: c
+        data: d
       });
     } catch (o) {
       return Promise.resolve({
@@ -1884,7 +2021,7 @@ const We = {
     }
   }
 };
-class Ge {
+class at {
   constructor() {
     this.name = "mock", this.supportsStreaming = !0, this.supportsTools = !0, this.responses = /* @__PURE__ */ new Map(), this.defaultResponse = {
       text: "This is a mock response.",
@@ -1951,12 +2088,12 @@ class Ge {
    * @returns Matching response or default response
    */
   findResponse(e) {
-    const t = [...e].reverse().find((a) => a.role === "user");
+    const t = [...e].reverse().find((r) => r.role === "user");
     if (!t)
       return this.defaultResponse;
-    const r = t.content.toLowerCase();
-    for (const [a, o] of this.responses)
-      if (r.includes(a))
+    const s = t.content.toLowerCase();
+    for (const [r, o] of this.responses)
+      if (s.includes(r))
         return o;
     return this.defaultResponse;
   }
@@ -1968,17 +2105,17 @@ class Ge {
    * @param options.signal - Optional abort signal
    * @returns Promise resolving to LLM response
    */
-  async generate(e, t, r) {
+  async generate(e, t, s) {
     if (this.callHistory.push({
       messages: e,
       tools: t,
       streaming: !1,
       timestamp: Date.now()
-    }), r?.signal?.aborted)
+    }), s?.signal?.aborted)
       throw new Error("Request was aborted");
     if (this.configuredError)
       throw this.configuredError;
-    if (this.delay > 0 && await new Promise((a) => setTimeout(a, this.delay)), r?.signal?.aborted)
+    if (this.delay > 0 && await new Promise((r) => setTimeout(r, this.delay)), s?.signal?.aborted)
       throw new Error("Request was aborted");
     return this.findResponse(e);
   }
@@ -1990,28 +2127,28 @@ class Ge {
    * @param callbacks - Streaming callbacks for text and tool calls
    * @param signal - Optional abort signal
    */
-  async generateStream(e, t, r, a) {
+  async generateStream(e, t, s, r) {
     if (this.callHistory.push({
       messages: e,
       tools: t,
       streaming: !0,
       timestamp: Date.now()
-    }), a?.aborted)
+    }), r?.aborted)
       throw new Error("Request was aborted");
     if (this.configuredError)
-      throw r.onError(this.configuredError), this.configuredError;
+      throw s.onError(this.configuredError), this.configuredError;
     const o = this.findResponse(e), { text: n } = o;
     for (const l of n) {
-      if (a?.aborted)
+      if (r?.aborted)
         throw new Error("Request was aborted");
-      r.onChunk(l), this.delay > 0 && await new Promise((i) => setTimeout(i, this.delay / n.length));
+      s.onChunk(l), this.delay > 0 && await new Promise((i) => setTimeout(i, this.delay / n.length));
     }
     for (const l of o.toolCalls) {
-      if (a?.aborted)
+      if (r?.aborted)
         throw new Error("Request was aborted");
-      r.onToolCall(l.name, l.arguments);
+      s.onToolCall(l.name, l.arguments);
     }
-    r.onComplete(o);
+    s.onComplete(o);
   }
   /**
    * Validate the API key.
@@ -2026,7 +2163,7 @@ class Ge {
     return Promise.resolve(!0);
   }
 }
-class He {
+class ot {
   /**
    * Creates a new VercelAiProvider instance.
    * @param providerType - Type of provider (openai, anthropic, or google)
@@ -2050,9 +2187,9 @@ class He {
       throw new Error(`API key not configured for ${this.name}`);
     switch (this.providerType) {
       case "openai":
-        return Q({ apiKey: this.apiKey, baseURL: this.baseUrl })(this.model ?? "gpt-4o");
+        return le({ apiKey: this.apiKey, baseURL: this.baseUrl })(this.model ?? "gpt-4o");
       case "anthropic":
-        return Y({
+        return ne({
           apiKey: this.apiKey,
           baseURL: this.baseUrl,
           // Enable browser support - Anthropic requires this header for CORS
@@ -2061,7 +2198,7 @@ class He {
           }
         })(this.model ?? "claude-3-haiku-20240307");
       default:
-        return J({ apiKey: this.apiKey, baseURL: this.baseUrl })(this.model ?? "gemini-2.0-flash");
+        return ie({ apiKey: this.apiKey, baseURL: this.baseUrl })(this.model ?? "gemini-2.0-flash");
     }
   }
   /**
@@ -2072,14 +2209,14 @@ class He {
    * @param options.signal - Optional abort signal
    * @returns Promise resolving to LLM response
    */
-  async generate(e, t, r) {
-    const a = this.getModel(), o = this.convertMessages(e), n = this.convertTools(t), l = await ee({
-      model: a,
+  async generate(e, t, s) {
+    const r = this.getModel(), o = this.convertMessages(e), n = this.convertTools(t), l = await ce({
+      model: r,
       messages: o,
       tools: n,
       maxOutputTokens: this.maxTokens,
       temperature: this.temperature,
-      abortSignal: r?.signal
+      abortSignal: s?.signal
     }), { usage: i } = l;
     return {
       text: l.text,
@@ -2094,53 +2231,53 @@ class He {
    * @param callbacks - Streaming callbacks for text and tool calls
    * @param signal - Optional abort signal
    */
-  async generateStream(e, t, r, a) {
-    const o = this.getModel(), n = this.convertMessages(e), l = this.convertTools(t), i = te({
+  async generateStream(e, t, s, r) {
+    const o = this.getModel(), n = this.convertMessages(e), l = this.convertTools(t), i = ue({
       model: o,
       messages: n,
       tools: l,
       maxOutputTokens: this.maxTokens,
       temperature: this.temperature,
-      abortSignal: a
+      abortSignal: r
     });
     let u = "";
-    const c = [];
+    const d = [];
     try {
-      for await (const d of i.fullStream)
-        switch (d.type) {
+      for await (const m of i.fullStream)
+        switch (m.type) {
           case "text-delta":
-            u += d.text, r.onChunk(d.text);
+            u += m.text, s.onChunk(m.text);
             break;
           case "tool-call": {
             let h = {};
-            "input" in d ? { input: h } = d : "args" in d && ({ args: h } = d);
+            "input" in m ? { input: h } = m : "args" in m && ({ args: h } = m);
             const g = {
-              id: d.toolCallId,
-              name: d.toolName,
+              id: m.toolCallId,
+              name: m.toolName,
               arguments: h
             };
-            c.push(g), r.onToolCall(d.toolName, h);
+            d.push(g), s.onToolCall(m.toolName, h);
             break;
           }
           case "tool-result": {
             let h;
-            "output" in d ? { output: h } = d : "result" in d && ({ result: h } = d), r.onToolResult(d.toolName, h);
+            "output" in m ? { output: h } = m : "result" in m && ({ result: h } = m), s.onToolResult(m.toolName, h);
             break;
           }
           case "error":
-            r.onError(new Error(String(d.error)));
+            s.onError(new Error(String(m.error)));
             break;
           default:
             break;
         }
       const p = await i.usage;
-      r.onComplete({
+      s.onComplete({
         text: u,
-        toolCalls: c,
+        toolCalls: d,
         usage: p.inputTokens !== void 0 && p.outputTokens !== void 0 ? { promptTokens: p.inputTokens, completionTokens: p.outputTokens } : void 0
       });
     } catch (p) {
-      throw r.onError(p instanceof Error ? p : new Error(String(p))), p;
+      throw s.onError(p instanceof Error ? p : new Error(String(p))), p;
     }
   }
   /**
@@ -2160,11 +2297,11 @@ class He {
             role: "assistant",
             content: [
               ...t.content ? [{ type: "text", text: t.content }] : [],
-              ...t.toolCalls.map((r) => ({
+              ...t.toolCalls.map((s) => ({
                 type: "tool-call",
-                toolCallId: r.id,
-                toolName: r.name,
-                input: r.arguments
+                toolCallId: s.id,
+                toolName: s.name,
+                input: s.arguments
               }))
             ]
           } : { role: "assistant", content: t.content };
@@ -2193,10 +2330,10 @@ class He {
    */
   convertTools(e) {
     const t = {};
-    for (const r of e)
-      t[r.name] = {
-        description: r.description,
-        inputSchema: r.parameters
+    for (const s of e)
+      t[s.name] = {
+        description: s.description,
+        inputSchema: s.parameters
       };
     return t;
   }
@@ -2229,75 +2366,75 @@ class He {
     }
   }
 }
-async function Be() {
+async function nt() {
   return (await import("./WebLlmProvider-BEFvNcC5.js")).WebLlmProvider;
 }
-function Xe(s) {
-  if (s === "mock")
-    return new Ge();
-  if (s === "webllm")
+function it(a) {
+  if (a === "mock")
+    return new at();
+  if (a === "webllm")
     throw new Error(
       "WebLlmProvider cannot be created synchronously. Use createWebLlmProvider() or getWebLlmProviderClass() instead."
     );
-  return new He(s);
+  return new ot(a);
 }
-async function wt() {
-  const s = await Be();
-  return new s();
+async function It() {
+  const a = await nt();
+  return new a();
 }
-const w = 10, R = 50;
-function Ze(s) {
+const $ = 10, V = 50;
+function lt(a) {
   const e = [];
-  return e.push(Ye(s)), s.nodeProperties.length > 0 ? e.push(Je(s.nodeProperties)) : s.nodeCount > 0 && e.push(`### Node Properties
-No custom properties on node data.`), s.edgeProperties.length > 0 ? e.push(Qe(s.edgeProperties)) : s.edgeCount > 0 && e.push(`### Edge Properties
+  return e.push(ct(a)), a.nodeProperties.length > 0 ? e.push(ut(a.nodeProperties)) : a.nodeCount > 0 && e.push(`### Node Properties
+No custom properties on node data.`), a.edgeProperties.length > 0 ? e.push(dt(a.edgeProperties)) : a.edgeCount > 0 && e.push(`### Edge Properties
 No custom properties on edge data.`), e.join(`
 
 `);
 }
-function Ye(s) {
+function ct(a) {
   return `## Data Schema
-- Nodes: ${s.nodeCount}
-- Edges: ${s.edgeCount}`;
+- Nodes: ${a.nodeCount}
+- Edges: ${a.edgeCount}`;
 }
-function Je(s) {
+function ut(a) {
   const e = ["### Node Properties"];
-  for (const t of s)
-    e.push(O(t));
+  for (const t of a)
+    e.push(X(t));
   return e.join(`
 `);
 }
-function Qe(s) {
+function dt(a) {
   const e = ["### Edge Properties"];
-  for (const t of s)
-    e.push(O(t));
+  for (const t of a)
+    e.push(X(t));
   return e.join(`
 `);
 }
-function O(s) {
-  const e = rt(s.name), t = s.nullable ? "?" : "", r = et(s), a = tt(s);
-  return `- \`${e}\`: ${r}${t}${a}`;
+function X(a) {
+  const e = gt(a.name), t = a.nullable ? "?" : "", s = mt(a), r = pt(a);
+  return `- \`${e}\`: ${s}${t}${r}`;
 }
-function et(s) {
-  return s.type === "array" && s.itemType ? `${s.itemType}[]` : s.type;
+function mt(a) {
+  return a.type === "array" && a.itemType ? `${a.itemType}[]` : a.type;
 }
-function tt(s) {
+function pt(a) {
   const e = [];
-  if (s.format && e.push(`format: ${s.format}`), s.enumValues && s.enumValues.length > 0) {
-    const t = st(s.enumValues);
+  if (a.format && e.push(`format: ${a.format}`), a.enumValues && a.enumValues.length > 0) {
+    const t = ht(a.enumValues);
     e.push(`values: [${t}]`);
   }
-  return s.range && e.push(`range: ${s.range.min}..${s.range.max}`), e.length === 0 ? "" : ` (${e.join(", ")})`;
+  return a.range && e.push(`range: ${a.range.min}..${a.range.max}`), e.length === 0 ? "" : ` (${e.join(", ")})`;
 }
-function st(s) {
-  if (s.length <= w)
-    return s.map((r) => `"${r}"`).join(", ");
-  const e = s.slice(0, w), t = s.length - w;
-  return `${e.map((r) => `"${r}"`).join(", ")}, ... +${t} more`;
+function ht(a) {
+  if (a.length <= $)
+    return a.map((s) => `"${s}"`).join(", ");
+  const e = a.slice(0, $), t = a.length - $;
+  return `${e.map((s) => `"${s}"`).join(", ")}, ... +${t} more`;
 }
-function rt(s) {
-  return s.length <= R ? s : `${s.slice(0, R - 3)}...`;
+function gt(a) {
+  return a.length <= V ? a : `${a.slice(0, V - 3)}...`;
 }
-class at {
+class ft {
   /**
    * Create a new SchemaManager.
    * @param graph - The graph to extract schema from
@@ -2314,7 +2451,7 @@ class at {
    */
   extract() {
     if (this.cachedSchema === null) {
-      const e = new D(this.graph, this.options);
+      const e = new O(this.graph, this.options);
       this.cachedSchema = e.extract();
     }
     return this.cachedSchema;
@@ -2335,7 +2472,7 @@ class at {
   getFormattedSchema() {
     if (this.cachedFormattedSchema === null) {
       const e = this.extract();
-      this.cachedFormattedSchema = Ze(e);
+      this.cachedFormattedSchema = lt(e);
     }
     return this.cachedFormattedSchema;
   }
@@ -2349,13 +2486,13 @@ class at {
     this.cachedSchema = null, this.cachedFormattedSchema = null;
   }
 }
-const ot = 300;
-class F {
+const yt = 300;
+class Z {
   /**
    * Creates a new AiManager instance.
    */
   constructor() {
-    this.graph = null, this.controller = null, this.provider = null, this.schemaManager = null, this.dataAddedListenerId = null, this.debouncedSchemaUpdate = null, this.disposed = !1, this.initialized = !1, this.commandRegistry = new ae(), this.apiKeyManager = new se(), this.statusManager = new I();
+    this.graph = null, this.controller = null, this.provider = null, this.schemaManager = null, this.dataAddedListenerId = null, this.debouncedSchemaUpdate = null, this.disposed = !1, this.initialized = !1, this.commandRegistry = new pe(), this.apiKeyManager = new de(), this.statusManager = new F();
   }
   /**
    * Initialize the AI Manager with a graph and configuration.
@@ -2367,18 +2504,18 @@ class F {
       encryptionKey: t.keyPersistence.encryptionKey,
       storage: t.keyPersistence.storage ?? "localStorage",
       prefix: t.keyPersistence.prefix
-    }), t.providerInstance ? this.provider = t.providerInstance : (this.provider = Xe(t.provider), t.apiKey && (this.apiKeyManager.setKey(t.provider, t.apiKey), this.provider.configure({
+    }), t.providerInstance ? this.provider = t.providerInstance : (this.provider = it(t.provider), t.apiKey && (this.apiKeyManager.setKey(t.provider, t.apiKey), this.provider.configure({
       apiKey: t.apiKey,
       model: t.model
-    }))), t.registerBuiltinCommands !== !1 && this.registerBuiltinCommands(), this.initializeSchemaManager(), this.controller = new re({
+    }))), t.registerBuiltinCommands !== !1 && this.registerBuiltinCommands(), this.initializeSchemaManager(), this.controller = new me({
       provider: this.provider,
       commandRegistry: this.commandRegistry,
       graph: this.graph,
       schemaManager: this.schemaManager,
       // Onto the graph's own event channel, so `addListener` and the element's DOM
       // forwarder both deliver every AI event.
-      emitEvent: (r) => {
-        e.eventManager.emitGraphEvent(r.type, { ...r });
+      emitEvent: (s) => {
+        e.eventManager.emitGraphEvent(s.type, { ...s });
       }
     }), this.initialized = !0);
   }
@@ -2387,9 +2524,9 @@ class F {
    */
   initializeSchemaManager() {
     if (this.graph) {
-      this.schemaManager = new at(this.graph), this.schemaManager.extract(), this.debouncedSchemaUpdate = _.debounce(() => {
+      this.schemaManager = new ft(this.graph), this.schemaManager.extract(), this.debouncedSchemaUpdate = Y.debounce(() => {
         this.schemaManager && this.schemaManager.invalidateCache();
-      }, ot);
+      }, yt);
       try {
         const { eventManager: e } = this.graph;
         this.dataAddedListenerId = e.addListener("data-added", () => {
@@ -2403,7 +2540,7 @@ class F {
    * Register built-in commands for graph control.
    */
   registerBuiltinCommands() {
-    this.registerCommand(le), this.registerCommand(ce), this.registerCommand(de), this.registerCommand(qe), this.registerCommand(We), this.registerCommand(he), this.registerCommand(ge), this.registerCommand(ye), this.registerCommand(Me), this.registerCommand(Pe), this.registerCommand(Ee), this.registerCommand(Ae), this.registerCommand(ke);
+    this.registerCommand(ye), this.registerCommand(be), this.registerCommand(Se), this.registerCommand(Ze), this.registerCommand(rt), this.registerCommand(_e), this.registerCommand(Oe), this.registerCommand(xe), this.registerCommand(Me), this.registerCommand(Ae), this.registerCommand(Le), this.registerCommand(je), this.registerCommand(ze), this.registerCommand(Ue), this.registerCommand(Fe);
   }
   /**
    * Register a custom command.
@@ -2531,39 +2668,41 @@ class F {
     }
   }
 }
-function nt() {
-  return new F();
+function vt() {
+  return new Z();
 }
-const St = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+const Rt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  AiManager: F,
-  createAiManager: nt
+  AiManager: Z,
+  createAiManager: vt
 }, Symbol.toStringTag, { value: "Module" }));
 export {
-  re as A,
-  ae as C,
-  Ge as M,
-  D as S,
-  He as V,
-  F as a,
-  I as b,
-  at as c,
-  Ee as d,
-  nt as e,
-  Ze as f,
-  Xe as g,
-  wt as h,
-  We as i,
-  Pe as j,
-  Me as k,
-  ce as l,
-  Be as m,
-  Ae as n,
-  ge as o,
-  ye as p,
-  le as q,
-  he as r,
-  qe as s,
-  St as t,
-  ke as z
+  me as A,
+  pe as C,
+  at as M,
+  O as S,
+  ot as V,
+  Z as a,
+  F as b,
+  ft as c,
+  ze as d,
+  vt as e,
+  lt as f,
+  it as g,
+  It as h,
+  rt as i,
+  je as j,
+  Le as k,
+  be as l,
+  nt as m,
+  _e as n,
+  Ue as o,
+  Me as p,
+  ye as q,
+  Oe as r,
+  Ze as s,
+  Ae as t,
+  xe as u,
+  Rt as v,
+  Fe as z
 };