osai-agent 4.0.0

package/src/agent/react-loop.js

@@ -0,0 +1,697 @@
+// =============================================================================
+// OS AI Agent — Agent Loop (v4.0 — Coding Mode + Todos + Web Tools)
+// =============================================================================
+// Core agent loop: GOAL -> PLAN -> EXECUTE -> OBSERVE -> REFLECT -> REPEAT
+// Supports GENERAL, NETWORK, and CODING modes with full tool dispatch.
+// =============================================================================
+
+import {
+  executeLocal, readFile, writeFile, editFile, listDir, detectOS, getSystemInfo, resolvePath,
+  searchInFiles, appendFile, deleteFile, createDir, treeView, runScript,
+  moveFile, copyFile, getFileInfo, fetchUrl, webSearch,
+  todoAdd, todoComplete, todoUpdate, todoList, todoClear, todoStore,
+  globFiles, grepFiles, gitOp, readFileRange, askUserQuestion, diagPostEdit,
+  getDependencies, reloadTodos,
+} from '../tools/local.js';
+import { executeSSH, closeAllConnections } from '../tools/ssh.js';
+import { browse as browserBrowse, searchAndBrowse as browserSearch, extractStructuredData as browserExtract } from '../tools/browser.js';
+import { checkSafety } from '../safety/check.js';
+import { memory } from '../memory/store.js';
+import { mcpClientManager } from '../tools/mcp-client.js';
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import Conf from 'conf';
+import WebSocket from 'ws';
+import path from 'path';
+import fs from 'fs';
+import { DEFAULTS, TOOLS, COMPLETION_SIGNALS, SAFETY_TIERS, MODES, EXECUTION_MODES, READ_ONLY_TOOLS, CODING_TOOLS, CRITICAL_ENV_FILENAMES, CRITICAL_ENV_FILENAME_PATTERNS, CRITICAL_ENV_PATH_SEGMENTS, CRITICAL_ENV_EXCLUDE, MAX_ITERATIONS, AUTO_CONTINUE_LIMIT, READ_FRESHNESS_INTERACTIONS, TOOL_SEQUENCE_WINDOW_SIZE, CONTEXT_SUMMARY_TAG, SUBAGENT_MAX_ITERATIONS } from '../utils/constants.js';
+import { discoverSkills } from '../skills/loader.js';
+import { logger } from '../utils/logger.js';
+import { sleep, cancellableSleep } from '../utils/helpers.js';
+
+import contextSummaryMethods from './loop/context-summary.js';
+import loopDetectionMethods from './loop/loop-detection.js';
+import streamParserMethods from './loop/stream-parser.js';
+import verificationMethods from './loop/verification.js';
+import directoryUtilsMethods from './loop/directory-utils.js';
+import toolExecutorMethods from './loop/tool-executor.js';
+import websocketMethods from './loop/websocket.js';
+import localMethods from './loop/local.js';
+
+export class AgentLoop {
+  constructor({
+    device, mode, server, token, executionMode,
+    onMarkdown, onThought, onToolStart, onToolResult, onObservation,
+    onError, onComplete, onTodos, onBlocked, onThinkingStart, onThinkingEnd,
+    onBadge, onConfirmPrompt, onAskUserPrompt, onPlanPrompt,
+    onStats, onConnectionChange, onUpdateLastText, readline, noConfirm = false,
+    isSubagent = false, maxIterations = null, local = false,
+  }) {
+    this.device = device;
+    this.mode = mode || MODES.GENERAL;
+    this.executionMode = executionMode || EXECUTION_MODES.EXEC;
+    this.local = local;
+    this.server = server;
+    this.token = token;
+    this.conversationHistory = [];
+    this.iteration = 0;
+    this.autoContinueCount = 0;
+    this.ws = null;
+    this.pendingCommands = null;
+    this.currentTaskId = null;
+    this.displayedContent = new Set();
+    this.readline = readline;
+    this.noConfirm = noConfirm;
+    this.isSubagent = isSubagent;
+    this._maxIterations = maxIterations || (isSubagent ? SUBAGENT_MAX_ITERATIONS : MAX_ITERATIONS);
+    this._subagentActive = false;
+    this._subagentState = null;
+    this._lastSubagentResult = null;
+    this.abortController = null;
+    this.startTime = null;
+    this.totalTokensUsed = 0;
+    this.commandsExecuted = 0;
+    this._cancelled = false;
+    this._escapeFirstPress = false;
+    this._isThinking = false;
+    this._lastCompletionSignal = null;
+    this._lastDisplayOutput = null;
+    this._lastToolResult = null;
+    this._lastToolSignature = '';
+    this._sameToolCallStreak = 0;
+    this._lastToolResultFingerprint = '';
+    this._sameToolResultStreak = 0;
+    this._consecutiveFailedToolStreak = 0;
+    this._searchStreak = 0;
+    this._readFileCallCount = new Map();
+    this._localCmdPathCount = new Map();
+    this._readFiles = new Set();
+    this._sessionReadFiles = new Set();
+    this._readFileState = new Map();
+    this._readFileOps = 0;
+    this._blockedWritesWithoutRead = 0;
+    this._toolInteractionCounter = 0;
+    this._verificationStateLoaded = false;
+    this._lastCompactInteraction = null;
+    this._codingRootPath = this._normalizeTrackedPath(process.cwd()) || path.normalize(process.cwd());
+    reloadTodos();
+    this._approvedExternalDirs = new Set();
+    this._toolSequenceWindow = [];
+    this._summaryInProgress = false;
+    this._summaryTimer = null;
+    this._lastSummaryAtTokenCount = 0;
+
+     this._config = new Conf({ projectName: 'osai-agent' });
+     this._userOS = this._config.get('os') || detectOS();
+
+     this.onMarkdown = onMarkdown || (() => {});
+     this.onThought = onThought || (() => {});
+     this.onToolStart = onToolStart || (() => {});
+     this.onToolResult = onToolResult || (() => {});
+     this.onObservation = onObservation || (() => {});
+     this.onError = onError || (() => {});
+     this.onComplete = onComplete || (() => {});
+     this.onTodos = onTodos || (() => {});
+     this.onThinkingStart = onThinkingStart || (() => {});
+     this.onThinkingEnd = onThinkingEnd || (() => {});
+     this.onBadge = onBadge || (() => {});
+     this.onConfirmPrompt = onConfirmPrompt || (() => {});
+     this.onAskUserPrompt = onAskUserPrompt || (() => {});
+     this.onPlanPrompt = onPlanPrompt || (() => {});
+     this.onStats = onStats || (() => {});
+      this.onConnectionChange = onConnectionChange || (() => {});
+     this.onUpdateLastText = onUpdateLastText || (() => {});
+     this.onStats(0);
+   }
+
+   /**
+    * Set up Escape key listener to cancel active subagent.
+    * Listens for the Esc key (code 27) on stdin and cancels the subagent if active.
+    */
+   _setupEscapeKeyListener() {
+     if (!this.readline || !this.readline.input) return;
+
+     const onKeyPress = (char, key) => {
+       if (!key) return;
+       if (key.name === 'escape' || (key.code && key.code === 'Escape') || char === '\u001b') {
+          if (this._subagentActive && this._subagentLoop) {
+            if (this._escapeFirstPress) {
+              this._subagentLoop.cancel();
+              this.cancel();
+              this._escapeFirstPress = false;
+            } else {
+              this._subagentLoop.cancel();
+              this._escapeFirstPress = true;
+            }
+          } else {
+            this.cancel();
+          }
+        }
+     };
+
+     // Set raw mode to capture Esc key without needing Enter
+     this.readline.input.setRawMode(true);
+     this.readline.input.on('keypress', onKeyPress);
+
+     // Store the listener to clean up later
+     this._escapeKeyListener = onKeyPress;
+   }
+
+   /**
+    * Clean up Escape key listener and restore stdin settings.
+    */
+   _cleanupEscapeKeyListener() {
+     if (!this.readline || !this.readline.input) return;
+     if (this._escapeKeyListener) {
+       this.readline.input.off('keypress', this._escapeKeyListener);
+       this._escapeKeyListener = null;
+     }
+     // Restore normal mode
+     try { this.readline.input.setRawMode(false); } catch {}
+   }
+
+  getStats() {
+    return {
+      iterations: this.iteration,
+      commandsExecuted: this.commandsExecuted,
+      estimatedTokens: this.totalTokensUsed,
+      elapsedMs: this.startTime ? Date.now() - this.startTime : 0,
+      conversationLength: this.conversationHistory.length,
+      mode: this.mode,
+      executionMode: this.executionMode,
+      todoStats: todoStore.getStats(this.mode),
+      verification: {
+        filesReadOps: this._readFileOps,
+        filesReadUnique: this._readFiles.size,
+        blockedWritesWithoutRead: this._blockedWritesWithoutRead,
+        interactionIndex: this._toolInteractionCounter,
+        freshnessWindow: READ_FRESHNESS_INTERACTIONS,
+      },
+    };
+  }
+
+  setConversationHistory(messages = []) {
+    if (!Array.isArray(messages)) return;
+    const normalized = messages
+      .filter((m) => m && typeof m.content === 'string' && typeof m.role === 'string')
+      .map((m) => ({ role: m.role, content: m.content }))
+      .filter((m) => (m.role === 'user' || m.role === 'assistant' || m.role === 'system') && m.content.trim().length > 0);
+    this.conversationHistory = normalized;
+    const first = this.conversationHistory[0];
+    if (first?.role === 'system' && first.content.startsWith(CONTEXT_SUMMARY_TAG)) {
+      this._lastSummaryAtTokenCount = 0;
+    }
+    this._trimContext();
+    this.totalTokensUsed = this._estimateTokens();
+    this.onStats(this.totalTokensUsed);
+  }
+
+  getConversationHistory() {
+    return this.conversationHistory.map((m) => ({ role: m.role, content: m.content }));
+  }
+
+  _shouldCancel() {
+    return this._cancelled || !!this.abortController?.signal?.aborted;
+  }
+
+  async _cancellableSleep(ms) {
+    return cancellableSleep(ms, () => this._shouldCancel());
+  }
+
+  cancel() {
+    this._cancelled = true;
+    if (this.abortController) {
+      try { this.abortController.abort(); } catch {}
+    }
+
+    if (this.ws && this.ws.readyState === WebSocket.OPEN && this.currentTaskId) {
+      try {
+        this.ws.send(JSON.stringify({
+          type: 'CANCEL',
+          taskId: this.currentTaskId,
+          timestamp: Date.now()
+        }));
+        logger.info('Cancellation signal sent to server');
+      } catch (error) {
+        logger.warn('Failed to send cancellation signal to server', { error: error.message });
+      }
+    }
+
+  }
+
+  async cleanup() {
+    if (this.ws) { try { this.ws.close(); } catch {} this.ws = null; }
+    if (this.mode === MODES.NETWORK) closeAllConnections();
+  }
+
+  // --- Main Loop ---
+
+  async run(instruction) {
+    if (this._cancelled) this._cancelled = false;
+    this._escapeFirstPress = false;
+
+    // Yield immédiat pour laisser Ink afficher "streaming" avant tout traitement
+    await new Promise(r => setTimeout(r, 0));
+
+    await this._loadVerificationState();
+
+    this._appendConversationMessage('user', instruction);
+    this.iteration = 0;
+    this.autoContinueCount = 0;
+    this.pendingCommands = null;
+    this.currentTaskId = null;
+    this.displayedContent.clear();
+    this._lastToolSignature = '';
+    this._sameToolCallStreak = 0;
+    this._lastToolResultFingerprint = '';
+    this._sameToolResultStreak = 0;
+    this._consecutiveFailedToolStreak = 0;
+    this._searchStreak = 0;
+    this._readFileCallCount = new Map();
+    this.startTime = Date.now();
+    this.abortController = new AbortController();
+
+  if (!this.local) {
+    try {
+      await this._connectWebSocket();
+    } catch (err) {
+      this.onConnectionChange(false);
+      logger.warn(`WebSocket connection failed, continuing via HTTP: ${err.message}`);
+      this.ws = null;
+    }
+  } else {
+    this.onConnectionChange(true);
+  }
+  
+  // Set up Escape key listener to cancel active subagent
+  this._setupEscapeKeyListener();
+
+    try { await memory.recordAction({ instruction, mode: this.mode, os: this._userOS }); } catch {}
+
+    // Load configured MCP servers (non-blocking) 
+    const mcpConfig = this._config.get('mcpServers', {});
+    if (Object.keys(mcpConfig).length > 0) {
+      mcpClientManager.loadFromConfig(mcpConfig).catch(err => {
+        logger.warn('MCP server loading error', { error: err.message });
+      });
+    }
+
+    this._trimContext();
+
+    let iterationRetrying = false;
+
+    while (this.iteration < this._maxIterations && !this._cancelled) {
+      this.iteration++;
+      logger.debug(`Iteration ${this.iteration}/${this._maxIterations}`);
+
+      if (iterationRetrying) { this.onUpdateLastText(''); iterationRetrying = false; }
+
+      try {
+        const shouldContinue = await this._executeIteration();
+        if (!shouldContinue) break;
+
+        if (this._lastCompletionSignal === COMPLETION_SIGNALS.INCOMPLETE) {
+          if (this.autoContinueCount < AUTO_CONTINUE_LIMIT) {
+            this.autoContinueCount++;
+            logger.debug(`Auto-continuing (${this.autoContinueCount}/${AUTO_CONTINUE_LIMIT})`);
+            this._appendConversationMessage('user', `Continue with the next step. But FIRST, review your progress:
+- Have you searched/grepped 3+ times without editing? STOP, make an edit now.
+- Have you read the same file more than once? Use content already in context.
+- Are you stuck in a READ → EDIT → READ cycle? Change approach entirely.
+- Output [BLOCKED] if you cannot proceed, explaining why.`);
+    this._trimContext();
+
+    this.totalTokensUsed = this._estimateTokens();
+    this.onStats(this.totalTokensUsed);
+            continue;
+          } else {
+            this.onMarkdown('\n_The agent needs more steps. Type "continue" or "yes" to proceed, or describe a new task._\n');
+            break;
+          }
+        }
+        if (this._lastCompletionSignal === COMPLETION_SIGNALS.DONE || this._lastCompletionSignal === COMPLETION_SIGNALS.BLOCKED) break;
+        this._trimContext();
+      } catch (error) {
+        if (this._shouldCancel()) break;
+        try { await memory.recordFailure({ error: error.message, iteration: this.iteration, mode: this.mode }); } catch {}
+        if (this.iteration <= 1 && !this._shouldCancel()) {
+          logger.info('Retrying iteration after error...');
+          iterationRetrying = true;
+          this.onMarkdown(`\n⏳ Retrying after error: ${error.message}\n`);
+          this.iteration--;
+          const slept = await this._cancellableSleep(DEFAULTS.API_RETRY_DELAY);
+          if (!slept || this._shouldCancel()) break;
+          continue;
+        }
+        this.onError(error.message);
+        break;
+      }
+    }
+
+    if (this.iteration >= this._maxIterations && !this._cancelled) {
+      this.onError(this.isSubagent
+        ? 'Subagent reached maximum iterations without completion'
+        : 'Maximum iterations reached without completion');
+    }
+
+    try {
+      await memory.recordResult({
+        status: this._cancelled ? 'cancelled' : (this._lastCompletionSignal || 'unknown'),
+        iterations: this.iteration, commandsExecuted: this.commandsExecuted, mode: this.mode,
+        verification: {
+          filesReadOps: this._readFileOps,
+          filesReadUnique: this._readFiles.size,
+          blockedWritesWithoutRead: this._blockedWritesWithoutRead,
+          interactionIndex: this._toolInteractionCounter,
+          freshnessWindow: READ_FRESHNESS_INTERACTIONS,
+        },
+      });
+    } catch {}
+
+    this.onTodos(todoStore.list(this.mode));
+    this.onComplete({
+      ...this.getStats(),
+      completionSignal: this._lastCompletionSignal,
+      status: this._cancelled ? 'cancelled' : 'completed',
+    });
+  }
+
+  // --- Iteration Execution ---
+
+  async _executeIteration() {
+    this._lastCompletionSignal = null;
+
+    if (this.pendingCommands && this.pendingCommands.length > 0) {
+      const commands = this.pendingCommands;
+      this.pendingCommands = null;
+      const toolCall = commands[0];
+      const result = await this._executeTool(toolCall);
+      const fullOutput = result.success ? result.output : result.error;
+      const aiSafeOutput = fullOutput.length > DEFAULTS.MAX_TOOL_RESULT_LENGTH
+        ? fullOutput.slice(0, DEFAULTS.MAX_TOOL_RESULT_LENGTH) + '\n...[output truncated]'
+        : fullOutput;
+
+      if (toolCall.tool === TOOLS.READ_FILE && toolCall.path) {
+        await this._trackReadFile(toolCall, result);
+      }
+
+      const pcToolName = toolCall.tool || TOOLS.LOCAL_CMD;
+      const pcTarget = toolCall.path || toolCall.cmd || toolCall.url || toolCall.query || '';
+      this._toolSequenceWindow.push({ tool: pcToolName, target: pcTarget });
+      if (this._toolSequenceWindow.length > TOOL_SEQUENCE_WINDOW_SIZE) {
+        this._toolSequenceWindow.shift();
+      }
+
+      if (this._detectRepeatedToolLoop(toolCall, result, aiSafeOutput) || this._detectCrossToolLoop()) {
+        this._lastCompletionSignal = COMPLETION_SIGNALS.BLOCKED;
+        const msg = this._buildLoopBlockedMessage(toolCall);
+        this.onBlocked(msg);
+        this._appendConversationMessage('assistant', msg);
+        return false;
+      }
+      const toolResultContent = this._buildToolResultMessage(toolCall, result, aiSafeOutput);
+      this._appendConversationMessage('user', toolResultContent);
+      return true;
+    }
+
+    const response = await this._callWorker();
+    if (!response) return false;
+
+    const { toolCalls } = await this._parseResponse(response);
+
+    // Yield pour laisser Ink render les derniers chunks de streaming avant d'exécuter les tools
+    await new Promise(r => setTimeout(r, 0));
+
+    if (this._isThinking) {
+      this._isThinking = false;
+      this.onThinkingEnd();
+    }
+
+    if (toolCalls.length === 0) {
+      if (this.isSubagent && !this._shouldCancel()) {
+        const signal = this._lastCompletionSignal;
+        const hasUsedTools = this.commandsExecuted > 0;
+
+        if (!hasUsedTools || signal !== COMPLETION_SIGNALS.DONE) {
+          this._lastCompletionSignal = COMPLETION_SIGNALS.INCOMPLETE;
+          const correctivePrompt = hasUsedTools
+            ? `Subagent continuation required: no valid tool call was detected. If your exploration is truly complete, respond with [DONE] and a concise findings summary. Otherwise, emit exactly one allowed read-only tool call now. Do not stop just because a previous path required confirmation; skip restricted files and continue with non-sensitive alternatives.`
+            : `Subagent continuation required: you have not used any tools yet. Emit exactly one allowed read-only tool call now to inspect the project. Do not answer from assumptions, and do not stop just because a path might require confirmation; skip restricted files and continue with non-sensitive alternatives.`;
+          this._appendConversationMessage('user', correctivePrompt);
+          return true;
+        }
+      }
+      if (!this._shouldCancel()) {
+        this._lastCompletionSignal = COMPLETION_SIGNALS.DONE;
+      }
+      return false;
+    }
+
+    const batchCalls = this._batchFileReads(toolCalls);
+
+    if (batchCalls.length > 1) {
+      const MAX_CONCURRENCY = 4;
+      const results = [];
+      for (let i = 0; i < batchCalls.length; i += MAX_CONCURRENCY) {
+        const chunk = batchCalls.slice(i, i + MAX_CONCURRENCY);
+        const chunkResults = await Promise.all(chunk.map(tc => this._executeTool(tc)));
+        results.push(...chunkResults);
+      }
+      for (let i = 0; i < batchCalls.length; i++) {
+        const tc = batchCalls[i];
+        const result = results[i];
+
+        this._toolSequenceWindow.push({ tool: TOOLS.READ_FILE, target: tc.path || '' });
+        if (this._toolSequenceWindow.length > TOOL_SEQUENCE_WINDOW_SIZE) {
+          this._toolSequenceWindow.shift();
+        }
+
+        const fullOutput = result.success ? result.output : result.error;
+
+        const normPath = this._normalizeTrackedPath(tc.path) || tc.path;
+        const isFirstRead = normPath && !this._sessionReadFiles.has(normPath);
+        const aiSafeOutput = (isFirstRead || fullOutput.length <= DEFAULTS.MAX_TOOL_RESULT_LENGTH)
+          ? fullOutput
+          : fullOutput.slice(0, DEFAULTS.MAX_TOOL_RESULT_LENGTH) + '\n...[output truncated]';
+
+        const toolResultContent = this._buildToolResultMessage(tc, result, aiSafeOutput);
+        const labeledContent = i === 0
+          ? `[PARALLEL_READ: ${batchCalls.length} files]\n\n${toolResultContent}`
+          : toolResultContent;
+
+        this._appendConversationMessage('user', labeledContent);
+        this._lastDisplayOutput = fullOutput;
+        this._lastToolResult = result;
+
+        if (normPath) {
+          await this._trackReadFile(tc, result);
+        }
+      }
+      this.onTodos(todoStore.list(this.mode));
+      return true;
+    }
+
+    const toolCall = toolCalls[0];
+    const result = await this._executeTool(toolCall);
+    const fullOutput = result.success ? result.output : result.error;
+
+    const normalizedSinglePath = this._normalizeTrackedPath(toolCall.path) || toolCall.path;
+    const isFirstSingleRead = toolCall.tool === TOOLS.READ_FILE && normalizedSinglePath && !this._sessionReadFiles.has(normalizedSinglePath);
+    const aiSafeOutput = (isFirstSingleRead || fullOutput.length <= DEFAULTS.MAX_TOOL_RESULT_LENGTH)
+      ? fullOutput
+      : fullOutput.slice(0, DEFAULTS.MAX_TOOL_RESULT_LENGTH) + '\n...[output truncated]';
+
+    if (toolCall.tool === TOOLS.READ_FILE && normalizedSinglePath) {
+      await this._trackReadFile(toolCall, result);
+    }
+
+    const toolName = toolCall.tool || TOOLS.LOCAL_CMD;
+    const target = toolCall.path || toolCall.cmd || toolCall.url || toolCall.query || '';
+    this._toolSequenceWindow.push({ tool: toolName, target });
+    if (this._toolSequenceWindow.length > TOOL_SEQUENCE_WINDOW_SIZE) {
+      this._toolSequenceWindow.shift();
+    }
+
+    if (this._detectRepeatedToolLoop(toolCall, result, aiSafeOutput) || this._detectCrossToolLoop()) {
+      this._lastCompletionSignal = COMPLETION_SIGNALS.BLOCKED;
+      const msg = this._buildLoopBlockedMessage(toolCall);
+      this.onBlocked(msg);
+      this._appendConversationMessage('assistant', msg);
+      return false;
+    }
+
+    const toolResultContent = this._buildToolResultMessage(toolCall, result, aiSafeOutput);
+    this._lastDisplayOutput = fullOutput;
+    this._lastToolResult = result;
+    this._appendConversationMessage('user', toolResultContent);
+
+    this.onTodos(todoStore.list(this.mode));
+
+    return true;
+  }
+
+  // --- LLM Communication ---
+
+  async _callWorker() {
+    if (this.local) return this._callWorkerLocal();
+
+    const cleanHistory = [...this.conversationHistory];
+    if (cleanHistory.length === 0) throw new Error('No valid conversation history');
+
+    const lastMessage = cleanHistory[cleanHistory.length - 1];
+    const historyWithoutLast = cleanHistory.slice(0, -1);
+    let memoryContext = null;
+    try { memoryContext = await memory.buildContextSummary(3); } catch {}
+
+    const estTokens = this._estimateTokens();
+    this.totalTokensUsed = estTokens;
+    this.onStats(estTokens);
+
+    const maxAttempts = DEFAULTS.API_RETRY_ATTEMPTS;
+    const isRetryableStatus = (status) => status === 408 || status === 429 || status >= 500;
+    let retrying = false;
+
+    let skillsCatalog = [];
+    try {
+      skillsCatalog = await discoverSkills();
+    } catch {}
+
+    let providerType = 'auto';
+    this.currentProvider = null;
+    this.currentModel = null;
+    try {
+      const provRes = await fetch(`${this.server}/api/provider`, {
+        headers: { Authorization: `Bearer ${this.token}` }
+      });
+      if (provRes.ok) {
+        const data = await provRes.json();
+        if (data.type && data.type !== 'osai') {
+          providerType = data.type;
+          this.currentProvider = data.type;
+          this.currentModel = data.model || null;
+        }
+      }
+    } catch {}
+
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      if (this._shouldCancel()) {
+        logger.info('Worker call cancelled before attempt');
+        return null;
+      }
+
+      try {
+        const response = await fetch(`${this.server}/stream`, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${this.token}` },
+          body: JSON.stringify({
+            provider: providerType,
+            message: lastMessage.content,
+            history: historyWithoutLast,
+            os: this._userOS,
+            meta: {
+              mode: this.mode,
+              executionMode: this.executionMode,
+              os: this._userOS,
+              cwd: process.cwd(), dateTime: new Date().toLocaleString("fr-FR", { timeZone: "UTC" }), timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+              iteration: this.iteration,
+              mcpTools: mcpClientManager.getToolDescriptions(),
+              skills: skillsCatalog.map((s) => ({ name: s.name, description: s.description, source: s.source })),
+              isSubagent: this.isSubagent,
+              ...(memoryContext ? { memoryContext } : {}),
+            },
+          }),
+          signal: this.abortController?.signal,
+        });
+
+        if (this._shouldCancel()) {
+          logger.info('Worker call cancelled after fetch');
+          return null;
+        }
+
+        if (!response.ok) {
+          const errorText = await response.text();
+          let errorMsg = errorText;
+          try {
+            const parsed = JSON.parse(errorText);
+            errorMsg = parsed.error || parsed.message || errorText;
+          } catch {}
+
+          if (!isRetryableStatus(response.status) || attempt >= maxAttempts - 1) {
+            this.onError(errorMsg);
+            return null;
+          }
+
+          const backoffMs = DEFAULTS.API_RETRY_DELAY * (attempt + 1);
+          retrying = true;
+          this.onMarkdown(`⏳ Request failed (${response.status}) — retrying in ${Math.ceil(backoffMs / 1000)}s...`);
+          const slept = await this._cancellableSleep(backoffMs);
+          if (!slept || this._shouldCancel()) return null;
+          continue;
+        }
+
+        const contentType = response.headers.get('content-type') || '';
+
+        if (contentType.includes('application/json')) {
+          const json = await response.json();
+          if (json.content || json.message) {
+            if (retrying) { this.onUpdateLastText(''); retrying = false; }
+            const textContent = json.content || json.message || '';
+            const cleanText = textContent
+              .replace(/^\s*\{(?:\\")?tool(?:\\")?\s*:\s*.*$/gim, '')
+              .replace(/<tool\b[^>]*>[\s\S]*?<\/tool\s*>|<tool\b[^>]*\/>/gim, '')
+              .trim();
+            this._appendConversationMessage('assistant', cleanText || textContent);
+            const extractedToolCalls = this._extractToolCalls(textContent);
+            this._detectCompletionSignal(textContent);
+            return { toolCalls: extractedToolCalls, fullResponse: textContent };
+          }
+          if (json.error) {
+            if (attempt >= maxAttempts - 1) {
+              this.onError(json.error);
+              return null;
+            }
+            retrying = true;
+            const backoffMs = DEFAULTS.API_RETRY_DELAY * (attempt + 1);
+            this.onMarkdown(`⏳ Worker error — retrying in ${Math.ceil(backoffMs / 1000)}s...`);
+            const slept = await this._cancellableSleep(backoffMs);
+            if (!slept || this._shouldCancel()) return null;
+            continue;
+          }
+          return null;
+        }
+
+        if (retrying) { this.onUpdateLastText(''); retrying = false; }
+        return response;
+      } catch (error) {
+        if (error.name === 'AbortError' || this._shouldCancel()) {
+          logger.info('Worker call aborted');
+          return null;
+        }
+        if (attempt >= maxAttempts - 1) {
+          this.onError(error.message);
+          return null;
+        }
+        retrying = true;
+        const backoffMs = DEFAULTS.API_RETRY_DELAY * (attempt + 1);
+        this.onMarkdown(`⏳ Retrying in ${Math.ceil(backoffMs / 1000)}s...`);
+        const slept = await this._cancellableSleep(backoffMs);
+        if (!slept || this._shouldCancel()) return null;
+      }
+    }
+
+    return null;
+  }
+}
+
+// Assemble prototype methods from extracted modules
+Object.assign(
+  AgentLoop.prototype,
+  contextSummaryMethods,
+  loopDetectionMethods,
+  streamParserMethods,
+  verificationMethods,
+  directoryUtilsMethods,
+  toolExecutorMethods,
+  websocketMethods,
+  localMethods,
+);