@defai.digital/automatosx 12.0.1 → 12.1.1

package/dist/mcp/index.js

@@ -26,12 +26,6 @@ import { gzipSync, gunzipSync } from 'zlib';
 
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
@@ -4122,8 +4116,12 @@ function isSDKModeAvailable() {
   const hasAPIKey = !!process.env.OPENAI_API_KEY;
   let hasSDK = false;
   try {
-    __require.resolve("openai");
-    hasSDK = true;
+    if (typeof import.meta.resolve === "function") {
+      import.meta.resolve("openai");
+      hasSDK = true;
+    } else {
+      hasSDK = true;
+    }
   } catch {
     hasSDK = false;
   }
@@ -4164,6 +4162,8 @@ function getVersion() {
     const possiblePaths = [
       join(__dirname$1, "../../../package.json"),
       // From src/shared/helpers
+      join(__dirname$1, "../../package.json"),
+      // From dist/mcp (bundled MCP entry)
       join(__dirname$1, "../package.json")
       // From dist
     ];
@@ -5156,58 +5156,6 @@ var PRECOMPILED_CONFIG = {
         "window": "daily",
         "resetHourUtc": 0
       }
-    },
-    "glm": {
-      "enabled": true,
-      "priority": 4,
-      "timeout": 12e4,
-      "command": "ax-glm",
-      "model": "glm-4",
-      "healthCheck": {
-        "enabled": true,
-        "interval": 3e5,
-        "timeout": 5e3
-      },
-      "circuitBreaker": {
-        "enabled": true,
-        "failureThreshold": 3,
-        "recoveryTimeout": 6e4
-      },
-      "processManagement": {
-        "gracefulShutdownTimeout": 5e3,
-        "forceKillDelay": 1e3
-      },
-      "versionDetection": {
-        "timeout": 5e3,
-        "forceKillDelay": 1e3,
-        "cacheEnabled": true
-      }
-    },
-    "grok": {
-      "enabled": true,
-      "priority": 5,
-      "timeout": 12e4,
-      "command": "ax-grok",
-      "model": "grok-3",
-      "healthCheck": {
-        "enabled": true,
-        "interval": 3e5,
-        "timeout": 5e3
-      },
-      "circuitBreaker": {
-        "enabled": true,
-        "failureThreshold": 3,
-        "recoveryTimeout": 6e4
-      },
-      "processManagement": {
-        "gracefulShutdownTimeout": 5e3,
-        "forceKillDelay": 1e3
-      },
-      "versionDetection": {
-        "timeout": 5e3,
-        "forceKillDelay": 1e3,
-        "cacheEnabled": true
-      }
     }
   },
   "execution": {
@@ -5419,15 +5367,7 @@ var PRECOMPILED_CONFIG = {
     "enableFreeTierPrioritization": true,
     "enableWorkloadAwareRouting": true
   },
-  "featureFlags": {
-    "sdkFirstMode": false,
-    "mcpBidirectional": false,
-    "autoInjectMCPConfig": false,
-    "sdkFallbackEnabled": true,
-    "deprecationWarnings": true,
-    "providerMetrics": true
-  },
-  "version": "12.0.1"
+  "version": "12.1.1"
 };
 
 // src/core/config/schemas.ts
