@node-i3x/mcp 0.0.0-stage → 0.11.0

package/dist/index.js

@@ -0,0 +1,932 @@
+// src/utils/similarity.ts
+function computeSimilarity(a, b) {
+  const s1 = a.toLowerCase().trim();
+  const s2 = b.toLowerCase().trim();
+  if (s1 === s2) return 1;
+  if (!s1 || !s2) return 0;
+  if (s1.includes(s2) || s2.includes(s1)) {
+    const ratio = Math.min(s1.length, s2.length) / Math.max(s1.length, s2.length);
+    return Math.max(0.7, ratio);
+  }
+  const m = s1.length;
+  const n = s2.length;
+  const dp = Array.from({ length: n + 1 }, (_, i) => i);
+  for (let i = 1; i <= m; i++) {
+    let prev = dp[0];
+    dp[0] = i;
+    for (let j = 1; j <= n; j++) {
+      const temp = dp[j];
+      const cost = s1[i - 1] === s2[j - 1] ? 0 : 1;
+      dp[j] = Math.min(dp[j] + 1, dp[j - 1] + 1, prev + cost);
+      prev = temp;
+    }
+  }
+  const distance = dp[n];
+  const maxLen = Math.max(m, n);
+  return Math.max(0, 1 - distance / maxLen);
+}
+function rankSuggestions(query, candidates, topN = 5, minScore = 0.4) {
+  return candidates.map((candidate) => ({
+    candidate,
+    score: computeSimilarity(query, candidate)
+  })).filter((item) => item.score >= minScore).sort((a, b) => b.score - a.score).slice(0, topN).map((item) => item.candidate);
+}
+
+// src/bindings/connector-binding.ts
+var InProcessConnectorBinding = class {
+  constructor(stack) {
+    this.stack = stack;
+  }
+  stack;
+  async getInfo() {
+    return {
+      specVersion: "1.0.0-beta",
+      serverVersion: "0.10.0",
+      serverName: "node-i3x (In-Process Direct)",
+      capabilities: {
+        query: { history: true },
+        update: { current: true, history: true },
+        subscribe: { stream: true }
+      }
+    };
+  }
+  async getNamespaces() {
+    const model = await this.stack.modelService.getOrBuildModel();
+    const uris = /* @__PURE__ */ new Set();
+    for (const node of model.nodesById.values()) {
+      if (node.namespaceUri) uris.add(node.namespaceUri);
+    }
+    return Array.from(uris).map((uri) => ({
+      uri,
+      displayName: uri
+    }));
+  }
+  async getObjectTypes(namespaceUri) {
+    return this.stack.typeService.getObjectTypes(namespaceUri);
+  }
+  async getRelationshipTypes() {
+    return [
+      {
+        elementId: "HasComponent",
+        displayName: "Has Component",
+        namespaceUri: "http://opcfoundation.org/UA/",
+        relationshipId: "i=47",
+        reverseOf: "ComponentOf"
+      },
+      {
+        elementId: "HasProperty",
+        displayName: "Has Property",
+        namespaceUri: "http://opcfoundation.org/UA/",
+        relationshipId: "i=46",
+        reverseOf: "PropertyOf"
+      }
+    ];
+  }
+  async getObjects(options) {
+    const model = await this.stack.modelService.getOrBuildModel();
+    let nodes;
+    if (options?.rootOnly) {
+      nodes = model.rootIds.map((id) => model.nodesById.get(id)).filter((n) => n !== void 0 && n.kind === "instance");
+    } else {
+      nodes = Array.from(model.nodesById.values()).filter(
+        (n) => n.kind === "instance" || n.kind === "property"
+      );
+    }
+    if (options?.typeElementId) {
+      nodes = nodes.filter((n) => n.type === options.typeElementId);
+    }
+    const rootSet = new Set(model.rootIds);
+    return nodes.map((n) => ({
+      elementId: n.id,
+      displayName: n.name,
+      typeElementId: n.type || "BaseObjectType",
+      parentId: rootSet.has(n.id) ? null : void 0,
+      isComposition: n.kind === "instance",
+      metadata: {
+        typeNamespaceUri: n.namespaceUri,
+        engUnit: n.engUnit || null,
+        sourceTypeId: n.sourceTypeId || null
+      }
+    }));
+  }
+  async getObjectById(elementId) {
+    const objects = await this.getObjects();
+    return objects.find((o) => o.elementId === elementId) || null;
+  }
+  async getRelatedObjects(elementId) {
+    const model = await this.stack.modelService.getOrBuildModel();
+    const node = model.nodesById.get(elementId);
+    if (!node?.children) return [];
+    const children = node.children.map((childId) => model.nodesById.get(childId)).filter((n) => n !== void 0);
+    return children.map((n) => ({
+      elementId: n.id,
+      displayName: n.name,
+      typeElementId: n.type || "BaseObjectType",
+      parentId: elementId,
+      isComposition: n.kind === "instance",
+      metadata: {
+        typeNamespaceUri: n.namespaceUri,
+        engUnit: n.engUnit || null,
+        sourceTypeId: n.sourceTypeId || null
+      }
+    }));
+  }
+  async getObjectValues(elementIds, maxDepth = 1) {
+    const bulkResults = await this.stack.valueService.readValues(elementIds, maxDepth);
+    return bulkResults.map((r) => r.result).filter((v) => v !== null && v !== void 0);
+  }
+  async getHistoricalValues(elementIds, startTime, endTime, maxDepth = 1) {
+    const start = startTime ? new Date(startTime) : null;
+    const end = endTime ? new Date(endTime) : null;
+    const bulkResults = await this.stack.historyService.readHistory(
+      elementIds,
+      start,
+      end,
+      maxDepth
+    );
+    return bulkResults.map((r) => r.result).filter((v) => v !== null && v !== void 0);
+  }
+  async findSuggestions(unknownId) {
+    try {
+      const allObjects = await this.getObjects();
+      const candidates = allObjects.map((o) => o.elementId);
+      return rankSuggestions(unknownId, candidates, 5, 0.4);
+    } catch {
+      return [];
+    }
+  }
+};
+
+// src/bindings/rest-binding.ts
+var RestClientBinding = class {
+  baseUrl;
+  headers;
+  requestTimeoutMs;
+  constructor(baseUrl = "http://localhost:3000", token, timeoutMs = 15e3) {
+    let cleanUrl = baseUrl.trim().replace(/\/+$/, "");
+    if (!cleanUrl.startsWith("http://") && !cleanUrl.startsWith("https://")) {
+      cleanUrl = `http://${cleanUrl}`;
+    }
+    this.baseUrl = cleanUrl;
+    this.requestTimeoutMs = timeoutMs;
+    this.headers = {
+      "Content-Type": "application/json",
+      Accept: "application/json"
+    };
+    if (token) {
+      this.headers.Authorization = `Bearer ${token}`;
+    }
+  }
+  async request(path, options = {}) {
+    const url = `${this.baseUrl}${path}`;
+    const signal = options.signal || AbortSignal.timeout(this.requestTimeoutMs);
+    try {
+      const response = await fetch(url, {
+        ...options,
+        signal,
+        headers: {
+          ...this.headers,
+          ...options.headers || {}
+        }
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        const truncated = errorText.length > 300 ? `${errorText.slice(0, 300)}...` : errorText;
+        throw new Error(`HTTP ${response.status} from ${path}: ${truncated}`);
+      }
+      return await response.json();
+    } catch (err) {
+      if (err.name === "TimeoutError") {
+        throw new Error(
+          `i3X Gateway request timed out after ${this.requestTimeoutMs}ms for ${path}`
+        );
+      }
+      throw err;
+    }
+  }
+  async getInfo() {
+    return this.request("/v1/info");
+  }
+  async getNamespaces() {
+    const res = await this.request("/v1/namespaces");
+    return res.namespaces || [];
+  }
+  async getObjectTypes(namespaceUri) {
+    const query = namespaceUri ? `?namespaceUri=${encodeURIComponent(namespaceUri)}` : "";
+    const res = await this.request(
+      `/v1/objecttypes${query}`
+    );
+    return res.objectTypes || [];
+  }
+  async getRelationshipTypes() {
+    const res = await this.request(
+      "/v1/relationshiptypes"
+    );
+    return res.relationshipTypes || [];
+  }
+  async getObjects(options) {
+    const params = new URLSearchParams();
+    if (options?.rootOnly) params.set("root", "true");
+    if (options?.typeElementId) params.set("typeElementId", options.typeElementId);
+    const query = params.toString() ? `?${params.toString()}` : "";
+    const res = await this.request(
+      `/v1/objects${query}`
+    );
+    return res.objects || [];
+  }
+  async getObjectById(elementId) {
+    try {
+      const res = await this.request(
+        "/v1/objects/list",
+        {
+          method: "POST",
+          body: JSON.stringify({ elementIds: [elementId] })
+        }
+      );
+      if (res.objects && res.objects.length > 0) {
+        return res.objects[0] ?? null;
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+  async getRelatedObjects(elementId, relationshipType) {
+    try {
+      const body = { elementId };
+      if (relationshipType) body.relationshipType = relationshipType;
+      const res = await this.request("/v1/objects/related", {
+        method: "POST",
+        body: JSON.stringify(body)
+      });
+      return (res.relatedObjects || []).map((r) => r.targetObject);
+    } catch {
+      return [];
+    }
+  }
+  async getObjectValues(elementIds, maxDepth = 1) {
+    const res = await this.request(
+      "/v1/objects/value",
+      {
+        method: "POST",
+        body: JSON.stringify({ elementIds, maxDepth })
+      }
+    );
+    return res.values || [];
+  }
+  async getHistoricalValues(elementIds, startTime, endTime, maxDepth = 1) {
+    const res = await this.request(
+      "/v1/objects/history",
+      {
+        method: "POST",
+        body: JSON.stringify({ elementIds, startTime, endTime, maxDepth })
+      }
+    );
+    return res.history || [];
+  }
+  async findSuggestions(unknownId) {
+    try {
+      const allObjects = await this.getObjects();
+      const candidates = allObjects.map((o) => o.elementId);
+      return rankSuggestions(unknownId, candidates, 5, 0.4);
+    } catch {
+      return [];
+    }
+  }
+};
+
+// src/server.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListResourcesRequestSchema,
+  ListToolsRequestSchema,
+  ReadResourceRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+
+// src/tools/connect.ts
+import { z } from "zod";
+var connectSchema = z.object({
+  serverUrl: z.string().describe(
+    "The base URL of the i3X Gateway (e.g. 'http://192.168.1.50:8000' or 'https://i3x-portal.sterfive.io/instance/SESSION_ID')"
+  ),
+  authToken: z.string().optional().describe("Optional Bearer authentication token for secured endpoints"),
+  verifyConnection: z.boolean().optional().default(true).describe("Whether to immediately verify connectivity by querying server /v1/info")
+});
+async function handleConnect(args, onBindingSwitch) {
+  const { serverUrl, authToken, verifyConnection } = args;
+  const newBinding = new RestClientBinding(serverUrl, authToken);
+  let serverInfo;
+  if (verifyConnection) {
+    try {
+      serverInfo = await newBinding.getInfo();
+    } catch (err) {
+      return {
+        status: "connection_failed",
+        serverUrl,
+        error: err.message,
+        tip: "Please check that the server URL is reachable and the authentication token (if required) is valid."
+      };
+    }
+  }
+  onBindingSwitch(newBinding);
+  return {
+    status: "connected",
+    serverUrl,
+    authenticated: Boolean(authToken),
+    serverInfo: serverInfo || "Connection established without verification.",
+    message: `Successfully connected to ${serverUrl}. All subsequent i3X tool calls will query this endpoint.`
+  };
+}
+
+// src/tools/discover-types.ts
+import { z as z2 } from "zod";
+var discoverTypesSchema = z2.object({
+  typeElementId: z2.string().optional().describe(
+    "Optional specific ObjectType elementId (e.g. 'BoilerType'). If omitted, lists all types."
+  ),
+  namespaceUri: z2.string().optional().describe("Optional namespaceUri filter (e.g. 'http://sterfive.com/UA/Demo/')")
+});
+async function handleDiscoverTypes(binding, args) {
+  const { typeElementId, namespaceUri } = args;
+  const [objectTypes, relationshipTypes, namespaces] = await Promise.all([
+    binding.getObjectTypes(namespaceUri),
+    binding.getRelationshipTypes(),
+    binding.getNamespaces()
+  ]);
+  if (typeElementId) {
+    const matched = objectTypes.find((t) => t.elementId === typeElementId);
+    if (!matched) {
+      return {
+        error: `ObjectType '${typeElementId}' not found.`,
+        availableTypes: objectTypes.map((t) => t.elementId)
+      };
+    }
+    return {
+      objectType: matched
+    };
+  }
+  return {
+    namespacesCount: namespaces.length,
+    namespaces,
+    objectTypesCount: objectTypes.length,
+    objectTypes: objectTypes.map((t) => {
+      const schemaObj = t.schema && typeof t.schema === "object" ? t.schema : null;
+      const required = schemaObj && Array.isArray(schemaObj.required) ? schemaObj.required : [];
+      return {
+        elementId: t.elementId,
+        displayName: t.displayName || t.elementId,
+        namespaceUri: t.namespaceUri,
+        requiredProperties: required
+      };
+    }),
+    relationshipTypesCount: relationshipTypes.length,
+    relationshipTypes
+  };
+}
+
+// src/tools/explore-hierarchy.ts
+import { z as z3 } from "zod";
+var exploreHierarchySchema = z3.object({
+  rootElementId: z3.string().optional().describe(
+    "Optional specific root asset elementId. If omitted, explores all root assets."
+  ),
+  maxDepth: z3.number().optional().default(2).describe("Maximum depth to traverse child components (1 to 5, default: 2)")
+});
+async function handleExploreHierarchy(binding, args) {
+  const maxDepth = Math.min(Math.max(args.maxDepth || 2, 1), 5);
+  let roots;
+  if (args.rootElementId) {
+    const root = await binding.getObjectById(args.rootElementId);
+    if (!root) {
+      const suggestions = await binding.findSuggestions(args.rootElementId);
+      return {
+        error: `Root asset '${args.rootElementId}' not found.`,
+        suggestions
+      };
+    }
+    roots = [root];
+  } else {
+    roots = await binding.getObjects({ rootOnly: true });
+  }
+  async function buildNode(asset, currentDepth, visited) {
+    const node = {
+      elementId: asset.elementId,
+      displayName: asset.displayName || asset.elementId,
+      typeElementId: asset.typeElementId
+    };
+    visited.add(asset.elementId);
+    if (currentDepth < maxDepth) {
+      const children = await binding.getRelatedObjects(asset.elementId);
+      const unvisitedChildren = children.filter((c) => !visited.has(c.elementId));
+      if (unvisitedChildren.length > 0) {
+        node.children = await Promise.all(
+          unvisitedChildren.map(
+            (child) => buildNode(child, currentDepth + 1, new Set(visited))
+          )
+        );
+      }
+    }
+    return node;
+  }
+  const hierarchyTree = await Promise.all(
+    roots.map((root) => buildNode(root, 1, /* @__PURE__ */ new Set()))
+  );
+  return {
+    totalRoots: roots.length,
+    traversalDepth: maxDepth,
+    plantTopology: hierarchyTree
+  };
+}
+
+// src/tools/inspect-asset.ts
+import { z as z4 } from "zod";
+var inspectAssetSchema = z4.object({
+  elementId: z4.string().describe("The elementId of the asset to inspect (e.g. 'Pump_101', 'Boiler_101')"),
+  includeValues: z4.boolean().optional().default(true).describe("Whether to include live VQT (Value, Quality, Timestamp) telemetry values"),
+  includeSchema: z4.boolean().optional().default(true).describe("Whether to include the ObjectType JSON Schema definition")
+});
+async function handleInspectAsset(binding, args) {
+  const { elementId, includeValues, includeSchema } = args;
+  const asset = await binding.getObjectById(elementId);
+  if (!asset) {
+    const suggestions = await binding.findSuggestions(elementId);
+    return {
+      error: `Asset '${elementId}' not found in i3X address space.`,
+      suggestions: suggestions.length > 0 ? suggestions : "No close matches found.",
+      tip: "Use 'i3x_explore_plant_hierarchy' to list all root industrial assets."
+    };
+  }
+  const result = {
+    elementId: asset.elementId,
+    displayName: asset.displayName || asset.elementId,
+    description: asset.metadata?.description || void 0,
+    typeElementId: asset.typeElementId,
+    isRoot: !asset.parentId
+  };
+  const relatedPromise = binding.getRelatedObjects(elementId);
+  const schemaPromise = includeSchema && asset.typeElementId ? binding.getObjectTypes() : Promise.resolve(null);
+  const valuesPromise = includeValues ? binding.getObjectValues([elementId]) : Promise.resolve(null);
+  const [relatedResult, schemaResult, valuesResult] = await Promise.allSettled([
+    relatedPromise,
+    schemaPromise,
+    valuesPromise
+  ]);
+  if (relatedResult.status === "fulfilled" && Array.isArray(relatedResult.value) && relatedResult.value.length > 0) {
+    result.subComponents = relatedResult.value.map((r) => ({
+      elementId: r.elementId,
+      displayName: r.displayName || r.elementId,
+      typeElementId: r.typeElementId
+    }));
+  }
+  if (schemaResult.status === "fulfilled" && Array.isArray(schemaResult.value)) {
+    const targetType = schemaResult.value.find(
+      (t) => t.elementId === asset.typeElementId
+    );
+    if (targetType) {
+      result.typeDefinition = {
+        elementId: targetType.elementId,
+        displayName: targetType.displayName,
+        schema: targetType.schema
+      };
+    }
+  }
+  if (valuesResult.status === "fulfilled" && Array.isArray(valuesResult.value) && valuesResult.value.length > 0) {
+    result.currentValues = valuesResult.value[0];
+  } else if (valuesResult.status === "rejected") {
+    result.currentValuesWarning = "Telemetry data temporarily unavailable";
+  }
+  return result;
+}
+
+// src/tools/monitor-events.ts
+import { z as z5 } from "zod";
+var monitorEventsSchema = z5.object({
+  elementIds: z5.array(z5.string()).min(1).describe("Array of asset elementIds to monitor (e.g. ['Boiler_101', 'Pump_101'])"),
+  condition: z5.string().optional().describe(
+    "Optional monitoring alert condition filter (e.g. 'temperature > 85 || quality != Good')"
+  )
+});
+async function handleMonitorEvents(binding, args) {
+  const { elementIds, condition } = args;
+  const currentValues = await binding.getObjectValues(elementIds);
+  return {
+    status: "monitoring_active",
+    monitoredAssets: elementIds,
+    alertCondition: condition || "All value or quality changes",
+    initialSnapshot: currentValues,
+    instructions: "Subscription stream registered. The MCP server will emit notification events on matching VQT telemetry updates or threshold breaches."
+  };
+}
+
+// src/tools/query-telemetry.ts
+import { z as z6 } from "zod";
+var queryTelemetrySchema = z6.object({
+  elementIds: z6.array(z6.string()).min(1).describe("Array of asset elementIds to query (e.g. ['Pump_101', 'Boiler_101'])"),
+  mode: z6.enum(["current", "history"]).optional().default("current").describe(
+    "Query mode: 'current' for live VQT telemetry, 'history' for time-series trend analysis"
+  ),
+  startTime: z6.string().optional().describe(
+    "ISO 8601 start time or relative time string (e.g. '-2h', '-30m', '-1d') for history mode"
+  ),
+  endTime: z6.string().optional().describe("ISO 8601 end time (defaults to now) for history mode"),
+  aggregateStats: z6.boolean().optional().default(true).describe(
+    "Whether to pre-compute min/max/mean statistical summaries for numeric sensor streams"
+  )
+});
+function parseStartTime(input) {
+  if (!input) {
+    const d = /* @__PURE__ */ new Date();
+    d.setHours(d.getHours() - 1);
+    return d.toISOString();
+  }
+  const match = input.match(/^-(\d+)([smhdw])$/i);
+  if (match) {
+    const amount = parseInt(match[1], 10);
+    const unit = match[2].toLowerCase();
+    const d = /* @__PURE__ */ new Date();
+    switch (unit) {
+      case "s":
+        d.setSeconds(d.getSeconds() - amount);
+        break;
+      case "m":
+        d.setMinutes(d.getMinutes() - amount);
+        break;
+      case "h":
+        d.setHours(d.getHours() - amount);
+        break;
+      case "d":
+        d.setDate(d.getDate() - amount);
+        break;
+      case "w":
+        d.setDate(d.getDate() - amount * 7);
+        break;
+    }
+    return d.toISOString();
+  }
+  const parsed = new Date(input);
+  if (Number.isNaN(parsed.getTime())) {
+    const defaultDate = /* @__PURE__ */ new Date();
+    defaultDate.setHours(defaultDate.getHours() - 1);
+    return defaultDate.toISOString();
+  }
+  return parsed.toISOString();
+}
+async function handleQueryTelemetry(binding, args) {
+  const { elementIds, mode, aggregateStats } = args;
+  if (mode === "current") {
+    const values = await binding.getObjectValues(elementIds);
+    return {
+      mode: "current",
+      telemetry: values
+    };
+  }
+  const startTime = parseStartTime(args.startTime);
+  const endTimeDate = args.endTime ? new Date(args.endTime) : /* @__PURE__ */ new Date();
+  const endTime = Number.isNaN(endTimeDate.getTime()) ? (/* @__PURE__ */ new Date()).toISOString() : endTimeDate.toISOString();
+  const history = await binding.getHistoricalValues(elementIds, startTime, endTime);
+  if (!aggregateStats) {
+    return {
+      mode: "history",
+      timeRange: { startTime, endTime },
+      history
+    };
+  }
+  const reports = history.map((record, idx) => {
+    const elementId = elementIds[idx] || `element_${idx}`;
+    const report = {
+      elementId,
+      timeRange: { startTime, endTime },
+      dataPoints: record.values || []
+    };
+    const numericValues = [];
+    let badQualityCount = 0;
+    for (const v of record.values || []) {
+      if (v.quality && String(v.quality).toUpperCase() !== "GOOD") {
+        badQualityCount++;
+      }
+      if (typeof v.value === "number" && !Number.isNaN(v.value)) {
+        numericValues.push(v.value);
+      }
+    }
+    if (numericValues.length > 0) {
+      const min = Math.min(...numericValues);
+      const max = Math.max(...numericValues);
+      const sum = numericValues.reduce((a, b) => a + b, 0);
+      const mean = Math.round(sum / numericValues.length * 100) / 100;
+      report.statistics = {
+        min,
+        max,
+        mean,
+        count: numericValues.length,
+        badQualityCount
+      };
+    } else {
+      report.statistics = {
+        count: (record.values || []).length,
+        badQualityCount
+      };
+    }
+    return report;
+  });
+  return {
+    mode: "history",
+    timeRange: { startTime, endTime },
+    telemetryReports: reports
+  };
+}
+
+// src/server.ts
+var NodeI3xMcpServer = class {
+  server;
+  binding;
+  constructor(binding) {
+    this.binding = binding || new RestClientBinding();
+    this.server = new Server(
+      {
+        name: "@node-i3x/mcp",
+        version: "0.10.0"
+      },
+      {
+        capabilities: {
+          tools: {},
+          resources: {}
+        }
+      }
+    );
+    this.setupHandlers();
+  }
+  setBinding(binding) {
+    this.binding = binding;
+  }
+  getBinding() {
+    return this.binding;
+  }
+  setupHandlers() {
+    this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
+      tools: [
+        {
+          name: "i3x_connect",
+          description: "Connect or switch dynamically to a specific i3X server endpoint URL and optional Bearer token at runtime.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              serverUrl: {
+                type: "string",
+                description: "Target i3X Gateway REST endpoint URL (e.g. 'http://192.168.1.50:8000' or 'https://i3x-portal.sterfive.io/instance/SESSION_ID')"
+              },
+              authToken: {
+                type: "string",
+                description: "Optional Bearer authentication token for secured endpoints"
+              },
+              verifyConnection: {
+                type: "boolean",
+                description: "Whether to verify connectivity by querying server /v1/info (default: true)"
+              }
+            },
+            required: ["serverUrl"]
+          }
+        },
+        {
+          name: "i3x_inspect_asset",
+          description: "Single-turn complete asset diagnostic. Returns identity, ObjectType schema, parent/child hierarchy, and live VQT telemetry in 1 call.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              elementId: {
+                type: "string",
+                description: "The elementId of the asset to inspect (e.g. 'Pump_101', 'Boiler_101')"
+              },
+              includeValues: {
+                type: "boolean",
+                description: "Whether to include live VQT telemetry values (default: true)"
+              },
+              includeSchema: {
+                type: "boolean",
+                description: "Whether to include the ObjectType JSON Schema definition (default: true)"
+              }
+            },
+            required: ["elementId"]
+          }
+        },
+        {
+          name: "i3x_explore_plant_hierarchy",
+          description: "ISA-95 plant topology discovery. Traverses plant hierarchy from root assets down to child components up to maxDepth.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              rootElementId: {
+                type: "string",
+                description: "Optional specific root asset elementId. If omitted, explores all root assets."
+              },
+              maxDepth: {
+                type: "number",
+                description: "Maximum depth to traverse child components (1 to 5, default: 2)"
+              }
+            }
+          }
+        },
+        {
+          name: "i3x_query_telemetry",
+          description: "Live current VQT telemetry or historical time-series trend analysis with pre-computed statistical summaries (min, max, mean).",
+          inputSchema: {
+            type: "object",
+            properties: {
+              elementIds: {
+                type: "array",
+                items: { type: "string" },
+                description: "Array of asset elementIds to query (e.g. ['Pump_101', 'Boiler_101'])"
+              },
+              mode: {
+                type: "string",
+                enum: ["current", "history"],
+                description: "Query mode: 'current' for live VQT, 'history' for time-series trend analysis"
+              },
+              startTime: {
+                type: "string",
+                description: "ISO 8601 or relative duration (e.g. '-2h', '-30m') for history mode"
+              },
+              endTime: {
+                type: "string",
+                description: "ISO 8601 end time (defaults to now) for history mode"
+              },
+              aggregateStats: {
+                type: "boolean",
+                description: "Whether to pre-compute min/max/mean statistical summaries (default: true)"
+              }
+            },
+            required: ["elementIds"]
+          }
+        },
+        {
+          name: "i3x_discover_types_and_schemas",
+          description: "Search registered i3X ObjectTypes, RelationshipTypes, and JSON Schema field validation requirements.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              typeElementId: {
+                type: "string",
+                description: "Optional specific ObjectType elementId (e.g. 'BoilerType'). If omitted, lists all types."
+              },
+              namespaceUri: {
+                type: "string",
+                description: "Optional namespaceUri filter (e.g. 'http://sterfive.com/UA/Demo/')"
+              }
+            }
+          }
+        },
+        {
+          name: "i3x_monitor_asset_events",
+          description: "Create an i3X subscription stream to monitor real-time VQT value changes or threshold alert conditions.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              elementIds: {
+                type: "array",
+                items: { type: "string" },
+                description: "Array of asset elementIds to monitor"
+              },
+              condition: {
+                type: "string",
+                description: "Optional alert condition filter (e.g. 'temperature > 85 || quality != Good')"
+              }
+            },
+            required: ["elementIds"]
+          }
+        }
+      ]
+    }));
+    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      const { name, arguments: rawArgs } = request.params;
+      try {
+        let result;
+        switch (name) {
+          case "i3x_connect": {
+            const parsed = connectSchema.parse(rawArgs);
+            result = await handleConnect(parsed, (newBinding) => {
+              this.binding = newBinding;
+            });
+            break;
+          }
+          case "i3x_inspect_asset": {
+            const parsed = inspectAssetSchema.parse(rawArgs);
+            result = await handleInspectAsset(this.binding, parsed);
+            break;
+          }
+          case "i3x_explore_plant_hierarchy": {
+            const parsed = exploreHierarchySchema.parse(rawArgs);
+            result = await handleExploreHierarchy(this.binding, parsed);
+            break;
+          }
+          case "i3x_query_telemetry": {
+            const parsed = queryTelemetrySchema.parse(rawArgs);
+            result = await handleQueryTelemetry(this.binding, parsed);
+            break;
+          }
+          case "i3x_discover_types_and_schemas": {
+            const parsed = discoverTypesSchema.parse(rawArgs);
+            result = await handleDiscoverTypes(this.binding, parsed);
+            break;
+          }
+          case "i3x_monitor_asset_events": {
+            const parsed = monitorEventsSchema.parse(rawArgs);
+            result = await handleMonitorEvents(this.binding, parsed);
+            break;
+          }
+          default:
+            throw new Error(`Unknown tool: ${name}`);
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  error: err.message,
+                  tip: "Check parameters or use 'i3x_explore_plant_hierarchy' to list available assets."
+                },
+                null,
+                2
+              )
+            }
+          ],
+          isError: true
+        };
+      }
+    });
+    this.server.setRequestHandler(ListResourcesRequestSchema, async () => ({
+      resources: [
+        {
+          uri: "i3x://info",
+          name: "i3X Server Metadata",
+          description: "Server capabilities, spec version, and vendor information",
+          mimeType: "application/json"
+        },
+        {
+          uri: "i3x://namespaces",
+          name: "Registered Namespaces",
+          description: "List of registered OPC UA / i3X namespace URIs",
+          mimeType: "application/json"
+        }
+      ]
+    }));
+    this.server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+      const { uri } = request.params;
+      if (uri === "i3x://info") {
+        const info = await this.binding.getInfo();
+        return {
+          contents: [
+            {
+              uri,
+              mimeType: "application/json",
+              text: JSON.stringify(info, null, 2)
+            }
+          ]
+        };
+      }
+      if (uri === "i3x://namespaces") {
+        const namespaces = await this.binding.getNamespaces();
+        return {
+          contents: [
+            {
+              uri,
+              mimeType: "application/json",
+              text: JSON.stringify(namespaces, null, 2)
+            }
+          ]
+        };
+      }
+      throw new Error(`Unknown resource URI: ${uri}`);
+    });
+  }
+  async startStdio() {
+    const transport = new StdioServerTransport();
+    await this.server.connect(transport);
+  }
+};
+export {
+  InProcessConnectorBinding,
+  NodeI3xMcpServer,
+  RestClientBinding,
+  discoverTypesSchema,
+  exploreHierarchySchema,
+  handleDiscoverTypes,
+  handleExploreHierarchy,
+  handleInspectAsset,
+  handleMonitorEvents,
+  handleQueryTelemetry,
+  inspectAssetSchema,
+  monitorEventsSchema,
+  queryTelemetrySchema
+};
+//# sourceMappingURL=index.js.map