@defai.digital/automatosx 11.4.0 → 12.1.0

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;
 };
@@ -40,7 +34,7 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 var init_esm_shims = __esm({
-  "node_modules/tsup/assets/esm_shims.js"() {
+  "node_modules/.pnpm/tsup@8.5.1_jiti@2.6.1_postcss@8.5.6_tsx@4.20.6_typescript@5.9.3_yaml@2.8.2/node_modules/tsup/assets/esm_shims.js"() {
   }
 });
 function sanitizeObject(obj, maxDepth = 5, currentDepth = 0) {
@@ -2013,7 +2007,7 @@ function isRateLimitError(error, providerName) {
 function isLimitError(error, providerName) {
   return isQuotaError(error, providerName) || isRateLimitError(error, providerName);
 }
-var GEMINI_PATTERNS, CLAUDE_PATTERNS, OPENAI_PATTERNS, AX_CLI_PATTERNS, PROVIDER_ERROR_PATTERNS, GENERIC_ERROR_PATTERNS;
+var GEMINI_PATTERNS, CLAUDE_PATTERNS, OPENAI_PATTERNS, PROVIDER_ERROR_PATTERNS, GENERIC_ERROR_PATTERNS;
 var init_error_patterns = __esm({
   "src/providers/error-patterns.ts"() {
     init_esm_shims();
@@ -2097,64 +2091,27 @@ var init_error_patterns = __esm({
         "billing_hard_limit_reached"
       ]
     };
-    AX_CLI_PATTERNS = {
-      quota: [
-        // GLM patterns
-        "quota exceeded",
-        "quota limit reached",
-        "insufficient quota",
-        // OpenAI patterns (via ax-cli)
-        "insufficient_quota",
-        "quota_exceeded",
-        "billing hard limit reached",
-        "usage limit exceeded",
-        "monthly quota exceeded",
-        "credit limit reached",
-        // Generic patterns
-        "daily quota exceeded",
-        "api quota exceeded"
-      ],
-      rateLimit: [
-        // Common patterns
-        "rate_limit_exceeded",
-        "rate limit exceeded",
-        "too_many_requests",
-        "too many requests",
-        "requests per minute exceeded",
-        "tokens per minute exceeded",
-        "rate limit reached",
-        // Anthropic patterns (via ax-cli)
-        "rate_limit_error",
-        "overloaded_error",
-        "overloaded",
-        // xAI/Grok patterns
-        "throttled",
-        "request throttled"
-      ],
-      statusCodes: [429, 529],
-      errorCodes: [
-        "insufficient_quota",
-        "rate_limit_exceeded",
-        "quota_exceeded",
-        "rate_limit_error",
-        "overloaded_error",
-        "RATE_LIMIT_EXCEEDED",
-        "QUOTA_EXCEEDED"
-      ]
-    };
     PROVIDER_ERROR_PATTERNS = {
       // Primary providers
       gemini: GEMINI_PATTERNS,
       claude: CLAUDE_PATTERNS,
       codex: OPENAI_PATTERNS,
-      "ax-cli": AX_CLI_PATTERNS,
+      // v12.0.0: Removed ax-cli (deprecated)
+      glm: OPENAI_PATTERNS,
+      // v12.0.0: GLM uses OpenAI-compatible API
+      grok: OPENAI_PATTERNS,
+      // v12.0.0: Grok uses OpenAI-compatible API
       // Aliases - reference same patterns to avoid duplication
       "gemini-cli": GEMINI_PATTERNS,
       // Alias for gemini
       "claude-code": CLAUDE_PATTERNS,
       // Alias for claude
-      "openai": OPENAI_PATTERNS
+      "openai": OPENAI_PATTERNS,
       // Alias for codex (same underlying API)
+      "ax-glm": OPENAI_PATTERNS,
+      // v12.0.0: Alias for glm
+      "ax-grok": OPENAI_PATTERNS
+      // v12.0.0: Alias for grok
     };
     GENERIC_ERROR_PATTERNS = {
       quota: [
@@ -2195,10 +2152,11 @@ function getRetryableErrors(provider) {
       return [...baseErrors, ...GEMINI_RETRYABLE_ERRORS];
     case "openai":
       return [...baseErrors, ...OPENAI_RETRYABLE_ERRORS];
-    case "ax-cli":
-      return [...baseErrors, ...AX_CLI_RETRYABLE_ERRORS];
     case "codex":
       return [...baseErrors, ...CODEX_RETRYABLE_ERRORS];
+    case "glm":
+    case "grok":
+      return [...baseErrors, ...OPENAI_RETRYABLE_ERRORS];
     case "base":
     default:
       return baseErrors;
@@ -2212,7 +2170,7 @@ function shouldRetryError(error, provider) {
   const retryableErrors = getRetryableErrors(provider);
   return containsErrorPattern(message, retryableErrors);
 }
-var COMMON_NETWORK_ERRORS, COMMON_RATE_LIMIT_ERRORS, COMMON_SERVER_ERRORS, CLAUDE_RETRYABLE_ERRORS, GEMINI_RETRYABLE_ERRORS, OPENAI_RETRYABLE_ERRORS, AX_CLI_RETRYABLE_ERRORS, CODEX_RETRYABLE_ERRORS, NON_RETRYABLE_ERRORS;
+var COMMON_NETWORK_ERRORS, COMMON_RATE_LIMIT_ERRORS, COMMON_SERVER_ERRORS, CLAUDE_RETRYABLE_ERRORS, GEMINI_RETRYABLE_ERRORS, OPENAI_RETRYABLE_ERRORS, CODEX_RETRYABLE_ERRORS, NON_RETRYABLE_ERRORS;
 var init_retry_errors = __esm({
   "src/providers/retry-errors.ts"() {
     init_esm_shims();
@@ -2248,17 +2206,6 @@ var init_retry_errors = __esm({
     OPENAI_RETRYABLE_ERRORS = [
       "internal_error"
     ];
-    AX_CLI_RETRYABLE_ERRORS = [
-      // Inherited from Anthropic (via ax-cli)
-      "overloaded_error",
-      // Inherited from OpenAI (via ax-cli)
-      "internal_error",
-      // ax-cli specific
-      "agent_error",
-      "tool_execution_error",
-      // xAI/Grok specific
-      "service_overloaded"
-    ];
     CODEX_RETRYABLE_ERRORS = [
       ...OPENAI_RETRYABLE_ERRORS,
       "sandbox_error"
@@ -2291,8 +2238,7 @@ var init_base_provider = __esm({
       /**
        * Whitelist of allowed provider names for security
        * v8.3.0: Support both old (claude-code, gemini-cli) and new (claude, gemini) names for backward compatibility
-       * v9.2.0: Added 'ax-cli' (multi-model provider: GLM, xAI, OpenAI, Anthropic, Ollama)
-       * v9.2.0: 'glm' is deprecated, use 'ax-cli' instead (kept for backward compatibility)
+       * v12.0.0: Removed ax-cli (deprecated), added native 'glm' and 'grok' providers
        */
       static ALLOWED_PROVIDER_NAMES = [
         "claude",
@@ -2303,10 +2249,14 @@ var init_base_provider = __esm({
         // Backward compatibility - maps to gemini CLI
         "openai",
         "codex",
-        "ax-cli",
-        // v9.2.0: Multi-model provider via ax-cli (GLM, xAI, OpenAI, Anthropic, Ollama, DeepSeek, Llama)
         "glm",
-        // v9.2.0: DEPRECATED - use 'ax-cli' instead (kept for backward compatibility)
+        // v12.0.0: Native GLM provider (Zhipu AI)
+        "ax-glm",
+        // v12.0.0: Alias for glm
+        "grok",
+        // v12.0.0: Native Grok provider (xAI)
+        "ax-grok",
+        // v12.0.0: Alias for grok
         "test-provider"
         // For unit tests
       ];
@@ -3042,8 +2992,10 @@ ${fullPrompt}
           retryableProvider = "openai";
         } else if (providerName === "codex") {
           retryableProvider = "codex";
-        } else if (providerName === "ax-cli" || providerName === "glm") {
-          retryableProvider = "ax-cli";
+        } else if (providerName === "glm" || providerName === "ax-glm") {
+          retryableProvider = "glm";
+        } else if (providerName === "grok" || providerName === "ax-grok") {
+          retryableProvider = "grok";
         }
         return shouldRetryError(error, retryableProvider);
       }
@@ -4036,6 +3988,9 @@ var init_openai_provider = __esm({
         }
         const startTime = Date.now();
         await this.ensureInitialized();
+        if (this.isDestroyed || !this.hybridAdapter) {
+          throw new Error("OpenAIProvider has been destroyed or not properly initialized");
+        }
         try {
           const result = await this.hybridAdapter.execute(
             request.prompt,
@@ -4161,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;
   }
@@ -4203,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
     ];
@@ -5195,6 +5156,58 @@ 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": {
@@ -5406,7 +5419,15 @@ var PRECOMPILED_CONFIG = {
     "enableFreeTierPrioritization": true,
     "enableWorkloadAwareRouting": true
   },
-  "version": "11.3.3"
+  "featureFlags": {
+    "sdkFirstMode": false,
+    "mcpBidirectional": false,
+    "autoInjectMCPConfig": false,
+    "sdkFallbackEnabled": true,
+    "deprecationWarnings": true,
+    "providerMetrics": true
+  },
+  "version": "12.1.0"
 };
 
 // src/core/config/schemas.ts
@@ -5418,10 +5439,14 @@ z.enum([
   "gemini-cli",
   "openai",
   "codex",
-  "ax-cli",
-  // v9.2.0: Multi-model provider (GLM, xAI, OpenAI, Anthropic, Ollama, DeepSeek, Llama)
   "glm",
-  // v9.2.0: DEPRECATED - use 'ax-cli' instead
+  // v12.0.0: Native GLM provider (Zhipu AI)
+  "ax-glm",
+  // v12.0.0: Alias for glm
+  "grok",
+  // v12.0.0: Native Grok provider (xAI)
+  "ax-grok",
+  // v12.0.0: Alias for grok
   "test-provider"
 ]).describe("Provider name (whitelisted for security)");
 var commandSchema = z.string().min(1, "command is required").max(VALIDATION_LIMITS.MAX_COMMAND_LENGTH).regex(
@@ -7195,8 +7220,8 @@ var ProviderMetricsTracker = class extends EventEmitter {
         p50,
         p95,
         p99,
-        min: latencies[0],
-        max: latencies[latencies.length - 1]
+        min: latencies.length > 0 ? latencies[0] : 0,
+        max: latencies.length > 0 ? latencies[latencies.length - 1] : 0
       },
       quality: {
         totalRequests: records.length,
@@ -17116,20 +17141,25 @@ var PROVIDER_MAP = {
   mcpToActual: {
     "claude": "claude-code",
     "gemini": "gemini-cli",
-    "openai": "openai"
+    "openai": "openai",
+    "glm": "glm",
+    "grok": "grok"
   },
   // Actual name → MCP name
   actualToMcp: {
     "claude-code": "claude",
     "gemini-cli": "gemini",
-    "openai": "openai"
+    "openai": "openai",
+    "glm": "glm",
+    "grok": "grok"
   },
   // Normalized caller → Actual name (for Smart Routing)
   normalizedToActual: {
     "claude": "claude-code",
     "gemini": "gemini-cli",
     "codex": "openai",
-    "ax-cli": "ax-cli"
+    "glm": "glm",
+    "grok": "grok"
   }
 };
 function mapMcpProviderToActual(mcpProvider) {
@@ -18134,6 +18164,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();
 
@@ -18173,7 +18323,8 @@ var TaskEngineSchema = z.enum([
   "gemini",
   "claude",
   "codex",
-  "ax-cli"
+  "glm",
+  "grok"
 ]);
 var TaskStatusSchema = z.enum([
   "pending",
@@ -18186,7 +18337,8 @@ var OriginClientSchema = z.enum([
   "claude-code",
   "gemini-cli",
   "codex-cli",
-  "ax-cli",
+  "glm",
+  "grok",
   "unknown"
 ]);
 var CreateTaskInputSchema = z.object({
@@ -18210,7 +18362,7 @@ var TaskFilterSchema = z.object({
   offset: z.number().int().min(0).default(0)
 });
 z.object({
-  engineOverride: z.enum(["gemini", "claude", "codex", "ax-cli"]).optional(),
+  engineOverride: z.enum(["gemini", "claude", "codex", "glm", "grok"]).optional(),
   timeoutMs: z.number().int().min(5e3).max(3e5).optional(),
   skipCache: z.boolean().default(false)
 });
@@ -18240,10 +18392,13 @@ var CLIENT_NORMALIZATION_MAP = {
   "codex-cli": "codex-cli",
   "openai": "codex-cli",
   "gpt": "codex-cli",
-  // ax-cli variants
-  "ax": "ax-cli",
-  "ax-cli": "ax-cli",
-  "axcli": "ax-cli"
+  // v12.0.0: GLM and Grok (replacing ax-cli)
+  "glm": "glm",
+  "zhipu": "glm",
+  "ax-glm": "glm",
+  "grok": "grok",
+  "xai": "grok",
+  "ax-grok": "grok"
 };
 var LoopGuard = class {
   config;
@@ -18496,7 +18651,7 @@ var SQL = {
       id TEXT PRIMARY KEY,
       type TEXT NOT NULL CHECK (type IN ('web_search', 'code_review', 'code_generation', 'analysis', 'custom')),
       status TEXT NOT NULL DEFAULT 'pending' CHECK (status IN ('pending', 'running', 'completed', 'failed', 'expired')),
-      engine TEXT CHECK (engine IN ('gemini', 'claude', 'codex', 'ax-cli', NULL)),
+      engine TEXT CHECK (engine IN ('gemini', 'claude', 'codex', 'glm', 'grok', NULL)),
       priority INTEGER NOT NULL DEFAULT 5 CHECK (priority BETWEEN 1 AND 10),
 
       payload_compressed BLOB NOT NULL,
@@ -19693,7 +19848,8 @@ function mapNormalizedProviderToOriginClient(provider) {
     "claude": "claude-code",
     "gemini": "gemini-cli",
     "codex": "codex-cli",
-    "ax-cli": "ax-cli",
+    "glm": "glm",
+    "grok": "grok",
     "unknown": "unknown"
   };
   return mapping[provider] ?? "unknown";
@@ -19715,7 +19871,7 @@ var createTaskSchema = {
       },
       engine: {
         type: "string",
-        enum: ["auto", "gemini", "claude", "codex", "ax-cli"],
+        enum: ["auto", "gemini", "claude", "codex", "glm", "grok"],
         default: "auto",
         description: "Target engine (auto = router decides)"
       },
@@ -19806,7 +19962,7 @@ var runTaskSchema = {
       },
       engine_override: {
         type: "string",
-        enum: ["gemini", "claude", "codex", "ax-cli"],
+        enum: ["gemini", "claude", "codex", "glm", "grok"],
         description: "Override the estimated engine"
       },
       timeout_ms: {
@@ -19967,7 +20123,7 @@ var listTasksSchema = {
       },
       engine: {
         type: "string",
-        enum: ["gemini", "claude", "codex", "ax-cli"],
+        enum: ["gemini", "claude", "codex", "glm", "grok"],
         description: "Filter by engine"
       },
       limit: {
@@ -20787,27 +20943,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);
   }
@@ -20870,7 +21032,8 @@ var EventSourceSchema = z.enum([
   "claude",
   "gemini",
   "codex",
-  "ax-cli",
+  "glm",
+  "grok",
   "mcp",
   "internal"
 ]);
@@ -22044,201 +22207,12 @@ var CodexEventNormalizer = class extends BaseEventNormalizer {
   }
 };
 
-// src/core/events/normalizers/ax-cli-normalizer.ts
-init_esm_shims();
-var AxCliEventNormalizer = class extends BaseEventNormalizer {
-  source = "ax-cli";
-  tokenCount = 0;
-  startTime = Date.now();
-  canHandle(rawEvent) {
-    if (typeof rawEvent !== "object" || rawEvent === null) {
-      return false;
-    }
-    const event = rawEvent;
-    if ("type" in event && typeof event.type === "string") {
-      const validPatterns = [
-        "execution.",
-        "tool.",
-        "agent.",
-        "memory.",
-        "session.",
-        // Legacy ax-cli event types
-        "start",
-        "progress",
-        "complete",
-        "error",
-        "token"
-      ];
-      return validPatterns.some(
-        (pattern) => event.type.includes(pattern) || event.type === pattern.replace(".", "")
-      );
-    }
-    return false;
-  }
-  normalize(rawEvent, correlationId) {
-    if (!this.canHandle(rawEvent)) {
-      return null;
-    }
-    const event = rawEvent;
-    if (this.isUnifiedFormat(event.type)) {
-      return this.normalizeUnifiedEvent(event, correlationId);
-    }
-    return this.normalizeLegacyEvent(event, correlationId);
-  }
-  /**
-   * Check if event type matches unified format
-   */
-  isUnifiedFormat(type) {
-    const unifiedTypes = [
-      "execution.started",
-      "execution.progress",
-      "execution.token",
-      "execution.completed",
-      "execution.error",
-      "execution.cancelled",
-      "tool.called",
-      "tool.progress",
-      "tool.result",
-      "tool.error",
-      "agent.selected",
-      "agent.delegated",
-      "agent.context_loaded",
-      "memory.searched",
-      "memory.added",
-      "session.created",
-      "session.updated",
-      "session.completed"
-    ];
-    return unifiedTypes.includes(type);
-  }
-  /**
-   * Normalize events that already match unified format
-   */
-  normalizeUnifiedEvent(event, correlationId) {
-    const payload = this.buildPayload(event);
-    return this.createEvent(
-      event.type,
-      payload,
-      correlationId
-    );
-  }
-  /**
-   * Normalize legacy ax-cli event types
-   */
-  normalizeLegacyEvent(event, correlationId) {
-    const type = event.type.toLowerCase();
-    if (type === "start" || type.includes("start")) {
-      this.startTime = Date.now();
-      this.tokenCount = 0;
-      return this.createEvent("execution.started", {
-        agent: event.agent || "ax-cli",
-        task: event.task || event.message || "Unknown task",
-        provider: event.provider || "ax-cli",
-        model: event.model
-      }, correlationId);
-    }
-    if (type === "progress") {
-      return this.createEvent("execution.progress", {
-        agent: event.agent || "ax-cli",
-        progress: event.progress ?? 0,
-        message: event.message,
-        stage: event.stage
-      }, correlationId);
-    }
-    if (type === "token") {
-      this.tokenCount += 1;
-      return this.createEvent("execution.token", {
-        agent: event.agent || "ax-cli",
-        token: event.token || event.content || "",
-        tokensReceived: event.tokensReceived ?? this.tokenCount,
-        throughput: event.throughput
-      }, correlationId);
-    }
-    if (type === "complete" || type.includes("complete")) {
-      const latencyMs = Date.now() - this.startTime;
-      return this.createEvent("execution.completed", {
-        agent: event.agent || "ax-cli",
-        content: event.content || "",
-        tokens: event.tokens || {
-          prompt: 0,
-          completion: this.tokenCount,
-          total: this.tokenCount
-        },
-        latencyMs: event.latencyMs ?? latencyMs,
-        provider: event.provider || "ax-cli",
-        model: event.model
-      }, correlationId);
-    }
-    if (type === "error") {
-      const errorMessage = typeof event.error === "string" ? event.error : event.error?.message || "Unknown error";
-      return this.createEvent("execution.error", {
-        agent: event.agent || "ax-cli",
-        error: errorMessage,
-        code: event.code,
-        retryable: event.retryable ?? false,
-        provider: event.provider || "ax-cli"
-      }, correlationId);
-    }
-    return null;
-  }
-  /**
-   * Build payload from event data
-   */
-  buildPayload(event) {
-    const payload = {};
-    const copyFields = [
-      "agent",
-      "task",
-      "provider",
-      "model",
-      "content",
-      "progress",
-      "message",
-      "stage",
-      "token",
-      "tokensReceived",
-      "throughput",
-      "tokens",
-      "latencyMs",
-      "tool",
-      "arguments",
-      "result",
-      "success",
-      "caller",
-      "error",
-      "code",
-      "retryable",
-      "fromAgent",
-      "toAgent",
-      "reason",
-      "score",
-      "confidence",
-      "alternatives",
-      "autoSelected"
-    ];
-    for (const field of copyFields) {
-      if (field in event && event[field] !== void 0) {
-        payload[field] = event[field];
-      }
-    }
-    if (!payload.agent) payload.agent = "ax-cli";
-    return payload;
-  }
-  /**
-   * Reset state for new execution
-   */
-  reset() {
-    this.tokenCount = 0;
-    this.startTime = Date.now();
-  }
-};
-
 // src/mcp/server.ts
 var CLIENT_PATTERNS = [
   [["claude"], "claude"],
   [["gemini"], "gemini"],
-  [["codex", "openai"], "codex"],
-  [["ax-cli", "ax", "automatosx"], "ax-cli"]
+  [["codex", "openai"], "codex"]
+  // v12.0.0: Removed ax-cli (deprecated)
 ];
 var STDIO_MAX_ITERATIONS = 100;
 var STDIO_MAX_BUFFER_SIZE = 10 * 1024 * 1024;
@@ -22331,6 +22305,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",
@@ -22507,7 +22497,6 @@ var McpServer = class _McpServer {
     this.eventBridge.registerNormalizer(new ClaudeEventNormalizer());
     this.eventBridge.registerNormalizer(new GeminiEventNormalizer());
     this.eventBridge.registerNormalizer(new CodexEventNormalizer());
-    this.eventBridge.registerNormalizer(new AxCliEventNormalizer());
     if (this.enableStreamingNotifications) {
       this.streamingNotifier = getGlobalStreamingNotifier({
         enabled: true,
@@ -22601,6 +22590,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
     }));