@@ -18164,6 +18104,126 @@ Task: ${task}`;
   };
 }
 
+// src/mcp/tools/get-capabilities.ts
+init_esm_shims();
+init_logger();
+function categorizeTools(name) {
+  if (name.startsWith("memory_") || name === "search_memory") return "memory";
+  if (name.startsWith("session_")) return "session";
+  if (name.startsWith("create_task") || name.startsWith("run_task") || name.startsWith("get_task") || name.startsWith("list_task") || name.startsWith("delete_task")) return "task";
+  if (name === "get_capabilities" || name === "list_agents" || name === "get_status" || name === "get_agent_context") return "discovery";
+  if (name.includes("context")) return "context";
+  return "execution";
+}
+function getExecutionMode(providerName, providerConfig) {
+  if (providerName === "glm" || providerName === "grok") {
+    return "sdk";
+  }
+  if (providerName === "claude-code" || providerName === "gemini-cli") {
+    return "cli";
+  }
+  if (providerName === "openai") {
+    return "hybrid";
+  }
+  return "cli";
+}
+function getProviderType(providerName) {
+  if (providerName === "glm" || providerName === "grok") return "sdk";
+  if (providerName === "openai") return "hybrid";
+  return "cli";
+}
+function createGetCapabilitiesHandler(deps) {
+  return async () => {
+    logger.info("[MCP] get_capabilities called");
+    try {
+      const projectDir = process.cwd();
+      const config = await loadConfig(projectDir);
+      const version = getVersion();
+      const providers = [];
+      const providerConfigs = config.providers || {};
+      for (const [name, providerConfig] of Object.entries(providerConfigs)) {
+        const cfg = providerConfig;
+        const enabled = cfg.enabled === true;
+        let available = false;
+        try {
+          const availableProviders = await deps.router.getAvailableProviders();
+          available = availableProviders.some((p) => p.name === name);
+        } catch {
+          available = enabled;
+        }
+        providers.push({
+          name,
+          enabled,
+          available,
+          type: getProviderType(name),
+          executionMode: getExecutionMode(name, cfg),
+          priority: cfg.priority || 0,
+          model: cfg.model
+        });
+      }
+      providers.sort((a, b) => b.priority - a.priority);
+      const agentNames = await deps.profileLoader.listProfiles();
+      const agents = [];
+      for (const agentName of agentNames) {
+        try {
+          const profile = await deps.profileLoader.loadProfile(agentName);
+          agents.push({
+            name: profile.name,
+            displayName: profile.displayName,
+            role: profile.role,
+            description: profile.systemPrompt?.substring(0, 200),
+            team: profile.team,
+            abilities: profile.abilities || []
+          });
+        } catch (error) {
+          logger.warn(`Failed to load profile for ${agentName}`, { error });
+        }
+      }
+      const tools = deps.toolSchemas.map((schema) => ({
+        name: schema.name,
+        description: schema.description,
+        category: categorizeTools(schema.name)
+      }));
+      const memoryStats = await deps.memoryManager.getStats();
+      const activeSessions = await deps.sessionManager.getActiveSessions();
+      const result = {
+        version,
+        providers,
+        agents,
+        tools,
+        memory: {
+          enabled: true,
+          entryCount: memoryStats.totalEntries,
+          maxEntries: config.memory?.maxEntries || 1e4
+        },
+        sessions: {
+          enabled: true,
+          activeCount: activeSessions.length,
+          maxSessions: config.orchestration?.session?.maxSessions || 100
+        },
+        features: {
+          smartRouting: true,
+          // Always enabled in v13.0.0
+          memorySearch: true,
+          multiAgentSessions: true,
+          streamingNotifications: false
+          // Configured via MCP server options
+        }
+      };
+      logger.info("[MCP] get_capabilities completed", {
+        version,
+        providersCount: providers.length,
+        agentsCount: agents.length,
+        toolsCount: tools.length
+      });
+      return result;
+    } catch (error) {
+      logger.error("[MCP] get_capabilities failed", { error });
+      throw new Error(`Capabilities check failed: ${error.message}`);
+    }
+  };
+}
+
 // src/mcp/tools/task/index.ts
 init_esm_shims();
 
@@ -20823,27 +20883,33 @@ var McpClientPool = class extends EventEmitter {
   }
   startHealthChecks() {
     this.healthCheckTimer = setInterval(async () => {
-      for (const [provider, pool] of this.pools) {
-        const toRemove = [];
-        for (const pooledClient of pool.clients) {
-          if (!pooledClient.inUse && pooledClient.client.isConnected()) {
-            const healthy = await pooledClient.client.healthCheck();
-            if (!healthy) {
-              toRemove.push(pooledClient);
+      try {
+        for (const [provider, pool] of this.pools) {
+          const toRemove = [];
+          for (const pooledClient of pool.clients) {
+            if (!pooledClient.inUse && pooledClient.client.isConnected()) {
+              const healthy = await pooledClient.client.healthCheck();
+              if (!healthy) {
+                toRemove.push(pooledClient);
+              }
             }
           }
-        }
-        for (const pooledClient of toRemove) {
-          if (pooledClient.inUse) {
-            logger.debug("[MCP Pool] Skipping unhealthy client removal - now in use", { provider });
-            continue;
+          for (const pooledClient of toRemove) {
+            if (pooledClient.inUse) {
+              logger.debug("[MCP Pool] Skipping unhealthy client removal - now in use", { provider });
+              continue;
+            }
+            this.emitEvent("health_check_failed", provider);
+            logger.warn("[MCP Pool] Health check failed, removing connection", { provider });
+            await pooledClient.client.disconnect();
+            this.removeFromPool(pool, pooledClient);
+            this.emitEvent("connection_closed", provider, { reason: "health_check_failed" });
           }
-          this.emitEvent("health_check_failed", provider);
-          logger.warn("[MCP Pool] Health check failed, removing connection", { provider });
-          await pooledClient.client.disconnect();
-          this.removeFromPool(pool, pooledClient);
-          this.emitEvent("connection_closed", provider, { reason: "health_check_failed" });
         }
+      } catch (error) {
+        logger.error("[MCP Pool] Unexpected error in health check interval", {
+          error: error.message
+        });
       }
     }, this.config.healthCheckIntervalMs);
   }
@@ -22179,6 +22245,22 @@ var McpServer = class _McpServer {
         description: "Get AutomatosX system status and configuration",
         inputSchema: { type: "object", properties: {} }
       },
+      // v13.0.0: Enhanced Service Discovery
+      {
+        name: "get_capabilities",
+        description: `Get comprehensive AutomatosX capabilities for service discovery.
+
+Returns:
+- providers: All AI providers with execution modes (cli/sdk/hybrid)
+- agents: All available agent profiles with roles and abilities
+- tools: All MCP tools organized by category
+- memory: Memory system status (entries, limits)
+- sessions: Session management status
+- features: Enabled features (smart routing, streaming, etc.)
+
+Use this tool first to understand what AutomatosX offers.`,
+        inputSchema: { type: "object", properties: {} }
+      },
       {
         name: "session_create",
         description: "Create a new multi-agent session",
@@ -22448,6 +22530,13 @@ var McpServer = class _McpServer {
       profileLoader: this.profileLoader,
       memoryManager: this.memoryManager
     }));
+    register("get_capabilities", createGetCapabilitiesHandler({
+      memoryManager: this.memoryManager,
+      sessionManager: this.sessionManager,
+      router: this.router,
+      profileLoader: this.profileLoader,
+      toolSchemas: staticSchemas
+    }));
     register("create_task", createCreateTaskHandler({
       getSession: () => this.session
     }));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@defai.digital/automatosx",
-  "version": "12.0.1",
+  "version": "12.1.1",
   "description": "Provider-agnostic AI orchestration platform with 20+ specialized agents, persistent memory, and multi-provider routing for Claude Code, Gemini CLI, Codex CLI, GLM, and Grok",
   "type": "module",
   "publishConfig": {
@@ -157,6 +157,11 @@
     "@ax-cli/schemas": "zod@^3.23.8",
     "@modelcontextprotocol/sdk": "^1.24.0"
   },
+  "pnpm": {
+    "overrides": {
+      "tmp": "^0.2.4"
+    }
+  },
   "config": {
     "commitizen": {
       "path": "cz-conventional-changelog"