@aiaiaichain/agent 0.1.4 → 0.1.5

package/dist/cli.js

@@ -15,6 +15,7 @@ import { loadExtension } from "./loader.js";
 import { App } from "./tui/App.js";
 import { T } from "./tui/theme.js";
 import { wireNotify, safeLog } from "./util/safeLog.js";
+import { logger } from "./util/logger.js";
 import { modelRegistry } from "./models/ModelRegistry.js";
 import { CostTracker } from "./models/CostTracker.js";
 import { AgentRunner } from "./runner/AgentRunner.js";
@@ -26,6 +27,7 @@ import { agentWallet, DEPOSIT_WALLET, ACTION_WALLET, SIGNER } from "./wallet/Age
 import { PROVIDERS, getConfigured, getUnconfigured } from "./providers/ProviderRegistry.js";
 import { env } from "./core/EnvLoader.js";
 import { gmgnHelp, gmgnStatus, saveGmgnApiKey } from "./tools/GmgnIntegration.js";
+import { scanTokenSecurityTool } from "./tools/TokenSecurityScanner.js";
 import { sessionStore } from "./session/SessionStore.js";
 const AIAIAI_HOME = process.env.AIAIAI_HOME ?? join(homedir(), ".aiaiai");
 const envPath = join(AIAIAI_HOME, ".env");
@@ -79,6 +81,10 @@ if (subcmd === "--help" || subcmd === "-h" || subcmd === "help") {
     console.log("    aiaiaichain deposit               Show deposit instructions");
     console.log("    aiaiaichain burn                  Show burn instructions");
     console.log("    aiaiaichain actions               Recent agent actions");
+    console.log("    aiaiaichain pnl                   Profit & Loss report");
+    console.log("    aiaiaichain health                System health & diagnostics");
+    console.log("    aiaiaichain doctor                Comprehensive provider check");
+    console.log("    aiaiaichain scan <address>        Token security scan");
     console.log("    aiaiaichain --help               This help");
     console.log("    aiaiaichain --version            Show version");
     console.log("");
@@ -106,7 +112,22 @@ if (subcmd === "setup") {
         console.log(T.muted(`  Home: ${AIAIAI_HOME}`));
         console.log(T.accent("\n  Run `aiaiaichain` to start the agent.\n"));
         process.exit(0);
-    })().catch(e => { console.error(T.error(`Setup error: ${e.message}`)); process.exit(1); });
+    })().catch(e => {
+        const msg = e instanceof Error ? e.message : String(e);
+        if (msg.includes('ENOENT')) {
+            console.error(T.error(`Setup error: Cannot write to ~/.aiaiai/.env — check permissions.`));
+        }
+        else if (msg.includes('EACCES')) {
+            console.error(T.error(`Setup error: Permission denied — try running with correct user.`));
+        }
+        else if (msg.includes('API') || msg.includes('401')) {
+            console.error(T.error(`Setup error: API key invalid — check your provider key.`));
+        }
+        else {
+            console.error(T.error(`Setup error: ${msg}`));
+        }
+        process.exit(1);
+    });
     await new Promise(() => { });
 }
 if (subcmd === "config") {
@@ -205,6 +226,39 @@ if (subcmd === "fees") {
     })();
     await new Promise(() => { });
 }
