@flutchai/flutch-sdk 0.1.5 → 0.1.7

package/dist/index.cjs

@@ -3,7 +3,9 @@
 require('reflect-metadata');
 var common = require('@nestjs/common');
 var swagger = require('@nestjs/swagger');
-var path = require('path');
+var fs = require('fs');
+var path2 = require('path');
+var os = require('os');
 var crypto = require('crypto');
 var promClient = require('prom-client');
 var core = require('@nestjs/core');
@@ -40,7 +42,9 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var path__namespace = /*#__PURE__*/_interopNamespace(path);
+var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
+var path2__namespace = /*#__PURE__*/_interopNamespace(path2);
+var os__namespace = /*#__PURE__*/_interopNamespace(os);
 var net__namespace = /*#__PURE__*/_interopNamespace(net);
 var LangGraph__namespace = /*#__PURE__*/_interopNamespace(LangGraph);
 var axios2__default = /*#__PURE__*/_interopDefault(axios2);
@@ -459,12 +463,21 @@ var init_ui_endpoints_discovery = __esm({
         this.endpointRegistry = endpointRegistry;
       }
       logger = new common.Logger(exports.UIEndpointsDiscoveryService.name);
+      async onModuleInit() {
+        await this.discoverUIEndpoints();
+      }
       /**
        * Discover and register all UI endpoint classes
        * Called automatically during module initialization
        */
       async discoverUIEndpoints() {
         this.logger.log("Starting UI endpoints discovery...");
+        if (!this.discoveryService) {
+          this.logger.warn(
+            "DiscoveryService not available, skipping UI endpoints discovery"
+          );
+          return;
+        }
         const providers = this.discoveryService.getProviders();
         let registeredCount = 0;
         let totalEndpoints = 0;
@@ -516,7 +529,9 @@ var init_ui_endpoints_discovery = __esm({
       }
     };
     exports.UIEndpointsDiscoveryService = __decorateClass([
-      common.Injectable()
+      common.Injectable(),
+      __decorateParam(0, common.Optional()),
+      __decorateParam(1, common.Optional())
     ], exports.UIEndpointsDiscoveryService);
   }
 });
@@ -711,6 +726,523 @@ var init_agent_ui = __esm({
     init_ui_dispatch_controller();
   }
 });
