@defai.digital/automatosx 12.3.0 → 12.4.1

package/dist/mcp/index.js

@@ -1,18 +1,19 @@
 #!/usr/bin/env node
 import * as path4 from 'path';
-import path4__default, { dirname, join, extname as extname$1, basename, resolve, relative, isAbsolute, sep, parse, delimiter } from 'path';
+import path4__default, { dirname, join, extname as extname$1, basename, resolve, relative, isAbsolute, sep, delimiter, parse } from 'path';
 import { fileURLToPath } from 'url';
 import { mkdir, appendFile, readFile, readdir, writeFile, rename, unlink, copyFile, access, stat, realpath } from 'fs/promises';
 import * as fs4 from 'fs';
 import { existsSync, readFileSync, promises, mkdirSync, createWriteStream, writeFileSync, unlinkSync, constants } from 'fs';
 import Database2 from 'better-sqlite3';
 import { glob } from 'glob';
-import { spawn, spawnSync } from 'child_process';
+import { spawn, exec, spawnSync } from 'child_process';
 import { z, ZodError } from 'zod';
 import chalk4 from 'chalk';
 import ora2 from 'ora';
 import readline, { createInterface } from 'readline';
 import { Mutex } from 'async-mutex';
+import { promisify } from 'util';
 import Ajv from 'ajv';
 import addFormats from 'ajv-formats';
 import os2, { cpus } from 'os';
@@ -37,6 +38,226 @@ var init_esm_shims = __esm({
   "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"() {
   }
 });
