termux-dev 1.2.2 → 1.4.0

package/dist/mcp/client.js

@@ -0,0 +1,218 @@
+import { spawn } from 'child_process';
+export class MCPClient {
+    name;
+    config;
+    process = null;
+    nextRequestId = 1;
+    pendingRequests = new Map();
+    buffer = '';
+    tools = [];
+    isConnected = false;
+    constructor(name, config) {
+        this.name = name;
+        this.config = config;
+    }
+    async start() {
+        if (this.config.disabled) {
+            throw new Error(`MCP server "${this.name}" is disabled in configuration.`);
+        }
+        return new Promise(async (resolve, reject) => {
+            let isSettled = false;
+            const initialTimer = setTimeout(() => {
+                if (!isSettled) {
+                    isSettled = true;
+                    this.close();
+                    reject(new Error(`MCP server "${this.name}" initialization timed out after 15s.`));
+                }
+            }, 15000);
+            try {
+                const env = {
+                    ...process.env,
+                    ...(this.config.env || {})
+                };
+                const isWindows = process.platform === 'win32';
+                const useShell = isWindows && (this.config.command.endsWith('.cmd') ||
+                    this.config.command.endsWith('.bat') ||
+                    this.config.command === 'npx' ||
+                    this.config.command === 'npm');
+                this.process = spawn(this.config.command, this.config.args || [], {
+                    env,
+                    stdio: ['pipe', 'pipe', 'pipe'],
+                    shell: useShell
+                });
+                this.process.stdout?.on('data', (data) => {
+                    this.handleStdout(data.toString());
+                });
+                this.process.stderr?.on('data', (_data) => {
+                    // Stderr from MCP servers is used for logging/debugging
+                });
+                this.process.on('error', (err) => {
+                    if (!isSettled) {
+                        isSettled = true;
+                        clearTimeout(initialTimer);
+                        reject(new Error(`Failed to start MCP server "${this.name}": ${err.message}`));
+                    }
+                    this.cleanup();
+                });
+                this.process.on('close', (_code) => {
+                    this.cleanup();
+                });
+                // 1. Initialize Handshake
+                const initResult = await this.sendRequest('initialize', {
+                    protocolVersion: '2024-11-05',
+                    capabilities: {},
+                    clientInfo: {
+                        name: 'devx',
+                        version: '1.4.0'
+                    }
+                });
+                if (!initResult) {
+                    throw new Error(`Invalid initialize response from MCP server "${this.name}".`);
+                }
+                // 2. Send initialized notification
+                this.sendNotification('notifications/initialized', {});
+                // 3. Fetch Tools List
+                const toolsResult = await this.sendRequest('tools/list', {});
+                this.tools = toolsResult?.tools || [];
+                this.isConnected = true;
+                if (!isSettled) {
+                    isSettled = true;
+                    clearTimeout(initialTimer);
+                    resolve(this.tools);
+                }
+            }
+            catch (err) {
+                if (!isSettled) {
+                    isSettled = true;
+                    clearTimeout(initialTimer);
+                    this.close();
+                    reject(err);
+                }
+            }
+        });
+    }
+    getTools() {
+        return this.tools;
+    }
+    hasConnected() {
+        return this.isConnected;
+    }
+    async callTool(toolName, args) {
+        if (!this.process || !this.isConnected) {
+            throw new Error(`MCP server "${this.name}" is not connected.`);
+        }
+        const res = await this.sendRequest('tools/call', {
+            name: toolName,
+            arguments: args || {}
+        }, 60000); // 60s timeout for tool calls
+        if (!res || !res.content) {
+            return JSON.stringify(res || {});
+        }
+        const outputParts = [];
+        for (const c of res.content) {
+            if (c.type === 'text' && c.text) {
+                outputParts.push(c.text);
+            }
+            else if (c.type === 'image' && c.data) {
+                outputParts.push(`[Image content (${c.mimeType || 'image/png'})]`);
+            }
+            else if (c.type === 'resource') {
+                outputParts.push(`[Resource: ${JSON.stringify(c)}]`);
+            }
+        }
+        const finalResult = outputParts.join('\n\n') || JSON.stringify(res);
+        if (res.isError) {
+            throw new Error(finalResult);
+        }
+        return finalResult;
+    }
+    handleStdout(chunk) {
+        this.buffer += chunk;
+        const lines = this.buffer.split('\n');
+        this.buffer = lines.pop() || '';
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            try {
+                const msg = JSON.parse(trimmed);
+                if ('id' in msg && msg.id !== undefined) {
+                    const pending = this.pendingRequests.get(msg.id);
+                    if (pending) {
+                        clearTimeout(pending.timer);
+                        this.pendingRequests.delete(msg.id);
+                        if (msg.error) {
+                            pending.reject(new Error(`MCP error ${msg.error.code}: ${msg.error.message}`));
+                        }
+                        else {
+                            pending.resolve(msg.result);
+                        }
+                    }
+                }
+            }
+            catch {
+                // Ignore non-JSON line outputs (e.g. startup banner)
+            }
+        }
+    }
+    sendRequest(method, params, timeoutMs = 15000) {
+        return new Promise((resolve, reject) => {
+            if (!this.process || !this.process.stdin) {
+                return reject(new Error(`MCP server "${this.name}" process is not running.`));
+            }
+            const id = this.nextRequestId++;
+            const timer = setTimeout(() => {
+                if (this.pendingRequests.has(id)) {
+                    this.pendingRequests.delete(id);
+                    reject(new Error(`MCP request "${method}" to server "${this.name}" timed out (${timeoutMs / 1000}s).`));
+                }
+            }, timeoutMs);
+            this.pendingRequests.set(id, { resolve, reject, timer });
+            const request = {
+                jsonrpc: '2.0',
+                id,
+                method,
+                params
+            };
+            try {
+                this.process.stdin.write(JSON.stringify(request) + '\n');
+            }
+            catch (err) {
+                clearTimeout(timer);
+                this.pendingRequests.delete(id);
+                reject(new Error(`Failed to write to MCP server "${this.name}": ${err.message}`));
+            }
+        });
+    }
+    sendNotification(method, params) {
+        if (!this.process || !this.process.stdin)
+            return;
+        const notif = {
+            jsonrpc: '2.0',
+            method,
+            params
+        };
+        try {
+            this.process.stdin.write(JSON.stringify(notif) + '\n');
+        }
+        catch { }
+    }
+    close() {
+        this.cleanup();
+        if (this.process) {
+            try {
+                this.process.kill();
+            }
+            catch { }
+            this.process = null;
+        }
+    }
+    cleanup() {
+        this.isConnected = false;
+        for (const [id, req] of this.pendingRequests.entries()) {
+            clearTimeout(req.timer);
+            req.reject(new Error(`MCP server "${this.name}" disconnected.`));
+        }
+        this.pendingRequests.clear();
+    }
+}

