ft-scout 9.0.7 → 9.0.8

package/bin/src/engine/agentEngine.js

@@ -20,6 +20,7 @@ import { SystemComputerController, MockComputerController } from './computer/ind
 import { AgentWorkspace, inferExecutionIntent, resolveDesktopPath } from './workspace/index.js';
 import { AgentRuntime } from './runtime/index.js';
 import { loadAuthConfig, isProOrHigher } from '../utils/auth.js';
+import { getMCPManager } from '../mcp/index.js';
 export { AgentRuntime, AgentWorkspace, inferExecutionIntent, resolveDesktopPath, SystemComputerController, MockComputerController };
 const execAsync = promisify(exec);
 export function robustSnippetReplace(origContent, target, replacement) {
@@ -157,7 +158,7 @@ export const AGENT_TOOLS = [
     },
     {
         name: 'run_command',
-        description: 'Execute a terminal/shell command in the workspace (e.g. npm test, npm run build, git status). WARNING: Do NOT use run_command to create files or folders (e.g. mkdir, touch, echo >)—call write_file directly instead!',
+        description: 'Execute a terminal/shell command in the workspace (e.g. npm test, npm run build, git status). WARNING: Do NOT use run_command to create files or folders (e.g. mkdir, touch, echo >)call write_file directly instead!',
         parameters: {
             type: 'object',
             properties: {
@@ -270,7 +271,7 @@ export const AGENT_TOOLS = [
     },
     {
         name: 'ask_user',
-        description: 'ONLY use for missing API keys or secret credentials. DO NOT use to ask the user what code to write or to re-confirm their prompt—take immediate autonomous tool action instead.',
+        description: 'ONLY use for missing API keys or secret credentials. DO NOT use to ask the user what code to write or to re-confirm their prompttake immediate autonomous tool action instead.',
         parameters: {
             type: 'object',
             properties: {
@@ -374,6 +375,7 @@ export class AgentExecutionLoop {
     cancelReason;
     executionIntent;
     userTier;
+    currentGoal = '';
     constructor(options) {
         this.cwd = process.cwd();
         this.autoApprove = Boolean(options?.autoApprove);
@@ -582,6 +584,8 @@ PLAN TIER & CAPABILITIES: DEVELOPER FREE (BASIC DEVELOPER OPS ONLY)
   4. Reading & exploring: use read_file, list_dir, grep_search to inspect files.
 • Do NOT attempt to use scratchpad, computer, or browser tools. Execute the requested file edit, file creation, or command directly and call task_completed immediately.
 `;
+        const mcpRouting = getMCPManager().routeTools(this.currentGoal);
+        const mcpCapabilitiesSection = mcpRouting.capabilitiesSummary ? `\n${mcpRouting.capabilitiesSummary}\n` : '';
         return `You are Scout Agent, an elite AI Principal Software Engineer & Autonomous Computer-Use Operator (developed by FrontTerrain).
 
 Working Directory: "${this.cwd}"
@@ -589,6 +593,7 @@ Host OS Platform: "${process.platform}"
 Current Date & Time: "${new Date().toISOString()}" (Current Year: ${new Date().getFullYear()})
 ${tierDirective}
 ${intentInfo}
+${mcpCapabilitiesSection}
 Workspace Overview (first 100 files):
 ${filesList.join('\n')}
 
@@ -631,6 +636,7 @@ When returning tool calls, use standard OpenAI function calling format or JSON t
     }
     async executeGoal(userGoal) {
         this.resetContext();
+        this.currentGoal = userGoal;
         this.executionIntent = inferExecutionIntent(userGoal);
         this.taskStateManager.setObjective(userGoal);
         if (this.computerController.setExpectedApplication && this.executionIntent.requiredApplications.length > 0) {
@@ -638,7 +644,9 @@ When returning tool calls, use standard OpenAI function calling format or JSON t
         }
         const structuredPlan = this.taskPlanner.createPlan(userGoal);
         this.taskStateManager.setPlan(structuredPlan.steps);
-        this.taskStateManager.setAvailableTools(this.toolRegistry.getToolsForTier(this.userTier).map((t) => t.name));
+        const mcpRouted = getMCPManager().routeTools(userGoal);
+        const mcpNames = mcpRouted.tools.map((t) => t.originalName);
+        this.taskStateManager.setAvailableTools([...this.toolRegistry.getToolsForTier(this.userTier).map((t) => t.name), ...mcpNames]);
         if (this.mockMode) {
             for (let i = 1; i <= structuredPlan.steps.length; i++) {
                 this.taskStateManager.startStep(i);
@@ -791,12 +799,26 @@ When returning tool calls, use standard OpenAI function calling format or JSON t
             stepSpinner.start(chalk.cyan(`Scout is Working (Step ${step}/${this.maxSteps} • Est. completion: ~${estLeftStr} left)`));
             try {
                 let response;
+                const mcpRouting = getMCPManager().routeTools(userGoal);
+                const mcpToolDefs = mcpRouting.tools.map((mt) => ({
+                    name: mt.originalName,
+                    description: `[MCP: ${mt.serverName}] ${mt.description}`,
+                    parameters: {
+                        type: 'object',
+                        properties: mt.inputSchema.properties || {},
+                        required: mt.inputSchema.required || [],
+                    },
+                    source: 'mcp',
+                    mcpServerId: mt.serverId,
+                    mcpServerName: mt.serverName,
+                }));
+                const activeLoopTools = [...this.toolRegistry.getToolsForTier(this.userTier), ...mcpToolDefs];
                 try {
                     response = await callOpenAIWithRetry(async (model) => {
                         return await openai.chat.completions.create({
                             model,
                             messages: sanitizeMessages(this.historyMessages),
-                            tools: this.toolRegistry.getToolsForTier(this.userTier).map((t) => ({ type: 'function', function: t })),
+                            tools: activeLoopTools.map((t) => ({ type: 'function', function: t })),
                             tool_choice: 'auto',
                             temperature: 0.1,
                             presence_penalty: 0.1,
@@ -807,7 +829,7 @@ When returning tool calls, use standard OpenAI function calling format or JSON t
                 catch (err) {
                     const errStr = String(err?.message || err?.error || err || '').toLowerCase();
                     if (errStr.includes('tool') || errStr.includes('400') || errStr.includes('not supported') || errStr.includes('reasoning')) {
-                        // Model doesn't support native function calling — inject tool-call formatting hint
+                        // Model doesn't support native function calling  inject tool-call formatting hint
                         // so extractJsonToolCall can parse the response as a structured tool invocation
                         const toolHintMsg = {
                             role: 'user',
@@ -816,7 +838,7 @@ When returning tool calls, use standard OpenAI function calling format or JSON t
 { "tool": "tool_name", "args": { ... } }
 \`\`\`
 Available tools: read_file, write_file, edit_file, run_command, list_dir, grep_search, glob_search, tree_view, file_info, multi_edit_file, fetch_url, git_diff, ask_user, speak_text, task_completed.
-You MUST output exactly ONE JSON code block per tool call. Do NOT describe what you would do in plain text—output the JSON tool call directly!`,
+You MUST output exactly ONE JSON code block per tool call. Do NOT describe what you would do in plain textoutput the JSON tool call directly!`,
                         };
                         const fallbackMessages = [...this.historyMessages, toolHintMsg];
                         response = await callOpenAIWithRetry(async (model) => {
@@ -1423,13 +1445,13 @@ You MUST output exactly ONE JSON code block per tool call. Do NOT describe what
                 checkSpin.start(chalk.cyan(` Checking for error: edited ${targetPath}...`));
                 const syntaxCheck = await checkFileSyntax(targetPath, this.cwd);
                 if (!syntaxCheck.valid) {
-                    checkSpin.stop(chalk.red(`️ Checking for error: edited ${targetPath} — Compiler/Syntax Error!`));
+                    checkSpin.stop(chalk.red(`️ Checking for error: edited ${targetPath}  Compiler/Syntax Error!`));
                     this.taskStateManager.recordError(`Syntax error in "${targetPath}": ${syntaxCheck.errors.join('; ')}`, 'write_file');
                     return {
                         result: `Successfully wrote ${content.length} characters (${numberOfLinesChanged} lines changed) to "${targetPath}".\n\n️ AUTOMATED SYNTAX / COMPILER ERROR DETECTED IN "${targetPath}":\n${syntaxCheck.errors.join('\n')}\n\nPLEASE IMMEDIATELY FIX THIS SYNTAX ERROR IN YOUR NEXT TOOL CALL.`
                     };
                 }
-                checkSpin.stop(chalk.green(` Checking for error: edited ${targetPath} — Syntax & build clean.`));
+                checkSpin.stop(chalk.green(` Checking for error: edited ${targetPath}  Syntax & build clean.`));
                 this.taskStateManager.recordArtifact({
                     filename: path.basename(targetPath),
                     path: targetPath,
@@ -1489,12 +1511,12 @@ You MUST output exactly ONE JSON code block per tool call. Do NOT describe what
                 checkSpin.start(chalk.cyan(` Checking for error: edited ${targetPath}...`));
                 const syntaxCheck = await checkFileSyntax(targetPath, this.cwd);
                 if (!syntaxCheck.valid) {
-                    checkSpin.stop(chalk.red(`️ Checking for error: edited ${targetPath} — Compiler/Syntax Error!`));
+                    checkSpin.stop(chalk.red(`️ Checking for error: edited ${targetPath}  Compiler/Syntax Error!`));
                     return {
                         result: `Successfully replaced snippet (${numberOfLinesChanged} lines changed) in "${targetPath}".\n\n️ AUTOMATED SYNTAX / COMPILER ERROR DETECTED IN "${targetPath}":\n${syntaxCheck.errors.join('\n')}\n\nPLEASE IMMEDIATELY FIX THIS SYNTAX ERROR IN YOUR NEXT TOOL CALL.`
                     };
                 }
-                checkSpin.stop(chalk.green(` Checking for error: edited ${targetPath} — Syntax & build clean.`));
+                checkSpin.stop(chalk.green(` Checking for error: edited ${targetPath}  Syntax & build clean.`));
                 return { result: `Successfully replaced target snippet (${numberOfLinesChanged} lines changed) in "${targetPath}". Rationale: ${reason}. Syntax check passed cleanly.` };
             }
             case 'run_command': {
@@ -2132,8 +2154,28 @@ You MUST output exactly ONE JSON code block per tool call. Do NOT describe what
                 this.taskStateManager.completeStep(this.currentStep, summaryStr);
                 return { result: summaryStr };
             }
-            default:
+            default: {
+                // Check if this tool is provided by a connected MCP server
+                const mcpManager = getMCPManager();
+                const mcpTarget = mcpManager.findTool(name);
+                if (mcpTarget) {
+                    const mcpRes = await mcpManager.executeTool(name, args);
+                    const isSuccess = mcpRes.status === 'success';
+                    const outputStr = typeof mcpRes.result === 'string'
+                        ? mcpRes.result
+                        : (mcpRes.result?.text ? String(mcpRes.result.text) : JSON.stringify(mcpRes.result ?? { status: mcpRes.status, error: mcpRes.error }));
+                    this.taskStateManager.addObservation(name, mcpRes.outputSummary || outputStr, isSuccess);
+                    // Check if MCP result generated or referenced local files/artifacts
+                    if (isSuccess && typeof mcpRes.result === 'object' && mcpRes.result !== null) {
+                        const possiblePath = mcpRes.result.path || mcpRes.result.filePath || mcpRes.result.file || args.destPath || args.path || args.outputPath;
+                        if (typeof possiblePath === 'string' && fs.existsSync(path.resolve(this.cwd, possiblePath))) {
+                            this.modifiedFiles.add(path.relative(this.cwd, path.resolve(this.cwd, possiblePath)).replace(/\\/g, '/'));
+                        }
+                    }
+                    return { result: outputStr };
+                }
                 return { result: `Unknown tool call name: "${name}"` };
+            }
         }
     }
 }