+
+// src/core/validation-limits.ts
+function isValidRelativePath(path7) {
+  if (!path7 || typeof path7 !== "string") {
+    return false;
+  }
+  const normalizedPath = path7.replace(/\\/g, "/");
+  if (normalizedPath.startsWith("/")) {
+    return false;
+  }
+  if (normalizedPath.includes("..")) {
+    return false;
+  }
+  if (/^[a-zA-Z]:/.test(normalizedPath)) {
+    return false;
+  }
+  if (normalizedPath.startsWith("//")) {
+    return false;
+  }
+  return true;
+}
+function isValidCommand(command) {
+  if (!command || typeof command !== "string") {
+    return false;
+  }
+  if (command.length > VALIDATION_LIMITS.MAX_COMMAND_LENGTH) {
+    return false;
+  }
+  if (!/^[a-z0-9_-]+$/i.test(command)) {
+    return false;
+  }
+  return true;
+}
+function isValidName(name) {
+  if (!name || typeof name !== "string") {
+    return false;
+  }
+  if (name.length > VALIDATION_LIMITS.MAX_NAME_LENGTH) {
+    return false;
+  }
+  if (!/^[a-z0-9][a-z0-9-_]*$/i.test(name)) {
+    return false;
+  }
+  return true;
+}
+function isValidExtension(ext) {
+  if (!ext || typeof ext !== "string") {
+    return false;
+  }
+  const normalized = ext.startsWith(".") ? ext : `.${ext}`;
+  if (normalized.length > 10 || normalized.length < 2) {
+    return false;
+  }
+  if (!/^\.[a-z0-9]+$/i.test(normalized)) {
+    return false;
+  }
+  return true;
+}
+function isPositiveInteger(value) {
+  return typeof value === "number" && Number.isInteger(value) && value > 0;
+}
+function isNonNegativeInteger(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0;
+}
+var AX_PATHS, TIMEOUTS, DATABASE, VALIDATION_LIMITS;
+var init_validation_limits = __esm({
+  "src/core/validation-limits.ts"() {
+    init_esm_shims();
+    AX_PATHS = {
+      /** Root directory for AutomatosX data */
+      ROOT: ".automatosx",
+      /** Log files directory */
+      LOGS: ".automatosx/logs",
+      /** Memory/database directory */
+      MEMORY: ".automatosx/memory",
+      /** Agent workspaces directory */
+      WORKSPACES: ".automatosx/workspaces",
+      /** Session data directory */
+      SESSIONS: ".automatosx/sessions",
+      /** Team configurations directory */
+      TEAMS: ".automatosx/teams",
+      /** Agent profiles directory */
+      AGENTS: ".automatosx/agents",
+      /** Workflow definitions directory */
+      WORKFLOWS: ".automatosx/workflows",
+      /** Abilities/skills directory */
+      ABILITIES: ".automatosx/abilities",
+      /** Checkpoints directory */
+      CHECKPOINTS: ".automatosx/checkpoints",
+      /** Cache directory */
+      CACHE: ".automatosx/cache",
+      /** Task database directory */
+      TASKS: ".automatosx/tasks",
+      /** Status files directory */
+      STATUS: ".automatosx/status",
+      /** Provider configurations directory */
+      PROVIDERS: ".automatosx/providers",
+      /** Iterate mode directory */
+      ITERATE: ".automatosx/iterate",
+      /** State directory (mode, provider overrides) */
+      STATE: ".automatosx/state",
+      /** Usage tracking directory */
+      USAGE: ".automatosx/usage",
+      /** Context store directory */
+      CONTEXT: ".automatosx/context",
+      /** Telemetry directory */
+      TELEMETRY: ".automatosx/telemetry",
+      /** Workspace index directory */
+      WORKSPACE: ".automatosx/workspace",
+      /** Config file paths */
+      CONFIG_YAML: ".automatosx/config.yaml",
+      CONFIG_JSON: ".automatosx/config.json"
+    };
+    TIMEOUTS = {
+      /** Default provider execution timeout (2 minutes) */
+      PROVIDER_DEFAULT: 12e4,
+      /** Provider detection/health check timeout (5 seconds) */
+      PROVIDER_DETECTION: 5e3,
+      /** Database busy timeout (5 seconds) */
+      DATABASE_BUSY: 5e3,
+      /** Provider cooldown after failure (30 seconds) */
+      PROVIDER_COOLDOWN: 3e4,
+      /** Circuit breaker recovery timeout (1 minute) */
+      CIRCUIT_BREAKER_RECOVERY: 6e4,
+      /** Circuit breaker failure window (5 minutes) */
+      CIRCUIT_BREAKER_WINDOW: 3e5,
+      /** Health check interval (5 minutes) */
+      HEALTH_CHECK_INTERVAL: 3e5,
+      /** Idle connection timeout (5 minutes) */
+      IDLE_CONNECTION: 3e5,
+      /** User decision/prompt timeout (10 minutes) */
+      USER_DECISION: 6e5,
+      /** Maximum execution timeout (1 hour) */
+      MAX_EXECUTION: 36e5,
+      /** Default global timeout (25 minutes) */
+      GLOBAL_DEFAULT: 15e5,
+      /** Config cache TTL (1 minute) */
+      CONFIG_CACHE_TTL: 6e4,
+      /** Score cache TTL (5 minutes) */
+      SCORE_CACHE_TTL: 3e5,
+      /** MCP health check interval (30 seconds) */
+      MCP_HEALTH_CHECK: 3e4,
+      /** CLI command confirmation delay (5 seconds) */
+      CLI_CONFIRM_DELAY: 5e3,
+      /** Kill switch confirmation delay (5 seconds) */
+      KILL_SWITCH_DELAY: 5e3,
+      /** Minimum rollout duration (1 hour) */
+      MIN_ROLLOUT_DURATION: 36e5,
+      /** Graceful shutdown timeout (30 seconds) */
+      GRACEFUL_SHUTDOWN: 3e4,
+      /** Package installation timeout (1 minute) */
+      PACKAGE_INSTALL: 6e4,
+      /** Quick CLI command timeout (3 seconds) */
+      QUICK_COMMAND: 3e3,
+      /** CLI version check timeout (10 seconds) */
+      VERSION_CHECK: 1e4
+    };
+    DATABASE = {
+      /** SQLite busy timeout in milliseconds */
+      BUSY_TIMEOUT: 5e3,
+      /** Maximum database connections in pool */
+      MAX_CONNECTIONS: 10,
+      /** Connection idle timeout (5 minutes) */
+      IDLE_TIMEOUT: 3e5,
+      /** Default query limit */
+      DEFAULT_QUERY_LIMIT: 1e3,
+      /** Maximum query limit */
+      MAX_QUERY_LIMIT: 1e4
+    };
+    VALIDATION_LIMITS = {
+      // Resource limits (prevent DoS)
+      MAX_ENTRIES: 1e6,
+      // 1 million entries (memory, cache)
+      MAX_TIMEOUT: 36e5,
+      // 1 hour (execution, delegation)
+      MAX_FILE_SIZE: 104857600,
+      // 100 MB (workspace, abilities)
+      MAX_CACHE_SIZE: 524288e3,
+      // 500 MB (cache storage)
+      MAX_SESSIONS: 1e4,
+      // 10k concurrent sessions
+      // Performance limits (prevent resource exhaustion)
+      MAX_CONCURRENT_AGENTS: 100,
+      // Maximum concurrent agents
+      MAX_CPU_PERCENT: 80,
+      // Maximum CPU usage percent
+      MAX_MEMORY_MB: 2048,
+      // Maximum memory usage in MB
+      // Config validation limits
+      MAX_CONFIG_FILE_SIZE: 1048576,
+      // 1MB max config file size
+      MAX_NAME_LENGTH: 50,
+      // Max name length for agents/providers
+      MAX_COMMAND_LENGTH: 100,
+      // Max command length
+      MAX_ARRAY_LENGTH: 1e4,
+      // Max array elements in config
+      // Path and file limits
+      MIN_FILE_SIZE: 1,
+      // Minimum file size in bytes
+      MIN_TIMEOUT: 1e3,
+      // Minimum timeout in ms (1 second)
+      MIN_INTERVAL: 100,
+      // Minimum interval in ms
+      MIN_BACKOFF_FACTOR: 1,
+      // Minimum backoff multiplier
+      MAX_BACKOFF_FACTOR: 5,
+      // Maximum backoff multiplier
+      MAX_TTL: 864e5,
+      // Maximum TTL in ms (24 hours)
+      MIN_BYTES: 1,
+      // Minimum bytes for file sizes
+      // Network limits
+      MIN_PORT: 1024,
+      // Minimum port number
+      MAX_PORT: 65535
+      // Maximum port number
+    };
+  }
+});
 function sanitizeObject(obj, maxDepth = 5, currentDepth = 0) {
   if (currentDepth > maxDepth) {
     return "[Max Depth Reached]";
@@ -581,7 +802,7 @@ function installExitHandlers() {
       if (process.stderr.writable) {
         process.stderr.end();
       }
-    } catch (error) {
+    } catch (_error) {
     }
     process.exit(signal === "SIGTERM" || signal === "SIGINT" ? 0 : 1);
   };
@@ -602,6 +823,7 @@ var init_process_manager = __esm({
   "src/shared/process/process-manager.ts"() {
     init_esm_shims();
     init_logger();
+    init_validation_limits();
     ProcessManager = class {
       childProcesses = /* @__PURE__ */ new Set();
       isShuttingDown = false;
@@ -638,7 +860,7 @@ var init_process_manager = __esm({
        *
        * @param timeout Maximum time to wait for graceful shutdown (ms)
        */
-      async shutdown(timeout = 5e3) {
+      async shutdown(timeout = TIMEOUTS.PROVIDER_DETECTION) {
         if (this.isShuttingDown) {
           return;
         }
@@ -767,9 +989,10 @@ var init_factory = __esm({
   "src/core/database/factory.ts"() {
     init_esm_shims();
     init_logger();
+    init_validation_limits();
     DEFAULT_OPTIONS = {
       readonly: false,
-      busyTimeout: 5e3,
+      busyTimeout: DATABASE.BUSY_TIMEOUT,
       verbose: false,
       enableWal: true,
       createDir: true
@@ -1615,8 +1838,8 @@ var init_verbosity_manager = __esm({
   }
 });
 function findOnPath(cmdBase) {
-  const isWindows2 = process.platform === "win32";
-  if (isWindows2) {
+  const isWindows = process.platform === "win32";
+  if (isWindows) {
     return findOnPathWindows(cmdBase);
   }
   return findOnPathUnix(cmdBase);
@@ -1964,9 +2187,10 @@ var init_streaming_progress_parser = __esm({
 // src/providers/error-patterns.ts
 function isQuotaError(error, providerName) {
   const patterns = PROVIDER_ERROR_PATTERNS[providerName] || GENERIC_ERROR_PATTERNS;
-  const message = (error?.message || "").toLowerCase();
-  const code = error?.code || "";
-  const statusCode = error?.status || error?.statusCode;
+  const errorObj = error;
+  const message = (errorObj?.message || "").toLowerCase();
+  const code = errorObj?.code || "";
+  const statusCode = errorObj?.status || errorObj?.statusCode;
   if (patterns.quota.some((pattern) => message.includes(pattern.toLowerCase()))) {
     return true;
   }
@@ -1983,9 +2207,10 @@ function isQuotaError(error, providerName) {
 }
 function isRateLimitError(error, providerName) {
   const patterns = PROVIDER_ERROR_PATTERNS[providerName] || GENERIC_ERROR_PATTERNS;
-  const message = (error?.message || "").toLowerCase();
-  const code = error?.code || "";
-  const statusCode = error?.status || error?.statusCode;
+  const errorObj = error;
+  const message = (errorObj?.message || "").toLowerCase();
+  const code = errorObj?.code || "";
+  const statusCode = errorObj?.status || errorObj?.statusCode;
   if (patterns.rateLimit.some((pattern) => message.includes(pattern.toLowerCase()))) {
     return true;
   }
@@ -2224,6 +2449,7 @@ var init_base_provider = __esm({
     init_esm_shims();
     init_logger();
     init_errors();
+    init_validation_limits();
     init_cli_provider_detector();
     init_provider_schemas();
     init_streaming_progress_parser();
@@ -2266,15 +2492,16 @@ var init_base_provider = __esm({
         DEBIAN_FRONTEND: "noninteractive"
       };
       /** Default CLI execution timeout in milliseconds */
-      static DEFAULT_TIMEOUT_MS = 12e4;
+      static DEFAULT_TIMEOUT_MS = TIMEOUTS.PROVIDER_DEFAULT;
       /** Time to wait after SIGTERM before escalating to SIGKILL */
-      static SIGKILL_ESCALATION_MS = 5e3;
+      static SIGKILL_ESCALATION_MS = TIMEOUTS.PROVIDER_DETECTION;
       config;
       logger = logger;
       health;
       constructor(config) {
         const providerName = config.name.toLowerCase();
-        if (!_BaseProvider.ALLOWED_PROVIDER_NAMES.includes(providerName)) {
+        const allowedNames = _BaseProvider.ALLOWED_PROVIDER_NAMES;
+        if (!allowedNames.includes(providerName)) {
           throw new ProviderError(
             `Invalid provider name: ${config.name}. Allowed: ${_BaseProvider.ALLOWED_PROVIDER_NAMES.join(", ")}`,
             "E1001" /* CONFIG_INVALID */
@@ -2319,8 +2546,8 @@ var init_base_provider = __esm({
           const escapedPrompt = this.escapeShellArg(prompt);
           const fullCommand = `${cliCommand} ${argsString}${escapedPrompt}`;
           const commandLength = fullCommand.length;
-          const isWindows2 = process.platform === "win32";
-          const useStdin = isWindows2 && commandLength > 7e3;
+          const isWindows = process.platform === "win32";
+          const useStdin = isWindows && commandLength > 7e3;
           logger.debug(`Executing ${cliCommand} CLI with streaming support`, {
             command: cliCommand,
             promptLength: prompt.length,
@@ -2909,8 +3136,8 @@ ${fullPrompt}
        * - Windows: hello"world → "hello\"world"
        */
       escapeShellArg(arg) {
-        const isWindows2 = process.platform === "win32";
-        if (isWindows2) {
+        const isWindows = process.platform === "win32";
+        if (isWindows) {
           return '"' + arg.replace(/"/g, '\\"').replace(/%/g, "%%") + '"';
         } else {
           return "'" + arg.replace(/'/g, "'\\''") + "'";
@@ -3778,7 +4005,7 @@ var init_sdk_adapter = __esm({
             this.codex = new this.sdkModule.Codex();
             this.initialized = true;
             logger.info("Codex SDK initialized");
-          } catch (error) {
+          } catch (_error) {
             throw new CodexError(
               "CLI_NOT_FOUND" /* CLI_NOT_FOUND */,
               "Codex SDK not available. Install with: npm install @openai/codex-sdk"
@@ -4129,7 +4356,7 @@ async function isCLIModeAvailable() {
     execSync("codex --version", {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"],
-      timeout: 3e3
+      timeout: TIMEOUTS.QUICK_COMMAND
     });
     return true;
   } catch {
@@ -4141,6 +4368,3205 @@ var init_openai_provider_factory = __esm({
     init_esm_shims();
     init_openai_provider();
     init_logger();
+    init_validation_limits();
+  }
+});
+var FeatureFlagManager;
+var init_flag_manager = __esm({
+  "src/core/feature-flags/flag-manager.ts"() {
+    init_esm_shims();
+    init_logger();
+    FeatureFlagManager = class {
+      flags = /* @__PURE__ */ new Map();
+      storagePath;
+      flagsDir;
+      workspacePath;
+      constructor(workspacePath = process.cwd()) {
+        this.workspacePath = workspacePath;
+        this.flagsDir = join(workspacePath, ".automatosx");
+        this.storagePath = join(this.flagsDir, "feature-flags.json");
+        this.loadFlags();
+      }
+      /**
+       * Check if workspace has a storage directory
+       */
+      hasStorage() {
+        return existsSync(this.flagsDir);
+      }
+      /**
+       * Get workspace path for diagnostics
+       */
+      getWorkspacePath() {
+        return this.workspacePath;
+      }
+      /**
+       * Load flags from storage
+       */
+      loadFlags() {
+        try {
+          if (!this.hasStorage()) {
+            logger.debug("Feature flag storage not initialized", {
+              workspacePath: this.workspacePath
+            });
+            return;
+          }
+          if (existsSync(this.storagePath)) {
+            const data = readFileSync(this.storagePath, "utf-8");
+            const flags = JSON.parse(data);
+            for (const flag of flags) {
+              this.flags.set(flag.name, flag);
+            }
+            logger.info("Feature flags loaded", {
+              count: flags.length,
+              path: this.storagePath
+            });
+          } else {
+            logger.info("No feature flags file found, starting fresh");
+          }
+        } catch (error) {
+          logger.error("Failed to load feature flags", {
+            error: error.message
+          });
+        }
+      }
+      /**
+       * Save flags to storage
+       */
+      saveFlags() {
+        try {
+          this.ensureStorageDir();
+          const flagsArray = Array.from(this.flags.values());
+          const data = JSON.stringify(flagsArray, null, 2);
+          writeFileSync(this.storagePath, data, "utf-8");
+        } catch (error) {
+          logger.error("Failed to save feature flags", {
+            error: error.message
+          });
+        }
+      }
+      /**
+       * Ensure storage directory exists before writing
+       */
+      ensureStorageDir() {
+        if (!existsSync(this.flagsDir)) {
+          mkdirSync(this.flagsDir, { recursive: true });
+        }
+      }
+      /**
+       * Define a feature flag
+       */
+      defineFlag(flag) {
+        this.flags.set(flag.name, flag);
+        this.saveFlags();
+        logger.info("Feature flag defined", { name: flag.name });
+      }
+      /**
+       * Check if flag is enabled
+       */
+      isEnabled(flagName, context) {
+        const flag = this.flags.get(flagName);
+        if (!flag) return false;
+        if (flag.killSwitch?.enabled) {
+          logger.warn(`Feature flag ${flagName} killed`, {
+            reason: flag.killSwitch.reason,
+            timestamp: flag.killSwitch.timestamp
+          });
+          return false;
+        }
+        const envOverride = process.env[`FEATURE_${flagName.toUpperCase()}`];
+        if (envOverride === "false" || envOverride === "0") {
+          logger.warn(`Feature flag ${flagName} disabled by env var`);
+          return false;
+        }
+        if (flag.rolloutPercentage !== void 0) {
+          const hash = this.hashContext(context);
+          const bucket = hash % 100;
+          const enabled = bucket < flag.rolloutPercentage;
+          return enabled;
+        }
+        return flag.enabled;
+      }
+      /**
+       * Gradually increase rollout percentage
+       */
+      async increaseRollout(flagName, newPercentage, options) {
+        const flag = this.flags.get(flagName);
+        if (!flag) throw new Error(`Flag ${flagName} not found`);
+        const currentPercentage = flag.rolloutPercentage || 0;
+        if (newPercentage > currentPercentage * 5 && newPercentage !== 100 && currentPercentage > 0) {
+          throw new Error(
+            `Rollout increase too aggressive: ${currentPercentage}% \u2192 ${newPercentage}%
+Maximum safe increase: ${currentPercentage * 5}%`
+          );
+        }
+        if (options?.minimumDuration && flag.lastUpdated) {
+          const timeSinceLastChange = Date.now() - flag.lastUpdated;
+          if (timeSinceLastChange < options.minimumDuration) {
+            throw new Error(
+              `Must wait ${options.minimumDuration}ms before increasing rollout
+Time since last change: ${timeSinceLastChange}ms`
+            );
+          }
+        }
+        flag.rolloutPercentage = newPercentage;
+        flag.lastUpdated = Date.now();
+        this.flags.set(flagName, flag);
+        this.saveFlags();
+        logger.info(`Feature flag ${flagName} rollout increased`, {
+          from: currentPercentage,
+          to: newPercentage,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      }
+      /**
+       * Emergency kill switch
+       */
+      async killSwitch(flagName, reason) {
+        const flag = this.flags.get(flagName);
+        if (!flag) throw new Error(`Flag ${flagName} not found`);
+        flag.killSwitch = {
+          enabled: true,
+          reason,
+          timestamp: Date.now(),
+          by: process.env.USER || "unknown"
+        };
+        this.flags.set(flagName, flag);
+        this.saveFlags();
+        logger.error(`\u{1F6A8} KILL SWITCH ACTIVATED: ${flagName}`, {
+          reason,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      }
+      /**
+       * Get all flags
+       */
+      getAllFlags() {
+        return Array.from(this.flags.values());
+      }
+      /**
+       * Get a specific flag
+       */
+      getFlag(flagName) {
+        return this.flags.get(flagName);
+      }
+      /**
+       * Hash context for deterministic bucketing
+       */
+      hashContext(context) {
+        const str = JSON.stringify(context || {});
+        let hash = 0;
+        for (let i = 0; i < str.length; i++) {
+          const char = str.charCodeAt(i);
+          hash = (hash << 5) - hash + char;
+          hash = hash & hash;
+        }
+        return hash >>> 0;
+      }
+    };
+  }
+});
+
+// src/core/feature-flags/flags.ts
+function getFlagManager(workspacePath) {
+  const path7 = process.cwd();
+  if (!flagManagerInstances.has(path7)) {
+    const manager = new FeatureFlagManager(path7);
+    initializeFlags(manager);
+    flagManagerInstances.set(path7, manager);
+  }
+  return flagManagerInstances.get(path7);
+}
+function initializeFlags(manager) {
+  if (!manager.hasStorage()) {
+    logger.debug("Skipping feature flag initialization; workspace not initialized", {
+      workspacePath: manager.getWorkspacePath()
+    });
+    return;
+  }
+  initializeGeminiStreamingFlag(manager);
+  initializeProviderArchitectureFlags(manager);
+}
+function initializeGeminiStreamingFlag(manager) {
+  const existingFlag = manager.getFlag("gemini_streaming");
+  if (!existingFlag) {
+    manager.defineFlag({
+      name: "gemini_streaming",
+      description: "Enable Gemini as a valid option for streaming workloads",
+      enabled: true,
+      rolloutPercentage: 0,
+      metadata: {
+        owner: "platform-team",
+        jiraTicket: "AUTO-1234",
+        expectedImpact: "96% cost reduction on streaming tasks"
+      }
+    });
+    logger.info("Feature flag gemini_streaming initialized at 0%");
+  }
+}
+function initializeProviderArchitectureFlags(manager) {
+  for (const flagDef of DEFAULT_PROVIDER_FLAGS) {
+    const existingFlag = manager.getFlag(flagDef.name);
+    if (!existingFlag) {
+      manager.defineFlag(flagDef);
+      logger.info(`Feature flag ${flagDef.name} initialized`, {
+        enabled: flagDef.enabled,
+        rolloutPercentage: flagDef.rolloutPercentage
+      });
+    }
+  }
+}
+function isSDKFirstModeEnabled(context) {
+  const manager = getFlagManager();
+  return manager.isEnabled(PROVIDER_ARCHITECTURE_FLAGS.SDK_FIRST_MODE, context);
+}
+function isSDKFallbackEnabled() {
+  const manager = getFlagManager();
+  return manager.isEnabled(PROVIDER_ARCHITECTURE_FLAGS.SDK_FALLBACK_ENABLED);
+}
+function shouldCollectProviderMetrics() {
+  const manager = getFlagManager();
+  return manager.isEnabled(PROVIDER_ARCHITECTURE_FLAGS.PROVIDER_METRICS);
+}
+var flagManagerInstances, PROVIDER_ARCHITECTURE_FLAGS, DEFAULT_PROVIDER_FLAGS;
+var init_flags = __esm({
+  "src/core/feature-flags/flags.ts"() {
+    init_esm_shims();
+    init_flag_manager();
+    init_logger();
+    flagManagerInstances = /* @__PURE__ */ new Map();
+    PROVIDER_ARCHITECTURE_FLAGS = {
+      /** Enable SDK-first execution pattern (SDK primary, CLI fallback) */
+      SDK_FIRST_MODE: "sdk_first_mode",
+      /** Enable MCP bidirectional communication for agentic providers */
+      MCP_BIDIRECTIONAL: "mcp_bidirectional",
+      /** Auto-inject MCP server config into provider config files */
+      AUTO_INJECT_MCP_CONFIG: "auto_inject_mcp_config",
+      /** Allow CLI fallback when SDK fails */
+      SDK_FALLBACK_ENABLED: "sdk_fallback_enabled",
+      /** Show deprecation warnings (legacy providers, etc.) */
+      DEPRECATION_WARNINGS: "deprecation_warnings",
+      /** Enable provider metrics collection */
+      PROVIDER_METRICS: "provider_metrics"
+    };
+    DEFAULT_PROVIDER_FLAGS = [
+      {
+        name: PROVIDER_ARCHITECTURE_FLAGS.SDK_FIRST_MODE,
+        description: "Enable SDK-first execution pattern (SDK primary, CLI fallback) for GLM, Grok, and Codex providers",
+        enabled: false,
+        // Disabled by default, enable in v11.7.0
+        rolloutPercentage: 0,
+        metadata: {
+          owner: "platform-team",
+          expectedImpact: "Lower latency (~5ms vs ~200ms), better type safety"
+        }
+      },
+      {
+        name: PROVIDER_ARCHITECTURE_FLAGS.MCP_BIDIRECTIONAL,
+        description: "Enable MCP bidirectional communication for Claude and Gemini agents",
+        enabled: false,
+        // Disabled by default, enable in v11.8.0
+        rolloutPercentage: 0,
+        metadata: {
+          owner: "platform-team",
+          expectedImpact: "Faster agent communication via MCP instead of stdout parsing"
+        }
+      },
+      {
+        name: PROVIDER_ARCHITECTURE_FLAGS.AUTO_INJECT_MCP_CONFIG,
+        description: "Automatically inject AutomatosX MCP server config into provider config files",
+        enabled: false,
+        // Disabled by default, requires careful testing
+        rolloutPercentage: 0,
+        metadata: {
+          owner: "platform-team",
+          expectedImpact: "Seamless MCP setup for agents"
+        }
+      },
+      {
+        name: PROVIDER_ARCHITECTURE_FLAGS.SDK_FALLBACK_ENABLED,
+        description: "Allow CLI fallback when SDK execution fails",
+        enabled: true,
+        // Enabled by default for safety
+        rolloutPercentage: 100,
+        metadata: {
+          owner: "platform-team",
+          expectedImpact: "Graceful degradation when SDK unavailable"
+        }
+      },
+      {
+        name: PROVIDER_ARCHITECTURE_FLAGS.DEPRECATION_WARNINGS,
+        description: "Show deprecation warnings for legacy features",
+        enabled: true,
+        // Enabled by default to warn users
+        rolloutPercentage: 100,
+        metadata: {
+          owner: "platform-team",
+          expectedImpact: "v13.0.0: ax-cli removed, GLM/Grok are SDK-first"
+        }
+      },
+      {
+        name: PROVIDER_ARCHITECTURE_FLAGS.PROVIDER_METRICS,
+        description: "Enable provider metrics collection (SDK/CLI usage, fallback rate, MCP connections)",
+        enabled: true,
+        // Enabled by default for observability
+        rolloutPercentage: 100,
+        metadata: {
+          owner: "platform-team",
+          expectedImpact: "Better visibility into provider performance"
+        }
+      }
+    ];
+  }
+});
+
+// src/providers/fallback-decision.ts
+function decideFallback(error, providerName) {
+  const errorMessage = getErrorMessage(error).toLowerCase();
+  const errorCode = getErrorCode(error);
+  const statusCode = getStatusCode(error);
+  logger.debug("Classifying error for fallback decision", {
+    provider: providerName,
+    message: errorMessage.substring(0, 100),
+    code: errorCode,
+    statusCode
+  });
+  if (matchesPatterns(errorMessage, SDK_UNAVAILABLE_PATTERNS)) {
+    return {
+      decision: "use_cli" /* USE_CLI */,
+      reason: "SDK not available or not installed",
+      severity: "warn"
+    };
+  }
+  if (matchesPatterns(errorMessage, AUTH_ERROR_PATTERNS) || statusCode === 401 || statusCode === 403) {
+    return {
+      decision: "propagate" /* PROPAGATE */,
+      reason: "Authentication error - CLI would fail with same credentials",
+      severity: "error"
+    };
+  }
+  if (matchesPatterns(errorMessage, RATE_LIMIT_PATTERNS) || statusCode === 429) {
+    return {
+      decision: "retry_sdk" /* RETRY_SDK */,
+      reason: "Rate limited - retrying with backoff",
+      severity: "warn",
+      retryDelayMs: 5e3
+      // Longer delay for rate limits
+    };
+  }
+  if (matchesPatterns(errorMessage, TRANSIENT_ERROR_PATTERNS)) {
+    return {
+      decision: "retry_sdk" /* RETRY_SDK */,
+      reason: "Transient network error - retrying",
+      severity: "warn",
+      retryDelayMs: 1e3
+    };
+  }
+  if (matchesPatterns(errorMessage, SERVER_ERROR_PATTERNS) || statusCode && statusCode >= 500 && statusCode < 600) {
+    return {
+      decision: "retry_sdk" /* RETRY_SDK */,
+      reason: "Server error - retrying",
+      severity: "warn",
+      retryDelayMs: 2e3
+    };
+  }
+  if (matchesPatterns(errorMessage, CLIENT_ERROR_PATTERNS) || statusCode && statusCode >= 400 && statusCode < 500) {
+    return {
+      decision: "propagate" /* PROPAGATE */,
+      reason: "Client error - request is invalid",
+      severity: "error"
+    };
+  }
+  if (isSDKFallbackEnabled()) {
+    return {
+      decision: "use_cli" /* USE_CLI */,
+      reason: "Unknown error - falling back to CLI",
+      severity: "warn"
+    };
+  }
+  return {
+    decision: "propagate" /* PROPAGATE */,
+    reason: "Unknown error and fallback is disabled",
+    severity: "error"
+  };
+}
+function getErrorMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  if (typeof error === "string") {
+    return error;
+  }
+  if (error && typeof error === "object") {
+    const obj = error;
+    if (typeof obj.message === "string") {
+      return obj.message;
+    }
+    if (typeof obj.error === "string") {
+      return obj.error;
+    }
+    if (obj.error && typeof obj.error === "object") {
+      const innerError = obj.error;
+      if (typeof innerError.message === "string") {
+        return innerError.message;
+      }
+    }
+  }
+  return String(error);
+}
+function getErrorCode(error) {
+  if (error && typeof error === "object") {
+    const obj = error;
+    if (typeof obj.code === "string") {
+      return obj.code;
+    }
+    if (typeof obj.errorCode === "string") {
+      return obj.errorCode;
+    }
+  }
+  return void 0;
+}
+function getStatusCode(error) {
+  if (error && typeof error === "object") {
+    const obj = error;
+    if (typeof obj.status === "number") {
+      return obj.status;
+    }
+    if (typeof obj.statusCode === "number") {
+      return obj.statusCode;
+    }
+    if (obj.response && typeof obj.response === "object") {
+      const response = obj.response;
+      if (typeof response.status === "number") {
+        return response.status;
+      }
+    }
+  }
+  return void 0;
+}
+function matchesPatterns(message, patterns) {
+  return patterns.some((pattern) => message.includes(pattern.toLowerCase()));
+}
+var SDK_UNAVAILABLE_PATTERNS, AUTH_ERROR_PATTERNS, TRANSIENT_ERROR_PATTERNS, RATE_LIMIT_PATTERNS, SERVER_ERROR_PATTERNS, CLIENT_ERROR_PATTERNS;
+var init_fallback_decision = __esm({
+  "src/providers/fallback-decision.ts"() {
+    init_esm_shims();
+    init_logger();
+    init_flags();
+    SDK_UNAVAILABLE_PATTERNS = [
+      "module not found",
+      "cannot find module",
+      "sdk not available",
+      "sdk not installed",
+      "failed to initialize sdk",
+      "sdk initialization failed",
+      "package not found",
+      "@zhipuai/sdk",
+      "@xai-org/grok-sdk",
+      "@openai/codex-sdk",
+      "enoent",
+      // File not found (npm module missing)
+      "cannot resolve",
+      "dynamic import failed"
+    ];
+    AUTH_ERROR_PATTERNS = [
+      "authentication failed",
+      "invalid api key",
+      "invalid_api_key",
+      "unauthorized",
+      "api key not found",
+      "api_key_invalid",
+      "invalid credentials",
+      "authentication required",
+      "access denied",
+      "401",
+      "403",
+      "forbidden",
+      "invalid_grant",
+      "token expired",
+      "invalid token"
+    ];
+    TRANSIENT_ERROR_PATTERNS = [
+      "timeout",
+      "etimedout",
+      "econnreset",
+      "econnrefused",
+      "enotfound",
+      "network error",
+      "socket hang up",
+      "connection reset",
+      "temporary failure",
+      "service unavailable",
+      "503",
+      "504",
+      "gateway timeout",
+      "bad gateway",
+      "502"
+    ];
+    RATE_LIMIT_PATTERNS = [
+      "rate limit",
+      "rate_limit",
+      "too many requests",
+      "429",
+      "throttled",
+      "quota exceeded",
+      "resource_exhausted",
+      "overloaded"
+    ];
+    SERVER_ERROR_PATTERNS = [
+      "500",
+      "502",
+      "503",
+      "504",
+      "internal server error",
+      "internal error",
+      "server error"
+    ];
+    CLIENT_ERROR_PATTERNS = [
+      "400",
+      "bad request",
+      "invalid request",
+      "validation error",
+      "invalid parameter",
+      "missing parameter",
+      "malformed request"
+    ];
+  }
+});
+
+// src/core/metrics/provider-metrics.ts
+function getProviderMetrics() {
+  return ProviderMetricsCollector.getInstance();
+}
+var ProviderMetricsCollector;
+var init_provider_metrics = __esm({
+  "src/core/metrics/provider-metrics.ts"() {
+    init_esm_shims();
+    init_logger();
+    init_flags();
+    ProviderMetricsCollector = class _ProviderMetricsCollector {
+      static instance = null;
+      // Per-provider metrics
+      providerMetrics = /* @__PURE__ */ new Map();
+      // MCP metrics
+      mcpMetrics = {
+        totalConnections: 0,
+        activeConnections: 0,
+        failedConnections: 0,
+        totalToolCalls: 0,
+        avgToolCallLatencyMs: 0,
+        sessionsByProvider: {}
+      };
+      // Latency tracking (for averages)
+      sdkLatencies = /* @__PURE__ */ new Map();
+      cliLatencies = /* @__PURE__ */ new Map();
+      mcpLatencies = [];
+      // Max samples to keep for latency averaging
+      MAX_LATENCY_SAMPLES = 100;
+      constructor() {
+      }
+      /**
+       * Get singleton instance
+       */
+      static getInstance() {
+        if (!_ProviderMetricsCollector.instance) {
+          _ProviderMetricsCollector.instance = new _ProviderMetricsCollector();
+        }
+        return _ProviderMetricsCollector.instance;
+      }
+      /**
+       * Reset singleton instance (for testing)
+       */
+      static resetInstance() {
+        _ProviderMetricsCollector.instance = null;
+      }
+      /**
+       * Check if metrics collection is enabled
+       */
+      isEnabled() {
+        return shouldCollectProviderMetrics();
+      }
+      /**
+       * Get or create provider metrics data
+       */
+      getOrCreateProviderMetrics(providerName) {
+        if (!this.providerMetrics.has(providerName)) {
+          this.providerMetrics.set(providerName, {
+            providerName,
+            executionMode: "cli",
+            // Default mode
+            circuitBreakerState: "closed",
+            metrics: {
+              sdkExecutions: 0,
+              cliExecutions: 0,
+              mcpToolCalls: 0,
+              sdkFallbacks: 0,
+              sdkErrors: 0,
+              cliErrors: 0,
+              mcpConnectionFailures: 0,
+              avgSdkLatencyMs: 0,
+              avgCliLatencyMs: 0,
+              avgMcpLatencyMs: 0,
+              fallbackRate: 0,
+              sdkSuccessRate: 1,
+              cliSuccessRate: 1,
+              mcpSuccessRate: 1
+            },
+            lastUpdated: Date.now()
+          });
+        }
+        return this.providerMetrics.get(providerName);
+      }
+      /**
+       * Record SDK execution
+       */
+      recordSDKExecution(providerName, latencyMs, success) {
+        if (!this.isEnabled()) return;
+        const data = this.getOrCreateProviderMetrics(providerName);
+        data.metrics.sdkExecutions++;
+        if (!success) {
+          data.metrics.sdkErrors++;
+        }
+        this.addLatencySample(this.sdkLatencies, providerName, latencyMs);
+        data.metrics.avgSdkLatencyMs = this.calculateAverageLatency(
+          this.sdkLatencies.get(providerName) || []
+        );
+        data.metrics.sdkSuccessRate = this.calculateSuccessRate(
+          data.metrics.sdkExecutions,
+          data.metrics.sdkErrors
+        );
+        data.lastUpdated = Date.now();
+        logger.debug("SDK execution recorded", {
+          provider: providerName,
+          latencyMs,
+          success,
+          totalExecutions: data.metrics.sdkExecutions
+        });
+      }
+      /**
+       * Record CLI execution
+       */
+      recordCLIExecution(providerName, latencyMs, success) {
+        if (!this.isEnabled()) return;
+        const data = this.getOrCreateProviderMetrics(providerName);
+        data.metrics.cliExecutions++;
+        if (!success) {
+          data.metrics.cliErrors++;
+        }
+        this.addLatencySample(this.cliLatencies, providerName, latencyMs);
+        data.metrics.avgCliLatencyMs = this.calculateAverageLatency(
+          this.cliLatencies.get(providerName) || []
+        );
+        data.metrics.cliSuccessRate = this.calculateSuccessRate(
+          data.metrics.cliExecutions,
+          data.metrics.cliErrors
+        );
+        data.lastUpdated = Date.now();
+        logger.debug("CLI execution recorded", {
+          provider: providerName,
+          latencyMs,
+          success,
+          totalExecutions: data.metrics.cliExecutions
+        });
+      }
+      /**
+       * Record SDK fallback to CLI
+       */
+      recordSDKFallback(providerName, reason) {
+        if (!this.isEnabled()) return;
+        const data = this.getOrCreateProviderMetrics(providerName);
+        data.metrics.sdkFallbacks++;
+        if (data.metrics.sdkExecutions > 0) {
+          data.metrics.fallbackRate = data.metrics.sdkFallbacks / data.metrics.sdkExecutions;
+        }
+        data.lastUpdated = Date.now();
+        logger.info("SDK fallback recorded", {
+          provider: providerName,
+          reason,
+          fallbackRate: data.metrics.fallbackRate
+        });
+      }
+      /**
+       * Record MCP connection
+       */
+      recordMCPConnection(providerName, success) {
+        if (!this.isEnabled()) return;
+        this.mcpMetrics.totalConnections++;
+        if (success) {
+          this.mcpMetrics.activeConnections++;
+          this.mcpMetrics.sessionsByProvider[providerName] = (this.mcpMetrics.sessionsByProvider[providerName] || 0) + 1;
+        } else {
+          this.mcpMetrics.failedConnections++;
+          const data = this.getOrCreateProviderMetrics(providerName);
+          data.metrics.mcpConnectionFailures++;
+          data.lastUpdated = Date.now();
+        }
+        logger.debug("MCP connection recorded", {
+          provider: providerName,
+          success,
+          activeConnections: this.mcpMetrics.activeConnections
+        });
+      }
+      /**
+       * Record MCP connection closed
+       */
+      recordMCPDisconnection(providerName) {
+        if (!this.isEnabled()) return;
+        if (this.mcpMetrics.activeConnections > 0) {
+          this.mcpMetrics.activeConnections--;
+        }
+        const currentCount = this.mcpMetrics.sessionsByProvider[providerName];
+        if (currentCount !== void 0 && currentCount > 0) {
+          this.mcpMetrics.sessionsByProvider[providerName] = currentCount - 1;
+        }
+        logger.debug("MCP disconnection recorded", {
+          provider: providerName,
+          activeConnections: this.mcpMetrics.activeConnections
+        });
+      }
+      /**
+       * Record MCP tool call
+       */
+      recordMCPToolCall(providerName, toolName, latencyMs, success) {
+        if (!this.isEnabled()) return;
+        const data = this.getOrCreateProviderMetrics(providerName);
+        data.metrics.mcpToolCalls++;
+        this.mcpMetrics.totalToolCalls++;
+        this.mcpLatencies.push(latencyMs);
+        if (this.mcpLatencies.length > this.MAX_LATENCY_SAMPLES) {
+          this.mcpLatencies.shift();
+        }
+        data.metrics.avgMcpLatencyMs = this.calculateAverageLatency(this.mcpLatencies);
+        this.mcpMetrics.avgToolCallLatencyMs = data.metrics.avgMcpLatencyMs;
+        data.lastUpdated = Date.now();
+        logger.debug("MCP tool call recorded", {
+          provider: providerName,
+          tool: toolName,
+          latencyMs,
+          success
+        });
+      }
+      /**
+       * Update circuit breaker state
+       */
+      updateCircuitBreakerState(providerName, state) {
+        if (!this.isEnabled()) return;
+        const data = this.getOrCreateProviderMetrics(providerName);
+        const previousState = data.circuitBreakerState;
+        data.circuitBreakerState = state;
+        data.lastUpdated = Date.now();
+        if (previousState !== state) {
+          logger.info("Circuit breaker state changed", {
+            provider: providerName,
+            from: previousState,
+            to: state
+          });
+        }
+      }
+      /**
+       * Update execution mode
+       */
+      updateExecutionMode(providerName, mode) {
+        if (!this.isEnabled()) return;
+        const data = this.getOrCreateProviderMetrics(providerName);
+        data.executionMode = mode;
+        data.lastUpdated = Date.now();
+      }
+      /**
+       * Get metrics for a specific provider
+       */
+      getProviderMetrics(providerName) {
+        return this.providerMetrics.get(providerName);
+      }
+      /**
+       * Get all provider metrics
+       */
+      getAllProviderMetrics() {
+        return Array.from(this.providerMetrics.values());
+      }
+      /**
+       * Get MCP session metrics
+       */
+      getMCPMetrics() {
+        return { ...this.mcpMetrics };
+      }
+      /**
+       * Get aggregated metrics summary
+       */
+      getMetricsSummary() {
+        let totalSDK = 0;
+        let totalCLI = 0;
+        let totalFallbacks = 0;
+        let sdkLatencySum = 0;
+        let cliLatencySum = 0;
+        let sdkCount = 0;
+        let cliCount = 0;
+        const openCircuitBreakers = [];
+        for (const data of this.providerMetrics.values()) {
+          totalSDK += data.metrics.sdkExecutions;
+          totalCLI += data.metrics.cliExecutions;
+          totalFallbacks += data.metrics.sdkFallbacks;
+          if (data.metrics.avgSdkLatencyMs > 0) {
+            sdkLatencySum += data.metrics.avgSdkLatencyMs;
+            sdkCount++;
+          }
+          if (data.metrics.avgCliLatencyMs > 0) {
+            cliLatencySum += data.metrics.avgCliLatencyMs;
+            cliCount++;
+          }
+          if (data.circuitBreakerState === "open") {
+            openCircuitBreakers.push(data.providerName);
+          }
+        }
+        return {
+          totalSDKExecutions: totalSDK,
+          totalCLIExecutions: totalCLI,
+          totalMCPConnections: this.mcpMetrics.totalConnections,
+          overallFallbackRate: totalSDK > 0 ? totalFallbacks / totalSDK : 0,
+          avgSDKLatencyMs: sdkCount > 0 ? sdkLatencySum / sdkCount : 0,
+          avgCLILatencyMs: cliCount > 0 ? cliLatencySum / cliCount : 0,
+          providersWithOpenCircuitBreaker: openCircuitBreakers
+        };
+      }
+      /**
+       * Reset all metrics (for testing)
+       */
+      reset() {
+        this.providerMetrics.clear();
+        this.sdkLatencies.clear();
+        this.cliLatencies.clear();
+        this.mcpLatencies = [];
+        this.mcpMetrics = {
+          totalConnections: 0,
+          activeConnections: 0,
+          failedConnections: 0,
+          totalToolCalls: 0,
+          avgToolCallLatencyMs: 0,
+          sessionsByProvider: {}
+        };
+      }
+      /**
+       * Add latency sample to provider's latency array
+       */
+      addLatencySample(latencyMap, providerName, latencyMs) {
+        if (!latencyMap.has(providerName)) {
+          latencyMap.set(providerName, []);
+        }
+        const latencies = latencyMap.get(providerName);
+        latencies.push(latencyMs);
+        if (latencies.length > this.MAX_LATENCY_SAMPLES) {
+          latencies.shift();
+        }
+      }
+      /**
+       * Calculate average latency from samples
+       */
+      calculateAverageLatency(latencies) {
+        if (latencies.length === 0) return 0;
+        const sum = latencies.reduce((a, b) => a + b, 0);
+        return Math.round(sum / latencies.length);
+      }
+      /**
+       * Calculate success rate
+       */
+      calculateSuccessRate(total, errors) {
+        if (total === 0) return 1;
+        return Math.max(0, (total - errors) / total);
+      }
+    };
+  }
+});
+
+// src/providers/hybrid-adapter-base.ts
+var DEFAULT_CIRCUIT_BREAKER_CONFIG, CircuitBreaker2, HybridAdapterBase;
+var init_hybrid_adapter_base = __esm({
+  "src/providers/hybrid-adapter-base.ts"() {
+    init_esm_shims();
+    init_logger();
+    init_flags();
+    init_fallback_decision();
+    init_provider_metrics();
+    DEFAULT_CIRCUIT_BREAKER_CONFIG = {
+      failureThreshold: 3,
+      resetTimeout: 6e4,
+      // 1 minute
+      halfOpenSuccessThreshold: 2
+    };
+    CircuitBreaker2 = class {
+      state = "closed";
+      failures = 0;
+      successes = 0;
+      lastFailureTime = 0;
+      config;
+      constructor(config = {}) {
+        this.config = { ...DEFAULT_CIRCUIT_BREAKER_CONFIG, ...config };
+      }
+      /**
+       * Check if circuit is open (requests should not be attempted)
+       */
+      isOpen() {
+        if (this.state === "open") {
+          if (Date.now() - this.lastFailureTime >= this.config.resetTimeout) {
+            this.state = "half-open";
+            this.successes = 0;
+            logger.debug("Circuit breaker transitioning to half-open");
+            return false;
+          }
+          return true;
+        }
+        return false;
+      }
+      /**
+       * Get current state
+       */
+      getState() {
+        if (this.state === "open" && Date.now() - this.lastFailureTime >= this.config.resetTimeout) {
+          this.state = "half-open";
+          this.successes = 0;
+        }
+        return this.state;
+      }
+      /**
+       * Record successful execution
+       */
+      recordSuccess() {
+        if (this.state === "half-open") {
+          this.successes++;
+          if (this.successes >= this.config.halfOpenSuccessThreshold) {
+            this.state = "closed";
+            this.failures = 0;
+            this.successes = 0;
+            logger.debug("Circuit breaker closed after recovery");
+          }
+        } else if (this.state === "closed") {
+          this.failures = 0;
+        }
+      }
+      /**
+       * Record failed execution
+       */
+      recordFailure() {
+        this.failures++;
+        this.lastFailureTime = Date.now();
+        if (this.state === "half-open") {
+          this.state = "open";
+          logger.warn("Circuit breaker opened after half-open failure");
+        } else if (this.failures >= this.config.failureThreshold) {
+          this.state = "open";
+          logger.warn("Circuit breaker opened after consecutive failures", {
+            failures: this.failures,
+            threshold: this.config.failureThreshold
+          });
+        }
+      }
+      /**
+       * Reset circuit breaker to closed state
+       */
+      reset() {
+        this.state = "closed";
+        this.failures = 0;
+        this.successes = 0;
+        this.lastFailureTime = 0;
+      }
+    };
+    HybridAdapterBase = class {
+      mode;
+      activeMode = null;
+      providerName;
+      sdkCircuitBreaker;
+      cliCircuitBreaker;
+      maxRetries;
+      // Track initialization state
+      sdkInitialized = false;
+      cliInitialized = false;
+      initPromise = null;
+      constructor(options) {
+        this.mode = options.mode || "auto";
+        this.providerName = options.providerName;
+        this.maxRetries = options.maxRetries ?? 1;
+        this.sdkCircuitBreaker = new CircuitBreaker2(options.sdkCircuitBreaker);
+        this.cliCircuitBreaker = new CircuitBreaker2(options.cliCircuitBreaker);
+        logger.debug("HybridAdapterBase initialized", {
+          provider: this.providerName,
+          mode: this.mode,
+          maxRetries: this.maxRetries
+        });
+      }
+      /**
+       * Execute a request using the appropriate mode
+       *
+       * Mode selection logic:
+       * 1. If mode is 'cli' or SDK-first is disabled → use CLI directly
+       * 2. If mode is 'sdk' → use SDK only (throw if unavailable)
+       * 3. If mode is 'auto' → try SDK first, fallback to CLI
+       */
+      async execute(request) {
+        await this.ensureInitialized();
+        const useSDKFirst = this.shouldUseSDKFirst();
+        if (!useSDKFirst || this.mode === "cli") {
+          return this.executeWithCLI(request);
+        }
+        if (this.mode === "sdk") {
+          return this.executeWithSDK(request);
+        }
+        return this.executeWithFallback(request);
+      }
+      /**
+       * Execute with SDK-first and CLI fallback
+       */
+      async executeWithFallback(request) {
+        if (this.sdkCircuitBreaker.isOpen()) {
+          logger.debug("SDK circuit breaker is open, using CLI", {
+            provider: this.providerName
+          });
+          return this.executeWithCLI(request);
+        }
+        const startTime = Date.now();
+        let lastError;
+        for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+          try {
+            const result = await this.executeViaSDK(request);
+            this.sdkCircuitBreaker.recordSuccess();
+            this.recordSDKMetrics(Date.now() - startTime, true);
+            return result;
+          } catch (error) {
+            lastError = error;
+            const classification = decideFallback(error, this.providerName);
+            logger.debug("SDK execution failed", {
+              provider: this.providerName,
+              attempt: attempt + 1,
+              decision: classification.decision,
+              reason: classification.reason
+            });
+            if (classification.decision === "retry_sdk" /* RETRY_SDK */ && attempt < this.maxRetries) {
+              const delay = classification.retryDelayMs || 1e3;
+              await this.sleep(delay);
+              continue;
+            }
+            if (classification.decision === "use_cli" /* USE_CLI */ || classification.decision === "retry_sdk" /* RETRY_SDK */ && attempt >= this.maxRetries) {
+              this.sdkCircuitBreaker.recordFailure();
+              this.recordSDKMetrics(Date.now() - startTime, false);
+              this.recordFallbackMetrics(classification.reason || "max retries exceeded");
+              if (isSDKFallbackEnabled()) {
+                logger.info("Falling back to CLI execution", {
+                  provider: this.providerName,
+                  reason: classification.reason || "max retries exceeded"
+                });
+                return this.executeWithCLI(request);
+              }
+            }
+            this.sdkCircuitBreaker.recordFailure();
+            this.recordSDKMetrics(Date.now() - startTime, false);
+            throw error;
+          }
+        }
+        this.sdkCircuitBreaker.recordFailure();
+        this.recordSDKMetrics(Date.now() - startTime, false);
+        if (isSDKFallbackEnabled()) {
+          this.recordFallbackMetrics("max retries exceeded");
+          return this.executeWithCLI(request);
+        }
+        throw lastError || new Error(`SDK execution failed after ${this.maxRetries + 1} attempts`);
+      }
+      /**
+       * Execute using SDK only
+       */
+      async executeWithSDK(request) {
+        if (this.sdkCircuitBreaker.isOpen()) {
+          throw new Error(`SDK circuit breaker is open for ${this.providerName}`);
+        }
+        const startTime = Date.now();
+        try {
+          const result = await this.executeViaSDK(request);
+          this.sdkCircuitBreaker.recordSuccess();
+          this.recordSDKMetrics(Date.now() - startTime, true);
+          return result;
+        } catch (error) {
+          this.sdkCircuitBreaker.recordFailure();
+          this.recordSDKMetrics(Date.now() - startTime, false);
+          throw error;
+        }
+      }
+      /**
+       * Execute using CLI only
+       */
+      async executeWithCLI(request) {
+        if (this.cliCircuitBreaker.isOpen()) {
+          throw new Error(`CLI circuit breaker is open for ${this.providerName}`);
+        }
+        const startTime = Date.now();
+        try {
+          const result = await this.executeViaCLI(request);
+          this.cliCircuitBreaker.recordSuccess();
+          this.recordCLIMetrics(Date.now() - startTime, true);
+          return result;
+        } catch (error) {
+          this.cliCircuitBreaker.recordFailure();
+          this.recordCLIMetrics(Date.now() - startTime, false);
+          throw error;
+        }
+      }
+      /**
+       * Check if SDK-first mode should be used
+       */
+      shouldUseSDKFirst() {
+        if (!isSDKFirstModeEnabled()) {
+          return false;
+        }
+        if (this.mode === "cli") {
+          return false;
+        }
+        return true;
+      }
+      /**
+       * Ensure adapters are initialized
+       */
+      async ensureInitialized() {
+        if (this.initPromise) {
+          return this.initPromise;
+        }
+        this.initPromise = this.initialize();
+        return this.initPromise;
+      }
+      /**
+       * Initialize adapters based on mode
+       */
+      async initialize() {
+        const useSDKFirst = this.shouldUseSDKFirst();
+        if (this.mode === "cli" || !useSDKFirst) {
+          if (!this.cliInitialized) {
+            const available = await this.isCLIAvailable();
+            if (!available) {
+              throw new Error(`CLI not available for ${this.providerName}`);
+            }
+            await this.initializeCLI();
+            this.cliInitialized = true;
+            this.activeMode = "cli";
+          }
+          return;
+        }
+        if (this.mode === "sdk") {
+          if (!this.sdkInitialized) {
+            const available = await this.isSDKAvailable();
+            if (!available) {
+              throw new Error(`SDK not available for ${this.providerName}`);
+            }
+            await this.initializeSDK();
+            this.sdkInitialized = true;
+            this.activeMode = "sdk";
+          }
+          return;
+        }
+        if (!this.sdkInitialized) {
+          const sdkAvailable = await this.isSDKAvailable();
+          if (sdkAvailable) {
+            try {
+              await this.initializeSDK();
+              this.sdkInitialized = true;
+              this.activeMode = "sdk";
+            } catch (error) {
+              logger.warn("SDK initialization failed, will use CLI", {
+                provider: this.providerName,
+                error: error instanceof Error ? error.message : String(error)
+              });
+            }
+          }
+        }
+        if (!this.cliInitialized) {
+          const cliAvailable = await this.isCLIAvailable();
+          if (cliAvailable) {
+            await this.initializeCLI();
+            this.cliInitialized = true;
+            if (!this.sdkInitialized) {
+              this.activeMode = "cli";
+            }
+          } else if (!this.sdkInitialized) {
+            throw new Error(`Neither SDK nor CLI available for ${this.providerName}`);
+          }
+        }
+      }
+      /**
+       * Record SDK execution metrics
+       */
+      recordSDKMetrics(latencyMs, success) {
+        try {
+          const collector = getProviderMetrics();
+          collector.recordSDKExecution(this.providerName, latencyMs, success);
+        } catch {
+        }
+      }
+      /**
+       * Record CLI execution metrics
+       */
+      recordCLIMetrics(latencyMs, success) {
+        try {
+          const collector = getProviderMetrics();
+          collector.recordCLIExecution(this.providerName, latencyMs, success);
+        } catch {
+        }
+      }
+      /**
+       * Record fallback event metrics
+       */
+      recordFallbackMetrics(reason) {
+        try {
+          const collector = getProviderMetrics();
+          collector.recordSDKFallback(this.providerName, reason);
+        } catch {
+        }
+      }
+      /**
+       * Sleep utility
+       */
+      sleep(ms) {
+        return new Promise((resolve5) => setTimeout(resolve5, ms));
+      }
+      /**
+       * Get current active mode
+       */
+      getActiveMode() {
+        return this.activeMode;
+      }
+      /**
+       * Get SDK circuit breaker state
+       */
+      getSDKCircuitBreakerState() {
+        return this.sdkCircuitBreaker.getState();
+      }
+      /**
+       * Get CLI circuit breaker state
+       */
+      getCLICircuitBreakerState() {
+        return this.cliCircuitBreaker.getState();
+      }
+      /**
+       * Reset both circuit breakers
+       */
+      resetCircuitBreakers() {
+        this.sdkCircuitBreaker.reset();
+        this.cliCircuitBreaker.reset();
+        logger.debug("Circuit breakers reset", { provider: this.providerName });
+      }
+      /**
+       * Clean up resources
+       */
+      async destroy() {
+        await this.destroySDK();
+        await this.destroyCLI();
+        this.sdkInitialized = false;
+        this.cliInitialized = false;
+        this.activeMode = null;
+        this.initPromise = null;
+      }
+    };
+  }
+});
+
+// src/integrations/ax-glm/types.ts
+function normalizeGLMModel(model) {
+  return GLM_MODEL_MAPPING[model] || model;
+}
+var GLM_MODEL_MAPPING, GLM_DEFAULT_BASE_URL, GLM_DEFAULT_MODEL, GLM_DEFAULT_COMMAND;
+var init_types2 = __esm({
+  "src/integrations/ax-glm/types.ts"() {
+    init_esm_shims();
+    GLM_MODEL_MAPPING = {
+      "glm-4-plus": "glm-4.6",
+      "glm-4v": "glm-4.5v",
+      "glm-4-air": "glm-4-flash",
+      "glm-4-airx": "glm-4-flash"
+    };
+    GLM_DEFAULT_BASE_URL = "https://open.bigmodel.cn/api/paas/v4";
+    GLM_DEFAULT_MODEL = "glm-4";
+    GLM_DEFAULT_COMMAND = "ax-glm";
+  }
+});
+
+// src/integrations/ax-glm/sdk-adapter.ts
+var GLMSdkAdapter;
+var init_sdk_adapter2 = __esm({
+  "src/integrations/ax-glm/sdk-adapter.ts"() {
+    init_esm_shims();
+    init_logger();
+    init_validation_limits();
+    init_types2();
+    GLMSdkAdapter = class {
+      client = null;
+      config;
+      initialized = false;
+      constructor(config = {}) {
+        this.config = {
+          apiKey: config.apiKey || process.env.ZAI_API_KEY || "",
+          baseUrl: config.baseUrl || GLM_DEFAULT_BASE_URL,
+          model: config.model || GLM_DEFAULT_MODEL,
+          timeout: config.timeout || TIMEOUTS.PROVIDER_DEFAULT
+        };
+        logger.debug("[GLM SDK] Adapter created", {
+          model: this.config.model,
+          baseUrl: this.config.baseUrl,
+          hasApiKey: !!this.config.apiKey
+        });
+      }
+      /**
+       * Check if SDK is available (OpenAI package installed)
+       */
+      async isAvailable() {
+        try {
+          if (!this.config.apiKey) {
+            logger.debug("[GLM SDK] No API key configured");
+            return false;
+          }
+          await import('openai');
+          return true;
+        } catch (error) {
+          logger.debug("[GLM SDK] OpenAI SDK not available", {
+            error: error instanceof Error ? error.message : String(error)
+          });
+          return false;
+        }
+      }
+      /**
+       * Initialize the SDK client
+       */
+      async initialize() {
+        if (this.initialized) {
+          return;
+        }
+        try {
+          const OpenAI = (await import('openai')).default;
+          this.client = new OpenAI({
+            apiKey: this.config.apiKey,
+            baseURL: this.config.baseUrl,
+            timeout: this.config.timeout
+          });
+          this.initialized = true;
+          logger.debug("[GLM SDK] Client initialized", {
+            model: this.config.model
+          });
+        } catch (error) {
+          throw new Error(
+            `Failed to initialize GLM SDK: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+      /**
+       * Execute a request using the GLM SDK
+       */
+      async execute(request) {
+        if (!this.initialized) {
+          await this.initialize();
+        }
+        const startTime = Date.now();
+        try {
+          const messages = [];
+          if (request.systemPrompt) {
+            messages.push({
+              role: "system",
+              content: request.systemPrompt
+            });
+          }
+          messages.push({
+            role: "user",
+            content: request.prompt
+          });
+          const model = normalizeGLMModel(this.config.model);
+          logger.debug("[GLM SDK] Executing request", {
+            model,
+            messageCount: messages.length,
+            promptLength: request.prompt.length
+          });
+          const openaiClient = this.client;
+          const response = await openaiClient.chat.completions.create({
+            model,
+            messages,
+            max_tokens: request.maxTokens,
+            temperature: request.temperature,
+            stream: false
+          });
+          const latencyMs = Date.now() - startTime;
+          if (!response.choices || response.choices.length === 0) {
+            throw new Error("GLM API returned empty choices array");
+          }
+          const choice = response.choices[0];
+          const content = choice?.message?.content || "";
+          const finishReason = choice?.finish_reason || "unknown";
+          logger.debug("[GLM SDK] Request completed", {
+            model: response.model,
+            latencyMs,
+            tokensUsed: response.usage?.total_tokens
+          });
+          return {
+            content,
+            model: response.model,
+            tokensUsed: response.usage ? {
+              prompt: response.usage.prompt_tokens,
+              completion: response.usage.completion_tokens,
+              total: response.usage.total_tokens
+            } : { prompt: 0, completion: 0, total: 0 },
+            latencyMs,
+            finishReason,
+            cached: false
+          };
+        } catch (error) {
+          const latencyMs = Date.now() - startTime;
+          logger.error("[GLM SDK] Request failed", {
+            error: error instanceof Error ? error.message : String(error),
+            latencyMs
+          });
+          throw error;
+        }
+      }
+      /**
+       * Get the configured model
+       */
+      getModel() {
+        return this.config.model;
+      }
+      /**
+       * Clean up resources
+       */
+      async destroy() {
+        this.client = null;
+        this.initialized = false;
+        logger.debug("[GLM SDK] Adapter destroyed");
+      }
+    };
+  }
+});
+var execAsync, GLMCliWrapper;
+var init_cli_wrapper2 = __esm({
+  "src/integrations/ax-glm/cli-wrapper.ts"() {
+    init_esm_shims();
+    init_logger();
+    init_validation_limits();
+    init_types2();
+    execAsync = promisify(exec);
+    GLMCliWrapper = class {
+      config;
+      cliPath = null;
+      cliVersion = null;
+      constructor(config = {}) {
+        this.config = {
+          command: config.command || GLM_DEFAULT_COMMAND,
+          model: config.model || GLM_DEFAULT_MODEL,
+          timeout: config.timeout || TIMEOUTS.PROVIDER_DEFAULT
+        };
+        logger.debug("[GLM CLI] Wrapper created", {
+          command: this.config.command,
+          model: this.config.model
+        });
+      }
+      /**
+       * Check if CLI is available
+       */
+      async isAvailable() {
+        try {
+          const { stdout } = await execAsync(`which ${this.config.command}`, {
+            timeout: TIMEOUTS.PROVIDER_DETECTION
+          });
+          this.cliPath = stdout.trim();
+          if (this.cliPath) {
+            try {
+              const { stdout: versionOutput } = await execAsync(
+                `${this.config.command} --version`,
+                { timeout: TIMEOUTS.PROVIDER_DETECTION }
+              );
+              this.cliVersion = versionOutput.trim();
+            } catch {
+              this.cliVersion = "unknown";
+            }
+            logger.debug("[GLM CLI] CLI available", {
+              path: this.cliPath,
+              version: this.cliVersion
+            });
+            return true;
+          }
+          return false;
+        } catch (error) {
+          logger.debug("[GLM CLI] CLI not available", {
+            error: error instanceof Error ? error.message : String(error)
+          });
+          return false;
+        }
+      }
+      /**
+       * Initialize the CLI wrapper
+       */
+      async initialize() {
+        const available = await this.isAvailable();
+        if (!available) {
+          throw new Error(`${this.config.command} CLI is not installed or not in PATH`);
+        }
+      }
+      /**
+       * Execute a request using the CLI
+       */
+      async execute(request) {
+        const startTime = Date.now();
+        try {
+          const args2 = this.buildArgs(request);
+          logger.debug("[GLM CLI] Executing", {
+            command: this.config.command,
+            args: args2,
+            promptLength: request.prompt.length
+          });
+          const result = await this.spawnCLI(args2, request.prompt);
+          const latencyMs = Date.now() - startTime;
+          const response = this.parseResponse(result);
+          logger.debug("[GLM CLI] Request completed", {
+            latencyMs,
+            contentLength: response.content.length
+          });
+          return {
+            ...response,
+            latencyMs,
+            cached: false
+          };
+        } catch (error) {
+          const latencyMs = Date.now() - startTime;
+          logger.error("[GLM CLI] Request failed", {
+            error: error instanceof Error ? error.message : String(error),
+            latencyMs
+          });
+          throw error;
+        }
+      }
+      /**
+       * Build CLI arguments
+       */
+      buildArgs(request) {
+        const args2 = ["-p"];
+        const model = normalizeGLMModel(this.config.model);
+        if (model !== "glm-4") {
+          args2.push("--model", model);
+        }
+        if (request.systemPrompt) {
+          args2.push("--system", request.systemPrompt);
+        }
+        if (request.maxTokens) {
+          args2.push("--max-tokens", String(request.maxTokens));
+        }
+        if (request.temperature !== void 0) {
+          args2.push("--temperature", String(request.temperature));
+        }
+        return args2;
+      }
+      /**
+       * Spawn CLI process and get output
+       */
+      spawnCLI(args2, prompt) {
+        return new Promise((resolve5, reject) => {
+          const process2 = spawn(this.config.command, args2, {
+            stdio: ["pipe", "pipe", "pipe"],
+            timeout: this.config.timeout
+          });
+          let stdout = "";
+          let stderr = "";
+          process2.stdout.on("data", (data) => {
+            stdout += data.toString();
+          });
+          process2.stderr.on("data", (data) => {
+            stderr += data.toString();
+          });
+          process2.on("error", (error) => {
+            reject(new Error(`CLI process error: ${error.message}`));
+          });
+          process2.on("close", (code) => {
+            if (code === 0) {
+              resolve5(stdout);
+            } else {
+              reject(new Error(
+                `CLI exited with code ${code}: ${stderr || "No error message"}`
+              ));
+            }
+          });
+          process2.stdin.write(prompt);
+          process2.stdin.end();
+        });
+      }
+      /**
+       * Parse CLI response
+       */
+      parseResponse(output) {
+        try {
+          const parsed = JSON.parse(output.trim());
+          if (parsed.content || parsed.message) {
+            return {
+              content: parsed.content || parsed.message || "",
+              model: parsed.model || normalizeGLMModel(this.config.model),
+              tokensUsed: parsed.usage ? {
+                prompt: parsed.usage.prompt_tokens || 0,
+                completion: parsed.usage.completion_tokens || 0,
+                total: parsed.usage.total_tokens || 0
+              } : { prompt: 0, completion: 0, total: 0 },
+              finishReason: parsed.finish_reason || "stop"
+            };
+          }
+        } catch {
+        }
+        return {
+          content: output.trim(),
+          model: normalizeGLMModel(this.config.model),
+          tokensUsed: { prompt: 0, completion: 0, total: 0 },
+          finishReason: "stop"
+        };
+      }
+      /**
+       * Get the configured model
+       */
+      getModel() {
+        return this.config.model;
+      }
+      /**
+       * Get CLI version
+       */
+      getVersion() {
+        return this.cliVersion;
+      }
+      /**
+       * Get CLI command
+       */
+      getCommand() {
+        return this.config.command;
+      }
+      /**
+       * Clean up resources
+       */
+      async destroy() {
+        logger.debug("[GLM CLI] Wrapper destroyed");
+      }
+    };
+  }
+});
+
+// src/integrations/ax-glm/hybrid-adapter.ts
+var GLMHybridAdapter;
+var init_hybrid_adapter2 = __esm({
+  "src/integrations/ax-glm/hybrid-adapter.ts"() {
+    init_esm_shims();
+    init_hybrid_adapter_base();
+    init_sdk_adapter2();
+    init_cli_wrapper2();
+    init_types2();
+    init_logger();
+    GLMHybridAdapter = class extends HybridAdapterBase {
+      sdkAdapter = null;
+      cliWrapper = null;
+      model;
+      sdkConfig;
+      cliConfig;
+      constructor(options = {}) {
+        const baseOptions = {
+          mode: options.mode || "auto",
+          providerName: "glm",
+          maxRetries: options.maxRetries ?? 1
+        };
+        super(baseOptions);
+        this.model = options.model || GLM_DEFAULT_MODEL;
+        this.sdkConfig = {
+          apiKey: options.apiKey,
+          baseUrl: options.baseUrl,
+          timeout: options.timeout
+        };
+        this.cliConfig = {
+          command: options.command,
+          timeout: options.timeout
+        };
+        logger.debug("[GLM Hybrid] Adapter created", {
+          mode: this.mode,
+          model: this.model
+        });
+      }
+      /**
+       * Execute request via SDK
+       */
+      async executeViaSDK(request) {
+        if (!this.sdkAdapter) {
+          throw new Error("GLM SDK adapter not initialized");
+        }
+        return this.sdkAdapter.execute(request);
+      }
+      /**
+       * Execute request via CLI
+       */
+      async executeViaCLI(request) {
+        if (!this.cliWrapper) {
+          throw new Error("GLM CLI wrapper not initialized");
+        }
+        return this.cliWrapper.execute(request);
+      }
+      /**
+       * Check if SDK is available
+       */
+      async isSDKAvailable() {
+        try {
+          const adapter = new GLMSdkAdapter({
+            ...this.sdkConfig,
+            model: this.model
+          });
+          const available = await adapter.isAvailable();
+          if (!available) {
+            return false;
+          }
+          this.sdkAdapter = adapter;
+          return true;
+        } catch (error) {
+          logger.debug("[GLM Hybrid] SDK availability check failed", {
+            error: error instanceof Error ? error.message : String(error)
+          });
+          return false;
+        }
+      }
+      /**
+       * Check if CLI is available
+       */
+      async isCLIAvailable() {
+        try {
+          const wrapper = new GLMCliWrapper({
+            ...this.cliConfig,
+            model: this.model
+          });
+          const available = await wrapper.isAvailable();
+          if (!available) {
+            return false;
+          }
+          this.cliWrapper = wrapper;
+          return true;
+        } catch (error) {
+          logger.debug("[GLM Hybrid] CLI availability check failed", {
+            error: error instanceof Error ? error.message : String(error)
+          });
+          return false;
+        }
+      }
+      /**
+       * Initialize SDK adapter
+       */
+      async initializeSDK() {
+        if (!this.sdkAdapter) {
+          this.sdkAdapter = new GLMSdkAdapter({
+            ...this.sdkConfig,
+            model: this.model
+          });
+        }
+        await this.sdkAdapter.initialize();
+        logger.debug("[GLM Hybrid] SDK initialized", {
+          model: this.model
+        });
+      }
+      /**
+       * Initialize CLI wrapper
+       */
+      async initializeCLI() {
+        if (!this.cliWrapper) {
+          this.cliWrapper = new GLMCliWrapper({
+            ...this.cliConfig,
+            model: this.model
+          });
+        }
+        await this.cliWrapper.initialize();
+        logger.debug("[GLM Hybrid] CLI initialized", {
+          model: this.model,
+          version: this.cliWrapper.getVersion()
+        });
+      }
+      /**
+       * Clean up SDK resources
+       */
+      async destroySDK() {
+        if (this.sdkAdapter) {
+          await this.sdkAdapter.destroy();
+          this.sdkAdapter = null;
+        }
+      }
+      /**
+       * Clean up CLI resources
+       */
+      async destroyCLI() {
+        if (this.cliWrapper) {
+          await this.cliWrapper.destroy();
+          this.cliWrapper = null;
+        }
+      }
+      /**
+       * Get the configured model
+       */
+      getModel() {
+        return this.model;
+      }
+      /**
+       * Get the CLI command being used
+       */
+      getCommand() {
+        return this.cliWrapper?.getCommand() || this.cliConfig.command || "ax-glm";
+      }
+      /**
+       * Get CLI version
+       */
+      getCLIVersion() {
+        return this.cliWrapper?.getVersion() || null;
+      }
+    };
+  }
+});
+
+// src/integrations/ax-glm/sdk-only-adapter.ts
+var GLMSdkOnlyAdapter;
+var init_sdk_only_adapter = __esm({
+  "src/integrations/ax-glm/sdk-only-adapter.ts"() {
+    init_esm_shims();
+    init_logger();
+    init_sdk_adapter2();
+    init_types2();
+    GLMSdkOnlyAdapter = class {
+      sdkAdapter;
+      initialized = false;
+      model;
+      maxRetries;
+      retryDelayMs;
+      constructor(options = {}) {
+        this.model = options.model || GLM_DEFAULT_MODEL;
+        this.maxRetries = options.maxRetries ?? 2;
+        this.retryDelayMs = options.retryDelayMs ?? 1e3;
+        this.sdkAdapter = new GLMSdkAdapter({
+          model: this.model,
+          apiKey: options.apiKey,
+          baseUrl: options.baseUrl,
+          timeout: options.timeout
+        });
+        logger.debug("[GLM SDK-Only] Adapter created", {
+          model: this.model,
+          maxRetries: this.maxRetries
+        });
+      }
+      /**
+       * Check if SDK is available
+       */
+      async isAvailable() {
+        return this.sdkAdapter.isAvailable();
+      }
+      /**
+       * Initialize the adapter
+       */
+      async initialize() {
+        if (this.initialized) {
+          return;
+        }
+        const available = await this.sdkAdapter.isAvailable();
+        if (!available) {
+          throw new Error("GLM SDK not available - check API key and openai package");
+        }
+        await this.sdkAdapter.initialize();
+        this.initialized = true;
+        logger.debug("[GLM SDK-Only] Initialized", { model: this.model });
+      }
+      /**
+       * Execute a request using GLM SDK
+       *
+       * Retries transient errors up to maxRetries times with exponential backoff.
+       * Does NOT fall back to CLI - throws on persistent failure.
+       */
+      async execute(request) {
+        if (!this.initialized) {
+          await this.initialize();
+        }
+        const startTime = Date.now();
+        let lastError;
+        for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+          try {
+            const response = await this.sdkAdapter.execute(request);
+            logger.debug("[GLM SDK-Only] Execution succeeded", {
+              model: this.model,
+              attempt: attempt + 1,
+              latencyMs: response.latencyMs
+            });
+            return response;
+          } catch (error) {
+            lastError = error;
+            logger.warn("[GLM SDK-Only] Execution failed", {
+              model: this.model,
+              attempt: attempt + 1,
+              maxRetries: this.maxRetries,
+              error: lastError.message
+            });
+            if (attempt < this.maxRetries && this.isRetryableError(lastError)) {
+              const delay = this.retryDelayMs * Math.pow(2, attempt);
+              logger.debug("[GLM SDK-Only] Retrying after delay", {
+                attempt: attempt + 1,
+                delayMs: delay
+              });
+              await this.sleep(delay);
+              continue;
+            }
+            break;
+          }
+        }
+        const totalTime = Date.now() - startTime;
+        logger.error("[GLM SDK-Only] All retries exhausted", {
+          model: this.model,
+          totalAttempts: this.maxRetries + 1,
+          totalTimeMs: totalTime,
+          lastError: lastError?.message
+        });
+        throw new Error(
+          `GLM SDK execution failed after ${this.maxRetries + 1} attempts: ${lastError?.message || "Unknown error"}`
+        );
+      }
+      /**
+       * Check if error is retryable
+       */
+      isRetryableError(error) {
+        const message = error.message.toLowerCase();
+        if (message.includes("rate limit") || message.includes("429")) {
+          return true;
+        }
+        if (message.includes("500") || message.includes("502") || message.includes("503") || message.includes("504")) {
+          return true;
+        }
+        if (message.includes("timeout") || message.includes("etimedout")) {
+          return true;
+        }
+        if (message.includes("econnreset") || message.includes("econnrefused")) {
+          return true;
+        }
+        return false;
+      }
+      /**
+       * Sleep utility
+       */
+      sleep(ms) {
+        return new Promise((resolve5) => setTimeout(resolve5, ms));
+      }
+      /**
+       * Get the configured model
+       */
+      getModel() {
+        return this.model;
+      }
+      /**
+       * Clean up resources
+       */
+      async destroy() {
+        await this.sdkAdapter.destroy();
+        this.initialized = false;
+        logger.debug("[GLM SDK-Only] Adapter destroyed");
+      }
+    };
+  }
+});
+
+// src/integrations/ax-glm/mcp-client-mode.ts
+var init_mcp_client_mode = __esm({
+  "src/integrations/ax-glm/mcp-client-mode.ts"() {
+    init_esm_shims();
+    init_logger();
+    init_sdk_adapter2();
+  }
+});
+
+// src/integrations/ax-glm/index.ts
+var init_ax_glm = __esm({
+  "src/integrations/ax-glm/index.ts"() {
+    init_esm_shims();
+    init_hybrid_adapter2();
+    init_sdk_adapter2();
+    init_cli_wrapper2();
+    init_sdk_only_adapter();
+    init_mcp_client_mode();
+    init_types2();
+  }
+});
+
+// src/providers/glm-provider.ts
+var glm_provider_exports = {};
+__export(glm_provider_exports, {
+  GLMProvider: () => GLMProvider,
+  default: () => GLMProvider
+});
+var MODEL_MAPPING, GLMProvider;
+var init_glm_provider = __esm({
+  "src/providers/glm-provider.ts"() {
+    init_esm_shims();
+    init_base_provider();
+    init_logger();
+    init_ax_glm();
+    MODEL_MAPPING = {
+      "glm-4-plus": "glm-4.6",
+      "glm-4v": "glm-4.5v",
+      "glm-4-air": "glm-4-flash",
+      "glm-4-airx": "glm-4-flash"
+    };
+    GLMProvider = class _GLMProvider extends BaseProvider {
+      /** Selected model */
+      model;
+      /** SDK-only adapter for direct execution (v13.0.0) */
+      sdkOnlyAdapter = null;
+      /** Legacy hybrid adapter for 'auto' mode (backwards compatibility) */
+      hybridAdapter = null;
+      /** Provider configuration */
+      glmConfig;
+      /** Supported models */
+      static SUPPORTED_MODELS = [
+        "glm-4.6",
+        "glm-4.5v",
+        "glm-4",
+        "glm-4-flash",
+        // Legacy aliases
+        "glm-4-plus",
+        "glm-4v",
+        "glm-4-air",
+        "glm-4-airx"
+      ];
+      constructor(config) {
+        super({
+          ...config,
+          command: "ax-glm"
+        });
+        this.glmConfig = config;
+        const requestedModel = config.model || "glm-4";
+        if (!_GLMProvider.SUPPORTED_MODELS.includes(requestedModel)) {
+          logger.warn(`[GLM] Unknown model: ${requestedModel}. Using glm-4.`);
+          this.model = "glm-4";
+        } else {
+          this.model = requestedModel;
+        }
+        logger.debug("[GLM Provider] Initialized", {
+          model: this.model,
+          mode: config.mode || "auto"
+        });
+      }
+      /**
+       * Get the normalized model name
+       */
+      getNormalizedModel() {
+        return MODEL_MAPPING[this.model] || this.model;
+      }
+      /**
+       * Get or create SDK-only adapter (v13.0.0 default)
+       */
+      getSdkOnlyAdapter() {
+        if (!this.sdkOnlyAdapter) {
+          this.sdkOnlyAdapter = new GLMSdkOnlyAdapter({
+            model: this.model,
+            apiKey: this.glmConfig.apiKey,
+            baseUrl: this.glmConfig.baseUrl,
+            timeout: this.glmConfig.timeout
+          });
+        }
+        return this.sdkOnlyAdapter;
+      }
+      /**
+       * Get or create hybrid adapter (legacy, for 'auto' mode only)
+       */
+      getHybridAdapter() {
+        if (!this.hybridAdapter) {
+          const options = {
+            mode: this.glmConfig.mode || "auto",
+            model: this.model,
+            apiKey: this.glmConfig.apiKey,
+            baseUrl: this.glmConfig.baseUrl,
+            command: "ax-glm",
+            timeout: this.glmConfig.timeout
+          };
+          this.hybridAdapter = new GLMHybridAdapter(options);
+        }
+        return this.hybridAdapter;
+      }
+      /**
+       * Execute a task using GLM
+       *
+       * Execution flow (v13.0.0):
+       * 1. Mock mode → return mock response
+       * 2. mode='sdk' (default) → use SDK-only adapter (NO CLI fallback)
+       * 3. mode='auto' (legacy) → use hybrid adapter (SDK with CLI fallback)
+       * 4. mode='cli' → use CLI via BaseProvider (deprecated for GLM)
+       */
+      async execute(request) {
+        if (process.env.AX_MOCK_PROVIDERS === "true") {
+          return this.createMockResponse(request.prompt);
+        }
+        const effectiveMode = this.glmConfig.mode || "sdk";
+        if (effectiveMode === "cli") {
+          logger.warn("[GLM Provider] CLI mode is deprecated for GLM. Consider using SDK mode.", {
+            model: this.model
+          });
+          return super.execute(request);
+        }
+        if (effectiveMode === "auto") {
+          logger.debug("[GLM Provider] Executing via hybrid adapter (legacy auto mode)", {
+            promptLength: request.prompt.length,
+            model: this.model
+          });
+          const adapter2 = this.getHybridAdapter();
+          return adapter2.execute(request);
+        }
+        logger.debug("[GLM Provider] Executing via SDK-only adapter", {
+          promptLength: request.prompt.length,
+          model: this.model
+        });
+        const adapter = this.getSdkOnlyAdapter();
+        return adapter.execute(request);
+      }
+      /**
+       * Get CLI command
+       */
+      getCLICommand() {
+        const adapter = this.hybridAdapter;
+        if (adapter) {
+          const activeMode = adapter.getActiveMode();
+          if (activeMode === "sdk") {
+            return "glm-sdk";
+          }
+        }
+        return "ax-glm";
+      }
+      /**
+       * Get CLI arguments for ax-glm headless mode
+       */
+      getCLIArgs() {
+        const args2 = ["-p"];
+        const normalizedModel = this.getNormalizedModel();
+        if (normalizedModel !== "glm-4") {
+          args2.push("--model", normalizedModel);
+        }
+        return args2;
+      }
+      /**
+       * Create mock response for testing
+       */
+      createMockResponse(prompt) {
+        return {
+          content: this.getMockResponse(),
+          model: this.getNormalizedModel(),
+          tokensUsed: {
+            prompt: this.estimateTokens(prompt),
+            completion: 50,
+            total: this.estimateTokens(prompt) + 50
+          },
+          latencyMs: 10,
+          finishReason: "stop",
+          cached: false
+        };
+      }
+      /**
+       * Estimate token count
+       */
+      estimateTokens(text) {
+        return Math.ceil(text.length / 4);
+      }
+      /**
+       * Get mock response for testing
+       */
+      getMockResponse() {
+        return `[Mock GLM Response]
+
+This is a mock response from the GLM provider (${this.getNormalizedModel()}).
+In production, this would be a response from ${this.glmConfig.mode === "sdk" ? "GLM SDK" : "ax-glm CLI"}.
+
+Model: ${this.getNormalizedModel()}
+Provider: GLM (Zhipu AI)
+Mode: ${this.glmConfig.mode || "auto"}`;
+      }
+      /**
+       * Get provider capabilities
+       */
+      get capabilities() {
+        const model = this.getNormalizedModel();
+        const isVision = model.includes("v") || model === "glm-4.5v";
+        let maxContextTokens = 128e3;
+        if (model === "glm-4.6") maxContextTokens = 2e5;
+        if (model === "glm-4.5v") maxContextTokens = 64e3;
+        const activeMode = this.hybridAdapter?.getActiveMode();
+        const integrationMode = activeMode === "sdk" ? "sdk" : "cli";
+        return {
+          ...super.capabilities,
+          supportsStreaming: true,
+          supportsVision: isVision,
+          maxContextTokens,
+          supportedModels: _GLMProvider.SUPPORTED_MODELS,
+          integrationMode
+        };
+      }
+      /**
+       * Get the active execution mode
+       */
+      getActiveMode() {
+        return this.hybridAdapter?.getActiveMode() || null;
+      }
+      /**
+       * Reset circuit breakers
+       */
+      resetCircuitBreakers() {
+        this.hybridAdapter?.resetCircuitBreakers();
+      }
+      /**
+       * Clean up resources
+       */
+      async destroy() {
+        if (this.sdkOnlyAdapter) {
+          await this.sdkOnlyAdapter.destroy();
+          this.sdkOnlyAdapter = null;
+        }
+        if (this.hybridAdapter) {
+          await this.hybridAdapter.destroy();
+          this.hybridAdapter = null;
+        }
+      }
+      /**
+       * Get the list of supported models
+       */
+      static getSupportedModels() {
+        return [..._GLMProvider.SUPPORTED_MODELS];
+      }
+    };
+  }
+});
+
+// src/integrations/ax-grok/types.ts
+function normalizeGrokModel(model) {
+  return GROK_MODEL_MAPPING[model] || model;
+}
+var GROK_MODEL_MAPPING, GROK_DEFAULT_BASE_URL, GROK_DEFAULT_MODEL, GROK_DEFAULT_COMMAND;
+var init_types3 = __esm({
+  "src/integrations/ax-grok/types.ts"() {
+    init_esm_shims();
+    GROK_MODEL_MAPPING = {
+      "grok-beta": "grok-3"
+    };
+    GROK_DEFAULT_BASE_URL = "https://api.x.ai/v1";
+    GROK_DEFAULT_MODEL = "grok-3";
+    GROK_DEFAULT_COMMAND = "ax-grok";
+  }
+});
+
+// src/integrations/ax-grok/sdk-adapter.ts
+var GrokSdkAdapter;
+var init_sdk_adapter3 = __esm({
+  "src/integrations/ax-grok/sdk-adapter.ts"() {
+    init_esm_shims();
+    init_logger();
+    init_validation_limits();
+    init_types3();
+    GrokSdkAdapter = class {
+      client = null;
+      config;
+      initialized = false;
+      constructor(config = {}) {
+        this.config = {
+          apiKey: config.apiKey || process.env.XAI_API_KEY || "",
+          baseUrl: config.baseUrl || GROK_DEFAULT_BASE_URL,
+          model: config.model || GROK_DEFAULT_MODEL,
+          timeout: config.timeout || TIMEOUTS.PROVIDER_DEFAULT
+        };
+        logger.debug("[Grok SDK] Adapter created", {
+          model: this.config.model,
+          baseUrl: this.config.baseUrl,
+          hasApiKey: !!this.config.apiKey
+        });
+      }
+      /**
+       * Check if SDK is available (OpenAI package installed and API key present)
+       */
+      async isAvailable() {
+        try {
+          if (!this.config.apiKey) {
+            logger.debug("[Grok SDK] No API key configured");
+            return false;
+          }
+          await import('openai');
+          return true;
+        } catch (error) {
+          logger.debug("[Grok SDK] OpenAI SDK not available", {
+            error: error instanceof Error ? error.message : String(error)
+          });
+          return false;
+        }
+      }
+      /**
+       * Initialize the SDK client
+       */
+      async initialize() {
+        if (this.initialized) {
+          return;
+        }
+        try {
+          const OpenAI = (await import('openai')).default;
+          this.client = new OpenAI({
+            apiKey: this.config.apiKey,
+            baseURL: this.config.baseUrl,
+            timeout: this.config.timeout
+          });
+          this.initialized = true;
+          logger.debug("[Grok SDK] Client initialized", {
+            model: this.config.model
+          });
+        } catch (error) {
+          throw new Error(
+            `Failed to initialize Grok SDK: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+      /**
+       * Execute a request using the Grok SDK
+       */
+      async execute(request) {
+        if (!this.initialized) {
+          await this.initialize();
+        }
+        const startTime = Date.now();
+        try {
+          const messages = [];
+          if (request.systemPrompt) {
+            messages.push({
+              role: "system",
+              content: request.systemPrompt
+            });
+          }
+          messages.push({
+            role: "user",
+            content: request.prompt
+          });
+          const model = normalizeGrokModel(this.config.model);
+          logger.debug("[Grok SDK] Executing request", {
+            model,
+            messageCount: messages.length,
+            promptLength: request.prompt.length
+          });
+          const openaiClient = this.client;
+          const response = await openaiClient.chat.completions.create({
+            model,
+            messages,
+            max_tokens: request.maxTokens,
+            temperature: request.temperature,
+            stream: false
+          });
+          const latencyMs = Date.now() - startTime;
+          if (!response.choices || response.choices.length === 0) {
+            throw new Error("Grok API returned empty choices array");
+          }
+          const choice = response.choices[0];
+          const content = choice?.message?.content || "";
+          const finishReason = choice?.finish_reason || "unknown";
+          logger.debug("[Grok SDK] Request completed", {
+            model: response.model,
+            latencyMs,
+            tokensUsed: response.usage?.total_tokens
+          });
+          return {
+            content,
+            model: response.model,
+            tokensUsed: response.usage ? {
+              prompt: response.usage.prompt_tokens,
+              completion: response.usage.completion_tokens,
+              total: response.usage.total_tokens
+            } : { prompt: 0, completion: 0, total: 0 },
+            latencyMs,
+            finishReason,
+            cached: false
+          };
+        } catch (error) {
+          const latencyMs = Date.now() - startTime;
+          logger.error("[Grok SDK] Request failed", {
+            error: error instanceof Error ? error.message : String(error),
+            latencyMs
+          });
+          throw error;
+        }
+      }
+      /**
+       * Get the configured model
+       */
+      getModel() {
+        return this.config.model;
+      }
+      /**
+       * Clean up resources
+       */
+      async destroy() {
+        this.client = null;
+        this.initialized = false;
+        logger.debug("[Grok SDK] Adapter destroyed");
+      }
+    };
+  }
+});
+var execAsync2, GrokCliWrapper;
+var init_cli_wrapper3 = __esm({
+  "src/integrations/ax-grok/cli-wrapper.ts"() {
+    init_esm_shims();
+    init_logger();
+    init_validation_limits();
+    init_types3();
+    execAsync2 = promisify(exec);
+    GrokCliWrapper = class {
+      config;
+      cliPath = null;
+      cliVersion = null;
+      constructor(config = {}) {
+        this.config = {
+          command: config.command || GROK_DEFAULT_COMMAND,
+          model: config.model || GROK_DEFAULT_MODEL,
+          timeout: config.timeout || TIMEOUTS.PROVIDER_DEFAULT
+        };
+        logger.debug("[Grok CLI] Wrapper created", {
+          command: this.config.command,
+          model: this.config.model
+        });
+      }
+      /**
+       * Check if CLI is available
+       */
+      async isAvailable() {
+        try {
+          const { stdout } = await execAsync2(`which ${this.config.command}`, {
+            timeout: TIMEOUTS.PROVIDER_DETECTION
+          });
+          this.cliPath = stdout.trim();
+          if (this.cliPath) {
+            try {
+              const { stdout: versionOutput } = await execAsync2(
+                `${this.config.command} --version`,
+                { timeout: TIMEOUTS.PROVIDER_DETECTION }
+              );
+              this.cliVersion = versionOutput.trim();
+            } catch {
+              this.cliVersion = "unknown";
+            }
+            logger.debug("[Grok CLI] CLI available", {
+              path: this.cliPath,
+              version: this.cliVersion
+            });
+            return true;
+          }
+          return false;
+        } catch (error) {
+          logger.debug("[Grok CLI] CLI not available", {
+            error: error instanceof Error ? error.message : String(error)
+          });
+          return false;
+        }
+      }
+      /**
+       * Initialize the CLI wrapper
+       */
+      async initialize() {
+        const available = await this.isAvailable();
+        if (!available) {
+          throw new Error(`${this.config.command} CLI is not installed or not in PATH`);
+        }
+      }
+      /**
+       * Execute a request using the CLI
+       */
+      async execute(request) {
+        const startTime = Date.now();
+        try {
+          const args2 = this.buildArgs(request);
+          logger.debug("[Grok CLI] Executing", {
+            command: this.config.command,
+            args: args2,
+            promptLength: request.prompt.length
+          });
+          const result = await this.spawnCLI(args2, request.prompt);
+          const latencyMs = Date.now() - startTime;
+          const response = this.parseResponse(result);
+          logger.debug("[Grok CLI] Request completed", {
+            latencyMs,
+            contentLength: response.content.length
+          });
+          return {
+            ...response,
+            latencyMs,
+            cached: false
+          };
+        } catch (error) {
+          const latencyMs = Date.now() - startTime;
+          logger.error("[Grok CLI] Request failed", {
+            error: error instanceof Error ? error.message : String(error),
+            latencyMs
+          });
+          throw error;
+        }
+      }
+      /**
+       * Build CLI arguments
+       */
+      buildArgs(request) {
+        const args2 = ["-p"];
+        const model = normalizeGrokModel(this.config.model);
+        if (model !== "grok-3") {
+          args2.push("--model", model);
+        }
+        if (request.systemPrompt) {
+          args2.push("--system", request.systemPrompt);
+        }
+        if (request.maxTokens) {
+          args2.push("--max-tokens", String(request.maxTokens));
+        }
+        if (request.temperature !== void 0) {
+          args2.push("--temperature", String(request.temperature));
+        }
+        return args2;
+      }
+      /**
+       * Spawn CLI process and get output
+       */
+      spawnCLI(args2, prompt) {
+        return new Promise((resolve5, reject) => {
+          const process2 = spawn(this.config.command, args2, {
+            stdio: ["pipe", "pipe", "pipe"],
+            timeout: this.config.timeout
+          });
+          let stdout = "";
+          let stderr = "";
+          process2.stdout.on("data", (data) => {
+            stdout += data.toString();
+          });
+          process2.stderr.on("data", (data) => {
+            stderr += data.toString();
+          });
+          process2.on("error", (error) => {
+            reject(new Error(`CLI process error: ${error.message}`));
+          });
+          process2.on("close", (code) => {
+            if (code === 0) {
+              resolve5(stdout);
+            } else {
+              reject(new Error(
+                `CLI exited with code ${code}: ${stderr || "No error message"}`
+              ));
+            }
+          });
+          process2.stdin.write(prompt);
+          process2.stdin.end();
+        });
+      }
+      /**
+       * Parse CLI response
+       */
+      parseResponse(output) {
+        try {
+          const parsed = JSON.parse(output.trim());
+          if (parsed.content || parsed.message) {
+            return {
+              content: parsed.content || parsed.message || "",
+              model: parsed.model || normalizeGrokModel(this.config.model),
+              tokensUsed: parsed.usage ? {
+                prompt: parsed.usage.prompt_tokens || 0,
+                completion: parsed.usage.completion_tokens || 0,
+                total: parsed.usage.total_tokens || 0
+              } : { prompt: 0, completion: 0, total: 0 },
+              finishReason: parsed.finish_reason || "stop"
+            };
+          }
+        } catch {
+        }
+        return {
+          content: output.trim(),
+          model: normalizeGrokModel(this.config.model),
+          tokensUsed: { prompt: 0, completion: 0, total: 0 },
+          finishReason: "stop"
+        };
+      }
+      /**
+       * Get the configured model
+       */
+      getModel() {
+        return this.config.model;
+      }
+      /**
+       * Get CLI version
+       */
+      getVersion() {
+        return this.cliVersion;
+      }
+      /**
+       * Get CLI command
+       */
+      getCommand() {
+        return this.config.command;
+      }
+      /**
+       * Clean up resources
+       */
+      async destroy() {
+        logger.debug("[Grok CLI] Wrapper destroyed");
+      }
+    };
+  }
+});
+
+// src/integrations/ax-grok/hybrid-adapter.ts
+var GrokHybridAdapter;
+var init_hybrid_adapter3 = __esm({
+  "src/integrations/ax-grok/hybrid-adapter.ts"() {
+    init_esm_shims();
+    init_hybrid_adapter_base();
+    init_sdk_adapter3();
+    init_cli_wrapper3();
+    init_types3();
+    init_logger();
+    GrokHybridAdapter = class extends HybridAdapterBase {
+      sdkAdapter = null;
+      cliWrapper = null;
+      model;
+      sdkConfig;
+      cliConfig;
+      constructor(options = {}) {
+        const baseOptions = {
+          mode: options.mode || "auto",
+          providerName: "grok",
+          maxRetries: options.maxRetries ?? 1
+        };
+        super(baseOptions);
+        this.model = options.model || GROK_DEFAULT_MODEL;
+        this.sdkConfig = {
+          apiKey: options.apiKey,
+          baseUrl: options.baseUrl,
+          timeout: options.timeout
+        };
+        this.cliConfig = {
+          command: options.command,
+          timeout: options.timeout
+        };
+        logger.debug("[Grok Hybrid] Adapter created", {
+          mode: this.mode,
+          model: this.model
+        });
+      }
+      /**
+       * Execute request via SDK
+       */
+      async executeViaSDK(request) {
+        if (!this.sdkAdapter) {
+          throw new Error("Grok SDK adapter not initialized");
+        }
+        return this.sdkAdapter.execute(request);
+      }
+      /**
+       * Execute request via CLI
+       */
+      async executeViaCLI(request) {
+        if (!this.cliWrapper) {
+          throw new Error("Grok CLI wrapper not initialized");
+        }
+        return this.cliWrapper.execute(request);
+      }
+      /**
+       * Check if SDK is available
+       */
+      async isSDKAvailable() {
+        try {
+          const adapter = new GrokSdkAdapter({
+            ...this.sdkConfig,
+            model: this.model
+          });
+          const available = await adapter.isAvailable();
+          if (!available) {
+            return false;
+          }
+          this.sdkAdapter = adapter;
+          return true;
+        } catch (error) {
+          logger.debug("[Grok Hybrid] SDK availability check failed", {
+            error: error instanceof Error ? error.message : String(error)
+          });
+          return false;
+        }
+      }
+      /**
+       * Check if CLI is available
+       */
+      async isCLIAvailable() {
+        try {
+          const wrapper = new GrokCliWrapper({
+            ...this.cliConfig,
+            model: this.model
+          });
+          const available = await wrapper.isAvailable();
+          if (!available) {
+            return false;
+          }
+          this.cliWrapper = wrapper;
+          return true;
+        } catch (error) {
+          logger.debug("[Grok Hybrid] CLI availability check failed", {
+            error: error instanceof Error ? error.message : String(error)
+          });
+          return false;
+        }
+      }
+      /**
+       * Initialize SDK adapter
+       */
+      async initializeSDK() {
+        if (!this.sdkAdapter) {
+          this.sdkAdapter = new GrokSdkAdapter({
+            ...this.sdkConfig,
+            model: this.model
+          });
+        }
+        await this.sdkAdapter.initialize();
+        logger.debug("[Grok Hybrid] SDK initialized", {
+          model: this.model
+        });
+      }
+      /**
+       * Initialize CLI wrapper
+       */
+      async initializeCLI() {
+        if (!this.cliWrapper) {
+          this.cliWrapper = new GrokCliWrapper({
+            ...this.cliConfig,
+            model: this.model
+          });
+        }
+        await this.cliWrapper.initialize();
+        logger.debug("[Grok Hybrid] CLI initialized", {
+          model: this.model,
+          version: this.cliWrapper.getVersion()
+        });
+      }
+      /**
+       * Clean up SDK resources
+       */
+      async destroySDK() {
+        if (this.sdkAdapter) {
+          await this.sdkAdapter.destroy();
+          this.sdkAdapter = null;
+        }
+      }
+      /**
+       * Clean up CLI resources
+       */
+      async destroyCLI() {
+        if (this.cliWrapper) {
+          await this.cliWrapper.destroy();
+          this.cliWrapper = null;
+        }
+      }
+      /**
+       * Get the configured model
+       */
+      getModel() {
+        return this.model;
+      }
+      /**
+       * Get the CLI command being used
+       */
+      getCommand() {
+        return this.cliWrapper?.getCommand() || this.cliConfig.command || "ax-grok";
+      }
+      /**
+       * Get CLI version
+       */
+      getCLIVersion() {
+        return this.cliWrapper?.getVersion() || null;
+      }
+    };
+  }
+});
+
+// src/integrations/ax-grok/sdk-only-adapter.ts
+var GrokSdkOnlyAdapter;
+var init_sdk_only_adapter2 = __esm({
+  "src/integrations/ax-grok/sdk-only-adapter.ts"() {
+    init_esm_shims();
+    init_logger();
+    init_sdk_adapter3();
+    init_types3();
+    GrokSdkOnlyAdapter = class {
+      sdkAdapter;
+      initialized = false;
+      model;
+      maxRetries;
+      retryDelayMs;
+      constructor(options = {}) {
+        this.model = options.model || GROK_DEFAULT_MODEL;
+        this.maxRetries = options.maxRetries ?? 2;
+        this.retryDelayMs = options.retryDelayMs ?? 1e3;
+        this.sdkAdapter = new GrokSdkAdapter({
+          model: this.model,
+          apiKey: options.apiKey,
+          baseUrl: options.baseUrl,
+          timeout: options.timeout
+        });
+        logger.debug("[Grok SDK-Only] Adapter created", {
+          model: this.model,
+          maxRetries: this.maxRetries
+        });
+      }
+      /**
+       * Check if SDK is available
+       */
+      async isAvailable() {
+        return this.sdkAdapter.isAvailable();
+      }
+      /**
+       * Initialize the adapter
+       */
+      async initialize() {
+        if (this.initialized) {
+          return;
+        }
+        const available = await this.sdkAdapter.isAvailable();
+        if (!available) {
+          throw new Error("Grok SDK not available - check API key and openai package");
+        }
+        await this.sdkAdapter.initialize();
+        this.initialized = true;
+        logger.debug("[Grok SDK-Only] Initialized", { model: this.model });
+      }
+      /**
+       * Execute a request using Grok SDK
+       *
+       * Retries transient errors up to maxRetries times with exponential backoff.
+       * Does NOT fall back to CLI - throws on persistent failure.
+       */
+      async execute(request) {
+        if (!this.initialized) {
+          await this.initialize();
+        }
+        const startTime = Date.now();
+        let lastError;
+        for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+          try {
+            const response = await this.sdkAdapter.execute(request);
+            logger.debug("[Grok SDK-Only] Execution succeeded", {
+              model: this.model,
+              attempt: attempt + 1,
+              latencyMs: response.latencyMs
+            });
+            return response;
+          } catch (error) {
+            lastError = error;
+            logger.warn("[Grok SDK-Only] Execution failed", {
+              model: this.model,
+              attempt: attempt + 1,
+              maxRetries: this.maxRetries,
+              error: lastError.message
+            });
+            if (attempt < this.maxRetries && this.isRetryableError(lastError)) {
+              const delay = this.retryDelayMs * Math.pow(2, attempt);
+              logger.debug("[Grok SDK-Only] Retrying after delay", {
+                attempt: attempt + 1,
+                delayMs: delay
+              });
+              await this.sleep(delay);
+              continue;
+            }
+            break;
+          }
+        }
+        const totalTime = Date.now() - startTime;
+        logger.error("[Grok SDK-Only] All retries exhausted", {
+          model: this.model,
+          totalAttempts: this.maxRetries + 1,
+          totalTimeMs: totalTime,
+          lastError: lastError?.message
+        });
+        throw new Error(
+          `Grok SDK execution failed after ${this.maxRetries + 1} attempts: ${lastError?.message || "Unknown error"}`
+        );
+      }
+      /**
+       * Check if error is retryable
+       */
+      isRetryableError(error) {
+        const message = error.message.toLowerCase();
+        if (message.includes("rate limit") || message.includes("429")) {
+          return true;
+        }
+        if (message.includes("500") || message.includes("502") || message.includes("503") || message.includes("504")) {
+          return true;
+        }
+        if (message.includes("timeout") || message.includes("etimedout")) {
+          return true;
+        }
+        if (message.includes("econnreset") || message.includes("econnrefused")) {
+          return true;
+        }
+        return false;
+      }
+      /**
+       * Sleep utility
+       */
+      sleep(ms) {
+        return new Promise((resolve5) => setTimeout(resolve5, ms));
+      }
+      /**
+       * Get the configured model
+       */
+      getModel() {
+        return this.model;
+      }
+      /**
+       * Clean up resources
+       */
+      async destroy() {
+        await this.sdkAdapter.destroy();
+        this.initialized = false;
+        logger.debug("[Grok SDK-Only] Adapter destroyed");
+      }
+    };
+  }
+});
+
+// src/integrations/ax-grok/mcp-client-mode.ts
+var init_mcp_client_mode2 = __esm({
+  "src/integrations/ax-grok/mcp-client-mode.ts"() {
+    init_esm_shims();
+    init_logger();
+    init_sdk_adapter3();
+  }
+});
+
+// src/integrations/ax-grok/index.ts
+var init_ax_grok = __esm({
+  "src/integrations/ax-grok/index.ts"() {
+    init_esm_shims();
+    init_hybrid_adapter3();
+    init_sdk_adapter3();
+    init_cli_wrapper3();
+    init_sdk_only_adapter2();
+    init_mcp_client_mode2();
+    init_types3();
+  }
+});
+
+// src/providers/grok-provider.ts
+var grok_provider_exports = {};
+__export(grok_provider_exports, {
+  GrokProvider: () => GrokProvider,
+  default: () => GrokProvider
+});
+var MODEL_MAPPING2, GrokProvider;
+var init_grok_provider = __esm({
+  "src/providers/grok-provider.ts"() {
+    init_esm_shims();
+    init_base_provider();
+    init_logger();
+    init_ax_grok();
+    MODEL_MAPPING2 = {
+      "grok-beta": "grok-3"
+    };
+    GrokProvider = class _GrokProvider extends BaseProvider {
+      /** Selected model */
+      model;
+      /** SDK-only adapter for direct execution (v13.0.0) */
+      sdkOnlyAdapter = null;
+      /** Legacy hybrid adapter for 'auto' mode (backwards compatibility) */
+      hybridAdapter = null;
+      /** Provider configuration */
+      grokConfig;
+      /** Supported models */
+      static SUPPORTED_MODELS = [
+        "grok-3",
+        "grok-3-mini",
+        "grok-2-vision",
+        "grok-2",
+        // Legacy alias
+        "grok-beta"
+      ];
+      constructor(config) {
+        super({
+          ...config,
+          command: "ax-grok"
+        });
+        this.grokConfig = config;
+        const requestedModel = config.model || "grok-3";
+        if (!_GrokProvider.SUPPORTED_MODELS.includes(requestedModel)) {
+          logger.warn(`[Grok] Unknown model: ${requestedModel}. Using grok-3.`);
+          this.model = "grok-3";
+        } else {
+          this.model = requestedModel;
+        }
+        logger.debug("[Grok Provider] Initialized", {
+          model: this.model,
+          mode: config.mode || "auto"
+        });
+      }
+      /**
+       * Get the normalized model name
+       */
+      getNormalizedModel() {
+        return MODEL_MAPPING2[this.model] || this.model;
+      }
+      /**
+       * Get or create SDK-only adapter (v13.0.0 default)
+       */
+      getSdkOnlyAdapter() {
+        if (!this.sdkOnlyAdapter) {
+          this.sdkOnlyAdapter = new GrokSdkOnlyAdapter({
+            model: this.model,
+            apiKey: this.grokConfig.apiKey,
+            baseUrl: this.grokConfig.baseUrl,
+            timeout: this.grokConfig.timeout
+          });
+        }
+        return this.sdkOnlyAdapter;
+      }
+      /**
+       * Get or create hybrid adapter (legacy, for 'auto' mode only)
+       */
+      getHybridAdapter() {
+        if (!this.hybridAdapter) {
+          const options = {
+            mode: this.grokConfig.mode || "auto",
+            model: this.model,
+            apiKey: this.grokConfig.apiKey,
+            baseUrl: this.grokConfig.baseUrl,
+            command: "ax-grok",
+            timeout: this.grokConfig.timeout
+          };
+          this.hybridAdapter = new GrokHybridAdapter(options);
+        }
+        return this.hybridAdapter;
+      }
+      /**
+       * Execute a task using Grok
+       *
+       * Execution flow (v13.0.0):
+       * 1. Mock mode → return mock response
+       * 2. mode='sdk' (default) → use SDK-only adapter (NO CLI fallback)
+       * 3. mode='auto' (legacy) → use hybrid adapter (SDK with CLI fallback)
+       * 4. mode='cli' → use CLI via BaseProvider (deprecated for Grok)
+       */
+      async execute(request) {
+        if (process.env.AX_MOCK_PROVIDERS === "true") {
+          return this.createMockResponse(request.prompt);
+        }
+        const effectiveMode = this.grokConfig.mode || "sdk";
+        if (effectiveMode === "cli") {
+          logger.warn("[Grok Provider] CLI mode is deprecated for Grok. Consider using SDK mode.", {
+            model: this.model
+          });
+          return super.execute(request);
+        }
+        if (effectiveMode === "auto") {
+          logger.debug("[Grok Provider] Executing via hybrid adapter (legacy auto mode)", {
+            promptLength: request.prompt.length,
+            model: this.model
+          });
+          const adapter2 = this.getHybridAdapter();
+          return adapter2.execute(request);
+        }
+        logger.debug("[Grok Provider] Executing via SDK-only adapter", {
+          promptLength: request.prompt.length,
+          model: this.model
+        });
+        const adapter = this.getSdkOnlyAdapter();
+        return adapter.execute(request);
+      }
+      /**
+       * Get CLI command
+       */
+      getCLICommand() {
+        const adapter = this.hybridAdapter;
+        if (adapter) {
+          const activeMode = adapter.getActiveMode();
+          if (activeMode === "sdk") {
+            return "grok-sdk";
+          }
+        }
+        return "ax-grok";
+      }
+      /**
+       * Get CLI arguments for ax-grok headless mode
+       */
+      getCLIArgs() {
+        const args2 = ["-p"];
+        const normalizedModel = this.getNormalizedModel();
+        if (normalizedModel !== "grok-3") {
+          args2.push("--model", normalizedModel);
+        }
+        return args2;
+      }
+      /**
+       * Create mock response for testing
+       */
+      createMockResponse(prompt) {
+        return {
+          content: this.getMockResponse(),
+          model: this.getNormalizedModel(),
+          tokensUsed: {
+            prompt: this.estimateTokens(prompt),
+            completion: 50,
+            total: this.estimateTokens(prompt) + 50
+          },
+          latencyMs: 10,
+          finishReason: "stop",
+          cached: false
+        };
+      }
+      /**
+       * Estimate token count
+       */
+      estimateTokens(text) {
+        return Math.ceil(text.length / 4);
+      }
+      /**
+       * Get mock response for testing
+       */
+      getMockResponse() {
+        return `[Mock Grok Response]
+
+This is a mock response from the Grok provider (${this.getNormalizedModel()}).
+In production, this would be a response from ${this.grokConfig.mode === "sdk" ? "Grok SDK" : "ax-grok CLI"}.
+
+Model: ${this.getNormalizedModel()}
+Provider: Grok (xAI)
+Mode: ${this.grokConfig.mode || "auto"}`;
+      }
+      /**
+       * Get provider capabilities
+       */
+      get capabilities() {
+        const model = this.getNormalizedModel();
+        const isVision = model.includes("vision") || model === "grok-2-vision";
+        const maxContextTokens = 131072;
+        const activeMode = this.hybridAdapter?.getActiveMode();
+        const integrationMode = activeMode === "sdk" ? "sdk" : "cli";
+        return {
+          ...super.capabilities,
+          supportsStreaming: true,
+          supportsVision: isVision,
+          maxContextTokens,
+          supportedModels: _GrokProvider.SUPPORTED_MODELS,
+          integrationMode
+        };
+      }
+      /**
+       * Get the active execution mode
+       */
+      getActiveMode() {
+        return this.hybridAdapter?.getActiveMode() || null;
+      }
+      /**
+       * Reset circuit breakers
+       */
+      resetCircuitBreakers() {
+        this.hybridAdapter?.resetCircuitBreakers();
+      }
+      /**
+       * Clean up resources
+       */
+      async destroy() {
+        if (this.sdkOnlyAdapter) {
+          await this.sdkOnlyAdapter.destroy();
+          this.sdkOnlyAdapter = null;
+        }
+        if (this.hybridAdapter) {
+          await this.hybridAdapter.destroy();
+          this.hybridAdapter = null;
+        }
+      }
+      /**
+       * Get the list of supported models
+       */
+      static getSupportedModels() {
+        return [..._GrokProvider.SUPPORTED_MODELS];
+      }
+    };
   }
 });
 
@@ -4149,18 +7575,19 @@ init_esm_shims();
 
 // src/mcp/server.ts
 init_esm_shims();
+init_validation_limits();
 
 // src/shared/helpers/version.ts
 init_esm_shims();
-var __dirname$1 = dirname(fileURLToPath(import.meta.url));
+var __dirname2 = dirname(fileURLToPath(import.meta.url));
 function getVersion() {
   try {
     const possiblePaths = [
-      join(__dirname$1, "../../../package.json"),
+      join(__dirname2, "../../../package.json"),
       // From src/shared/helpers
-      join(__dirname$1, "../../package.json"),
+      join(__dirname2, "../../package.json"),
       // From dist/mcp (bundled MCP entry)
-      join(__dirname$1, "../package.json")
+      join(__dirname2, "../package.json")
       // From dist
     ];
     for (const pkgPath of possiblePaths) {
@@ -4182,7 +7609,8 @@ function getVersion() {
 
 // src/mcp/types.ts
 init_esm_shims();
-var MCP_PROTOCOL_VERSION = "2024-11-05";
+var MCP_PROTOCOL_VERSION = "2025-11-25";
+var MCP_SUPPORTED_VERSIONS = ["2025-11-25", "2024-12-05", "2024-11-05"];
 
 // src/mcp/server.ts
 init_logger();
@@ -4618,119 +8046,8 @@ function deepMerge(defaults, user) {
   return result;
 }
 
-// src/core/validation-limits.ts
-init_esm_shims();
-var VALIDATION_LIMITS = {
-  // Resource limits (prevent DoS)
-  MAX_ENTRIES: 1e6,
-  // 1 million entries (memory, cache)
-  MAX_TIMEOUT: 36e5,
-  // 1 hour (execution, delegation)
-  MAX_FILE_SIZE: 104857600,
-  // 100 MB (workspace, abilities)
-  MAX_CACHE_SIZE: 524288e3,
-  // 500 MB (cache storage)
-  MAX_SESSIONS: 1e4,
-  // 10k concurrent sessions
-  // Performance limits (prevent resource exhaustion)
-  MAX_CONCURRENT_AGENTS: 100,
-  // Maximum concurrent agents
-  MAX_CPU_PERCENT: 80,
-  // Maximum CPU usage percent
-  MAX_MEMORY_MB: 2048,
-  // Maximum memory usage in MB
-  // Config validation limits
-  MAX_CONFIG_FILE_SIZE: 1048576,
-  // 1MB max config file size
-  MAX_NAME_LENGTH: 50,
-  // Max name length for agents/providers
-  MAX_COMMAND_LENGTH: 100,
-  // Max command length
-  MAX_ARRAY_LENGTH: 1e4,
-  // Max array elements in config
-  // Path and file limits
-  MIN_FILE_SIZE: 1,
-  // Minimum file size in bytes
-  MIN_TIMEOUT: 1e3,
-  // Minimum timeout in ms (1 second)
-  MIN_INTERVAL: 100,
-  // Minimum interval in ms
-  MIN_BACKOFF_FACTOR: 1,
-  // Minimum backoff multiplier
-  MAX_BACKOFF_FACTOR: 5,
-  // Maximum backoff multiplier
-  MAX_TTL: 864e5,
-  // Maximum TTL in ms (24 hours)
-  MIN_BYTES: 1,
-  // Minimum bytes for file sizes
-  // Network limits
-  MIN_PORT: 1024,
-  // Minimum port number
-  MAX_PORT: 65535
-  // Maximum port number
-};
-function isValidRelativePath(path7) {
-  if (!path7 || typeof path7 !== "string") {
-    return false;
-  }
-  const normalizedPath = path7.replace(/\\/g, "/");
-  if (normalizedPath.startsWith("/")) {
-    return false;
-  }
-  if (normalizedPath.includes("..")) {
-    return false;
-  }
-  if (/^[a-zA-Z]:/.test(normalizedPath)) {
-    return false;
-  }
-  if (normalizedPath.startsWith("//")) {
-    return false;
-  }
-  return true;
-}
-function isValidCommand(command) {
-  if (!command || typeof command !== "string") {
-    return false;
-  }
-  if (command.length > VALIDATION_LIMITS.MAX_COMMAND_LENGTH) {
-    return false;
-  }
-  if (!/^[a-z0-9_-]+$/i.test(command)) {
-    return false;
-  }
-  return true;
-}
-function isValidName(name) {
-  if (!name || typeof name !== "string") {
-    return false;
-  }
-  if (name.length > VALIDATION_LIMITS.MAX_NAME_LENGTH) {
-    return false;
-  }
-  if (!/^[a-z0-9][a-z0-9-_]*$/i.test(name)) {
-    return false;
-  }
-  return true;
-}
-function isValidExtension(ext) {
-  if (!ext || typeof ext !== "string") {
-    return false;
-  }
-  const normalized = ext.startsWith(".") ? ext : `.${ext}`;
-  if (normalized.length > 10 || normalized.length < 2) {
-    return false;
-  }
-  if (!/^\.[a-z0-9]+$/i.test(normalized)) {
-    return false;
-  }
-  return true;
-}
-function isPositiveInteger(value) {
-  return typeof value === "number" && Number.isInteger(value) && value > 0;
-}
-function isNonNegativeInteger(value) {
-  return typeof value === "number" && Number.isInteger(value) && value >= 0;
-}
+// src/core/config/loader.ts
+init_validation_limits();
 
 // src/core/cache/cache.ts
 init_esm_shims();
@@ -4806,7 +8123,7 @@ var TTLCache = class {
    * @param value Value to cache
    * @param customTTL Optional custom TTL for this entry (ms)
    */
-  set(key, value, customTTL) {
+  set(key, value, _customTTL) {
     const size = this.estimateSize(value);
     if (this.config.maxSize > 0 && size > this.config.maxSize) {
       logger.warn("Entry too large for cache", {
@@ -5063,11 +8380,12 @@ function calculateMaxConcurrentAgents(staticLimit) {
 init_esm_shims();
 var PRECOMPILED_CONFIG = {
   "providers": {
-    "claude-code": {
+    "gemini-cli": {
       "enabled": true,
-      "priority": 3,
+      "priority": 1,
       "timeout": 27e5,
-      "command": "claude",
+      "command": "gemini",
+      "description": "#1 Frontend/Design, multimodal, free tier, WebDev Arena leader",
       "healthCheck": {
         "enabled": true,
         "interval": 3e5,
@@ -5089,15 +8407,16 @@ var PRECOMPILED_CONFIG = {
       },
       "limitTracking": {
         "enabled": true,
-        "window": "weekly",
+        "window": "daily",
         "resetHourUtc": 0
       }
     },
-    "gemini-cli": {
+    "openai": {
       "enabled": true,
-      "priority": 2,
+      "priority": 3,
       "timeout": 27e5,
-      "command": "gemini",
+      "command": "codex",
+      "description": "Best reasoning (o3), strategy, 75% accuracy, 192k context",
       "healthCheck": {
         "enabled": true,
         "interval": 3e5,
@@ -5123,11 +8442,12 @@ var PRECOMPILED_CONFIG = {
         "resetHourUtc": 0
       }
     },
-    "openai": {
+    "claude-code": {
       "enabled": true,
-      "priority": 1,
+      "priority": 2,
       "timeout": 27e5,
-      "command": "codex",
+      "command": "claude",
+      "description": "#1 Coding model, agentic workflows, security, 0% edit error rate",
       "healthCheck": {
         "enabled": true,
         "interval": 3e5,
@@ -5147,6 +8467,50 @@ var PRECOMPILED_CONFIG = {
         "forceKillDelay": 1e3,
         "cacheEnabled": true
       },
+      "limitTracking": {
+        "enabled": true,
+        "window": "weekly",
+        "resetHourUtc": 0
+      }
+    },
+    "glm": {
+      "enabled": true,
+      "priority": 4,
+      "timeout": 27e5,
+      "type": "sdk",
+      "description": "Near Claude coding (48.6%), low cost $3/mo, 200k context, agentic",
+      "healthCheck": {
+        "enabled": true,
+        "interval": 3e5,
+        "timeout": 5e3
+      },
+      "circuitBreaker": {
+        "enabled": true,
+        "failureThreshold": 3,
+        "recoveryTimeout": 6e4
+      },
+      "limitTracking": {
+        "enabled": true,
+        "window": "daily",
+        "resetHourUtc": 0
+      }
+    },
+    "grok": {
+      "enabled": true,
+      "priority": 5,
+      "timeout": 27e5,
+      "type": "sdk",
+      "description": "Fastest (67ms), reasoning (93% AIME), 1M context, DeepSearch",
+      "healthCheck": {
+        "enabled": true,
+        "interval": 3e5,
+        "timeout": 5e3
+      },
+      "circuitBreaker": {
+        "enabled": true,
+        "failureThreshold": 3,
+        "recoveryTimeout": 6e4
+      },
       "limitTracking": {
         "enabled": true,
         "window": "daily",
@@ -5363,11 +8727,12 @@ var PRECOMPILED_CONFIG = {
     "enableFreeTierPrioritization": true,
     "enableWorkloadAwareRouting": true
   },
-  "version": "12.3.0"
+  "version": "12.4.1"
 };
 
 // src/core/config/schemas.ts
 init_esm_shims();
+init_validation_limits();
 z.enum([
   "claude",
   "claude-code",
@@ -5430,17 +8795,35 @@ var limitTrackingConfigSchema = z.object({
   resetHourUtc: z.number().int().min(0).max(23).default(0),
   customResetMs: positiveIntSchema.optional()
 }).describe("Provider limit tracking configuration");
+var providerTypeSchema = z.enum(["cli", "sdk", "hybrid"]).default("cli");
 var providerConfigSchema = z.object({
   enabled: z.boolean().default(true),
   priority: positiveIntSchema,
   timeout: timeoutSchema,
-  command: commandSchema,
+  type: providerTypeSchema.optional(),
+  command: commandSchema.optional(),
+  // Optional for SDK providers (glm, grok)
+  description: z.string().optional(),
+  // Provider description
+  model: z.string().optional(),
+  // Model name override
   healthCheck: healthCheckConfigSchema.optional(),
   circuitBreaker: circuitBreakerConfigSchema.optional(),
   processManagement: processManagementConfigSchema.optional(),
   versionDetection: versionDetectionConfigSchema.optional(),
   limitTracking: limitTrackingConfigSchema.optional()
-}).describe("Provider configuration");
+}).refine(
+  (data) => {
+    if (data.type === "sdk") {
+      return true;
+    }
+    return data.command !== void 0;
+  },
+  {
+    message: "CLI and hybrid providers require a command field",
+    path: ["command"]
+  }
+).describe("Provider configuration");
 var providersConfigSchema = z.record(
   safeNameSchema,
   providerConfigSchema
@@ -5826,9 +9209,15 @@ function validateConfig(config) {
     if (!isValidName(name)) {
       errors.push(`Provider "${name}": name invalid (use alphanumeric, dash, underscore only, max 50 chars)`);
     }
-    if (!provider.command) {
-      errors.push(`Provider ${name}: command is required`);
-    } else if (!isValidCommand(provider.command)) {
+    const providerType = provider.type;
+    const isSDKProvider = providerType === "sdk";
+    if (!isSDKProvider) {
+      if (!provider.command) {
+        errors.push(`Provider ${name}: command is required for CLI/hybrid providers`);
+      } else if (!isValidCommand(provider.command)) {
+        errors.push(`Provider ${name}: command invalid (alphanumeric, dash, underscore only, max 100 chars, no shell metacharacters)`);
+      }
+    } else if (provider.command && !isValidCommand(provider.command)) {
       errors.push(`Provider ${name}: command invalid (alphanumeric, dash, underscore only, max 100 chars, no shell metacharacters)`);
     }
     if (!isPositiveInteger(provider.priority)) {
@@ -6204,6 +9593,7 @@ function validateConfig(config) {
 init_esm_shims();
 init_logger();
 init_errors();
+init_validation_limits();
 
 // src/core/provider-limit-manager.ts
 init_esm_shims();
@@ -6414,6 +9804,9 @@ var PathResolver = class {
     }
   }
 };
+
+// src/core/provider-limit-manager.ts
+init_validation_limits();
 var ProviderLimitManager = class _ProviderLimitManager extends EventEmitter {
   static instance = null;
   stateFilePath;
@@ -6439,7 +9832,7 @@ var ProviderLimitManager = class _ProviderLimitManager extends EventEmitter {
   /**
    * Get singleton instance
    */
-  static getInstance(stateDirectory = ".automatosx/state") {
+  static getInstance(stateDirectory = AX_PATHS.STATE) {
     if (!_ProviderLimitManager.instance) {
       _ProviderLimitManager.instance = new _ProviderLimitManager(stateDirectory);
     }
@@ -6527,7 +9920,9 @@ var ProviderLimitManager = class _ProviderLimitManager extends EventEmitter {
       return { isLimited: false };
     }
     if (now >= state.resetAtMs) {
-      void this.clearLimit(providerName, "expired");
+      void this.clearLimit(providerName, "expired").catch((err) => {
+        logger.warn("Failed to clear expired limit", { provider: providerName, error: err.message });
+      });
       return { isLimited: false };
     }
     const remainingMs = state.resetAtMs - now;
@@ -6616,9 +10011,10 @@ var ProviderLimitManager = class _ProviderLimitManager extends EventEmitter {
   getManualOverride() {
     if (this.manualOverride && this.manualOverride.expiresAtMs) {
       if (Date.now() >= this.manualOverride.expiresAtMs) {
-        this.manualOverride;
         this.manualOverride = void 0;
-        void this.clearManualOverride();
+        void this.clearManualOverride().catch((err) => {
+          logger.warn("Failed to clear expired manual override", { error: err.message });
+        });
         return void 0;
       }
     }
@@ -6755,10 +10151,10 @@ var ProviderLimitManager = class _ProviderLimitManager extends EventEmitter {
 async function getProviderLimitManager(stateDirectory) {
   if (!stateDirectory) {
     if (process.env.NODE_ENV === "test" || process.env.VITEST) {
-      stateDirectory = ".automatosx/state";
+      stateDirectory = AX_PATHS.STATE;
     } else {
       const projectRoot = await detectProjectRoot();
-      stateDirectory = path4.join(projectRoot, ".automatosx", "state");
+      stateDirectory = path4.join(projectRoot, AX_PATHS.STATE);
     }
   }
   return ProviderLimitManager.getInstance(stateDirectory);
@@ -7741,13 +11137,12 @@ function getRoutingStrategyManager(config) {
 // src/core/router/circuit-breaker.ts
 init_esm_shims();
 init_logger();
+init_validation_limits();
 var DEFAULT_CONFIG2 = {
   failureThreshold: 3,
-  cooldownMs: 6e4,
-  // 1 minute
+  cooldownMs: TIMEOUTS.CIRCUIT_BREAKER_RECOVERY,
   successThreshold: 2,
-  failureWindowMs: 3e5
-  // v11.1.0: 5 minutes - failures outside this window don't count
+  failureWindowMs: TIMEOUTS.CIRCUIT_BREAKER_WINDOW
 };
 var CircuitBreaker = class {
   config;
@@ -7904,6 +11299,7 @@ var CircuitBreaker = class {
 // src/core/router/trace-logger.ts
 init_esm_shims();
 init_logger();
+init_validation_limits();
 var RouterTraceLogger = class {
   traceFile;
   stream;
@@ -7915,7 +11311,7 @@ var RouterTraceLogger = class {
   sigintHandler = () => this.close();
   sigtermHandler = () => this.close();
   constructor(options) {
-    this.traceFile = join(options.workspacePath, ".automatosx/logs/router.trace.jsonl");
+    this.traceFile = join(options.workspacePath, AX_PATHS.LOGS, "router.trace.jsonl");
     this.enabled = options.enabled ?? true;
     this.autoFlush = options.autoFlush ?? true;
     if (this.enabled) {
@@ -8302,13 +11698,12 @@ var Router = class {
       return a.priority - b.priority;
     });
     this.fallbackEnabled = config.fallbackEnabled;
-    this.providerCooldownMs = config.providerCooldownMs ?? 3e4;
+    this.providerCooldownMs = config.providerCooldownMs ?? TIMEOUTS.PROVIDER_COOLDOWN;
     this.cache = config.cache;
     this.circuitBreaker = new CircuitBreaker({
       failureThreshold: config.circuitBreakerThreshold ?? 3,
-      cooldownMs: config.providerCooldownMs ?? 3e4,
-      failureWindowMs: config.circuitBreakerWindowMs ?? 3e5
-      // 5 min default
+      cooldownMs: config.providerCooldownMs ?? TIMEOUTS.PROVIDER_COOLDOWN,
+      failureWindowMs: config.circuitBreakerWindowMs ?? TIMEOUTS.CIRCUIT_BREAKER_WINDOW
     });
     void (async () => {
       try {
@@ -8352,6 +11747,13 @@ var Router = class {
       }
     }
   }
+  /**
+   * Get the number of configured providers.
+   * @returns Number of providers registered with this router
+   */
+  get providerCount() {
+    return this.providers.length;
+  }
   /**
    * Warm up provider availability caches immediately.
    * Phase 3 (v5.6.3): Eliminates cold-start latency on first request.
@@ -10337,9 +13739,9 @@ var MemoryManager = class _MemoryManager {
       throw new MemoryError("Memory manager not initialized", "DATABASE_ERROR");
     }
     try {
-      const { mkdir: mkdir5 } = await import('fs/promises');
+      const { mkdir: mkdir4 } = await import('fs/promises');
       const destDir = dirname3(destPath);
-      await mkdir5(destDir, { recursive: true });
+      await mkdir4(destDir, { recursive: true });
       await this.db.backup(destPath);
       logger.info("Database backup created", { destPath: normalizePath(destPath) });
     } catch (error) {
@@ -10787,7 +14189,7 @@ var LazyMemoryManager = class {
   /**
    * Backup database to destination path (lazy initialization on first call)
    */
-  async backup(destPath, onProgress) {
+  async backup(destPath, _onProgress) {
     const manager = await this.ensureInitialized();
     return manager.backup(destPath);
   }
@@ -11681,12 +15083,13 @@ var SessionManager = class _SessionManager {
    */
   async getStats() {
     const sessions = Array.from(this.activeSessions.values());
-    return {
-      total: sessions.length,
-      active: sessions.filter((s) => s.status === "active").length,
-      completed: sessions.filter((s) => s.status === "completed").length,
-      failed: sessions.filter((s) => s.status === "failed").length
-    };
+    let active = 0, completed = 0, failed = 0;
+    for (const s of sessions) {
+      if (s.status === "active") active++;
+      else if (s.status === "completed") completed++;
+      else if (s.status === "failed") failed++;
+    }
+    return { total: sessions.length, active, completed, failed };
   }
   /**
    * Load sessions from persistence file
@@ -12967,11 +16370,13 @@ var ContextManager = class {
    * Cleanup context
    *
    * v5.2: No cleanup needed - agent workspaces no longer created
+   * Note: Returns Promise for interface compatibility
    */
-  async cleanup(context) {
+  cleanup(context) {
     logger.debug("Context cleanup (no-op in v5.2)", {
       agent: context.agent.name
     });
+    return Promise.resolve();
   }
 };
 
@@ -12995,6 +16400,7 @@ var AgentNotFoundError = class extends Error {
 
 // src/agents/profile-loader.ts
 init_logger();
+init_validation_limits();
 
 // src/agents/agent-schemas.ts
 init_esm_shims();
@@ -13395,7 +16801,7 @@ var ProfileLoader = class {
       const files = await readdir(this.fallbackProfilesDir);
       const profiles = files.filter((file) => extname$1(file) === ".yaml" || extname$1(file) === ".yml").map((file) => basename(file, extname$1(file)));
       profiles.forEach((p) => profileSet.add(p));
-    } catch (error) {
+    } catch (_error) {
       logger.debug("Fallback profiles directory not found", {
         dir: this.fallbackProfilesDir
       });
@@ -13672,7 +17078,7 @@ var ProfileLoader = class {
    * Protected by mutex to prevent race conditions
    */
   async clearCache() {
-    await this.initMutex.runExclusive(async () => {
+    await this.initMutex.runExclusive(() => {
       this.cache.clear();
       this.displayNameMap.clear();
       this.mapInitialized = false;
@@ -14447,7 +17853,7 @@ var DelegationParser = class _DelegationParser {
     await this.extractMatches(_DelegationParser.DELEGATION_PATTERNS.chineseRequest, response, fromAgent, delegations, "\u8ACB", resolvedNameCache);
     await this.extractMatches(_DelegationParser.DELEGATION_PATTERNS.chineseFormal, response, fromAgent, delegations, "\u59D4\u6D3E\u7D66", resolvedNameCache);
     delegations.sort((a, b) => a.position - b.position);
-    const result = delegations.map(({ position, ...rest }) => rest);
+    const result = delegations.map(({ position: _position, ...rest }) => rest);
     logger.info(`Parsed ${delegations.length} delegation(s)`, {
       fromAgent,
       delegations: result.map((d) => ({ toAgent: d.toAgent, taskPreview: d.task.substring(0, 50) }))
@@ -15487,7 +18893,7 @@ var ParallelAgentExecutor = class {
   /**
    * Execute a batch of agents in parallel
    */
-  async executeBatchParallel(batch, graph, context, options, results, timeline, executionStartTime) {
+  async executeBatchParallel(batch, graph, context, options, results, timeline, _executionStartTime) {
     logger.info("Executing batch in parallel", { agents: batch });
     const promises = batch.map(async (agentName) => {
       const node = graph.nodes.get(agentName);
@@ -15721,7 +19127,7 @@ var ParallelAgentExecutor = class {
   /**
    * Mark batch as cancelled
    */
-  markBatchAsCancelled(batch, graph, timeline, executionStartTime) {
+  markBatchAsCancelled(batch, graph, timeline, _executionStartTime) {
     const now = Date.now();
     for (const agentName of batch) {
       const node = graph.nodes.get(agentName);
@@ -15861,6 +19267,9 @@ var ParallelAgentExecutor = class {
 };
 
 // src/agents/executor.ts
+function isErrorLike(error) {
+  return typeof error === "object" && error !== null;
+}
 var AgentExecutor = class {
   sessionManager;
   workspaceManager;
@@ -15990,7 +19399,7 @@ Retry attempt ${attempt}/${maxAttempts}...`));
         }
         return await this.executeInternal(context, options);
       } catch (error) {
-        lastError = error;
+        lastError = error instanceof Error ? error : new Error(String(error));
         const isRetryable = this.isRetryableError(error, retryableErrors);
         if (!isRetryable || attempt >= maxAttempts) {
           throw error;
@@ -16000,7 +19409,8 @@ Retry attempt ${attempt}/${maxAttempts}...`));
           maxDelay
         );
         if (verbose) {
-          console.log(chalk4.yellow(`Retryable error occurred: ${error.message}`));
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          console.log(chalk4.yellow(`Retryable error occurred: ${errorMessage}`));
           console.log(chalk4.gray(`Waiting ${delay}ms before retry...`));
         }
         await this.sleep(delay, signal);
@@ -16015,7 +19425,7 @@ Retry attempt ${attempt}/${maxAttempts}...`));
    */
   async executeWithTimeout(context, options) {
     const timeout = options.timeout;
-    const { verbose = false } = options;
+    const { verbose: _verbose = false } = options;
     let timeoutId = null;
     const controller = new AbortController();
     const executionOptions = {
@@ -16713,7 +20123,12 @@ ${context.task}`;
    */
   isRetryableError(error, retryableErrors) {
     const patterns = retryableErrors || this.defaultRetryConfig.retryableErrors;
-    const errorString = (error.message || error.code || "").toLowerCase();
+    let errorString = "";
+    if (isErrorLike(error)) {
+      errorString = (error.message || error.code || "").toLowerCase();
+    } else if (typeof error === "string") {
+      errorString = error.toLowerCase();
+    }
     return patterns.some(
       (pattern) => errorString.includes(pattern.toLowerCase())
     );
@@ -18141,7 +21556,7 @@ function categorizeTools(name) {
   if (name.includes("context")) return "context";
   return "execution";
 }
-function getExecutionMode(providerName, providerConfig) {
+function getExecutionMode(providerName, _providerConfig) {
   if (providerName === "glm" || providerName === "grok") {
     return "sdk";
   }
@@ -18600,13 +22015,14 @@ function compressWithInfo(payload, options = {}) {
 init_esm_shims();
 init_factory();
 init_logger();
+init_validation_limits();
 var NATIVE_MODULE_ERROR_PATTERNS = [
   "NODE_MODULE_VERSION",
   "was compiled against a different Node.js version",
   "better_sqlite3.node"
 ];
 var DEFAULT_CONFIG3 = {
-  dbPath: ".automatosx/tasks/tasks.db",
+  dbPath: `${AX_PATHS.TASKS}/tasks.db`,
   maxPayloadBytes: 1024 * 1024,
   // 1MB
   compressionEnabled: true,
@@ -18614,7 +22030,7 @@ var DEFAULT_CONFIG3 = {
   defaultTtlHours: 24,
   maxTtlHours: 168,
   // 7 days
-  busyTimeout: 5e3
+  busyTimeout: DATABASE.BUSY_TIMEOUT
 };
 var SQL = {
   CREATE_TABLE: `
@@ -20133,7 +23549,6 @@ function createRunTaskHandler(deps) {
     });
     try {
       const taskEngine = getTaskEngine();
-      const session = deps.getSession();
       const options = {
         engineOverride: input.engine_override,
         timeoutMs: input.timeout_ms,
@@ -20627,7 +24042,11 @@ var McpClient = class _McpClient extends EventEmitter {
     const params = {
       protocolVersion: MCP_PROTOCOL_VERSION,
       capabilities: {
-        tools: {}
+        tools: {},
+        resources: {},
+        prompts: {},
+        resourceTemplates: {},
+        experimental: {}
       },
       clientInfo: {
         name: "automatosx",
@@ -22386,7 +25805,6 @@ var CodexEventNormalizer = class extends BaseEventNormalizer {
     const inputTokens = event.inputTokens ?? 0;
     const outputTokens = event.outputTokens ?? 0;
     this.tokenCount = inputTokens + outputTokens;
-    Date.now() - this.startTime;
     return this.createEvent("execution.progress", {
       agent: "codex",
       progress: 100,
@@ -22433,6 +25851,93 @@ var CodexEventNormalizer = class extends BaseEventNormalizer {
   }
 };
 
+// src/mcp/resource-templates.ts
+init_esm_shims();
+var AGENT_TEMPLATE_NAME = "agent_profile";
+var AGENT_URI_TEMPLATE = "agent/{agent}";
+var WORKSPACE_PRD_TEMPLATE_NAME = "workspace_prd_file";
+var WORKSPACE_PRD_URI_TEMPLATE = "workspace/prd/{path}";
+var WORKSPACE_TMP_TEMPLATE_NAME = "workspace_tmp_file";
+var WORKSPACE_TMP_URI_TEMPLATE = "workspace/tmp/{path}";
+var RESOURCE_TEMPLATES = [
+  {
+    name: AGENT_TEMPLATE_NAME,
+    uriTemplate: AGENT_URI_TEMPLATE,
+    description: "Render an AutomatosX agent profile by name",
+    mimeType: "text/markdown",
+    variableDefinitions: [
+      { name: "agent", description: "Agent name", required: true }
+    ]
+  },
+  {
+    name: WORKSPACE_PRD_TEMPLATE_NAME,
+    uriTemplate: WORKSPACE_PRD_URI_TEMPLATE,
+    description: "Read a PRD workspace file (automatosx/PRD)",
+    mimeType: "text/markdown",
+    variableDefinitions: [
+      { name: "path", description: "Relative path under automatosx/PRD", required: true }
+    ]
+  },
+  {
+    name: WORKSPACE_TMP_TEMPLATE_NAME,
+    uriTemplate: WORKSPACE_TMP_URI_TEMPLATE,
+    description: "Read a temporary workspace file (automatosx/tmp)",
+    mimeType: "text/markdown",
+    variableDefinitions: [
+      { name: "path", description: "Relative path under automatosx/tmp", required: true }
+    ]
+  }
+];
+function listResourceTemplates() {
+  return RESOURCE_TEMPLATES;
+}
+async function resolveResourceTemplate(uri, variables, profileLoader, workspaceManager) {
+  if (uri === AGENT_URI_TEMPLATE) {
+    const agent = variables?.agent;
+    if (!agent) {
+      throw new Error("Missing required variable: agent");
+    }
+    const profile = await profileLoader.loadProfile(agent);
+    const summary = [
+      `# ${agent}`,
+      profile.role ? `**Role:** ${profile.role}` : "",
+      profile.abilities?.length ? `**Abilities:** ${profile.abilities.join(", ")}` : "",
+      "",
+      profile.systemPrompt || "No system prompt defined."
+    ].filter(Boolean).join("\n");
+    return {
+      uri: `agent/${agent}`,
+      name: `Agent: ${agent}`,
+      description: `AutomatosX agent profile for ${agent}`,
+      mimeType: "text/markdown",
+      contents: [
+        { type: "text", text: summary },
+        { type: "application/json", json: profile }
+      ]
+    };
+  }
+  if (uri === WORKSPACE_PRD_URI_TEMPLATE || uri === WORKSPACE_TMP_URI_TEMPLATE) {
+    const path7 = variables?.path;
+    if (!path7) {
+      throw new Error("Missing required variable: path");
+    }
+    const isPrd = uri === WORKSPACE_PRD_URI_TEMPLATE;
+    const readFn = isPrd ? workspaceManager.readPRD.bind(workspaceManager) : workspaceManager.readTmp.bind(workspaceManager);
+    const content = await readFn(path7);
+    return {
+      uri: `${isPrd ? "prd" : "tmp"}/${path7}`,
+      name: `${isPrd ? "PRD" : "Tmp"}: ${path7}`,
+      description: `Workspace ${isPrd ? "PRD" : "tmp"} file`,
+      mimeType: "text/markdown",
+      contents: [
+        { type: "text", text: content },
+        { type: "application/json", json: { path: path7, content, workspace: isPrd ? "PRD" : "tmp" } }
+      ]
+    };
+  }
+  throw new Error(`Unknown resource template: ${uri}`);
+}
+
 // src/mcp/server.ts
 var CLIENT_PATTERNS = [
   [["claude"], "claude"],
@@ -22468,6 +25973,8 @@ var McpServer = class _McpServer {
   // Track client-initiated cancellations
   requestControllers = /* @__PURE__ */ new Map();
   // Abort long-running handlers
+  toolAllowlist;
+  authToken;
   // v10.5.0: MCP Session for Smart Routing
   session = null;
   // v10.6.0: MCP Client Pool for cross-provider execution
@@ -22476,6 +25983,7 @@ var McpServer = class _McpServer {
   eventBridge = null;
   streamingNotifier = null;
   enableStreamingNotifications = true;
+  negotiatedProtocolVersion = MCP_PROTOCOL_VERSION;
   // Shared services (initialized once per server)
   router;
   memoryManager;
@@ -22489,6 +25997,12 @@ var McpServer = class _McpServer {
     if (options.debug) {
       setLogLevel("debug");
     }
+    if (options.toolAllowlist?.length) {
+      this.toolAllowlist = new Set(options.toolAllowlist);
+    }
+    if (options.authToken) {
+      this.authToken = options.authToken;
+    }
     this.enableStreamingNotifications = options.enableStreamingNotifications ?? true;
     this.version = getVersion();
     this.ajv = new Ajv({ allErrors: true });
@@ -22498,6 +26012,24 @@ var McpServer = class _McpServer {
       streamingNotifications: this.enableStreamingNotifications
     });
   }
+  /** Determine if negotiated protocol is v2 */
+  isV2Protocol() {
+    return this.negotiatedProtocolVersion === MCP_SUPPORTED_VERSIONS[0];
+  }
+  /** Build capability set based on negotiated protocol */
+  buildCapabilities() {
+    const base = { tools: {} };
+    if (this.isV2Protocol()) {
+      return {
+        ...base,
+        resources: {},
+        prompts: {},
+        resourceTemplates: {},
+        experimental: {}
+      };
+    }
+    return base;
+  }
   /**
    * Get static tool schemas (no initialization required)
    * Returns tool schemas that can be provided during MCP handshake
@@ -22657,36 +26189,61 @@ Use this tool first to understand what AutomatosX offers.`,
     const projectDir = process.cwd();
     const config = await loadConfig(projectDir);
     const teamManager = new TeamManager(
-      join(projectDir, ".automatosx", "teams")
+      join(projectDir, AX_PATHS.TEAMS)
     );
     this.profileLoader = new ProfileLoader(
-      join(projectDir, ".automatosx", "agents"),
+      join(projectDir, AX_PATHS.AGENTS),
       void 0,
       teamManager
     );
     const abilitiesManager = new AbilitiesManager(
-      join(projectDir, ".automatosx", "abilities")
+      join(projectDir, AX_PATHS.ABILITIES)
     );
     this.memoryManager = new LazyMemoryManager({
-      dbPath: join(projectDir, ".automatosx", "memory", "memory.db")
+      dbPath: join(projectDir, AX_PATHS.MEMORY, "memory.db")
     });
     this.pathResolver = new PathResolver({
       projectDir,
       workingDir: process.cwd(),
-      agentWorkspace: join(projectDir, ".automatosx", "workspaces")
+      agentWorkspace: join(projectDir, AX_PATHS.WORKSPACES)
     });
     const providers = [];
     if (config.providers["claude-code"]?.enabled) {
       const { ClaudeProvider: ClaudeProvider2 } = await Promise.resolve().then(() => (init_claude_provider(), claude_provider_exports));
-      providers.push(new ClaudeProvider2({ ...config.providers["claude-code"], name: "claude-code" }));
+      const claudeConfig = config.providers["claude-code"];
+      providers.push(new ClaudeProvider2({ ...claudeConfig, name: "claude-code", command: claudeConfig.command || "claude" }));
     }
     if (config.providers["gemini-cli"]?.enabled) {
       const { GeminiProvider: GeminiProvider2 } = await Promise.resolve().then(() => (init_gemini_provider(), gemini_provider_exports));
-      providers.push(new GeminiProvider2({ ...config.providers["gemini-cli"], name: "gemini-cli" }));
+      const geminiConfig = config.providers["gemini-cli"];
+      providers.push(new GeminiProvider2({ ...geminiConfig, name: "gemini-cli", command: geminiConfig.command || "gemini" }));
     }
     if (config.providers["openai"]?.enabled) {
       const { createOpenAIProviderSync: createOpenAIProviderSync2 } = await Promise.resolve().then(() => (init_openai_provider_factory(), openai_provider_factory_exports));
-      providers.push(createOpenAIProviderSync2({ ...config.providers["openai"], name: "openai" }, config.providers["openai"].integration));
+      const openaiConfig = config.providers["openai"];
+      providers.push(createOpenAIProviderSync2({ ...openaiConfig, name: "openai", command: openaiConfig.command || "codex" }, openaiConfig.integration));
+    }
+    if (config.providers["glm"]?.enabled) {
+      const { GLMProvider: GLMProvider2 } = await Promise.resolve().then(() => (init_glm_provider(), glm_provider_exports));
+      const glmConfig = config.providers["glm"];
+      providers.push(new GLMProvider2({
+        name: "glm",
+        enabled: true,
+        priority: glmConfig.priority,
+        timeout: glmConfig.timeout,
+        mode: "sdk"
+      }));
+    }
+    if (config.providers["grok"]?.enabled) {
+      const { GrokProvider: GrokProvider2 } = await Promise.resolve().then(() => (init_grok_provider(), grok_provider_exports));
+      const grokConfig = config.providers["grok"];
+      providers.push(new GrokProvider2({
+        name: "grok",
+        enabled: true,
+        priority: grokConfig.priority,
+        timeout: grokConfig.timeout,
+        mode: "sdk"
+      }));
     }
     const healthCheckInterval = config.router?.healthCheckInterval;
     this.router = new Router({
@@ -22840,9 +26397,7 @@ Use this tool first to understand what AutomatosX offers.`,
     register("create_task", createCreateTaskHandler({
       getSession: () => this.session
     }));
-    register("run_task", createRunTaskHandler({
-      getSession: () => this.session
-    }));
+    register("run_task", createRunTaskHandler());
     register("get_task_result", createGetTaskResultHandler());
     register("list_tasks", createListTasksHandler());
     register("delete_task", createDeleteTaskHandler());
@@ -22877,6 +26432,14 @@ Use this tool first to understand what AutomatosX offers.`,
           return await this.handleResourcesList(request, responseId);
         case "resources/read":
           return await this.handleResourceRead(request, responseId);
+        case "resources/templates/list":
+          return await this.handleResourceTemplatesList(request, responseId);
+        case "resources/templates/read":
+          return await this.handleResourceTemplateRead(request, responseId);
+        case "prompts/list":
+          return await this.handlePromptsList(request, responseId);
+        case "prompts/get":
+          return await this.handlePromptGet(request, responseId);
         case "$/cancelRequest":
           return this.handleCancelRequest(request, responseId);
         default:
@@ -22915,9 +26478,12 @@ Use this tool first to understand what AutomatosX offers.`,
       clientName: clientInfo.name,
       normalizedProvider: this.session.normalizedProvider
     });
+    const requestedProtocol = request.params?.protocolVersion;
+    const negotiated = MCP_SUPPORTED_VERSIONS.find((version) => version === requestedProtocol) ?? "2024-11-05";
+    this.negotiatedProtocolVersion = negotiated;
     const response = {
-      protocolVersion: MCP_PROTOCOL_VERSION,
-      capabilities: { tools: {} },
+      protocolVersion: negotiated,
+      capabilities: this.buildCapabilities(),
       serverInfo: { name: "automatosx", version: this.version }
     };
     logger.info("[MCP Server] Initialize handshake complete (< 1ms)");
@@ -22931,7 +26497,11 @@ Use this tool first to understand what AutomatosX offers.`,
    */
   handleToolsList(_request, id) {
     logger.debug("[MCP Server] Tools list requested (static schemas)");
-    const tools = _McpServer.getStaticToolSchemas();
+    const tools = _McpServer.getStaticToolSchemas().map((schema) => ({
+      ...schema,
+      // If allowlist is set, hide tools not allowed
+      ...this.toolAllowlist && !this.toolAllowlist.has(schema.name) ? { hidden: true } : {}
+    }));
     return { jsonrpc: "2.0", id, result: { tools } };
   }
   /**
@@ -22948,6 +26518,81 @@ Use this tool first to understand what AutomatosX offers.`,
     }));
     return { jsonrpc: "2.0", id, result: { resources } };
   }
+  /**
+   * Handle resources/templates/list request (v2 capability)
+   */
+  async handleResourceTemplatesList(_request, id) {
+    if (!this.isV2Protocol()) {
+      return this.createErrorResponse(id, -32601 /* MethodNotFound */, "resources/templates/list is only available in MCP v2");
+    }
+    await this.ensureInitialized();
+    const resourceTemplates = listResourceTemplates();
+    return { jsonrpc: "2.0", id, result: { resourceTemplates } };
+  }
+  /**
+   * Handle prompts/list request (expose common starter prompts)
+   */
+  async handlePromptsList(_request, id) {
+    await this.ensureInitialized();
+    const prompts = [
+      {
+        name: "agent_context",
+        description: "Get agent context and system prompt for a given agent name",
+        arguments: [{ name: "agent", required: true, description: "Agent name" }]
+      },
+      {
+        name: "status",
+        description: "Get AutomatosX MCP status summary"
+      }
+    ];
+    return { jsonrpc: "2.0", id, result: { prompts } };
+  }
+  /**
+   * Handle prompts/get request
+   */
+  async handlePromptGet(request, id) {
+    await this.ensureInitialized();
+    const name = request.params?.name;
+    if (!name) {
+      return this.createErrorResponse(id, -32602 /* InvalidParams */, "Prompt name is required");
+    }
+    switch (name) {
+      case "agent_context": {
+        const agent = request.params?.arguments?.agent;
+        if (!agent) {
+          return this.createErrorResponse(id, -32602 /* InvalidParams */, "agent argument is required");
+        }
+        try {
+          const profile = await this.profileLoader.loadProfile(agent);
+          const content = [
+            { type: "text", text: `System prompt for ${agent}:
+${profile.systemPrompt || "No system prompt defined."}` },
+            { type: "application/json", json: profile }
+          ];
+          return { jsonrpc: "2.0", id, result: { prompt: { name, description: "Agent context", arguments: [{ name: "agent", required: true }] }, content } };
+        } catch (error) {
+          return this.createErrorResponse(id, -32603 /* InternalError */, `Failed to load agent: ${error.message}`);
+        }
+      }
+      case "status": {
+        const summary = {
+          version: this.version,
+          providerCount: this.router?.providerCount ?? 0,
+          streamingNotifications: this.enableStreamingNotifications
+        };
+        const content = [
+          { type: "text", text: `AutomatosX MCP status:
+Version: ${summary.version}
+Providers: ${summary.providerCount}
+Streaming: ${summary.streamingNotifications}` },
+          { type: "application/json", json: summary }
+        ];
+        return { jsonrpc: "2.0", id, result: { prompt: { name, description: "AutomatosX status" }, content } };
+      }
+      default:
+        return this.createErrorResponse(id, -32601 /* MethodNotFound */, `Prompt not found: ${name}`);
+    }
+  }
   /**
    * Handle resources/read request
    */
@@ -22976,6 +26621,30 @@ Use this tool first to understand what AutomatosX offers.`,
       return this.createErrorResponse(id, -32603 /* InternalError */, `Failed to read resource: ${error.message}`);
     }
   }
+  /**
+   * Handle resources/templates/read request (v2 capability)
+   */
+  async handleResourceTemplateRead(request, id) {
+    if (!this.isV2Protocol()) {
+      return this.createErrorResponse(id, -32601 /* MethodNotFound */, "resources/templates/read is only available in MCP v2");
+    }
+    await this.ensureInitialized();
+    const uri = request.params?.uri;
+    try {
+      if (!uri) {
+        return this.createErrorResponse(id, -32602 /* InvalidParams */, "Missing resource template URI");
+      }
+      const resolved = await resolveResourceTemplate(
+        uri,
+        request.params?.variables,
+        this.profileLoader,
+        this.workspaceManager
+      );
+      return { jsonrpc: "2.0", id, result: resolved };
+    } catch (error) {
+      return this.createErrorResponse(id, -32603 /* InternalError */, `Failed to read resource template: ${error.message}`);
+    }
+  }
   /**
    * Validate tool input against its JSON schema.
    * Returns null if valid, or error message string if invalid.
@@ -23050,6 +26719,16 @@ Use this tool first to understand what AutomatosX offers.`,
     const { name, arguments: args2 } = request.params;
     logger.info("[MCP Server] Tool call", { tool: name });
     const requestId = id ?? null;
+    if (this.toolAllowlist && !this.toolAllowlist.has(name)) {
+      return this.createErrorResponse(id, -32600 /* InvalidRequest */, `Tool not allowed: ${name}`);
+    }
+    const schema = this.toolSchemas.find((t) => t.name === name);
+    if (schema?.requiresAuth && this.authToken) {
+      const provided = args2?.auth_token;
+      if (provided !== this.authToken) {
+        return this.createErrorResponse(id, -32600 /* InvalidRequest */, "Unauthorized: invalid auth token");
+      }
+    }
     const abortController = requestId !== null ? new AbortController() : null;
     if (requestId !== null && abortController) {
       this.requestControllers.set(requestId, abortController);
@@ -23113,20 +26792,21 @@ Use this tool first to understand what AutomatosX offers.`,
     logger.debug("[MCP Server] Response sent", { id: response.id, length: json.length });
   }
   /**
-   * Start stdio server with newline-delimited framing
+   * Start stdio server with hybrid framing support
    *
-   * v12.2.0: Changed from Content-Length to newline-delimited framing
-   * per official MCP specification: https://spec.modelcontextprotocol.io/specification/basic/transports/
+   * v12.3.1: Supports BOTH framing formats for maximum compatibility:
+   * 1. Newline-delimited (official MCP spec, used by Claude Code, @modelcontextprotocol/sdk)
+   * 2. Content-Length (LSP-style, used by ax-glm, ax-grok, some older clients)
    *
-   * Format: Each JSON-RPC message is terminated by a newline character.
-   * Messages MUST NOT contain embedded newlines.
-   * Reference: @modelcontextprotocol/sdk ReadBuffer uses: buffer.indexOf('\n')
+   * Detection: If first line starts with "Content-Length:", use LSP framing.
+   * Otherwise, use newline-delimited framing.
    *
    * BUG FIX (v9.0.1): Added iteration limit and buffer size checks to prevent infinite loops
    */
   async start() {
     logger.info("[MCP Server] Starting stdio JSON-RPC server...");
     let buffer = "";
+    let detectedFraming = null;
     process.stdin.on("data", (chunk) => {
       void this.stdinMutex.runExclusive(async () => {
         buffer += chunk.toString("utf-8");
@@ -23138,17 +26818,49 @@ Use this tool first to understand what AutomatosX offers.`,
           buffer = "";
           return;
         }
+        if (detectedFraming === null) {
+          if (buffer.startsWith("Content-Length:")) {
+            detectedFraming = "content-length";
+            logger.info("[MCP Server] Detected Content-Length framing (LSP-style)");
+          } else if (buffer.includes("{")) {
+            detectedFraming = "newline";
+            logger.info("[MCP Server] Detected newline-delimited framing (MCP spec)");
+          }
+        }
         let iterations = 0;
         while (iterations < STDIO_MAX_ITERATIONS) {
           iterations++;
-          const newlineIndex = buffer.indexOf("\n");
-          if (newlineIndex === -1) break;
-          let jsonMessage = buffer.slice(0, newlineIndex);
-          if (jsonMessage.endsWith("\r")) {
-            jsonMessage = jsonMessage.slice(0, -1);
+          let jsonMessage = null;
+          if (detectedFraming === "content-length") {
+            const headerEnd = buffer.indexOf("\r\n\r\n");
+            if (headerEnd === -1) break;
+            const headers = buffer.slice(0, headerEnd);
+            const contentLengthMatch = headers.match(/Content-Length:\s*(\d+)/i);
+            if (!contentLengthMatch) {
+              const lineEnd = buffer.indexOf("\n");
+              if (lineEnd !== -1) {
+                buffer = buffer.slice(lineEnd + 1);
+                continue;
+              }
+              break;
+            }
+            const contentLength = parseInt(contentLengthMatch[1], 10);
+            const bodyStart = headerEnd + 4;
+            const bodyEnd = bodyStart + contentLength;
+            if (buffer.length < bodyEnd) break;
+            jsonMessage = buffer.slice(bodyStart, bodyEnd);
+            buffer = buffer.slice(bodyEnd);
+          } else {
+            const newlineIndex = buffer.indexOf("\n");
+            if (newlineIndex === -1) break;
+            jsonMessage = buffer.slice(0, newlineIndex);
+            if (jsonMessage.endsWith("\r")) {
+              jsonMessage = jsonMessage.slice(0, -1);
+            }
+            buffer = buffer.slice(newlineIndex + 1);
+            if (jsonMessage.trim() === "") continue;
           }
-          buffer = buffer.slice(newlineIndex + 1);
-          if (jsonMessage.trim() === "") continue;
+          if (!jsonMessage) break;
           if (jsonMessage.length > STDIO_MAX_MESSAGE_SIZE) {
             logger.error("[MCP Server] Message size exceeded maximum", {
               messageSize: jsonMessage.length,
@@ -23191,7 +26903,7 @@ Use this tool first to understand what AutomatosX offers.`,
     process.stdin.on("end", () => shutdown("Server stopped (stdin closed)"));
     process.on("SIGINT", () => shutdown("Received SIGINT, shutting down..."));
     process.on("SIGTERM", () => shutdown("Received SIGTERM, shutting down..."));
-    logger.info("[MCP Server] Server started successfully (newline-delimited framing)");
+    logger.info("[MCP Server] Server started successfully (hybrid framing: newline + Content-Length)");
   }
 };