+if (subcmd === "pnl" || subcmd === "pl" || subcmd === "profit") {
+    (async () => {
+        const { getPLSummary, getTradeHistory, exportCSV } = await import("./wallet/ProfitTracker.js");
+        const { priceFeed } = await import("./tools/PriceFeed.js");
+        const price = await priceFeed.getAiaiaiPrice();
+        const summary = getPLSummary(parseFloat(price.priceUsd ?? "0"));
+        const history = getTradeHistory();
+        console.log(T.accent("\n  Profit & Loss — $AIAIAI\n"));
+        console.log(`  Avg Cost:    $${summary.avgCostBasis.toFixed(8)}`);
+        console.log(`  Total Spent: ${summary.totalSpent.toFixed(4)} SOL`);
+        console.log(`  Total Received: ${summary.totalReceived.toFixed(4)} SOL`);
+        console.log(`  Realized P&L: ${summary.realizedPL >= 0 ? "+" : ""}${summary.realizedPL.toFixed(4)} SOL`);
+        console.log(`  Unrealized P&L: ${summary.unrealizedPL >= 0 ? "+" : ""}${summary.unrealizedPL.toFixed(4)} SOL`);
+        console.log(`  ROI: ${summary.roi >= 0 ? "+" : ""}${summary.roi.toFixed(2)}%`);
+        console.log(`  Trades: ${history.length}`);
+        if (history.length > 0) {
+            console.log(T.muted("\n  Recent trades:"));
+            history.slice(-5).forEach(t => {
+                const date = new Date(t.timestamp).toLocaleDateString();
+                console.log(`    ${date} ${t.type} ${t.tokenAmount.toFixed(0)} tokens @ ${t.pricePerToken.toFixed(8)} SOL`);
+            });
+        }
+        try {
+            const csvPath = exportCSV();
+            console.log(T.success(`\n  CSV exported: ${csvPath}`));
+        }
+        catch (error) {
+            logger.warn('CLI', 'CSV export failed', { error: error.message });
+        }
+        process.exit(0);
+    })();
+    await new Promise(() => { });
+}
 if (subcmd === "keys" || subcmd === "providers") {
     (async () => {
         const readline = await import("node:readline");
@@ -323,7 +377,9 @@ if (subcmd === "gmgn" || subcmd === "gmgnhelp") {
                     gmgnEnv[m[1]] = m[2];
             }
         }
-        catch { /* no gmgn env */ }
+        catch {
+            logger.debug('CLI', 'No GMGN env file found (optional)');
+        }
         const output = execSync(fullArgs.join(" "), {
             env: { ...process.env, ...gmgnEnv },
             encoding: "utf-8",
@@ -338,6 +394,25 @@ if (subcmd === "gmgn" || subcmd === "gmgnhelp") {
     }
     process.exit(0);
 }
+if (subcmd === "scan" || subcmd === "security") {
+    (async () => {
+        const tokenAddress = args[1];
+        if (!tokenAddress) {
+            console.log(T.error("  Usage: aiaiai scan <token-address>"));
+            process.exit(1);
+        }
+        console.log(T.accent("\n  \uD83D\uDD0D Scanning token...\n"));
+        const result = await scanTokenSecurityTool("", { address: tokenAddress });
+        if (result.isError) {
+            console.log(result.content[0].text);
+            process.exit(1);
+        }
+        console.log(result.content[0].text);
+        console.log("");
+        process.exit(0);
+    })().catch(e => { console.error(T.error("Scan error: " + e.message)); process.exit(1); });
+    await new Promise(() => { });
+}
 if (subcmd === "update" || subcmd === "upgrade") {
     (async () => {
         const pkgName = "@aiaiaichain/agent";
@@ -368,9 +443,12 @@ if (subcmd === "update" || subcmd === "upgrade") {
                     changelog = `Git: ${pkgData.gitHead.slice(0, 8)}`;
                 }
             }
-            catch { /* no changelog available */ }
+            catch {
+                logger.debug('CLI', 'No changelog available (optional)');
+            }
         }
-        catch {
+        catch (error) {
+            logger.warn('CLI', 'Could not reach npm registry', { error: error.message });
             console.log(T.error("  Could not reach npm registry. Check your connection."));
             process.exit(1);
         }
@@ -414,6 +492,119 @@ if (subcmd === "update" || subcmd === "upgrade") {
     })().catch(e => { console.error(T.error(`Error: ${e.message}`)); process.exit(1); });
     await new Promise(() => { });
 }
+if (subcmd === "health" || subcmd === "doctor") {
+    (async () => {
+        console.log(T.accent("\n  \u2705 AIAIAI Health Check\n"));
+        let healthy = true;
+        // Check env file
+        console.log(T.muted("  Config:"));
+        if (existsSync(envPath)) {
+            console.log(T.success("    .env found"));
+        }
+        else {
+            console.log(T.warn("    .env not found \u2014 run: aiaiai setup"));
+            healthy = false;
+        }
+        // Check API key
+        console.log(T.muted("  API Key:"));
+        if (process.env.OPENROUTER_API_KEY || env.get("OPENROUTER_API_KEY")) {
+            console.log(T.success("    OPENROUTER_API_KEY set"));
+        }
+        else {
+            console.log(T.warn("    OPENROUTER_API_KEY not set"));
+            healthy = false;
+        }
+        // Check RPC
+        console.log(T.muted("  Solana RPC:"));
+        try {
+            const { resilientFetch } = await import("./util/resilientFetch.js");
+            const rpcUrl = process.env.SOLANA_RPC_URL || "https://api.mainnet-beta.solana.com";
+            const res = await resilientFetch(rpcUrl, {
+                timeout: 10_000,
+                retries: 0,
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "getHealth", params: [] }),
+            });
+            const json = await res.json();
+            if (json.result === "ok") {
+                console.log(T.success("    RPC healthy: " + rpcUrl));
+            }
+            else {
+                console.log(T.warn("    RPC responded but unhealthy"));
+                healthy = false;
+            }
+        }
+        catch (e) {
+            console.log(T.error("    RPC unreachable: " + e.message));
+            healthy = false;
+        }
+        // Check disk writable
+        console.log(T.muted("  Disk:"));
+        try {
+            const { writeFileSync, unlinkSync } = await import("node:fs");
+            const testFile = join(AIAIAI_HOME, ".health-test");
+            writeFileSync(testFile, "test", "utf-8");
+            unlinkSync(testFile);
+            console.log(T.success("    writable"));
+        }
+        catch (error) {
+            logger.warn('CLI', 'Disk not writable', { error: error.message });
+            console.log(T.error("    not writable"));
+            healthy = false;
+        }
+        // ── Extras (doctor mode) ──────────────────────────────────────────
+        console.log(T.muted("\n  Extras:"));
+        // Theme
+        try {
+            const { getCurrentTheme } = await import("./tui/ThemePresets.js");
+            console.log(T.success(`    Theme: ${getCurrentTheme()} (run aiaiai to change)`));
+        }
+        catch {
+            console.log(T.muted("    Theme: default"));
+        }
+        // Clipboard
+        try {
+            const { clipboardSupported } = await import("./util/clipboard.js");
+            console.log(T.muted(`    Clipboard: ${clipboardSupported()}`));
+        }
+        catch {
+            console.log(T.muted("    Clipboard: not available"));
+        }
+        // Webhooks
+        try {
+            const { hasWebhooks } = await import("./util/webhooks.js");
+            console.log(hasWebhooks() ? T.success("    Webhooks: configured") : T.muted("    Webhooks: not configured (set WEBHOOK_DISCORD or WEBHOOK_TELEGRAM in .env)"));
+        }
+        catch {
+            console.log(T.muted("    Webhooks: not available"));
+        }
+        // Provider key check
+        console.log(T.muted("  Provider Keys:"));
+        const providers = [
+            { name: "OpenRouter", key: "OPENROUTER_API_KEY" },
+            { name: "Anthropic", key: "ANTHROPIC_API_KEY" },
+            { name: "OpenAI", key: "OPENAI_API_KEY" },
+            { name: "Google", key: "GOOGLE_API_KEY" },
+            { name: "DeepSeek", key: "DEEPSEEK_API_KEY" },
+            { name: "Groq", key: "GROQ_API_KEY" },
+            { name: "GMGN", key: "GMGN_API_KEY" },
+        ];
+        for (const p of providers) {
+            const has = process.env[p.key] || env.get(p.key);
+            console.log(has ? T.success(`    ${p.name}: ✓`) : T.dim(`    ${p.name}: ✗ (optional)`));
+        }
+        console.log("");
+        if (healthy) {
+            console.log(T.success("  All systems operational.\n"));
+        }
+        else {
+            console.log(T.warn("  Some checks failed. Review above for details.\n"));
+        }
+        process.exit(healthy ? 0 : 1);
+    })().catch(e => { console.error(T.error("Health check failed: " + e.message)); process.exit(2); });
+    await new Promise(() => { });
+}
 if (subcmd === "sessions") {
     const sessions = sessionStore.list();
     if (sessions.length === 0) {
@@ -461,7 +652,29 @@ for (let i = 0; i < args.length; i++) {
 }
 let systemPrompt = SYSTEM_PROMPT;
 if (promptPath && existsSync(promptPath)) {
-    systemPrompt = readFileSync(promptPath, "utf-8");
+    let rawPrompt = readFileSync(promptPath, "utf-8");
+    // Validate prompt file size
+    if (rawPrompt.length > 10_000) {
+        console.error(T.error("Prompt file too large (max 10KB)."));
+        process.exit(1);
+    }
+    // Strip control characters
+    rawPrompt = rawPrompt.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g, "");
+    // Basic prompt injection detection
+    const dangerousPatterns = [
+        /ignore (all |previous |above|prior) instructions/i,
+        /you are now /i,
+        /new instructions/i,
+        /override (system|safety)/i,
+    ];
+    for (const pattern of dangerousPatterns) {
+        if (pattern.test(rawPrompt)) {
+            console.error(T.error("Prompt file contains suspicious patterns. Use a simpler prompt."));
+            process.exit(1);
+        }
+    }
+    systemPrompt = rawPrompt;
+    console.log(T.muted("  Custom prompt loaded: " + promptPath));
 }
 // ── Headless mode ─────────────────────────────────────────────────────────
 const headlessIdx = args.indexOf("--headless");

package/dist/core/ChainConfig.js

@@ -7,7 +7,7 @@ export const CHAINS = {
         name: 'solana',
         symbol: 'SOL',
         chainId: 101,
-        rpcUrl: 'https://api.mainnet-beta.solana.com',
+        rpcUrl: process.env.SOLANA_RPC_URL || 'https://api.mainnet-beta.solana.com',
         explorerUrl: 'https://solscan.io',
         enabled: true,
         primary: true,

package/dist/core/SystemMonitor.d.ts

@@ -15,9 +15,7 @@ export interface SystemStats {
 }
 export declare class SystemMonitor {
     private apiCallCount;
-    private lastNetStats;
-    constructor();
-    private initNetStats;
+    private prevCpuTimes;
     /** Track an API call */
     trackApiCall(): void;
     /** Get current system stats */
@@ -25,7 +23,6 @@ export declare class SystemMonitor {
     private getCpuPercent;
     private getRamPercent;
     private getNetStats;
-    private getRawNetStats;
     private formatBytes;
     private formatUptime;
     /** Reset API call counter (call every minute) */

package/dist/core/SystemMonitor.js

@@ -2,20 +2,11 @@
  * SystemMonitor — tracks CPU, RAM, network, and agent stats.
  * Uses Node.js built-in modules only (no external deps).
  */
-import { cpus, totalmem, freemem, uptime, networkInterfaces } from 'node:os';
+import { cpus, totalmem, freemem, uptime } from 'node:os';
+import { logger } from '../util/logger.js';
 export class SystemMonitor {
     apiCallCount = 0;
-    lastNetStats = { rx: 0, tx: 0, time: Date.now() };
-    constructor() {
-        this.initNetStats();
-    }
-    initNetStats() {
-        try {
-            const stats = this.getRawNetStats();
-            this.lastNetStats = { rx: stats.rx, tx: stats.tx, time: Date.now() };
-        }
-        catch { /* non-fatal */ }
-    }
+    prevCpuTimes = { idle: 0, total: 0 };
     /** Track an API call */
     trackApiCall() {
         this.apiCallCount++;
@@ -45,9 +36,21 @@ export class SystemMonitor {
             }
             const idle = totalIdle / cpuInfo.length;
             const total = totalTick / cpuInfo.length;
-            return Math.round((1 - idle / total) * 100);
+            // Delta-based: compare against previous sample
+            const nowIdle = idle, nowTotal = total;
+            if (this.prevCpuTimes.total > 0) {
+                const idleDelta = nowIdle - this.prevCpuTimes.idle;
+                const totalDelta = nowTotal - this.prevCpuTimes.total;
+                this.prevCpuTimes = { idle: nowIdle, total: nowTotal };
+                if (totalDelta <= 0)
+                    return 0;
+                return Math.round((1 - idleDelta / totalDelta) * 100);
+            }
+            this.prevCpuTimes = { idle: nowIdle, total: nowTotal };
+            return 0;
         }
-        catch {
+        catch (error) {
+            logger.debug('SystemMonitor', 'CPU measurement failed', { error: error.message });
             return 0;
         }
     }
@@ -56,38 +59,9 @@ export class SystemMonitor {
         return Math.round((used / totalmem()) * 100);
     }
     getNetStats() {
-        try {
-            const current = this.getRawNetStats();
-            const elapsed = (Date.now() - this.lastNetStats.time) / 1000;
-            if (elapsed < 1)
-                return { netUp: '0 B/s', netDown: '0 B/s' };
-            const rxPerSec = Math.max(0, (current.rx - this.lastNetStats.rx) / elapsed);
-            const txPerSec = Math.max(0, (current.tx - this.lastNetStats.tx) / elapsed);
-            this.lastNetStats = { rx: current.rx, tx: current.tx, time: Date.now() };
-            return {
-                netUp: this.formatBytes(txPerSec) + '/s',
-                netDown: this.formatBytes(rxPerSec) + '/s',
-            };
-        }
-        catch {
-            return { netUp: 'N/A', netDown: 'N/A' };
-        }
-    }
-    getRawNetStats() {
-        let rx = 0, tx = 0;
-        const interfaces = networkInterfaces();
-        for (const name of Object.keys(interfaces)) {
-            const iface = interfaces[name];
-            if (!iface)
-                continue;
-            for (const info of iface) {
-                if (info.internal)
-                    continue;
-                // Node.js doesn't expose per-interface bytes by default
-                // This is a best-effort approximation
-            }
-        }
-        return { rx, tx };
+        // Node.js doesn't expose per-interface byte counters without native addons.
+        // Return N/A rather than pretending zeros are real data.
+        return { netUp: 'N/A', netDown: 'N/A' };
     }
     formatBytes(bytes) {
         if (bytes === 0)

package/dist/index.d.ts

@@ -48,4 +48,14 @@ export { AgentDir } from "./core/AgentDir.js";
 export { EnvLoader, env } from "./core/EnvLoader.js";
 export { CHAINS, getPrimaryChain, getEnabledChains, getChain, getSupportedChains } from "./core/ChainConfig.js";
 export type { ChainInfo } from "./core/ChainConfig.js";
+export { resilientFetch, isReachable } from "./util/resilientFetch.js";
+export { logger } from "./util/logger.js";
+export { getCached, setCache, getOrCompute, clearCache, cacheStats } from "./util/responseCache.js";
+export { addTask, removeTask, pauseTask, resumeTask, pauseAll, resumeAll, startScheduler } from "./util/scheduler.js";
+export { requireConfirmation, isNonInteractive } from "./util/confirmation.js";
+export { ProcessManager } from "./util/processManager.js";
+export { recordTrade, getPLSummary, getTradeHistory, exportCSV } from "./wallet/ProfitTracker.js";
+export type { Trade, ProfitState, PLSummary } from "./wallet/ProfitTracker.js";
+export { scanTokenSecurityTool } from "./tools/TokenSecurityScanner.js";
+export type { TokenSecurityResult } from "./tools/TokenSecurityScanner.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -50,4 +50,15 @@ export { MCPServer } from "./mcp/server.js";
 export { AgentDir } from "./core/AgentDir.js";
 export { EnvLoader, env } from "./core/EnvLoader.js";
 export { CHAINS, getPrimaryChain, getEnabledChains, getChain, getSupportedChains } from "./core/ChainConfig.js";
+// Utilities
+export { resilientFetch, isReachable } from "./util/resilientFetch.js";
+export { logger } from "./util/logger.js";
+export { getCached, setCache, getOrCompute, clearCache, cacheStats } from "./util/responseCache.js";
+export { addTask, removeTask, pauseTask, resumeTask, pauseAll, resumeAll, startScheduler } from "./util/scheduler.js";
+export { requireConfirmation, isNonInteractive } from "./util/confirmation.js";
+export { ProcessManager } from "./util/processManager.js";
+// Profit Tracker
+export { recordTrade, getPLSummary, getTradeHistory, exportCSV } from "./wallet/ProfitTracker.js";
+// Token Security
+export { scanTokenSecurityTool } from "./tools/TokenSecurityScanner.js";
 //# sourceMappingURL=index.js.map

package/dist/models/ModelRegistry.js

@@ -4,6 +4,8 @@
  */
 import { env } from "../core/EnvLoader.js";
 import { Type } from "@sinclair/typebox";
+import { logger } from "../util/logger.js";
+import { resilientFetch } from "../util/resilientFetch.js";
 const PROVIDERS_WITH_MODELS = [
     { id: "openrouter", envVar: "OPENROUTER_API_KEY", baseUrl: "https://openrouter.ai/api/v1/models", mapper: (m) => ({ id: m.id, name: m.name, context: m.context_length ?? 131072, max: m.top_provider?.max_completion_tokens ?? 4096 }) },
     { id: "anthropic", envVar: "ANTHROPIC_API_KEY", baseUrl: "https://api.anthropic.com/v1/models", mapper: (m) => ({ id: m.id, name: m.name, context: m.context_length ?? 200000, max: m.top_provider?.max_completion_tokens ?? 8192 }) },
@@ -56,9 +58,11 @@ export class ModelRegistry {
                 if (provider.id === "google") {
                     url = `${provider.baseUrl}?key=${apiKey}`;
                 }
-                const res = await fetch(url, { headers });
-                if (!res.ok)
+                const res = await resilientFetch(url, { timeout: 15_000, retries: 1, headers });
+                if (!res.ok) {
+                    logger.warn('ModelRegistry', `Provider ${provider.id} returned ${res.status}`);
                     continue;
+                }
                 const data = await res.json();
                 const items = data.data ?? data.models ?? data;
                 if (!Array.isArray(items))
@@ -80,10 +84,14 @@ export class ModelRegistry {
                             this.providerModels.set(provider.id, []);
                         this.providerModels.get(provider.id).push(model);
                     }
-                    catch { /* skip bad entries */ }
+                    catch (error) {
+                        logger.debug('ModelRegistry', 'Skipped bad model entry', { error: error.message });
+                    }
                 }
             }
-            catch { /* skip this provider */ }
+            catch (error) {
+                logger.warn('ModelRegistry', 'Skipped provider', { error: error.message });
+            }
         }
         this.buildTiers();
         this.initialized = true;

package/dist/runner/AgentRunner.d.ts

@@ -44,6 +44,8 @@ export declare class AgentRunner {
     private contextStore?;
     private abortController;
     private _pendingApproval?;
+    private _toolRetries;
+    private _maxToolRetries;
     constructor(registry: Registry, session: SessionManager, onEvent: (event: RunnerEvent) => void, sessionCtx: SessionContext, effectLevel: string, modelReg: ModelRegistry, costTracker?: CostTracker, goalManager?: GoalManager, contextStore?: ContextStore);
     setEffectLevel(level: string): void;
     run(input: string): Promise<void>;

package/dist/runner/AgentRunner.js

@@ -2,6 +2,7 @@
  * AgentRunner — main agent loop. Handles tool calling, streaming, and message processing.
  * The AI responds with text or tool calls; we parse, dispatch, and feed results back.
  */
+import { logger } from "../util/logger.js";
 import { ToolDispatcher } from "./ToolDispatcher.js";
 import { ModelClient, resolveModelConfig } from "./ModelClient.js";
 export class AgentRunner {
@@ -17,6 +18,8 @@ export class AgentRunner {
     contextStore;
     abortController = null;
     _pendingApproval;
+    _toolRetries = new Map();
+    _maxToolRetries = 2;
     constructor(registry, session, onEvent, sessionCtx, effectLevel, modelReg, costTracker, goalManager, contextStore) {
         this.registry = registry;
         this.session = session;
@@ -53,7 +56,9 @@ export class AgentRunner {
                     try {
                         args = JSON.parse(toolCallMatch[3]);
                     }
-                    catch { /* use empty args */ }
+                    catch {
+                        logger.warn('AgentRunner', 'Failed to parse tool call args from stream', { toolCall: toolCallMatch[0].slice(0, 100) });
+                    }
                     fullResponse = fullResponse.replace(toolCallMatch[0], "").trim();
                     toolCallBuffer = "";
                     if (toolName !== "noop") {
@@ -130,6 +135,18 @@ export class AgentRunner {
             result: resultText,
             isError: result.isError ?? false,
         });
+        // Break retry loop: don't feed back if tool has failed too many times
+        if (result.isError) {
+            const retries = (this._toolRetries.get(toolName) ?? 0) + 1;
+            this._toolRetries.set(toolName, retries);
+            if (retries > this._maxToolRetries) {
+                this._toolRetries.delete(toolName);
+                return; // Stop feeding errors — prevent loop
+            }
+        }
+        else {
+            this._toolRetries.delete(toolName);
+        }
         // Feed the result back to the model for a follow-up
         const toolMessages = [
             ...messages.slice(-5),