package/dist/mcp/manager.js

@@ -0,0 +1,196 @@
+import fs from 'fs/promises';
+import fsSync from 'fs';
+import path from 'path';
+import os from 'os';
+import pc from 'picocolors';
+import { MCPClient } from './client.js';
+import { getCurrentTheme } from '../cli/theme.js';
+function stripAnsi(str) {
+    return str.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, '');
+}
+export class MCPManager {
+    static instance;
+    clients = new Map();
+    tools = [];
+    serverStatuses = new Map();
+    isInitialized = false;
+    constructor() { }
+    static getInstance() {
+        if (!MCPManager.instance) {
+            MCPManager.instance = new MCPManager();
+        }
+        return MCPManager.instance;
+    }
+    async init(explicitConfigs) {
+        if (this.isInitialized) {
+            return this.tools;
+        }
+        const configs = explicitConfigs || await this.loadConfigs();
+        const serverEntries = Object.entries(configs);
+        if (serverEntries.length === 0) {
+            this.isInitialized = true;
+            return [];
+        }
+        const initPromises = serverEntries.map(async ([name, cfg]) => {
+            if (cfg.disabled) {
+                this.serverStatuses.set(name, {
+                    name,
+                    command: `${cfg.command} ${(cfg.args || []).join(' ')}`.trim(),
+                    status: 'disabled',
+                    toolsCount: 0,
+                    tools: []
+                });
+                return;
+            }
+            this.serverStatuses.set(name, {
+                name,
+                command: `${cfg.command} ${(cfg.args || []).join(' ')}`.trim(),
+                status: 'connecting',
+                toolsCount: 0,
+                tools: []
+            });
+            const client = new MCPClient(name, cfg);
+            this.clients.set(name, client);
+            try {
+                const mcpTools = await client.start();
+                this.serverStatuses.set(name, {
+                    name,
+                    command: `${cfg.command} ${(cfg.args || []).join(' ')}`.trim(),
+                    status: 'connected',
+                    toolsCount: mcpTools.length,
+                    tools: mcpTools.map(t => t.name)
+                });
+                // Convert MCP tools into devx Tool format
+                for (const mt of mcpTools) {
+                    const namespacedName = `mcp__${name}__${mt.name}`;
+                    const devxTool = {
+                        name: namespacedName,
+                        definition: {
+                            name: namespacedName,
+                            description: `[MCP: ${name}] ${mt.description || mt.name}`,
+                            parameters: {
+                                type: 'object',
+                                properties: mt.inputSchema?.properties || {},
+                                required: mt.inputSchema?.required
+                            }
+                        },
+                        validateArgs(_args) { },
+                        async execute(args) {
+                            return await client.callTool(mt.name, args);
+                        }
+                    };
+                    this.tools.push(devxTool);
+                }
+            }
+            catch (err) {
+                this.serverStatuses.set(name, {
+                    name,
+                    command: `${cfg.command} ${(cfg.args || []).join(' ')}`.trim(),
+                    status: 'failed',
+                    toolsCount: 0,
+                    tools: [],
+                    error: err.message
+                });
+            }
+        });
+        await Promise.all(initPromises);
+        this.isInitialized = true;
+        return this.tools;
+    }
+    getTools() {
+        return this.tools;
+    }
+    getStatuses() {
+        return Array.from(this.serverStatuses.values());
+    }
+    async reload() {
+        this.stopAll();
+        this.isInitialized = false;
+        this.clients.clear();
+        this.tools = [];
+        this.serverStatuses.clear();
+        return await this.init();
+    }
+    stopAll() {
+        for (const client of this.clients.values()) {
+            try {
+                client.close();
+            }
+            catch { }
+        }
+        this.clients.clear();
+    }
+    renderStatusCard() {
+        const theme = getCurrentTheme();
+        const statuses = this.getStatuses();
+        const cols = Math.min(process.stdout.columns || 80, 80);
+        const boxWidth = Math.max(48, cols - 4);
+        const innerWidth = boxWidth - 6;
+        const padRow = (left, right) => {
+            const plainLen = stripAnsi(left).length + stripAnsi(right).length;
+            const spaces = Math.max(1, innerWidth - plainLen);
+            return `│  ${left}${' '.repeat(spaces)}${right}  │`;
+        };
+        const header = theme.colorFn('┌─ ') + pc.bold('🔌 Model Context Protocol (MCP) Servers') + ' ' + theme.colorFn('─'.repeat(Math.max(2, boxWidth - 43)) + '┐');
+        const divider = theme.colorFn('├' + '─'.repeat(boxWidth - 2) + '┤');
+        const footer = theme.colorFn('└' + '─'.repeat(boxWidth - 2) + '┘');
+        const lines = [header];
+        if (statuses.length === 0) {
+            lines.push(padRow(pc.dim('No MCP servers configured.'), ''));
+            lines.push(padRow(pc.dim('Configure in .devx/mcp.json or ~/.devxrc.json'), ''));
+            lines.push(footer);
+            return lines.join('\n') + '\n';
+        }
+        for (let i = 0; i < statuses.length; i++) {
+            const s = statuses[i];
+            if (i > 0)
+                lines.push(divider);
+            let statusBadge = pc.green('🟢 Connected');
+            if (s.status === 'connecting')
+                statusBadge = pc.yellow('🟡 Connecting');
+            if (s.status === 'failed')
+                statusBadge = pc.red('🔴 Failed');
+            if (s.status === 'disabled')
+                statusBadge = pc.dim('⚪ Disabled');
+            lines.push(padRow(pc.bold(pc.white(`Server: ${s.name}`)), statusBadge));
+            lines.push(padRow(pc.dim(`  Command: ${s.command.slice(0, 36)}${s.command.length > 36 ? '...' : ''}`), pc.cyan(`${s.toolsCount} tools`)));
+            if (s.tools.length > 0) {
+                const toolsListStr = s.tools.slice(0, 3).map(t => pc.dim(`• ${t}`)).join(' ');
+                const extra = s.tools.length > 3 ? pc.dim(` +${s.tools.length - 3} more`) : '';
+                lines.push(padRow(`  ${toolsListStr}${extra}`, ''));
+            }
+            if (s.error) {
+                lines.push(padRow(pc.red(`  Error: ${s.error.slice(0, innerWidth - 10)}`), ''));
+            }
+        }
+        lines.push(footer);
+        return lines.join('\n') + '\n';
+    }
+    async loadConfigs() {
+        const result = {};
+        const configPaths = [
+            path.join(os.homedir(), '.devxrc.json'),
+            path.join(process.cwd(), '.devx', 'mcp.json'),
+            path.join(process.cwd(), '.claude', 'mcp.json'),
+            path.join(process.cwd(), '.devx.json'),
+            path.join(process.cwd(), '.mcp.json')
+        ];
+        for (const pth of configPaths) {
+            try {
+                if (fsSync.existsSync(pth)) {
+                    const raw = await fs.readFile(pth, 'utf8');
+                    const parsed = JSON.parse(raw);
+                    if (parsed && typeof parsed.mcpServers === 'object') {
+                        for (const [name, cfg] of Object.entries(parsed.mcpServers)) {
+                            if (cfg && typeof cfg === 'object' && cfg.command) {
+                                result[name] = cfg;
+                            }
+                        }
+                    }
+                }
+            }
+            catch { }
+        }
+        return result;
+    }
+}

