@defai.digital/automatosx 12.4.1 → 12.5.1

package/dist/mcp/index.js

@@ -8727,7 +8727,7 @@ var PRECOMPILED_CONFIG = {
     "enableFreeTierPrioritization": true,
     "enableWorkloadAwareRouting": true
   },
-  "version": "12.4.1"
+  "version": "12.5.1"
 };
 
 // src/core/config/schemas.ts
@@ -20348,6 +20348,232 @@ ${context.task}`;
   }
 };
 
+// src/agents/agent-selector.ts
+init_esm_shims();
+init_logger();
+function scoreAgent(task, profile) {
+  let score = 0;
+  const taskLower = task.toLowerCase();
+  if (profile.selectionMetadata?.primaryIntents) {
+    for (const intent of profile.selectionMetadata.primaryIntents) {
+      const intentKeywords = intent.toLowerCase().split(/\s+/);
+      const matchedKeywords = intentKeywords.filter(
+        (keyword) => taskLower.includes(keyword) && keyword.length > 3
+      );
+      if (matchedKeywords.length >= 2) {
+        score += 10;
+      } else if (matchedKeywords.length === 1) {
+        score += 5;
+      }
+    }
+  }
+  if (profile.selectionMetadata?.secondarySignals) {
+    for (const signal of profile.selectionMetadata.secondarySignals) {
+      if (taskLower.includes(signal.toLowerCase())) {
+        score += 5;
+      }
+    }
+  }
+  if (profile.selectionMetadata?.negativeIntents) {
+    for (const negative of profile.selectionMetadata.negativeIntents) {
+      const keywords = negative.split("(")[0]?.toLowerCase() || "";
+      const negativeKeywords = keywords.split(/\s+/).filter((k) => k.length > 3);
+      const matchedNegative = negativeKeywords.filter(
+        (keyword) => taskLower.includes(keyword)
+      );
+      if (matchedNegative.length >= 2) {
+        score -= 20;
+      }
+    }
+  }
+  if (profile.selectionMetadata?.redirectWhen) {
+    for (const rule of profile.selectionMetadata.redirectWhen) {
+      try {
+        const regex = new RegExp(rule.phrase, "i");
+        if (regex.test(task)) {
+          score -= 15;
+        }
+      } catch (error) {
+        logger.debug("Invalid regex pattern in redirectWhen rule", {
+          pattern: rule.phrase,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+  }
+  if (profile.abilitySelection?.taskBased) {
+    for (const keyword of Object.keys(profile.abilitySelection.taskBased)) {
+      if (taskLower.includes(keyword.toLowerCase())) {
+        score += 3;
+      }
+    }
+  }
+  return Math.max(0, score);
+}
+function buildRationale(task, profile) {
+  const rationale = [];
+  const taskLower = task.toLowerCase();
+  if (profile.selectionMetadata?.primaryIntents) {
+    const matchedIntents = profile.selectionMetadata.primaryIntents.filter((intent) => {
+      const keywords = intent.toLowerCase().split(/\s+/);
+      return keywords.some((k) => taskLower.includes(k) && k.length > 3);
+    });
+    if (matchedIntents.length > 0) {
+      rationale.push(`Matches: ${matchedIntents.slice(0, 2).join(", ")}`);
+    }
+  }
+  if (profile.selectionMetadata?.secondarySignals) {
+    const matchedSignals = profile.selectionMetadata.secondarySignals.filter(
+      (signal) => taskLower.includes(signal.toLowerCase())
+    );
+    if (matchedSignals.length > 0) {
+      rationale.push(`Keywords: ${matchedSignals.slice(0, 3).join(", ")}`);
+    }
+  }
+  if (profile.abilitySelection?.taskBased) {
+    const matchedAbilities = Object.keys(profile.abilitySelection.taskBased).filter(
+      (keyword) => taskLower.includes(keyword.toLowerCase())
+    );
+    if (matchedAbilities.length > 0) {
+      rationale.push(`Abilities: ${matchedAbilities.slice(0, 2).join(", ")}`);
+    }
+  }
+  if (rationale.length === 0) {
+    rationale.push("General capability match");
+  }
+  return rationale;
+}
+function getConfidence(score) {
+  if (score >= 30) return "high";
+  if (score >= 15) return "medium";
+  return "low";
+}
+var MIN_SELECTION_SCORE = 5;
+var FALLBACK_AGENT = "standard";
+var AgentSelector = class {
+  profileLoader;
+  constructor(profileLoader) {
+    this.profileLoader = profileLoader;
+  }
+  /**
+   * Select the best agent for a task
+   *
+   * @param task - Task description
+   * @returns Selection result with agent, score, confidence, and rationale
+   */
+  async selectAgent(task) {
+    logger.debug("[AgentSelector] Selecting agent for task", {
+      taskPreview: task.substring(0, 100)
+    });
+    const agentNames = await this.profileLoader.listProfiles();
+    if (agentNames.length === 0) {
+      logger.warn("[AgentSelector] No agents found, using fallback");
+      return this.createFallbackResult(task);
+    }
+    const profileResults = await Promise.all(
+      agentNames.map(async (name) => {
+        try {
+          const profile = await this.profileLoader.loadProfile(name);
+          return { name, profile, score: scoreAgent(task, profile) };
+        } catch (error) {
+          logger.debug(`[AgentSelector] Failed to load profile: ${name}`, { error });
+          return null;
+        }
+      })
+    );
+    const scoredAgents = profileResults.filter(
+      (result) => result !== null
+    );
+    if (scoredAgents.length === 0) {
+      logger.warn("[AgentSelector] Failed to load any profiles, using fallback");
+      return this.createFallbackResult(task);
+    }
+    scoredAgents.sort((a, b) => b.score - a.score);
+    const best = scoredAgents[0];
+    const alternatives = scoredAgents.slice(1, 4).map((a) => ({
+      agent: a.name,
+      score: a.score
+    }));
+    if (best.score < MIN_SELECTION_SCORE) {
+      logger.info("[AgentSelector] Best score below threshold, using fallback", {
+        bestAgent: best.name,
+        bestScore: best.score,
+        threshold: MIN_SELECTION_SCORE
+      });
+      const standardAgent = scoredAgents.find((a) => a.name === FALLBACK_AGENT);
+      if (standardAgent) {
+        return {
+          agent: standardAgent.name,
+          displayName: standardAgent.profile.displayName || standardAgent.name,
+          role: standardAgent.profile.role,
+          score: standardAgent.score,
+          confidence: "low",
+          rationale: ["No strong match found, using general-purpose agent"],
+          alternatives: scoredAgents.filter((a) => a.name !== FALLBACK_AGENT).slice(0, 3).map((a) => ({ agent: a.name, score: a.score })),
+          usedFallback: true
+        };
+      }
+      return {
+        agent: best.name,
+        displayName: best.profile.displayName || best.name,
+        role: best.profile.role,
+        score: best.score,
+        confidence: "low",
+        rationale: ["Low confidence match - consider specifying agent explicitly"],
+        alternatives,
+        usedFallback: false
+      };
+    }
+    const rationale = buildRationale(task, best.profile);
+    const confidence = getConfidence(best.score);
+    logger.info("[AgentSelector] Agent selected", {
+      agent: best.name,
+      score: best.score,
+      confidence,
+      rationale
+    });
+    return {
+      agent: best.name,
+      displayName: best.profile.displayName || best.name,
+      role: best.profile.role,
+      score: best.score,
+      confidence,
+      rationale,
+      alternatives,
+      usedFallback: false
+    };
+  }
+  /**
+   * Create a fallback result when no agents are available
+   */
+  async createFallbackResult(_task) {
+    try {
+      const profile = await this.profileLoader.loadProfile(FALLBACK_AGENT);
+      return {
+        agent: FALLBACK_AGENT,
+        displayName: profile.displayName || FALLBACK_AGENT,
+        role: profile.role,
+        score: 0,
+        confidence: "low",
+        rationale: ["No agents available, using fallback"],
+        alternatives: [],
+        usedFallback: true
+      };
+    } catch {
+      return {
+        agent: FALLBACK_AGENT,
+        displayName: "Standard",
+        role: "General-purpose agent",
+        score: 0,
+        confidence: "low",
+        rationale: ["No agents available"],
+        alternatives: [],
+        usedFallback: true
+      };
+    }
+  }
+};
+
 // src/mcp/tools/run-agent.ts
 init_logger();
 
@@ -20647,22 +20873,41 @@ async function buildAgentContext(agentName, task, deps, callerProvider, bestProv
 }
 function createRunAgentHandler(deps) {
   return async (input, context) => {
-    const { agent, task, provider, no_memory, mode = "auto" } = input;
+    const { task, provider, no_memory, mode = "auto" } = input;
+    let { agent } = input;
     if (context?.signal?.aborted) {
       throw new Error("Request was cancelled");
     }
-    validateAgentName(agent);
     validateStringParameter(task, "task", {
       required: true,
       minLength: 1,
       maxLength: 1e4
     });
+    let autoSelected = false;
+    if (!agent && deps.profileLoader) {
+      const selector = new AgentSelector(deps.profileLoader);
+      const selection = await selector.selectAgent(task);
+      agent = selection.agent;
+      autoSelected = true;
+      logger.info("[MCP] run_agent auto-selected agent", {
+        task: task.substring(0, 100),
+        selectedAgent: agent,
+        confidence: selection.confidence,
+        score: selection.score,
+        rationale: selection.rationale
+      });
+    }
+    if (!agent) {
+      throw new Error("Agent name is required when profileLoader is not available");
+    }
+    validateAgentName(agent);
     const actualProvider = mapMcpProviderToActual(provider);
     const session = deps.getSession?.() || null;
     const callerProvider = session?.normalizedProvider || "unknown";
     const callerActual = mapNormalizedCallerToActual(callerProvider);
     logger.info("[MCP] run_agent called (Smart Routing v10.5.0)", {
       agent,
+      autoSelected,
       task: task.substring(0, 100),
       mcpProvider: provider,
       actualProvider,
@@ -21475,20 +21720,35 @@ init_logger();
 function createGetAgentContextHandler(deps) {
   return async (input) => {
     const {
-      agent,
       task,
       includeMemory = true,
       maxMemoryResults = 5
     } = input;
+    let { agent } = input;
     const startTime = Date.now();
-    validateAgentName(agent);
     validateStringParameter(task, "task", {
       required: true,
       minLength: 1,
       maxLength: 1e4
     });
+    let autoSelected = false;
+    if (!agent) {
+      const selector = new AgentSelector(deps.profileLoader);
+      const selection = await selector.selectAgent(task);
+      agent = selection.agent;
+      autoSelected = true;
+      logger.info("[MCP] get_agent_context auto-selected agent", {
+        task: task.substring(0, 100),
+        selectedAgent: agent,
+        confidence: selection.confidence,
+        score: selection.score,
+        rationale: selection.rationale
+      });
+    }
+    validateAgentName(agent);
     logger.info("[MCP] get_agent_context called", {
       agent,
+      autoSelected,
       task: task.substring(0, 100),
       includeMemory,
       maxMemoryResults
@@ -26039,17 +26299,24 @@ var McpServer = class _McpServer {
     return [
       {
         name: "run_agent",
-        description: "Execute an AutomatosX agent with a specific task. Uses Smart Routing: returns context for same-provider calls, spawns cross-provider execution.",
+        description: `Execute an AutomatosX agent with a specific task.
+
+v12.5.1: Agent auto-selection - if agent is omitted, system automatically selects the best agent based on task keywords.
+Uses Smart Routing: returns context for same-provider calls, spawns cross-provider execution.
+
+Examples:
+- With agent: run_agent({ agent: "backend", task: "implement API" })
+- Auto-select: run_agent({ task: "fix bugs in the codebase" }) \u2192 selects "quality" agent`,
         inputSchema: {
           type: "object",
           properties: {
-            agent: { type: "string", description: "The name of the agent to run (e.g., backend, Paris, Bob)" },
+            agent: { type: "string", description: "Optional: Agent name (e.g., backend, quality). If omitted, best agent is auto-selected based on task." },
             task: { type: "string", description: "The task for the agent to perform" },
             provider: { type: "string", description: "Optional: Override the AI provider", enum: ["claude", "gemini", "openai"] },
             no_memory: { type: "boolean", description: "Optional: Skip memory injection", default: false },
             mode: { type: "string", description: "Optional: Execution mode - auto (default), context (always return context), execute (always spawn)", enum: ["auto", "context", "execute"], default: "auto" }
           },
-          required: ["agent", "task"]
+          required: ["task"]
         }
       },
       {
@@ -26161,16 +26428,18 @@ Use this tool first to understand what AutomatosX offers.`,
       // v10.5.0: Smart Routing - Explicit context retrieval
       {
         name: "get_agent_context",
-        description: "Get agent context without executing. Returns profile, relevant memory, and enhanced prompt for AI assistant to execute directly.",
+        description: `Get agent context without executing. Returns profile, relevant memory, and enhanced prompt for AI assistant to execute directly.
+
+v12.5.1: Agent auto-selection - if agent is omitted, system automatically selects the best agent based on task keywords.`,
         inputSchema: {
           type: "object",
           properties: {
-            agent: { type: "string", description: "The name of the agent (e.g., backend, Paris, Bob)" },
+            agent: { type: "string", description: "Optional: Agent name (e.g., backend, quality). If omitted, best agent is auto-selected based on task." },
             task: { type: "string", description: "The task description for context building" },
             includeMemory: { type: "boolean", description: "Include relevant memory entries (default: true)", default: true },
             maxMemoryResults: { type: "number", description: "Maximum memory entries to return (default: 5)", default: 5 }
           },
-          required: ["agent", "task"]
+          required: ["task"]
         }
       },
       // v11.3.5: Task Engine tools
@@ -26179,6 +26448,8 @@ Use this tool first to understand what AutomatosX offers.`,
       getTaskResultSchema,
       listTasksSchema,
       deleteTaskSchema
+      // v12.4.0: Bugfix tools intentionally NOT exposed via MCP
+      // Access via: run_agent({ agent: "quality", task: "scan for bugs" })
     ];
   }
   /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@defai.digital/automatosx",
-  "version": "12.4.1",
+  "version": "12.5.1",
   "description": "Provider-agnostic AI orchestration platform with 20+ specialized agents, persistent memory, and multi-provider routing for Claude Code, Gemini CLI, Codex CLI, GLM, and Grok",
   "type": "module",
   "publishConfig": {