+
+// src/service-discovery/file-based.discovery.ts
+var file_based_discovery_exports = {};
+__export(file_based_discovery_exports, {
+  FileBasedDiscovery: () => exports.FileBasedDiscovery
+});
+exports.FileBasedDiscovery = void 0;
+var init_file_based_discovery = __esm({
+  "src/service-discovery/file-based.discovery.ts"() {
+    exports.FileBasedDiscovery = class {
+      logger = new common.Logger(exports.FileBasedDiscovery.name);
+      servicesDir;
+      constructor() {
+        this.servicesDir = path2__namespace.join(os__namespace.homedir(), ".flutch", "services");
+        this.ensureServicesDirectory();
+        this.cleanupStaleServices();
+      }
+      /**
+       * Register service
+       */
+      async registerService(name, address, port, metadata, graphTypes = []) {
+        const registration = {
+          name,
+          address,
+          port,
+          metadata,
+          pid: process.pid,
+          timestamp: Date.now(),
+          graphTypes
+        };
+        const serviceFile = path2__namespace.join(
+          this.servicesDir,
+          `${name}-${process.pid}.json`
+        );
+        try {
+          await fs__namespace.promises.writeFile(
+            serviceFile,
+            JSON.stringify(registration, null, 2)
+          );
+          this.logger.log(`Registered service: ${name} at ${address}:${port}`);
+          process.on("exit", () => this.unregisterService(name));
+          process.on("SIGINT", () => {
+            this.unregisterService(name);
+            process.exit(0);
+          });
+          process.on("SIGTERM", () => {
+            this.unregisterService(name);
+            process.exit(0);
+          });
+        } catch (error) {
+          this.logger.error(`Failed to register service ${name}: ${error.message}`);
+        }
+      }
+      /**
+       * Unregister service
+       */
+      async unregisterService(name) {
+        const serviceFile = path2__namespace.join(
+          this.servicesDir,
+          `${name}-${process.pid}.json`
+        );
+        try {
+          if (fs__namespace.existsSync(serviceFile)) {
+            await fs__namespace.promises.unlink(serviceFile);
+            this.logger.log(`Unregistered service: ${name}`);
+          }
+        } catch (error) {
+          this.logger.error(
+            `Failed to unregister service ${name}: ${error.message}`
+          );
+        }
+      }
+      /**
+       * Get list of services by graph type
+       */
+      async getServices(graphType) {
+        try {
+          const files = await fs__namespace.promises.readdir(this.servicesDir);
+          const services = [];
+          for (const file of files) {
+            if (!file.endsWith(".json")) continue;
+            try {
+              const serviceFile = path2__namespace.join(this.servicesDir, file);
+              const content = await fs__namespace.promises.readFile(serviceFile, "utf-8");
+              const registration = JSON.parse(content);
+              if (!this.isProcessAlive(registration.pid)) {
+                await fs__namespace.promises.unlink(serviceFile);
+                continue;
+              }
+              if (registration.graphTypes.includes(graphType) || registration.metadata.graphTypes?.includes(graphType)) {
+                services.push({
+                  name: registration.name,
+                  address: registration.address,
+                  port: registration.port,
+                  metadata: registration.metadata
+                });
+              }
+            } catch (error) {
+              this.logger.warn(
+                `Failed to parse service file ${file}: ${error.message}`
+              );
+            }
+          }
+          return services;
+        } catch (error) {
+          this.logger.error(`Failed to get services: ${error.message}`);
+          return [];
+        }
+      }
+      /**
+       * Find service by name
+       */
+      async findServiceByName(serviceName) {
+        try {
+          const files = await fs__namespace.promises.readdir(this.servicesDir);
+          for (const file of files) {
+            if (!file.endsWith(".json")) continue;
+            try {
+              const serviceFile = path2__namespace.join(this.servicesDir, file);
+              const content = await fs__namespace.promises.readFile(serviceFile, "utf-8");
+              const registration = JSON.parse(content);
+              if (registration.name === serviceName && this.isProcessAlive(registration.pid)) {
+                return {
+                  name: registration.name,
+                  address: registration.address,
+                  port: registration.port,
+                  metadata: registration.metadata
+                };
+              }
+            } catch (error) {
+              this.logger.warn(
+                `Failed to parse service file ${file}: ${error.message}`
+              );
+            }
+          }
+          return null;
+        } catch (error) {
+          this.logger.error(
+            `Failed to find service ${serviceName}: ${error.message}`
+          );
+          return null;
+        }
+      }
+      /**
+       * Ensure services directory exists
+       */
+      ensureServicesDirectory() {
+        try {
+          const amelieDir = path2__namespace.join(os__namespace.homedir(), ".flutch");
+          if (!fs__namespace.existsSync(amelieDir)) {
+            fs__namespace.mkdirSync(amelieDir, { recursive: true });
+          }
+          if (!fs__namespace.existsSync(this.servicesDir)) {
+            fs__namespace.mkdirSync(this.servicesDir, { recursive: true });
+          }
+        } catch (error) {
+          this.logger.error(
+            `Failed to create services directory: ${error.message}`
+          );
+        }
+      }
+      /**
+       * Cleanup stale services
+       */
+      async cleanupStaleServices() {
+        try {
+          const files = await fs__namespace.promises.readdir(this.servicesDir);
+          for (const file of files) {
+            if (!file.endsWith(".json")) continue;
+            try {
+              const serviceFile = path2__namespace.join(this.servicesDir, file);
+              const content = await fs__namespace.promises.readFile(serviceFile, "utf-8");
+              const registration = JSON.parse(content);
+              if (!this.isProcessAlive(registration.pid)) {
+                await fs__namespace.promises.unlink(serviceFile);
+                this.logger.debug(`Cleaned up stale service: ${registration.name}`);
+              }
+            } catch (error) {
+              try {
+                await fs__namespace.promises.unlink(path2__namespace.join(this.servicesDir, file));
+              } catch {
+              }
+            }
+          }
+        } catch (error) {
+          this.logger.error(`Failed to cleanup stale services: ${error.message}`);
+        }
+      }
+      /**
+       * Check if process is still alive
+       */
+      isProcessAlive(pid) {
+        try {
+          process.kill(pid, 0);
+          return true;
+        } catch (error) {
+          return false;
+        }
+      }
+    };
+    exports.FileBasedDiscovery = __decorateClass([
+      common.Injectable()
+    ], exports.FileBasedDiscovery);
+  }
+});
+
+// src/core/builder-registry.service.ts
+var builder_registry_service_exports = {};
+__export(builder_registry_service_exports, {
+  BuilderRegistryService: () => exports.BuilderRegistryService
+});
+exports.BuilderRegistryService = void 0;
+var init_builder_registry_service = __esm({
+  "src/core/builder-registry.service.ts"() {
+    exports.BuilderRegistryService = class {
+      builders = [];
+      registerBuilder(builder) {
+        const existingBuilder = this.builders.find(
+          (b) => b.graphType === builder.graphType
+        );
+        if (!existingBuilder) {
+          this.builders.push(builder);
+        }
+      }
+      getBuilders() {
+        return this.builders;
+      }
+    };
+    exports.BuilderRegistryService = __decorateClass([
+      common.Injectable()
+    ], exports.BuilderRegistryService);
+  }
+});
+
+// src/utils/graph-type.utils.ts
+exports.GraphTypeUtils = void 0;
+var init_graph_type_utils = __esm({
+  "src/utils/graph-type.utils.ts"() {
+    exports.GraphTypeUtils = class {
+      /**
+       * Parse full graph type
+       * @param fullType - full graph type
+       * @returns object with type components
+       */
+      static parse(fullType) {
+        if (fullType.includes("::")) {
+          const [baseType, version] = fullType.split("::");
+          const [companyId, name] = baseType.split(".");
+          return { companyId, name, version };
+        }
+        const parts = fullType.split(".");
+        if (parts.length === 1) {
+          return { companyId: "global", name: parts[0] };
+        }
+        return { companyId: parts[0], name: parts[1] };
+      }
+      /**
+       * Build full type from components
+       * @param companyId - company ID
+       * @param name - graph name
+       * @param version - version (optional)
+       * @returns full graph type
+       */
+      static build(companyId, name, version) {
+        const base = `${companyId}.${name}`;
+        return version ? `${base}::${version}` : base;
+      }
+      /**
+       * Normalize graph type for backward compatibility
+       * @param graphType - graph type in any format
+       * @returns normalized type
+       */
+      static normalize(graphType) {
+        const { companyId, name, version } = this.parse(graphType);
+        return this.build(companyId, name, version);
+      }
+      /**
+       * Get base type without version
+       * @param graphType - full graph type
+       * @returns base type
+       */
+      static getBaseType(graphType) {
+        if (graphType.includes("::")) {
+          return graphType.split("::")[0];
+        }
+        const { companyId, name } = this.parse(graphType);
+        return `${companyId}.${name}`;
+      }
+      /**
+       * Extract version from graph type
+       * @param graphType - full graph type
+       * @returns version or undefined
+       */
+      static getVersion(graphType) {
+        return graphType.includes("::") ? graphType.split("::")[1] : void 0;
+      }
+      /**
+       * Validate version (basic semver check)
+       * @param version - version to check
+       * @returns true if version is valid
+       */
+      static isValidVersion(version) {
+        const semverRegex = /^\d+\.\d+\.\d+(-[a-zA-Z0-9.-]+)?$/;
+        return semverRegex.test(version);
+      }
+      /**
+       * Check if type is system (global)
+       * @param graphType - graph type
+       * @returns true if graph is system
+       */
+      static isSystemGraph(graphType) {
+        const { companyId } = this.parse(graphType);
+        return companyId === "global";
+      }
+      /**
+       * Compare versions (simple comparison for sorting)
+       * @param a - first version
+       * @param b - second version
+       * @returns -1, 0, 1 for sorting
+       */
+      static compareVersions(a, b) {
+        const parseVersion = (v) => {
+          const [main, prerelease] = v.split("-");
+          const [major, minor, patch] = main.split(".").map(Number);
+          return { major, minor, patch, prerelease };
+        };
+        const versionA = parseVersion(a);
+        const versionB = parseVersion(b);
+        if (versionA.major !== versionB.major) {
+          return versionA.major - versionB.major;
+        }
+        if (versionA.minor !== versionB.minor) {
+          return versionA.minor - versionB.minor;
+        }
+        if (versionA.patch !== versionB.patch) {
+          return versionA.patch - versionB.patch;
+        }
+        if (versionA.prerelease && !versionB.prerelease) return -1;
+        if (!versionA.prerelease && versionB.prerelease) return 1;
+        if (versionA.prerelease && versionB.prerelease) {
+          return versionA.prerelease.localeCompare(versionB.prerelease);
+        }
+        return 0;
+      }
+    };
+  }
+});
+
+// src/graph/versioning/versioned-graph.service.ts
+var versioned_graph_service_exports = {};
+__export(versioned_graph_service_exports, {
+  VersionedGraphService: () => exports.VersionedGraphService
+});
+exports.VersionedGraphService = void 0;
+var init_versioned_graph_service = __esm({
+  "src/graph/versioning/versioned-graph.service.ts"() {
+    init_graph_type_utils();
+    exports.VersionedGraphService = class {
+      logger = new common.Logger(exports.VersionedGraphService.name);
+      versionConfigs = /* @__PURE__ */ new Map();
+      constructor() {
+      }
+      /**
+       * Register versioning configuration
+       */
+      registerVersioning(config) {
+        this.versionConfigs.set(config.baseGraphType, config);
+        this.logger.log(
+          `Registered versioning for ${config.baseGraphType} with ${config.versions.length} versions`
+        );
+      }
+      /**
+       * Resolve graph version
+       */
+      async resolveVersion(graphType, options = {}) {
+        const parsed = exports.GraphTypeUtils.parse(graphType);
+        const baseType = exports.GraphTypeUtils.getBaseType(graphType);
+        const requestedVersion = exports.GraphTypeUtils.getVersion(graphType) || options.requestedVersion;
+        const config = this.versionConfigs.get(baseType);
+        if (!config) {
+          throw new Error(`No versioning configuration found for ${baseType}`);
+        }
+        const route = this.findBestVersionRoute(config, requestedVersion, options);
+        if (!route) {
+          throw new Error(
+            `No compatible version found for ${graphType} with options: ${JSON.stringify(options)}`
+          );
+        }
+        const fullGraphType = exports.GraphTypeUtils.build(
+          parsed.companyId,
+          parsed.name,
+          route.version
+        );
+        return {
+          version: route.version,
+          builderClass: route.builderClass,
+          fullGraphType
+        };
+      }
+      /**
+       * Create builder for specified version
+       */
+      async createVersionedBuilder(graphType, moduleRef, options = {}) {
+        const resolution = await this.resolveVersion(graphType, options);
+        try {
+          if (!moduleRef) {
+            throw new Error(
+              "ModuleRef is not available - falling back to direct instantiation"
+            );
+          }
+          const builder = await moduleRef.create(resolution.builderClass);
+          this.logger.debug(
+            `Created versioned builder for ${resolution.fullGraphType}`
+          );
+          return builder;
+        } catch (error) {
+          this.logger.error(
+            `Failed to create builder for ${resolution.fullGraphType}: ${error.message}`
+          );
+          throw new Error(`Failed to create versioned builder: ${error.message}`);
+        }
+      }
+      /**
+       * Get all available versions for a graph
+       */
+      getAvailableVersions(baseGraphType) {
+        const config = this.versionConfigs.get(baseGraphType);
+        if (!config) {
+          return [];
+        }
+        return config.versions.map((route) => route.version).sort((a, b) => exports.GraphTypeUtils.compareVersions(b, a));
+      }
+      /**
+       * Check version support
+       */
+      isVersionSupported(graphType, options = {}) {
+        try {
+          const baseType = exports.GraphTypeUtils.getBaseType(graphType);
+          const requestedVersion = exports.GraphTypeUtils.getVersion(graphType);
+          const config = this.versionConfigs.get(baseType);
+          if (!config) {
+            return false;
+          }
+          const route = this.findBestVersionRoute(
+            config,
+            requestedVersion,
+            options
+          );
+          return route !== null;
+        } catch {
+          return false;
+        }
+      }
+      /**
+       * Find best version
+       */
+      findBestVersionRoute(config, requestedVersion, options = {}) {
+        const { strict = false } = options;
+        let candidates = [...config.versions];
+        if (requestedVersion) {
+          const exactMatch = candidates.find(
+            (route) => route.version === requestedVersion
+          );
+          if (exactMatch) {
+            return exactMatch;
+          }
+          if (strict) {
+            return null;
+          }
+          const compatibleVersions = candidates.filter(
+            (route) => this.isVersionCompatible(requestedVersion, route.version)
+          );
+          if (compatibleVersions.length > 0) {
+            return compatibleVersions.sort(
+              (a, b) => exports.GraphTypeUtils.compareVersions(b.version, a.version)
+            )[0];
+          }
+        }
+        const defaultRoute = candidates.find((route) => route.isDefault);
+        if (defaultRoute) {
+          return defaultRoute;
+        }
+        if (config.defaultVersionStrategy === "latest" || !config.defaultVersionStrategy) {
+          const sortedVersions = candidates.sort(
+            (a, b) => exports.GraphTypeUtils.compareVersions(b.version, a.version)
+          );
+          return sortedVersions[0] || null;
+        }
+        return null;
+      }
+      /**
+       * Check version compatibility (simplified semantics)
+       */
+      isVersionCompatible(requested, available) {
+        try {
+          const requestedParts = requested.split(".").map(Number);
+          const availableParts = available.split(".").map(Number);
+          if (requestedParts[0] !== availableParts[0]) {
+            return false;
+          }
+          return exports.GraphTypeUtils.compareVersions(available, requested) >= 0;
+        } catch {
+          return false;
+        }
+      }
+      /**
+       * Get versioning configuration information
+       */
+      getVersioningInfo(baseGraphType) {
+        return this.versionConfigs.get(baseGraphType) || null;
+      }
+    };
+    exports.VersionedGraphService = __decorateClass([
+      common.Injectable()
+    ], exports.VersionedGraphService);
+  }
+});
 var CallbackStore = class {
   constructor(redis) {
     this.redis = redis;
@@ -2552,7 +3084,7 @@ var _AbstractGraphBuilder = class _AbstractGraphBuilder {
   /**
    * Path to root graph manifest (defaults to graph.manifest.json in root)
    */
-  manifestPath = path__namespace.join(
+  manifestPath = path2__namespace.join(
     process.cwd(),
     "graph.manifest.json"
   );
@@ -2632,10 +3164,10 @@ var _AbstractGraphBuilder = class _AbstractGraphBuilder {
       return null;
     }
     try {
-      const fs = await import('fs/promises');
-      const path2 = await import('path');
-      const manifestFullPath = path2.resolve(this.manifestPath);
-      const manifestContent = await fs.readFile(manifestFullPath, "utf-8");
+      const fs2 = await import('fs/promises');
+      const path3 = await import('path');
+      const manifestFullPath = path3.resolve(this.manifestPath);
+      const manifestContent = await fs2.readFile(manifestFullPath, "utf-8");
       const manifest = JSON.parse(manifestContent);
       this.manifest = manifest;
       return manifest;
@@ -2654,10 +3186,10 @@ var _AbstractGraphBuilder = class _AbstractGraphBuilder {
       return null;
     }
     try {
-      const fs = __require("fs");
-      const path2 = __require("path");
-      const manifestFullPath = path2.resolve(this.manifestPath);
-      const manifestContent = fs.readFileSync(manifestFullPath, "utf-8");
+      const fs2 = __require("fs");
+      const path3 = __require("path");
+      const manifestFullPath = path3.resolve(this.manifestPath);
+      const manifestContent = fs2.readFileSync(manifestFullPath, "utf-8");
       const manifest = JSON.parse(manifestContent);
       this.manifest = manifest;
       return manifest;
@@ -2697,12 +3229,12 @@ var _AbstractGraphBuilder = class _AbstractGraphBuilder {
     let configSchema = null;
     if (versionConfig.configSchemaPath) {
       try {
-        const fs = await import('fs/promises');
-        const schemaPath = path__namespace.resolve(
+        const fs2 = await import('fs/promises');
+        const schemaPath = path2__namespace.resolve(
           process.cwd(),
           versionConfig.configSchemaPath
         );
-        const schemaContent = await fs.readFile(schemaPath, "utf-8");
+        const schemaContent = await fs2.readFile(schemaPath, "utf-8");
         const schemaData = JSON.parse(schemaContent);
         configSchema = schemaData.schema;
       } catch (error) {
@@ -3167,6 +3699,20 @@ exports.UniversalGraphService = __decorateClass([
   __decorateParam(2, common.Inject("GRAPH_ENGINE")),
   __decorateParam(3, common.Inject(exports.EndpointRegistry))
 ], exports.UniversalGraphService);
+function setupRedisMock() {
+  if (process.env.NODE_ENV === "development" && !process.env.KUBERNETES_SERVICE_HOST) {
+    console.log("[REDIS_MOCK] Intercepting ioredis requires for development");
+    const Module2 = __require("module");
+    const originalRequire = Module2.prototype.require;
+    Module2.prototype.require = function(...args) {
+      if (args[0] === "ioredis") {
+        console.log("[REDIS_MOCK] Redirecting ioredis to ioredis-mock");
+        return originalRequire.apply(this, ["ioredis-mock"]);
+      }
+      return originalRequire.apply(this, args);
+    };
+  }
+}
 async function isPortAvailable(port) {
   return new Promise((resolve2) => {
     const server = net__namespace.createServer();
@@ -3188,10 +3734,110 @@ async function findAvailablePort(startPort) {
     `No available ports found in range ${startPort}-${startPort + 99}`
   );
 }
+async function registerWithServiceDiscovery(AppModule, port, logger2, app) {
+  try {
+    logger2.debug(
+      "[SERVICE_DISCOVERY] Starting service discovery registration..."
+    );
+    const { FileBasedDiscovery: FileBasedDiscovery2 } = await Promise.resolve().then(() => (init_file_based_discovery(), file_based_discovery_exports));
+    logger2.debug(
+      "[SERVICE_DISCOVERY] FileBasedDiscovery imported successfully"
+    );
+    const discovery = new FileBasedDiscovery2();
+    logger2.debug("[SERVICE_DISCOVERY] FileBasedDiscovery instance created");
+    const serviceName = AppModule.name.replace("Module", "").toLowerCase();
+    let graphTypes = [];
+    try {
+      if (app) {
+        const { BuilderRegistryService: BuilderRegistryService2 } = await Promise.resolve().then(() => (init_builder_registry_service(), builder_registry_service_exports));
+        const builderRegistry = app.get(BuilderRegistryService2, {
+          strict: false
+        });
+        logger2.debug(
+          `BuilderRegistryService found in DI: ${!!builderRegistry}`
+        );
+        if (builderRegistry) {
+          const builders = builderRegistry.getBuilders();
+          logger2.debug(`Found ${builders.length} builders in registry`);
+          const baseGraphTypes = builders.map((builder) => builder.graphType);
+          logger2.debug(`Base graph types: [${baseGraphTypes.join(", ")}]`);
+          try {
+            logger2.debug("Attempting to import VersionedGraphService...");
+            const { VersionedGraphService: VersionedGraphService2 } = await Promise.resolve().then(() => (init_versioned_graph_service(), versioned_graph_service_exports));
+            logger2.debug("VersionedGraphService imported successfully");
+            const versionedService = app.get(VersionedGraphService2, {
+              strict: false
+            });
+            logger2.debug(
+              `VersionedGraphService found in DI: ${!!versionedService}`
+            );
+            if (versionedService) {
+              const allVersionedTypes = [];
+              for (const baseType of baseGraphTypes) {
+                logger2.debug(`Getting versions for base type: ${baseType}`);
+                const versions = versionedService.getAvailableVersions(baseType);
+                logger2.debug(
+                  `Found ${versions.length} versions for ${baseType}: [${versions.join(", ")}]`
+                );
+                if (versions.length > 0) {
+                  allVersionedTypes.push(baseType);
+                  versions.forEach((version) => {
+                    allVersionedTypes.push(`${baseType}::${version}`);
+                  });
+                } else {
+                  allVersionedTypes.push(baseType);
+                }
+              }
+              graphTypes = allVersionedTypes;
+              logger2.debug(
+                `Found ${baseGraphTypes.length} base types with ${graphTypes.length} total versioned types: ${graphTypes.join(", ")}`
+              );
+            } else {
+              graphTypes = baseGraphTypes;
+              logger2.debug(
+                `VersionedGraphService not found in DI container, using base types: ${graphTypes.join(", ")}`
+              );
+            }
+          } catch (error) {
+            graphTypes = baseGraphTypes;
+            logger2.debug(
+              `Failed to get versioned types, using base types: ${error.message}`
+            );
+            logger2.debug(`Stack trace: ${error.stack}`);
+          }
+        }
+      }
+    } catch (error) {
+      logger2.debug(`Failed to get graph types from builders: ${error.message}`);
+    }
+    if (graphTypes.length === 0) {
+      logger2.debug("No builders found, using service name as graph type");
+      graphTypes = [serviceName];
+    }
+    await discovery.registerService(
+      serviceName,
+      "localhost",
+      port,
+      {
+        graphTypes,
+        environment: "development",
+        startTime: (/* @__PURE__ */ new Date()).toISOString(),
+        version: process.env.npm_package_version || "1.0.0"
+      },
+      graphTypes
+    );
+    logger2.log(
+      `\u{1F4E1} Service registered with discovery: ${serviceName} (types: ${graphTypes.join(", ")})`
+    );
+  } catch (error) {
+    logger2.warn(`Failed to register with service discovery: ${error.message}`);
+  }
+}
 async function bootstrap(AppModule, options = {}) {
+  setupRedisMock();
   const app = await core.NestFactory.create(AppModule);
   const logger2 = new common.Logger("Bootstrap");
-  const requestedPort = options.port || parseInt(process.env.PORT || "3000", 10);
+  const requestedPort = options.port || parseInt(process.env.PORT || "3100", 10);
   const port = await findAvailablePort(requestedPort);
   const globalPrefix = options.globalPrefix;
   if (port !== requestedPort) {
@@ -3212,63 +3858,27 @@ async function bootstrap(AppModule, options = {}) {
     credentials: true
   });
   const config = new swagger.DocumentBuilder().setTitle("Graph Service API").setDescription("API for graph service microservice").setVersion("1.0").addBearerAuth().build();
-  const document = swagger.SwaggerModule.createDocument(app, config);
-  swagger.SwaggerModule.setup("api/docs", app, document);
-  await app.listen(port);
-  const baseUrl = globalPrefix ? `http://localhost:${port}/${globalPrefix}` : `http://localhost:${port}`;
-  logger2.log(`\u{1F680} Graph service is running on: ${baseUrl}`);
-  logger2.log(`\u{1F4DA} API Documentation: http://localhost:${port}/api/docs`);
-  if (process.env.NODE_ENV !== "production") ;
-  return app;
-}
-exports.BuilderRegistryService = class BuilderRegistryService {
-  builders = [];
-  registerBuilder(builder) {
-    const existingBuilder = this.builders.find(
-      (b) => b.graphType === builder.graphType
-    );
-    if (!existingBuilder) {
-      this.builders.push(builder);
-    }
-  }
-  getBuilders() {
-    return this.builders;
-  }
-};
-exports.BuilderRegistryService = __decorateClass([
-  common.Injectable()
-], exports.BuilderRegistryService);
-var GraphEngineType = /* @__PURE__ */ ((GraphEngineType2) => {
-  GraphEngineType2["LANGGRAPH"] = "langgraph";
-  GraphEngineType2["LANGFLOW"] = "langflow";
-  GraphEngineType2["FLOWISE"] = "flowise";
-  return GraphEngineType2;
-})(GraphEngineType || {});
-exports.GraphEngineFactory = class GraphEngineFactory {
-  constructor(langgraph) {
-    this.langgraph = langgraph;
-  }
-  /**
-   * Get engine for the specified type
-   */
-  getEngine(engineType) {
-    switch (engineType) {
-      case "langgraph" /* LANGGRAPH */:
-        return this.langgraph;
-      // Will add other types in the future
-      // case GraphEngineType.LANGFLOW:
-      //   return new LangFlowEngine();
-      // case GraphEngineType.FLOWISE:
-      //   return new FlowiseEngine();
-      default:
-        throw new Error(`Unsupported graph engine type: ${engineType}`);
-    }
+  const document = swagger.SwaggerModule.createDocument(app, config);
+  swagger.SwaggerModule.setup("api/docs", app, document);
+  await app.listen(port);
+  const baseUrl = globalPrefix ? `http://localhost:${port}/${globalPrefix}` : `http://localhost:${port}`;
+  logger2.log(`\u{1F680} Graph service is running on: ${baseUrl}`);
+  logger2.log(`\u{1F4DA} API Documentation: http://localhost:${port}/api/docs`);
+  if (process.env.NODE_ENV !== "production") {
+    logger2.debug(
+      `Attempting service discovery registration (NODE_ENV: ${process.env.NODE_ENV || "undefined"})`
+    );
+    await registerWithServiceDiscovery(AppModule, port, logger2, app);
+  } else {
+    logger2.debug(
+      `Skipping service discovery registration (NODE_ENV: ${process.env.NODE_ENV})`
+    );
   }
-};
-exports.GraphEngineFactory = __decorateClass([
-  common.Injectable(),
-  __decorateParam(0, common.Inject())
-], exports.GraphEngineFactory);
+  return app;
+}
+
+// src/core/index.ts
+init_builder_registry_service();
 
 // src/messages/attachments.ts
 var AttachmentType = /* @__PURE__ */ ((AttachmentType2) => {
@@ -3650,274 +4260,8 @@ ${result.errors.join("\n")}`
   }
 };
 
-// src/utils/graph-type.utils.ts
-var GraphTypeUtils = class {
-  /**
-   * Parse full graph type
-   * @param fullType - full graph type
-   * @returns object with type components
-   */
-  static parse(fullType) {
-    if (fullType.includes("::")) {
-      const [baseType, version] = fullType.split("::");
-      const [companyId, name] = baseType.split(".");
-      return { companyId, name, version };
-    }
-    const parts = fullType.split(".");
-    if (parts.length === 1) {
-      return { companyId: "global", name: parts[0] };
-    }
-    return { companyId: parts[0], name: parts[1] };
-  }
-  /**
-   * Build full type from components
-   * @param companyId - company ID
-   * @param name - graph name
-   * @param version - version (optional)
-   * @returns full graph type
-   */
-  static build(companyId, name, version) {
-    const base = `${companyId}.${name}`;
-    return version ? `${base}::${version}` : base;
-  }
-  /**
-   * Normalize graph type for backward compatibility
-   * @param graphType - graph type in any format
-   * @returns normalized type
-   */
-  static normalize(graphType) {
-    const { companyId, name, version } = this.parse(graphType);
-    return this.build(companyId, name, version);
-  }
-  /**
-   * Get base type without version
-   * @param graphType - full graph type
-   * @returns base type
-   */
-  static getBaseType(graphType) {
-    if (graphType.includes("::")) {
-      return graphType.split("::")[0];
-    }
-    const { companyId, name } = this.parse(graphType);
-    return `${companyId}.${name}`;
-  }
-  /**
-   * Extract version from graph type
-   * @param graphType - full graph type
-   * @returns version or undefined
-   */
-  static getVersion(graphType) {
-    return graphType.includes("::") ? graphType.split("::")[1] : void 0;
-  }
-  /**
-   * Validate version (basic semver check)
-   * @param version - version to check
-   * @returns true if version is valid
-   */
-  static isValidVersion(version) {
-    const semverRegex = /^\d+\.\d+\.\d+(-[a-zA-Z0-9.-]+)?$/;
-    return semverRegex.test(version);
-  }
-  /**
-   * Check if type is system (global)
-   * @param graphType - graph type
-   * @returns true if graph is system
-   */
-  static isSystemGraph(graphType) {
-    const { companyId } = this.parse(graphType);
-    return companyId === "global";
-  }
-  /**
-   * Compare versions (simple comparison for sorting)
-   * @param a - first version
-   * @param b - second version
-   * @returns -1, 0, 1 for sorting
-   */
-  static compareVersions(a, b) {
-    const parseVersion = (v) => {
-      const [main, prerelease] = v.split("-");
-      const [major, minor, patch] = main.split(".").map(Number);
-      return { major, minor, patch, prerelease };
-    };
-    const versionA = parseVersion(a);
-    const versionB = parseVersion(b);
-    if (versionA.major !== versionB.major) {
-      return versionA.major - versionB.major;
-    }
-    if (versionA.minor !== versionB.minor) {
-      return versionA.minor - versionB.minor;
-    }
-    if (versionA.patch !== versionB.patch) {
-      return versionA.patch - versionB.patch;
-    }
-    if (versionA.prerelease && !versionB.prerelease) return -1;
-    if (!versionA.prerelease && versionB.prerelease) return 1;
-    if (versionA.prerelease && versionB.prerelease) {
-      return versionA.prerelease.localeCompare(versionB.prerelease);
-    }
-    return 0;
-  }
-};
-
-// src/graph/versioning/versioned-graph.service.ts
-exports.VersionedGraphService = class VersionedGraphService {
-  logger = new common.Logger(exports.VersionedGraphService.name);
-  versionConfigs = /* @__PURE__ */ new Map();
-  constructor() {
-  }
-  /**
-   * Register versioning configuration
-   */
-  registerVersioning(config) {
-    this.versionConfigs.set(config.baseGraphType, config);
-    this.logger.log(
-      `Registered versioning for ${config.baseGraphType} with ${config.versions.length} versions`
-    );
-  }
-  /**
-   * Resolve graph version
-   */
-  async resolveVersion(graphType, options = {}) {
-    const parsed = GraphTypeUtils.parse(graphType);
-    const baseType = GraphTypeUtils.getBaseType(graphType);
-    const requestedVersion = GraphTypeUtils.getVersion(graphType) || options.requestedVersion;
-    const config = this.versionConfigs.get(baseType);
-    if (!config) {
-      throw new Error(`No versioning configuration found for ${baseType}`);
-    }
-    const route = this.findBestVersionRoute(config, requestedVersion, options);
-    if (!route) {
-      throw new Error(
-        `No compatible version found for ${graphType} with options: ${JSON.stringify(options)}`
-      );
-    }
-    const fullGraphType = GraphTypeUtils.build(
-      parsed.companyId,
-      parsed.name,
-      route.version
-    );
-    return {
-      version: route.version,
-      builderClass: route.builderClass,
-      fullGraphType
-    };
-  }
-  /**
-   * Create builder for specified version
-   */
-  async createVersionedBuilder(graphType, moduleRef, options = {}) {
-    const resolution = await this.resolveVersion(graphType, options);
-    try {
-      if (!moduleRef) {
-        throw new Error(
-          "ModuleRef is not available - falling back to direct instantiation"
-        );
-      }
-      const builder = await moduleRef.create(resolution.builderClass);
-      this.logger.debug(
-        `Created versioned builder for ${resolution.fullGraphType}`
-      );
-      return builder;
-    } catch (error) {
-      this.logger.error(
-        `Failed to create builder for ${resolution.fullGraphType}: ${error.message}`
-      );
-      throw new Error(`Failed to create versioned builder: ${error.message}`);
-    }
-  }
-  /**
-   * Get all available versions for a graph
-   */
-  getAvailableVersions(baseGraphType) {
-    const config = this.versionConfigs.get(baseGraphType);
-    if (!config) {
-      return [];
-    }
-    return config.versions.map((route) => route.version).sort((a, b) => GraphTypeUtils.compareVersions(b, a));
-  }
-  /**
-   * Check version support
-   */
-  isVersionSupported(graphType, options = {}) {
-    try {
-      const baseType = GraphTypeUtils.getBaseType(graphType);
-      const requestedVersion = GraphTypeUtils.getVersion(graphType);
-      const config = this.versionConfigs.get(baseType);
-      if (!config) {
-        return false;
-      }
-      const route = this.findBestVersionRoute(
-        config,
-        requestedVersion,
-        options
-      );
-      return route !== null;
-    } catch {
-      return false;
-    }
-  }
-  /**
-   * Find best version
-   */
-  findBestVersionRoute(config, requestedVersion, options = {}) {
-    const { strict = false } = options;
-    let candidates = [...config.versions];
-    if (requestedVersion) {
-      const exactMatch = candidates.find(
-        (route) => route.version === requestedVersion
-      );
-      if (exactMatch) {
-        return exactMatch;
-      }
-      if (strict) {
-        return null;
-      }
-      const compatibleVersions = candidates.filter(
-        (route) => this.isVersionCompatible(requestedVersion, route.version)
-      );
-      if (compatibleVersions.length > 0) {
-        return compatibleVersions.sort(
-          (a, b) => GraphTypeUtils.compareVersions(b.version, a.version)
-        )[0];
-      }
-    }
-    const defaultRoute = candidates.find((route) => route.isDefault);
-    if (defaultRoute) {
-      return defaultRoute;
-    }
-    if (config.defaultVersionStrategy === "latest" || !config.defaultVersionStrategy) {
-      const sortedVersions = candidates.sort(
-        (a, b) => GraphTypeUtils.compareVersions(b.version, a.version)
-      );
-      return sortedVersions[0] || null;
-    }
-    return null;
-  }
-  /**
-   * Check version compatibility (simplified semantics)
-   */
-  isVersionCompatible(requested, available) {
-    try {
-      const requestedParts = requested.split(".").map(Number);
-      const availableParts = available.split(".").map(Number);
-      if (requestedParts[0] !== availableParts[0]) {
-        return false;
-      }
-      return GraphTypeUtils.compareVersions(available, requested) >= 0;
-    } catch {
-      return false;
-    }
-  }
-  /**
-   * Get versioning configuration information
-   */
-  getVersioningInfo(baseGraphType) {
-    return this.versionConfigs.get(baseGraphType) || null;
-  }
-};
-exports.VersionedGraphService = __decorateClass([
-  common.Injectable()
-], exports.VersionedGraphService);
+// src/graph/versioning/index.ts
+init_versioned_graph_service();
 var logger = new common.Logger("ApiCallTracer");
 var DEFAULT_TRACER_OPTIONS = {
   maxStringLength: 5e3,
@@ -4061,8 +4405,36 @@ function sanitizeTraceError(error, options) {
     raw: sanitizeTraceData(error, 0, /* @__PURE__ */ new WeakSet(), options)
   };
 }
-
-// src/engines/langgraph/event-processor.utils.ts
+var GraphEngineType = /* @__PURE__ */ ((GraphEngineType2) => {
+  GraphEngineType2["LANGGRAPH"] = "langgraph";
+  GraphEngineType2["LANGFLOW"] = "langflow";
+  GraphEngineType2["FLOWISE"] = "flowise";
+  return GraphEngineType2;
+})(GraphEngineType || {});
+exports.GraphEngineFactory = class GraphEngineFactory {
+  constructor(langgraph) {
+    this.langgraph = langgraph;
+  }
+  /**
+   * Get engine for the specified type
+   */
+  getEngine(engineType) {
+    switch (engineType) {
+      case "langgraph" /* LANGGRAPH */:
+        return this.langgraph;
+      // Will add other types in the future
+      // case GraphEngineType.LANGFLOW:
+      //   return new LangFlowEngine();
+      // case GraphEngineType.FLOWISE:
+      //   return new FlowiseEngine();
+      default:
+        throw new Error(`Unsupported graph engine type: ${engineType}`);
+    }
+  }
+};
+exports.GraphEngineFactory = __decorateClass([
+  common.Injectable()
+], exports.GraphEngineFactory);
 exports.EventProcessor = class EventProcessor {
   logger = new common.Logger(exports.EventProcessor.name);
   /**
@@ -4076,7 +4448,9 @@ exports.EventProcessor = class EventProcessor {
       llmCalls: [],
       traceEvents: [],
       traceStartedAt: null,
-      traceCompletedAt: null
+      traceCompletedAt: null,
+      currentReasoningSteps: [],
+      currentToolUse: null
     };
   }
   /**
@@ -4104,6 +4478,51 @@ exports.EventProcessor = class EventProcessor {
     }
     return [];
   }
+  /**
+   * Groups tool_use and input_json_delta into proper structure
+   * tool_use.input → output (tool execution result)
+   * input_json_delta.input → output (tool execution result, accumulated)
+   */
+  mapReasoningSteps(rawSteps) {
+    const steps = [];
+    let currentToolUse = null;
+    for (const raw of rawSteps) {
+      if (raw.type === "tool_use" || raw.type === "tool_call") {
+        if (currentToolUse) {
+          steps.push(currentToolUse);
+        }
+        currentToolUse = {
+          index: raw.index || 0,
+          type: "tool_use",
+          name: raw.name,
+          id: raw.id,
+          input: "",
+          // Parameters (IN) - filled separately or empty
+          output: raw.input || ""
+          // Result (OUT) - comes in tool_use.input
+        };
+      } else if (raw.type === "input_json_delta") {
+        if (currentToolUse) {
+          currentToolUse.output = (currentToolUse.output || "") + (raw.input || "");
+        }
+      } else {
+        if (currentToolUse) {
+          steps.push(currentToolUse);
+          currentToolUse = null;
+        }
+        steps.push({
+          index: raw.index || 0,
+          type: raw.type,
+          text: raw.text || "",
+          metadata: raw.metadata
+        });
+      }
+    }
+    if (currentToolUse) {
+      steps.push(currentToolUse);
+    }
+    return steps;
+  }
   /**
    * Process a LangGraph stream event
    * Mutates accumulator to collect data from different channels
@@ -4126,8 +4545,44 @@ exports.EventProcessor = class EventProcessor {
     if (event.event === "on_chat_model_stream" && event.metadata?.stream_channel === "processing" /* PROCESSING */ && event.data?.chunk?.content) {
       const chunk = event.data.chunk.content;
       const blocks = this.normalizeContentBlocks(chunk);
-      if (blocks.length > 0 && onPartial) {
-        onPartial(JSON.stringify({ processing: blocks }));
+      for (const block of blocks) {
+        if (block.type === "tool_use" || block.type === "tool_call") {
+          if (acc.currentToolUse) {
+            acc.currentReasoningSteps.push(acc.currentToolUse);
+          }
+          acc.currentToolUse = {
+            index: acc.currentReasoningSteps.length,
+            type: "tool_use",
+            name: block.name,
+            id: block.id,
+            input: block.input || "",
+            output: ""
+          };
+          if (onPartial) {
+            onPartial(
+              JSON.stringify({
+                processing_delta: {
+                  type: "step_started",
+                  step: acc.currentToolUse
+                }
+              })
+            );
+          }
+        } else if (block.type === "input_json_delta") {
+          if (acc.currentToolUse && onPartial) {
+            const chunk2 = block.input || "";
+            acc.currentToolUse.output += chunk2;
+            onPartial(
+              JSON.stringify({
+                processing_delta: {
+                  type: "output_chunk",
+                  stepId: acc.currentToolUse.id,
+                  chunk: chunk2
+                }
+              })
+            );
+          }
+        }
       }
       return;
     }
@@ -4164,29 +4619,59 @@ exports.EventProcessor = class EventProcessor {
         );
       }
       if (event.metadata?.stream_channel === "processing" /* PROCESSING */) {
-        const stepsRaw = output?.content || // AIMessageChunk object (direct)
-        output?.kwargs?.content || // Serialized LangChain format
-        event.data?.chunk?.content || // Older version
-        [];
-        let steps;
-        if (Array.isArray(stepsRaw)) {
-          steps = stepsRaw;
-        } else if (typeof stepsRaw === "string" && stepsRaw.trim().length > 0) {
-          steps = [
-            {
-              index: 0,
-              type: "text",
-              text: stepsRaw.trim()
-            }
-          ];
-        } else {
-          steps = [];
+        if (acc.currentToolUse) {
+          acc.currentReasoningSteps.push(acc.currentToolUse);
+          acc.currentToolUse = null;
         }
-        if (steps.length > 0) {
+        if (acc.currentReasoningSteps.length > 0) {
           acc.reasoningChains.push({
-            steps,
+            steps: acc.currentReasoningSteps,
             isComplete: true
           });
+          if (onPartial) {
+            onPartial(
+              JSON.stringify({
+                processing_delta: {
+                  type: "chain_completed"
+                }
+              })
+            );
+          }
+          acc.currentReasoningSteps = [];
+        } else {
+          const stepsRaw = output?.content || // AIMessageChunk object (direct)
+          output?.kwargs?.content || // Serialized LangChain format
+          event.data?.chunk?.content || // Older version
+          [];
+          let steps;
+          if (Array.isArray(stepsRaw)) {
+            steps = this.mapReasoningSteps(stepsRaw);
+          } else if (typeof stepsRaw === "string" && stepsRaw.trim().length > 0) {
+            steps = [
+              {
+                index: 0,
+                type: "text",
+                text: stepsRaw.trim()
+              }
+            ];
+          } else {
+            steps = [];
+          }
+          if (steps.length > 0) {
+            acc.reasoningChains.push({
+              steps,
+              isComplete: true
+            });
+            if (onPartial) {
+              onPartial(
+                JSON.stringify({
+                  processing_delta: {
+                    type: "chain_completed"
+                  }
+                })
+              );
+            }
+          }
         }
       }
       return;
@@ -4595,12 +5080,11 @@ exports.LangGraphEngine = class LangGraphEngine {
   }
 };
 exports.LangGraphEngine = __decorateClass([
-  common.Injectable(),
-  __decorateParam(0, common.Inject())
+  common.Injectable()
 ], exports.LangGraphEngine);
 
 // src/core/universal-graph.module.ts
-init_ui_dispatch_controller();
+init_builder_registry_service();
 init_agent_ui();
 function createMetaBuilder(config, versionedGraphService, moduleRef, callbackRegistry, endpointRegistry) {
   const className = `${config.baseGraphType.replace(/\./g, "")}VersionRouter`;
@@ -4669,6 +5153,8 @@ function createMetaBuilder(config, versionedGraphService, moduleRef, callbackReg
 exports.UniversalGraphModule = class UniversalGraphModule {
   static forRoot(options) {
     const providers = [
+      // Discovery services from @nestjs/core
+      core.MetadataScanner,
       // Event processor for stream handling
       exports.EventProcessor,
       // Graph engines
@@ -4698,14 +5184,8 @@ exports.UniversalGraphModule = class UniversalGraphModule {
         provide: CallbackRegistry,
         useClass: CallbackRegistry
       },
-      {
-        provide: exports.EndpointRegistry,
-        useClass: exports.EndpointRegistry
-      },
-      {
-        provide: exports.UIEndpointsDiscoveryService,
-        useClass: exports.UIEndpointsDiscoveryService
-      },
+      exports.EndpointRegistry,
+      exports.UIEndpointsDiscoveryService,
       {
         provide: exports.CallbackACL,
         useClass: exports.CallbackACL
@@ -4782,14 +5262,6 @@ exports.UniversalGraphModule = class UniversalGraphModule {
         },
         inject: [CallbackRegistry]
       },
-      {
-        provide: "UI_ENDPOINTS_DISCOVERY",
-        useFactory: async (discoveryService) => {
-          await discoveryService.discoverUIEndpoints();
-          return true;
-        },
-        inject: [exports.UIEndpointsDiscoveryService]
-      },
       {
         provide: "GRAPH_ENGINE",
         useFactory: (factory) => {
@@ -5209,6 +5681,94 @@ var McpToolFilter = class _McpToolFilter {
     }
   }
 };
+exports.McpRuntimeHttpClient = class McpRuntimeHttpClient {
+  logger = new common.Logger(exports.McpRuntimeHttpClient.name);
+  httpClient;
+  baseUrl;
+  constructor(mcpRuntimeUrl) {
+    this.baseUrl = mcpRuntimeUrl || process.env.MCP_RUNTIME_URL || "http://localhost:3004";
+    this.httpClient = axios2__default.default.create({
+      baseURL: this.baseUrl,
+      timeout: 3e4
+      // 30 seconds
+    });
+    this.logger.log(
+      `MCP Runtime HTTP Client initialized with URL: ${this.baseUrl}`
+    );
+  }
+  /**
+   * Get all available tools from MCP Runtime
+   */
+  async getTools() {
+    try {
+      this.logger.debug("Fetching available tools from MCP runtime");
+      const response = await this.httpClient.get("/tools/list");
+      const tools = Array.isArray(response.data) ? response.data : [];
+      this.logger.log(`Retrieved ${tools.length} tools from MCP runtime`);
+      return tools;
+    } catch (error) {
+      this.logger.error("Failed to fetch tools from MCP runtime:", error);
+      throw new Error(`Failed to fetch tools: ${error.message}`);
+    }
+  }
+  /**
+   * Execute a tool by name with given arguments
+   */
+  async executeTool(name, args, context) {
+    try {
+      this.logger.debug(`Executing tool: ${name} with args:`, args);
+      const payload = {
+        name,
+        arguments: args || {}
+      };
+      if (context) {
+        payload.context = context;
+      }
+      const response = await this.httpClient.post("/tools/execute", payload);
+      this.logger.log(`Tool ${name} executed successfully`);
+      return response.data;
+    } catch (error) {
+      this.logger.error(`Failed to execute tool ${name}:`, error);
+      if (error.response) {
+        return {
+          success: false,
+          error: error.response.data.message || error.response.data.error || "Tool execution failed"
+        };
+      }
+      return {
+        success: false,
+        error: error.message || "Unknown error occurred"
+      };
+    }
+  }
+  /**
+   * Get tool execution statistics from MCP Runtime
+   */
+  async getToolStats() {
+    try {
+      const response = await this.httpClient.get("/tools/stats");
+      return response.data;
+    } catch (error) {
+      this.logger.error("Failed to fetch tool stats:", error);
+      return null;
+    }
+  }
+  /**
+   * Health check for MCP Runtime service
+   */
+  async isHealthy() {
+    try {
+      const response = await this.httpClient.get("/", { timeout: 5e3 });
+      return response.status === 200;
+    } catch (error) {
+      this.logger.warn("MCP Runtime health check failed:", error.message);
+      return false;
+    }
+  }
+};
+exports.McpRuntimeHttpClient = __decorateClass([
+  common.Injectable()
+], exports.McpRuntimeHttpClient);
 
 // src/models/enums.ts
 var ModelProvider = /* @__PURE__ */ ((ModelProvider2) => {
@@ -6370,6 +6930,28 @@ exports.RetrieverService = __decorateClass([
   common.Injectable()
 ], exports.RetrieverService);
 
+// src/utils/index.ts
+init_graph_type_utils();
+
+// src/service-discovery/index.ts
+init_file_based_discovery();
+exports.StaticDiscovery = class StaticDiscovery {
+  constructor(services) {
+    this.services = services;
+  }
+  /**
+   * Get list of services by category
+   */
+  async getServices(category) {
+    return this.services.filter(
+      (service) => service.category === category || service.metadata?.category === category
+    );
+  }
+};
+exports.StaticDiscovery = __decorateClass([
+  common.Injectable()
+], exports.StaticDiscovery);
+
 exports.AbstractGraphBuilder = AbstractGraphBuilder;
 exports.AttachmentType = AttachmentType;
 exports.BaseGraphServiceController = exports.GraphController;
@@ -6385,7 +6967,6 @@ exports.GraphEngineType = GraphEngineType;
 exports.GraphManifestSchema = GraphManifestSchema;
 exports.GraphManifestValidator = GraphManifestValidator;
 exports.GraphServiceTokens = GraphServiceTokens;
-exports.GraphTypeUtils = GraphTypeUtils;
 exports.IdempotencyStatus = IdempotencyStatus;
 exports.McpConverter = McpConverter;
 exports.McpToolFilter = McpToolFilter;