package/dist/mcp/types.js

@@ -0,0 +1 @@
+export {};

package/dist/permissions/guard.js

@@ -23,25 +23,54 @@ function isPathOutsideCwd(targetPath) {
 function isDangerousBashCommand(commandStr) {
     if (!commandStr)
         return false;
-    const lower = commandStr.toLowerCase().trim();
-    return (lower.includes('rm -rf /') ||
-        lower.includes('rm -rf ~') ||
-        lower.includes('rm -rf *') ||
-        lower.includes('mkfs') ||
-        lower.includes('dd if=') ||
-        lower.includes(':(){ :|:& };:') ||
-        lower.includes('chmod -r 777 /') ||
-        lower.includes('> /dev/sda') ||
-        lower.includes('format c:'));
+    // Normalize whitespace: collapse multiple spaces/tabs into single space
+    const norm = commandStr.toLowerCase().replace(/\s+/g, ' ').trim();
+    // Pattern matching rm with combined flags (-rf, -fr, -r -f, etc.) targeting root, home, termux prefix, or glob
+    const isDangerousRm = /rm\s+-(?:[a-z]*r[a-z]*f|[a-z]*f[a-z]*r)\s+(?:\/|\/\*|~|~\/|\*|\$home|\$prefix|\/data\/data\/com\.termux)/i.test(norm) ||
+        /rm\s+-[a-z]*r[a-z]*\s+-[a-z]*f[a-z]*\s+(?:\/|\/\*|~|~\/|\*|\$home|\$prefix|\/data\/data\/com\.termux)/i.test(norm) ||
+        /rm\s+-[a-z]*f[a-z]*\s+-[a-z]*r[a-z]*\s+(?:\/|\/\*|~|~\/|\*|\$home|\$prefix|\/data\/data\/com\.termux)/i.test(norm);
+    return (isDangerousRm ||
+        norm.includes('rm -rf /') ||
+        norm.includes('rm -rf ~') ||
+        norm.includes('rm -rf *') ||
+        norm.includes('rm -rf $prefix') ||
+        norm.includes('rm -rf $home') ||
+        norm.includes('rm -rf /data/data/com.termux') ||
+        norm.includes('mkfs') ||
+        norm.includes('dd if=') ||
+        norm.includes(':(){ :|:& };:') ||
+        norm.includes('chmod -r 777 /') ||
+        norm.includes('> /dev/sda') ||
+        norm.includes('format c:'));
+}
+/**
+ * Checks if a command contains chaining, redirection, or subshell operators.
+ * Allowlist matches MUST be clean, single commands without hidden side-effects.
+ */
+function hasComplexChainingOrRedirection(commandStr) {
+    if (!commandStr)
+        return false;
+    return (commandStr.includes('&&') ||
+        commandStr.includes('||') ||
+        commandStr.includes(';') ||
+        commandStr.includes('|') ||
+        commandStr.includes('>') ||
+        commandStr.includes('<') ||
+        commandStr.includes('`') ||
+        commandStr.includes('$(') ||
+        commandStr.includes('\n') ||
+        commandStr.includes('\r'));
 }
 export class CLIConsoleGuard {
     autoApprove;
-    constructor(autoApprove = false) {
+    bashAllowlist;
+    constructor(autoApprove = false, bashAllowlist = []) {
         this.autoApprove = autoApprove;
+        this.bashAllowlist = bashAllowlist;
     }
     check(toolName, args) {
         const t = (toolName || '').toLowerCase();
-        const cmd = args?.command || args?.cmd || '';
+        const cmd = (args?.command || args?.cmd || '').trim();
         // Critical safety net: even in YOLO mode, warn and confirm destructive system commands
         if (this.autoApprove) {
             if (t === 'bash' && isDangerousBashCommand(cmd)) {
@@ -49,9 +78,19 @@ export class CLIConsoleGuard {
             }
             return false;
         }
-        // 1. Shell commands always require confirmation in safe mode
-        if (t === 'bash' || t === 'exec' || t === 'run_command') {
-            return true;
+        // Check Bash Allowlist: only allow if command is NOT dangerous AND does not use chaining/redirection
+        if ((t === 'bash' || t === 'exec' || t === 'run_command') && cmd) {
+            if (!isDangerousBashCommand(cmd) && !hasComplexChainingOrRedirection(cmd)) {
+                const isAllowed = this.bashAllowlist.some(pattern => {
+                    const p = pattern.trim().toLowerCase();
+                    const lowerCmd = cmd.toLowerCase();
+                    return lowerCmd === p || lowerCmd.startsWith(p + ' ');
+                });
+                if (isAllowed) {
+                    return false; // Automatically allowed!
+                }
+            }
+            return true; // Requires user confirmation
         }
         // 2. Package installations require confirmation
         if (t === 'install_package' || t === 'packages') {
@@ -68,15 +107,30 @@ export class CLIConsoleGuard {
                 return true;
             }
         }
+        // 5. MCP Tools: ask if autoApprove is false
+        if (t.startsWith('mcp__')) {
+            return true;
+        }
         return false;
     }
     async askUser(toolName, args) {
         const t = (toolName || '').toLowerCase();
         const cmd = args?.command || args?.cmd || '';
         const isDangerous = t === 'bash' && isDangerousBashCommand(cmd);
+        // In headless / non-interactive environment without TTY, deny confirmation-requiring actions immediately
+        if (!process.stdin.isTTY) {
+            console.error(pc.red(`\n🛡️  [PERMISSION DENIED] Action '${toolName}' requires user confirmation in safe mode, but no interactive terminal is available. Pass --yolo (-y) to auto-approve actions in headless mode.`));
+            return false;
+        }
         if (isDangerous) {
             p.log.error(pc.bold(pc.red('⚠️  [SECURITY WARNING] Agent requested a potentially dangerous system command!')));
         }
+        else if (t.startsWith('mcp__')) {
+            const parts = toolName.split('__');
+            const serverName = parts[1] || 'mcp';
+            const mcpToolName = parts.slice(2).join('__');
+            p.log.warn(pc.bold(pc.yellow(`🛡️  [PERMISSION GUARD] Agent wants to call MCP Tool: ${pc.cyan(serverName)} / ${pc.green(mcpToolName)}`)));
+        }
         else {
             p.log.warn(pc.bold(pc.yellow(`🛡️  [PERMISSION GUARD] Agent wants to execute: ${pc.cyan(toolName)}`)));
         }

package/dist/prompts/builder.js

@@ -72,5 +72,14 @@ export async function buildSystemPrompt(planMode) {
     }
     catch (e) {
     }
+    // Load Compact Repo Map (AST structure & exported symbols)
+    try {
+        const { RepoMapGenerator } = await import('../core/repomap.js');
+        const repoMap = await RepoMapGenerator.generate(process.cwd(), 50);
+        if (repoMap.trim()) {
+            prompt += `\n--- Codebase Map & Exported Symbols ---\n${repoMap}\n----------------------------------------\n`;
+        }
+    }
+    catch { }
     return prompt;
 }

package/dist/providers/openai.js

@@ -1,4 +1,5 @@
 import { calculateCost } from '../core/pricing.js';
+import { UsageTracker } from '../core/usage.js';
 export class OpenAIProvider {
     baseUrl;
     apiKey;
@@ -66,20 +67,23 @@ export class OpenAIProvider {
     async chat(request) {
         const url = `${this.baseUrl}/chat/completions`;
         const payload = this.buildPayload(request, false);
+        const bodyStr = JSON.stringify(payload);
         const headers = {
             'Content-Type': 'application/json',
         };
         if (this.apiKey) {
             headers['Authorization'] = `Bearer ${this.apiKey}`;
         }
+        UsageTracker.getInstance().recordRequest(Buffer.byteLength(bodyStr, 'utf8'));
         const res = await fetch(url, {
             method: 'POST',
             headers,
-            body: JSON.stringify(payload),
+            body: bodyStr,
             signal: request.signal
         });
         if (!res.ok) {
             const errText = await res.text();
+            UsageTracker.getInstance().recordResponseChunk(Buffer.byteLength(errText, 'utf8'));
             let errMsg = errText;
             try {
                 const parsed = JSON.parse(errText);
@@ -95,7 +99,15 @@ export class OpenAIProvider {
             err.status = res.status;
             throw err;
         }
-        const data = await res.json();
+        const rawResText = await res.text();
+        UsageTracker.getInstance().recordResponseChunk(Buffer.byteLength(rawResText, 'utf8'));
+        let data = {};
+        try {
+            data = JSON.parse(rawResText);
+        }
+        catch {
+            throw new Error(`Invalid JSON response from provider`);
+        }
         if (data.error) {
             const msg = data.error.message || data.error.code || JSON.stringify(data.error);
             throw new Error(`Provider Error: ${msg}`);
@@ -115,34 +127,47 @@ export class OpenAIProvider {
                 totalTokens,
                 cost
             };
+            UsageTracker.getInstance().recordTokens(promptTokens, completionTokens, cost);
         }
         return {
             content: choice.content || null,
-            toolCalls: choice.tool_calls ? choice.tool_calls.map((tc) => ({
-                id: tc.id,
-                name: tc.function.name,
-                arguments: JSON.parse(tc.function.arguments)
-            })) : undefined,
+            toolCalls: choice.tool_calls ? choice.tool_calls.map((tc) => {
+                let parsedArgs = {};
+                try {
+                    parsedArgs = JSON.parse(tc.function.arguments);
+                }
+                catch {
+                    parsedArgs = {};
+                }
+                return {
+                    id: tc.id || `call_${Math.random().toString(36).substring(2, 9)}`,
+                    name: tc.function.name,
+                    arguments: parsedArgs
+                };
+            }) : undefined,
             usage
         };
     }
     async *chatStream(request) {
         const url = `${this.baseUrl}/chat/completions`;
         const payload = this.buildPayload(request, true);
+        const bodyStr = JSON.stringify(payload);
         const headers = {
             'Content-Type': 'application/json',
         };
         if (this.apiKey) {
             headers['Authorization'] = `Bearer ${this.apiKey}`;
         }
+        UsageTracker.getInstance().recordRequest(Buffer.byteLength(bodyStr, 'utf8'));
         const res = await fetch(url, {
             method: 'POST',
             headers,
-            body: JSON.stringify(payload),
+            body: bodyStr,
             signal: request.signal
         });
         if (!res.ok) {
             const errText = await res.text();
+            UsageTracker.getInstance().recordResponseChunk(Buffer.byteLength(errText, 'utf8'));
             let errMsg = errText;
             try {
                 const parsed = JSON.parse(errText);
@@ -184,6 +209,9 @@ export class OpenAIProvider {
                 const { done, value } = await reader.read();
                 if (done || request.signal?.aborted)
                     break;
+                if (value) {
+                    UsageTracker.getInstance().recordResponseChunk(value.byteLength);
+                }
                 buffer += decoder.decode(value, { stream: true });
                 const lines = buffer.split('\n');
                 buffer = lines.pop() || '';
@@ -333,6 +361,7 @@ export class OpenAIProvider {
             totalTokens,
             cost
         };
+        UsageTracker.getInstance().recordTokens(promptTokens, completionTokens, cost);
         const finalResponse = {
             content: accumulatedContent || null,
             toolCalls: toolCalls.length > 0 ? toolCalls : undefined,