osai-agent 4.0.0

package/src/agent/loop/local.js

@@ -0,0 +1,196 @@
+import { buildSystemPrompt } from '../../prompts/systemPrompt.js';
+import { streamLocalCompletion, getLocalProviderConfig } from '../../llm/direct.js';
+import { discoverSkills } from '../../skills/loader.js';
+import { mcpClientManager } from '../../tools/mcp-client.js';
+import { memory } from '../../memory/store.js';
+import { DEFAULTS, COMPLETION_SIGNALS } from '../../utils/constants.js';
+import { logger } from '../../utils/logger.js';
+
+export default {
+  async _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;
+    let retrying = false;
+
+    const provider = getLocalProviderConfig();
+    if (!provider) {
+      this.onError('No local LLM provider configured. Run: osai-agent provider set <type> --key <key>');
+      return null;
+    }
+
+    let skillsCatalog = [];
+    try { skillsCatalog = await discoverSkills(); } catch {}
+
+    this.currentProvider = provider.type;
+    this.currentModel = provider.model;
+
+    const mcpConfig = this._config.get('mcpServers', {});
+    const mcpTools = Object.keys(mcpConfig).length > 0
+      ? mcpClientManager.getToolDescriptions()
+      : [];
+
+    const deviceInfo = this.device?.name
+      ? `${this.device.name} (${this.device.ip}:${this.device.port || 22})`
+      : '';
+
+    const systemPrompt = buildSystemPrompt(this._userOS, this.mode, {
+      executionMode: this.executionMode,
+      mcpTools,
+      skills: skillsCatalog.map(s => ({ name: s.name, description: s.description, source: s.source })),
+      isSubagent: this.isSubagent,
+      deviceInfo,
+      ...(memoryContext ? { memoryContext } : {}),
+    });
+
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      if (this._shouldCancel()) {
+        logger.info('Local worker call cancelled before attempt');
+        return null;
+      }
+
+      try {
+        const stream = streamLocalCompletion({
+          provider,
+          systemPrompt,
+          history: historyWithoutLast,
+          message: lastMessage.content,
+          signal: this.abortController?.signal,
+        });
+
+        const reader = stream.getReader();
+        const decoder = new TextDecoder();
+        let fullResponse = '';
+        let responseText = '';
+        let inThinkBlock = false;
+        let thinkContentAccumulator = '';
+
+        while (true) {
+          if (this._shouldCancel()) break;
+          const { done, value } = await reader.read();
+          if (done) break;
+
+          const chunk = decoder.decode(value, { stream: true });
+          const lines = chunk.split('\n');
+
+          for (const line of lines) {
+            if (!line.startsWith('data: ')) continue;
+            const payload = line.slice(6).trim();
+            if (!payload || payload === '[DONE]') continue;
+            try {
+              const event = JSON.parse(payload);
+              if (event.type === 'chunk' && event.content) {
+                fullResponse += event.content;
+                responseText += event.content;
+                let content = event.content;
+                // Detect <think> blocks and route to thought handler
+                const thinkOpenIdx = content.indexOf('<think>');
+                const thinkCloseIdx = content.indexOf('</think>');
+                if (inThinkBlock || thinkOpenIdx !== -1) {
+                  if (inThinkBlock) {
+                    if (thinkCloseIdx !== -1) {
+                      const beforeClose = content.slice(0, thinkCloseIdx);
+                      if (beforeClose.trim()) {
+                        thinkContentAccumulator += beforeClose;
+                        this.onThought(beforeClose);
+                      }
+                      inThinkBlock = false;
+                      thinkContentAccumulator = '';
+                      this.onThinkingEnd();
+                      content = content.slice(thinkCloseIdx + 8);
+                    } else {
+                      thinkContentAccumulator += content;
+                      this.onThought(content);
+                      content = '';
+                    }
+                  } else {
+                    const beforeThink = content.slice(0, thinkOpenIdx);
+                    const afterThink = content.slice(thinkOpenIdx + 7);
+                    inThinkBlock = true;
+                    thinkContentAccumulator = '';
+                    this.onThinkingStart();
+                    const closeInRemainder = afterThink.indexOf('</think>');
+                    if (closeInRemainder !== -1) {
+                      const thinkContent = afterThink.slice(0, closeInRemainder);
+                      if (thinkContent.trim()) {
+                        thinkContentAccumulator = thinkContent;
+                        this.onThought(thinkContent);
+                      }
+                      inThinkBlock = false;
+                      thinkContentAccumulator = '';
+                      this.onThinkingEnd();
+                      content = (beforeThink || '') + afterThink.slice(closeInRemainder + 8);
+                    } else {
+                      if (afterThink.trim()) {
+                        thinkContentAccumulator = afterThink;
+                        this.onThought(afterThink);
+                      }
+                      content = beforeThink || '';
+                    }
+                  }
+                }
+                if (content) {
+                  this.onMarkdown(content);
+                }
+              } else if (event.type === 'error') {
+                throw new Error(event.message);
+              }
+            } catch (e) {
+              if (e.message && e.message !== 'Unexpected end of JSON input') {
+                throw e;
+              }
+            }
+          }
+        }
+
+        // Clean up unclosed think block at end of stream
+        if (inThinkBlock) {
+          inThinkBlock = false;
+          thinkContentAccumulator = '';
+          this.onThinkingEnd();
+        }
+
+        if (this._shouldCancel()) return null;
+
+        if (retrying) { this.onUpdateLastText(''); retrying = false; }
+
+        if (!fullResponse) return null;
+
+        const cleanFullResponse = fullResponse
+          .replace(/^\s*\{(?:\\")?tool(?:\\")?\s*:\s*.*$/gim, '')
+          .replace(/<tool\b[^>]*>[\s\S]*?<\/tool\s*>|<tool\b[^>]*\/>/gim, '')
+          .trim();
+        this._appendConversationMessage('assistant', cleanFullResponse || fullResponse);
+        const extractedToolCalls = this._extractToolCalls(fullResponse);
+        this._detectCompletionSignal(fullResponse);
+        return { toolCalls: extractedToolCalls, fullResponse };
+      } catch (error) {
+        if (error.name === 'AbortError' || this._shouldCancel()) {
+          logger.info('Local 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;
+  },
+};

package/src/agent/loop/loop-detection.js

@@ -0,0 +1,288 @@
+import { TOOLS, TOOL_SEQUENCE_WINDOW_SIZE, MAX_ITERATIONS, MODES } from '../../utils/constants.js';
+import { resolvePath } from '../../tools/local.js';
+import { simpleHash } from '../../utils/helpers.js';
+import { logger } from '../../utils/logger.js';
+import path from 'path';
+import fs from 'fs';
+
+export default {
+  _buildLoopBlockedMessage(toolCall) {
+    const tool = toolCall?.tool || TOOLS.LOCAL_CMD;
+    const path = toolCall?.path || '';
+    if (tool === TOOLS.READ_FILE && path) {
+      const normalizedPath = this._normalizeTrackedPath(path) || path;
+      const count = this._readFileCallCount.get(normalizedPath) || 0;
+      return `[BLOCKED] The file "${path}" has been read ${count} times without any modification in between. Reading the same file repeatedly is pointless — the content does not change. Use the content already in context to make your edits with EDIT_FILE or WRITE_FILE.`;
+    }
+    if (this._searchStreak >= 4) {
+      return `[BLOCKED] You have performed ${this._searchStreak} consecutive search operations (grep, glob, search) without any edit. Searching repeatedly without making changes is a loop. Stop, examine what you already know, and either make an edit or change strategy.`;
+    }
+    if (this._detectCrossToolLoop()) {
+      return '[BLOCKED] Cross-tool loop detected: you are cycling through READ → EDIT → DIAG (or similar patterns) without making real progress. Stop, re-assess the problem, and change your approach completely.';
+    }
+    return '[BLOCKED] Repeated identical command/output detected. Stopping to avoid an infinite loop.';
+  },
+
+  _detectCrossToolLoop() {
+    if (this._toolSequenceWindow.length < TOOL_SEQUENCE_WINDOW_SIZE) return false;
+
+    const pairs = [];
+    for (let i = this._toolSequenceWindow.length - 4; i < this._toolSequenceWindow.length; i++) {
+      if (i >= 0) pairs.push(this._toolSequenceWindow[i].tool);
+    }
+    if (pairs.length < 4) return false;
+
+    const alternating = pairs.every((t, i) => {
+      if (i < 2) return true;
+      return t === pairs[i - 2];
+    });
+
+    if (alternating && pairs[0] !== pairs[1]) {
+      const targets = this._toolSequenceWindow.slice(-4).map(e => e.target);
+      const uniqueTargets = new Set(targets.filter(Boolean));
+      if (uniqueTargets.size <= 2) {
+        return true;
+      }
+    }
+
+    return false;
+  },
+
+  _batchFileReads(toolCalls) {
+    if (!toolCalls || toolCalls.length <= 1) return toolCalls || [];
+    const FILE_READ_TOOLS = new Set([
+      TOOLS.READ_FILE, TOOLS.GLOB, TOOLS.GREP,
+      TOOLS.SEARCH_FILE, TOOLS.LIST_DIR, TOOLS.TREE_VIEW, TOOLS.FILE_INFO,
+    ]);
+    const allReads = toolCalls.every(tc => FILE_READ_TOOLS.has(tc.tool));
+    if (allReads) return toolCalls;
+    return [toolCalls[0]];
+  },
+
+  _getFileDependencies(filePath) {
+    try {
+      if (!filePath) return [];
+      const resolved = resolvePath(filePath);
+      if (!resolved) return [];
+      const ext = path.extname(resolved).toLowerCase();
+      const baseDir = path.dirname(resolved);
+      const result = [];
+
+      if (ext === '.html' || ext === '.htm') {
+        const content = fs.readFileSync(resolved, 'utf-8');
+        const linkRegex = /<link[^>]+href\s*=\s*["']([^"']+)["']/gi;
+        let m;
+        while ((m = linkRegex.exec(content)) !== null) {
+          const href = m[1].split('?')[0].split('#')[0];
+          if (href && !href.startsWith('http')) {
+            const resolvedPath = path.resolve(baseDir, href);
+            if (fs.existsSync(resolvedPath)) result.push(resolvedPath);
+          }
+        }
+        const scriptRegex = /<script[^>]+src\s*=\s*["']([^"']+)["']/gi;
+        while ((m = scriptRegex.exec(content)) !== null) {
+          const src = m[1].split('?')[0].split('#')[0];
+          if (src && !src.startsWith('http')) {
+            const resolvedPath = path.resolve(baseDir, src);
+            if (fs.existsSync(resolvedPath)) result.push(resolvedPath);
+          }
+        }
+      } else if (ext === '.js' || ext === '.mjs' || ext === '.jsx' || ext === '.ts' || ext === '.tsx') {
+        const content = fs.readFileSync(resolved, 'utf-8');
+        const importRegex = /(?:import\s+(?:[\s\S]*?\s+from\s+)?["']([^"']+)["']|require\s*\(\s*["']([^"']+)["']\s*\))/g;
+        while ((m = importRegex.exec(content)) !== null) {
+          const spec = m[1] || m[2];
+          if (spec && (spec.startsWith('.') || spec.startsWith('/'))) {
+            const resolvedPath = path.resolve(baseDir, spec);
+            const exts = ['.js', '.mjs', '.jsx', '.ts', '.tsx', '.json', ''];
+            for (const ext of exts) {
+              const attempt = resolvedPath + ext;
+              if (fs.existsSync(attempt)) {
+                result.push(attempt);
+                break;
+              }
+            }
+          }
+        }
+      }
+
+      return [...new Set(result)];
+    } catch {
+      return [];
+    }
+  },
+
+  _detectRepeatedToolLoop(toolCall, result, outputForModel) {
+    const signature = JSON.stringify(toolCall || {});
+    const fingerprint = `${result?.success ? '1' : '0'}:${String(outputForModel || '').trim().slice(0, 500)}`;
+
+    if (signature === this._lastToolSignature) this._sameToolCallStreak += 1;
+    else this._sameToolCallStreak = 1;
+
+    if (signature === this._lastToolSignature && fingerprint === this._lastToolResultFingerprint) {
+      this._sameToolResultStreak += 1;
+    } else {
+      this._sameToolResultStreak = 1;
+    }
+
+    this._lastToolSignature = signature;
+    this._lastToolResultFingerprint = fingerprint;
+
+    if (!result?.success) {
+      this._consecutiveFailedToolStreak += 1;
+    } else {
+      this._consecutiveFailedToolStreak = 0;
+    }
+
+    const tool = toolCall.tool || TOOLS.LOCAL_CMD;
+
+    const SEARCH_TOOLS = new Set([TOOLS.GREP, TOOLS.SEARCH_FILE, TOOLS.GLOB, TOOLS.LIST_DIR, TOOLS.TREE_VIEW]);
+    const WRITE_TOOLS = new Set([TOOLS.WRITE_FILE, TOOLS.EDIT_FILE, TOOLS.APPEND_FILE, TOOLS.DELETE_FILE, TOOLS.MOVE_FILE, TOOLS.COPY_FILE, TOOLS.CREATE_DIR, TOOLS.RUN_SCRIPT]);
+    if (SEARCH_TOOLS.has(tool)) {
+      this._searchStreak++;
+      if (this._searchStreak >= 4) {
+        logger.debug('Search streak limit reached', { streak: this._searchStreak, mode: this.mode });
+      }
+    } else if (WRITE_TOOLS.has(tool)) {
+      this._searchStreak = 0;
+    }
+
+    if (tool === TOOLS.LOCAL_CMD && result?.success && toolCall.cmd) {
+      const cmd = toolCall.cmd;
+      const pathMatch = cmd.match(/(?:explorer|start)\s+(.+)/i);
+      if (pathMatch) {
+        const targetPath = pathMatch[1].replace(/["']/g, '').trim();
+        if (targetPath) {
+          const count = (this._localCmdPathCount.get(targetPath) || 0) + 1;
+          this._localCmdPathCount.set(targetPath, count);
+          if (count >= 3) {
+            return true;
+          }
+        }
+      }
+    }
+    if (tool === TOOLS.READ_FILE && toolCall.path && result?.success) {
+      const normalizedPath = this._normalizeTrackedPath(toolCall.path) || toolCall.path;
+      const count = (this._readFileCallCount.get(normalizedPath) || 0) + 1;
+      this._readFileCallCount.set(normalizedPath, count);
+      if (count >= 3 && !this.isSubagent) {
+        return true;
+      }
+      if (!result.output || String(result.output).trim() === '') {
+        this._consecutiveFailedToolStreak += 1;
+      }
+    }
+    if ([TOOLS.WRITE_FILE, TOOLS.EDIT_FILE, TOOLS.APPEND_FILE].includes(tool) && toolCall.path) {
+      const normalizedPath = this._normalizeTrackedPath(toolCall.path) || toolCall.path;
+      this._readFileCallCount.set(normalizedPath, 0);
+
+      if (result.success) {
+        let newContent = '';
+        try { newContent = fs.readFileSync(normalizedPath, 'utf8'); } catch {}
+        this._readFiles.add(normalizedPath);
+        this._readFileState.set(normalizedPath, {
+          lastReadInteraction: this._toolInteractionCounter,
+          lastReadIteration: this.iteration,
+          lastReadAt: new Date().toISOString(),
+          contentHash: simpleHash(newContent),
+        });
+      } else {
+        this._readFileState.delete(normalizedPath);
+      }
+    }
+
+    if (this._searchStreak >= 4 && !this.isSubagent) {
+      return true;
+    }
+
+    return (this._sameToolCallStreak >= 3 && this._sameToolResultStreak >= 2)
+        || this._consecutiveFailedToolStreak >= 5;
+  },
+
+  _buildToolResultMessage(toolCall, result, fullOutput) {
+    const toolName = toolCall.tool || TOOLS.LOCAL_CMD;
+    const identifier = toolCall.cmd || toolCall.path || toolCall.url || toolCall.query || '';
+    const failureHint = !result.success
+      ? this.isSubagent
+        ? `\nWARNING: This tool FAILED. Do NOT retry the same tool or a similar tool expecting a different result. If it failed because confirmation, sensitive-file access, permission, or ENOENT blocked this path, skip that target, continue with another allowed read-only tool, and mention the skipped target in your final summary.`
+        : `\nWARNING: This tool FAILED. Do NOT retry the same tool or a similar tool expecting a different result.\nIf the error is unrecoverable (e.g. missing binary, permission denied, ENOENT), output [BLOCKED] immediately.`
+      : '';
+
+    let readRepeatHint = '';
+    if (toolCall.tool === TOOLS.READ_FILE && toolCall.path && result.success) {
+      const normalizedPath = this._normalizeTrackedPath(toolCall.path) || toolCall.path;
+      const count = this._readFileCallCount.get(normalizedPath) || 0;
+      if (count >= 2) {
+        readRepeatHint = `\nWARNING: You have now read "${toolCall.path}" ${count} time(s). The file content does not change between reads. Do NOT read it again. Use the content in context to proceed with EDIT_FILE or WRITE_FILE immediately.`;
+      }
+    }
+
+    let emptyFileHint = '';
+    if (toolCall.tool === TOOLS.READ_FILE && result.success) {
+      const output = String(result.output || '').trim();
+      if (!output) {
+        emptyFileHint = `\nWARNING: The file appears empty or does not exist at that path. Verify the path is correct. Do NOT retry reading the same path expecting different content.`;
+      }
+    }
+
+    let listDirHint = '';
+    if (toolCall.tool === TOOLS.LIST_DIR && result.success) {
+      listDirHint = `\nTIP: If you need to read a file's content, use READ_FILE with the exact file path. LIST_DIR only shows filenames — it does NOT show file contents.`;
+    }
+
+    let subagentHint = '';
+    if (toolCall.tool === TOOLS.TASK) {
+      if (result.success && result.subagentLaunched) {
+        subagentHint = `\n[SUBAGENT_RESULT] You launched subagent "${result.subagentId || 'unknown'}". It has finished. The findings are in the Output below — use them to continue your work as the parent agent. Do NOT re-launch the same subagent unless you need a different scope.`;
+      } else if (!result.success && result.subagentLaunched) {
+        subagentHint = `\n[SUBAGENT_RESULT] Your subagent was launched but failed. Read the error and either narrow the task or investigate directly.`;
+      } else if (!result.success) {
+        subagentHint = `\n[SUBAGENT_RESULT] Subagent was NOT launched. ${result.error || 'Fix the issue and retry if needed.'}`;
+      }
+    }
+
+    if (this.mode === MODES.CODING) {
+      const nextSteps = this.isSubagent
+        ? `1. Interpret this result in ONE short sentence.
+2. If work remains, continue with another allowed read-only tool. Skip blocked/sensitive targets instead of stopping.
+3. Do NOT repeat the same search/grep/glob pattern. If you already explored enough, output [DONE] with a concise findings summary.
+4. Output [DONE] only after the requested exploration is actually complete.
+5. If impossible because every useful path is blocked, output [BLOCKED] with the blocker in one sentence.
+6. Before your next tool call, think/reason about the goal and the best approach. Only emit the tool call once your reasoning is complete.`
+        : `1. Interpret this result in ONE short sentence.
+2. If work remains, evaluate the result and decide the BEST next action — do NOT repeat the same search/grep/glob pattern. If you already explored enough, make an edit or output [BLOCKED].
+3. Output [DONE] only after the correction is actually applied and verified.
+4. If impossible, output [BLOCKED] with the blocker in one sentence.
+5. Before your next tool call, think/reason about the goal and the best approach. Only emit the tool call once your reasoning is complete.`;
+
+      return `[TOOL_RESULT]
+Tool: ${toolName}
+Target: ${identifier}
+Status: ${result.success ? 'SUCCESS' : 'ERROR'}
+Iteration: ${this.iteration}/${MAX_ITERATIONS}
+${failureHint}${readRepeatHint}${emptyFileHint}${listDirHint}${subagentHint}
+Output:
+${fullOutput}
+
+Now you MUST:
+${nextSteps}`;
+    }
+
+    return `[TOOL_RESULT]
+Tool: ${toolName}
+Target: ${identifier}
+Status: ${result.success ? 'SUCCESS' : 'ERROR'}
+Iteration: ${this.iteration}/${MAX_ITERATIONS}
+${failureHint}${readRepeatHint}${emptyFileHint}${listDirHint}${subagentHint}
+Output:
+${fullOutput}
+
+Now you MUST:
+1. Interpret this result in ONE short sentence.
+2. If you are a subagent and work remains, continue with another allowed read-only tool. Skip blocked/sensitive targets instead of stopping.
+3. If work remains, evaluate the result and decide the BEST next action — do NOT repeat the same search/grep/glob pattern. If you already explored enough, output [DONE] with a concise findings summary.
+4. Output [DONE] only after the requested exploration is actually complete.
+5. If impossible because every useful path is blocked, output [BLOCKED] with the blocker in one sentence.
+6. Before your next tool call, think/reason about the goal and the best approach. Only emit the tool call once your reasoning is complete.`;
+  },
+};