server.js

#!/usr/bin/env node
/**
 * OpenAI-compatible API server wrapping DeepSeek Web API
 * Supports BOTH streaming (SSE) and non-streaming modes
 * Includes tool calling: injects tool definitions into system prompt,
 * parses LLM text responses for TOOL_CALL patterns, returns OpenAI tool_calls format.
 * 
 * Per-agent sessions: each unique `user` field gets its own DeepSeek web session.
 * Auto-reset: sessions reset when message chain > 50 messages or age > 2 hours.
 * Listens on 0.0.0.0:9655
 */

const http = require('http');
const fs = require('fs');
const os = require('os');
const path = require('path');
const readline = require('readline');
const { spawnSync } = require('child_process');

const SERVER_HOST = os.hostname();  // Dynamic hostname detection
const SERVER_PUBLIC_IP = (() => {
    try {
        const interfaces = os.networkInterfaces();
        for (const name of Object.keys(interfaces)) {
            for (const iface of interfaces[name]) {
                if (iface.family === 'IPv4' && !iface.internal) return iface.address;
            }
        }
    } catch (e) {}
    return 'localhost';
})();

const FORGETMEAI_WATERMARK = 't.me/forgetmeai';
const PORT = Number(process.env.PORT || 9655);
const HOST = process.env.HOST || '0.0.0.0';
function formatWatermark(prefix = 'ForgetMeAI') { return `${prefix}: ${FORGETMEAI_WATERMARK}`; }
function printBanner() {
    console.log(`
███████ ██████  ███████ ███████ ██████  ███████ ███████ ███████ ██   ██
██      ██   ██ ██      ██      ██   ██ ██      ██      ██      ██  ██
█████   ██████  █████   █████   ██   ██ █████   █████   █████   █████
██      ██   ██ ██      ██      ██   ██ ██      ██      ██      ██  ██
██      ██   ██ ███████ ███████ ██████  ███████ ███████ ███████ ██   ██

   FreeDeepseekAPI — API-прокси для DeepSeek Web Chat
   ${formatWatermark()}
`);
}
function prompt(question) {
    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
    return new Promise(resolve => rl.question(question, ans => { rl.close(); resolve(ans); }));
}
function isTruthy(value) { return typeof value === 'string' && ['1','true','yes','on'].includes(value.trim().toLowerCase()); }

// === Per-Agent Session Store ===
const sessions = new Map();  // keyed by agent ID (from `user` field)
const MAX_HISTORY_LENGTH = 15;
const MAX_HISTORY_CHARS = 10000;
const MAX_MESSAGE_DEPTH = 100;  // auto-reset after this many messages
const SESSION_TTL_MS = 2 * 60 * 60 * 1000;  // 2 hours

// === DeepSeek Web API Config — loaded from external config file ===
const DS_CONFIG_PATH = process.env.DEEPSEEK_AUTH_PATH || path.join(__dirname, 'deepseek-auth.json');
const DEFAULT_ACCOUNT_COOLDOWN_MS = Number(process.env.DEEPSEEK_ACCOUNT_COOLDOWN_MS || 10 * 60 * 1000);
let DS_CONFIG = {};
let dsHeaders = {};
const accounts = [];
let accountRoundRobin = 0;
function buildBaseHeaders(config = DS_CONFIG) {
    return {
        "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36",
        "x-client-platform": "web",
        "x-client-version": "2.0.0",
        "x-client-locale": "ru",
        "x-client-timezone-offset": "14400",
        "x-app-version": "2.0.0",
        "Authorization": `Bearer ${config.token || ''}`,
        "x-hif-dliq": config.hif_dliq || '',
        "x-hif-leim": config.hif_leim || '',
        "Origin": "https://chat.deepseek.com",
        "Referer": "https://chat.deepseek.com/",
        "Cookie": config.cookie || '',
        "Content-Type": "application/json",
    };
}
function discoverAuthPaths() {
    if (process.env.DEEPSEEK_AUTH_DIR) {
        try {
            return fs.readdirSync(process.env.DEEPSEEK_AUTH_DIR)
                .filter(f => f.endsWith('.json'))
                .sort()
                .map(f => path.join(process.env.DEEPSEEK_AUTH_DIR, f));
        } catch (e) {
            console.error(`[DS-API] Could not read DEEPSEEK_AUTH_DIR: ${e.message}`);
            return [];
        }
    }
    if (process.env.DEEPSEEK_AUTH_PATH && process.env.DEEPSEEK_AUTH_PATH.includes(',')) {
        return process.env.DEEPSEEK_AUTH_PATH.split(',').map(s => s.trim()).filter(Boolean);
    }
    return [DS_CONFIG_PATH];
}
function loadDeepSeekConfig({ fatal = true } = {}) {
    accounts.length = 0;
    const paths = discoverAuthPaths();
    for (const file of paths) {
        try {
            const raw = fs.readFileSync(file, 'utf8');
            const config = JSON.parse(raw);
            const id = `account_${accounts.length + 1}`;
            accounts.push({ id, file, config, headers: buildBaseHeaders(config), cooldownUntil: 0, failures: 0, lastUsedAt: 0 });
        } catch (e) {
            console.error(`[DS-API] Could not load auth config ${file}: ${e.message}`);
        }
    }
    DS_CONFIG = accounts[0]?.config || {};
    dsHeaders = accounts[0]?.headers || buildBaseHeaders({});
    if (accounts.length > 0) {
        console.log(`[DS-API] Loaded ${accounts.length} auth account(s): ${accounts.map(a => a.id).join(', ')}`);
        return true;
    }
    if (fatal) {
        console.error(`[DS-API] FATAL: Could not load any auth config. Expected ${paths.join(', ') || DS_CONFIG_PATH}`);
        process.exit(1);
    }
    return false;
}
function hasAuthConfig() { return accounts.some(a => a.config.token && a.config.cookie); }
function accountStatus(account) {
    return {
        id: account.id,
        ready: !!(account.config.token && account.config.cookie),
        cooldown: account.cooldownUntil > Date.now(),
        cooldown_remaining_sec: Math.max(0, Math.ceil((account.cooldownUntil - Date.now()) / 1000)),
        failures: account.failures,
        last_used_at: account.lastUsedAt || null,
    };
}
function selectAccountForSession(session) {
    const now = Date.now();
    if (session.accountId) {
        const sticky = accounts.find(a => a.id === session.accountId);
        if (sticky && sticky.config.token && sticky.config.cookie && sticky.cooldownUntil <= now) return sticky;
        if (sticky && sticky.cooldownUntil > now) {
            // A DeepSeek chat_session belongs to the auth account that created it.
            // If that account is rate-limited/expired, do not keep hammering it;
            // reset the web session and let a healthy account take over.
            session.id = null;
            session.parentMessageId = null;
            session.createdAt = null;
            session.messageCount = 0;
        }
        session.accountId = null;
    }
    const ready = accounts.filter(a => a.config.token && a.config.cookie && a.cooldownUntil <= now);
    if (ready.length === 0) {
        const waiting = accounts.filter(a => a.config.token && a.config.cookie).sort((a, b) => a.cooldownUntil - b.cooldownUntil)[0];
        if (waiting) {
            const waitSec = Math.max(1, Math.ceil((waiting.cooldownUntil - now) / 1000));
            throw new Error(`All DeepSeek auth accounts are cooling down. Retry in ~${waitSec}s or import a fresh account with npm run auth:import.`);
        }
        throw new Error('No valid DeepSeek auth accounts. Run npm run auth or npm run auth:import.');
    }
    const account = ready[accountRoundRobin % ready.length];
    accountRoundRobin++;
    session.accountId = account.id;
    return account;
}
function markAccountFailure(account, status, reason = '') {
    if (!account) return;
    account.failures++;
    if ([401, 403, 429].includes(Number(status))) {
        account.cooldownUntil = Date.now() + DEFAULT_ACCOUNT_COOLDOWN_MS;
        console.log(`[account:${account.id}] cooldown for ${Math.round(DEFAULT_ACCOUNT_COOLDOWN_MS / 1000)}s after HTTP ${status}${reason ? ` (${reason})` : ''}`);
    }
}
async function readDeepSeekJsonResponse(resp, label, account) {
    const text = await resp.text();
    let json = null;
    if (text) {
        try { json = JSON.parse(text); }
        catch (e) {
            markAccountFailure(account, resp.status, label);
            throw new Error(`DeepSeek returned non-JSON ${label} response (HTTP ${resp.status}). Run npm run doctor. First chars: ${text.substring(0, 120)}`);
        }
    }
    if (!resp.ok) markAccountFailure(account, resp.status, label);
    return { json, text };
}
loadDeepSeekConfig({ fatal: false });

function createSession() {
    return {
        id: null,
        parentMessageId: null,
        createdAt: null,
        messageCount: 0,
        accountId: null,
        history: [],
    };
}

function getOrCreateAgentSession(agentId) {
    if (!sessions.has(agentId)) {
        sessions.set(agentId, createSession());
    }
    return sessions.get(agentId);
}

async function solvePOW(challenge, config = DS_CONFIG) {
    const resp = await fetch(config.wasmUrl);
    const wasmBytes = await resp.arrayBuffer();
    const mod = await WebAssembly.instantiate(wasmBytes, { wbg: {} });
    const e = mod.instance.exports;
    const encoder = new TextEncoder();
    const prefix = challenge.salt + '_' + challenge.expire_at + '_';
    const cBytes = encoder.encode(challenge.challenge);
    const pBytes = encoder.encode(prefix);
    const cP = e.__wbindgen_export_0(cBytes.length, 1) >>> 0;
    const pP = e.__wbindgen_export_0(pBytes.length, 1) >>> 0;
    new Uint8Array(e.memory.buffer, cP, cBytes.length).set(cBytes);
    new Uint8Array(e.memory.buffer, pP, pBytes.length).set(pBytes);
    const sp = e.__wbindgen_add_to_stack_pointer(-16);
    e.wasm_solve(sp, cP, cBytes.length, pP, pBytes.length, challenge.difficulty);
    const dv = new DataView(e.memory.buffer);
    const code = dv.getInt32(sp, true);
    const ans = dv.getFloat64(sp + 8, true);
    e.__wbindgen_add_to_stack_pointer(16);
    if (code === 0 || !Number.isFinite(ans) || ans <= 0) throw new Error('POW failed');
    return Math.floor(ans);
}

const MODEL_CONFIGS = {
    // DeepSeek Web real model_type: default / UI name: "Быстрый".
    // Public model family: DeepSeek-V3.2-Exp chat mode (fast, no visible reasoning).
    'deepseek-chat': {
        model_type: 'default', thinking_enabled: false, search_enabled: false,
        real_model: 'DeepSeek-V4-Flash non-thinking (DeepSeek Web “Быстрый” / default)',
        capabilities: { reasoning: false, web_search: false, files: true },
        supported: true,
    },
    'deepseek-v3': {
        model_type: 'default', thinking_enabled: false, search_enabled: false,
        real_model: 'DeepSeek-V4-Flash non-thinking (DeepSeek Web “Быстрый” / default)',
        capabilities: { reasoning: false, web_search: false, files: true },
        supported: true,
    },
    'deepseek-default': {
        model_type: 'default', thinking_enabled: false, search_enabled: false,
        real_model: 'DeepSeek-V4-Flash non-thinking (DeepSeek Web “Быстрый” / default)',
        capabilities: { reasoning: false, web_search: false, files: true },
        supported: true,
    },
    // Same DeepSeek Web default model, but with thinking_enabled=true. UI exposes it as thinking/reasoning mode.
    'deepseek-reasoner': {
        model_type: 'default', thinking_enabled: true, search_enabled: false,
        real_model: 'DeepSeek-V4-Flash thinking mode (DeepSeek Web “Быстрый” + thinking_enabled)',
        capabilities: { reasoning: true, web_search: false, files: true },
        supported: true,
    },
    'deepseek-r1': {
        model_type: 'default', thinking_enabled: true, search_enabled: false,
        real_model: 'DeepSeek-V4-Flash thinking mode; R1-compatible alias, not a separate R1 model_type in current Web API',
        capabilities: { reasoning: true, web_search: false, files: true },
        supported: true,
    },
    'deepseek-chat-search': {
        model_type: 'default', thinking_enabled: false, search_enabled: true,
        real_model: 'DeepSeek-V4-Flash non-thinking (DeepSeek Web “Быстрый” / default) + web search',
        capabilities: { reasoning: false, web_search: true, files: true },
        supported: true,
    },
    'deepseek-default-search': {
        model_type: 'default', thinking_enabled: false, search_enabled: true,
        real_model: 'DeepSeek-V4-Flash non-thinking (DeepSeek Web “Быстрый” / default) + web search',
        capabilities: { reasoning: false, web_search: true, files: true },
        supported: true,
    },
    'deepseek-reasoner-search': {
        model_type: 'default', thinking_enabled: true, search_enabled: true,
        real_model: 'DeepSeek-V4-Flash thinking mode + web search',
        capabilities: { reasoning: true, web_search: true, files: true },
        supported: true,
    },
    'deepseek-r1-search': {
        model_type: 'default', thinking_enabled: true, search_enabled: true,
        real_model: 'DeepSeek-V4-Flash thinking mode + web search; R1-compatible alias',
        capabilities: { reasoning: true, web_search: true, files: true },
        supported: true,
    },
    // DeepSeek Web UI name: “Эксперт”. Requires current web client headers (x-client-version=2.0.0).
    'deepseek-expert': {
        model_type: 'expert', thinking_enabled: false, search_enabled: false,
        real_model: 'DeepSeek Web “Эксперт” (limited resources)',
        capabilities: { reasoning: false, web_search: false, files: false },
        supported: true,
    },
    'deepseek-v4-pro': {
        model_type: 'expert', thinking_enabled: true, search_enabled: false,
        real_model: 'DeepSeek Web “Эксперт” + thinking mode (exposed as deepseek-v4-pro alias)',
        capabilities: { reasoning: true, web_search: false, files: false },
        supported: true,
    },
    'deepseek-expert-search': {
        model_type: 'expert', thinking_enabled: false, search_enabled: true,
        real_model: 'DeepSeek Web “Эксперт” + search requested, but Expert has search_feature=null in remote config',
        capabilities: { reasoning: false, web_search: false, files: false },
        supported: false,
        unavailable_reason: 'Expert mode is rejected; remote config says search is not available for Expert.',
    },
    'deepseek-vision': {
        model_type: 'vision', thinking_enabled: false, search_enabled: false,
        real_model: 'DeepSeek Web “Распознавание” / image understanding beta',
        capabilities: { reasoning: false, web_search: false, files: true, vision: true },
        supported: false,
        unavailable_reason: 'Current Web API returns: Vision is temporarily unavailable (backend_err_by_model).',
    },
};

const SUPPORTED_MODEL_IDS = Object.keys(MODEL_CONFIGS).filter(id => MODEL_CONFIGS[id].supported);
const ALL_MODEL_CAPABILITIES = Object.fromEntries(Object.entries(MODEL_CONFIGS).map(([id, cfg]) => [id, {
    id,
    real_model: cfg.real_model,
    model_type: cfg.model_type,
    thinking_enabled: cfg.thinking_enabled,
    search_enabled: cfg.search_enabled,
    capabilities: cfg.capabilities,
    supported: cfg.supported,
    unavailable_reason: cfg.unavailable_reason || null,
}]));

function resolveModelConfig(model) {
    const requested = String(model || 'deepseek-chat').toLowerCase();
    return MODEL_CONFIGS[requested] || MODEL_CONFIGS['deepseek-chat'];
}
function isKnownModel(model) { return Object.prototype.hasOwnProperty.call(MODEL_CONFIGS, String(model || '').toLowerCase()); }
function isSupportedModel(model) { return resolveModelConfig(model).supported === true; }

async function askDeepSeekStream(prompt, agentId, model = 'deepseek-default') {
    const modelCfg = resolveModelConfig(model);
    const session = getOrCreateAgentSession(agentId);
    const account = selectAccountForSession(session);
    const dsHeaders = account.headers;
    account.lastUsedAt = Date.now();
    const agentTag = `[${agentId}/acct:${account.id}]`;

    // Auto-reset on deep message chain
    if (session.id && session.messageCount >= MAX_MESSAGE_DEPTH) {
        console.log(`${agentTag} Session ${session.id} hit ${session.messageCount} messages. Auto-resetting.`);
        session.id = null;
        session.parentMessageId = null;
        session.createdAt = null;
        session.messageCount = 0;
        // History preserved for context injection
    }

    // Reset expired sessions (DeepSeek web sessions last ~1-2 hours)
    if (session.id && session.createdAt && (Date.now() - session.createdAt > SESSION_TTL_MS)) {
        console.log(`${agentTag} Session ${session.id} expired (age: ${Math.round((Date.now() - session.createdAt) / 60000)}min). Creating new...`);
        session.id = null;
        session.parentMessageId = null;
        session.createdAt = null;
        session.messageCount = 0;
    }

    const cr = await fetch('https://chat.deepseek.com/api/v0/chat/create_pow_challenge', {
        method: 'POST', headers: dsHeaders,
        body: JSON.stringify({ target_path: '/api/v0/chat/completion' })
    });
    const chalText = await cr.text();
    if (!cr.ok) {
        markAccountFailure(account, cr.status, 'pow challenge');
        throw new Error(`DeepSeek auth/network error while creating PoW challenge: HTTP ${cr.status}. Run npm run doctor. If auth expired, run npm run auth or npm run auth:import.`);
    }
    let chalJson;
    try { chalJson = JSON.parse(chalText); }
    catch (e) { throw new Error(`DeepSeek returned non-JSON PoW response. Run npm run doctor. First chars: ${chalText.substring(0, 120)}`); }
    const challenge = chalJson?.data?.biz_data?.challenge;
    if (!challenge) {
        throw new Error('DeepSeek PoW response has no data.biz_data.challenge. Auth may be expired, captcha may be required, or DeepSeek changed Web API. Run npm run doctor, then npm run auth.');
    }
    const answer = await solvePOW(challenge, account.config);

    if (!session.id) {
        const sr = await fetch('https://chat.deepseek.com/api/v0/chat_session/create', {
            method: 'POST', headers: dsHeaders, body: '{}'
        });
        const { json: sessionData, text: sessionText } = await readDeepSeekJsonResponse(sr, 'session create', account);
        const createdSessionId = sessionData?.data?.biz_data?.chat_session?.id || sessionData?.data?.biz_data?.id;
        if (!sr.ok || !createdSessionId) {
            throw new Error(`Could not create DeepSeek chat session (HTTP ${sr.status}). Auth may be expired/captcha-blocked. Run npm run doctor, then npm run auth. First chars: ${String(sessionText || '').substring(0, 120)}`);
        }
        session.id = createdSessionId;
        session.accountId = account.id;
        session.parentMessageId = null;
        session.createdAt = Date.now();
        session.messageCount = 0;
        console.log(`${agentTag} Created new session: ${session.id}`);
    } else {
        console.log(`${agentTag} Reusing session: ${session.id} (parent: ${session.parentMessageId}, msg#${session.messageCount})`);
    }

    const powB64 = Buffer.from(JSON.stringify({
        algorithm: challenge.algorithm, challenge: challenge.challenge,
        salt: challenge.salt, answer: answer,
        signature: challenge.signature, target_path: '/api/v0/chat/completion'
    })).toString('base64');
    const resp = await fetch('https://chat.deepseek.com/api/v0/chat/completion', {
        method: 'POST',
        headers: { ...dsHeaders, 'X-DS-PoW-Response': powB64 },
        body: JSON.stringify({
            chat_session_id: session.id,
            parent_message_id: session.parentMessageId,
            model_type: modelCfg.model_type,
            prompt: prompt, ref_file_ids: [],
            thinking_enabled: modelCfg.thinking_enabled, search_enabled: modelCfg.search_enabled,
            action: null, preempt: false,
        })
    });

    // If session expired, reset and retry once
    if (resp.status !== 200) {
        markAccountFailure(account, resp.status, 'completion');
        const errText = await resp.text();
        console.log(`${agentTag} Session error (${resp.status}): ${errText.substring(0, 100)}`);
        if (resp.status === 400 || resp.status === 404 || resp.status === 500) {
            console.log(`${agentTag} Session ${session.id} expired. Creating new session...`);
            session.id = null;
            session.parentMessageId = null;
            session.createdAt = null;
            session.messageCount = 0;

            const sr2 = await fetch('https://chat.deepseek.com/api/v0/chat_session/create', {
                method: 'POST', headers: dsHeaders, body: '{}'
            });
            const { json: sessionData2, text: sessionText2 } = await readDeepSeekJsonResponse(sr2, 'session recreate', account);
            const createdSessionId2 = sessionData2?.data?.biz_data?.chat_session?.id || sessionData2?.data?.biz_data?.id;
            if (!sr2.ok || !createdSessionId2) {
                throw new Error(`Could not recreate DeepSeek chat session (HTTP ${sr2.status}). Run npm run doctor, then npm run auth. First chars: ${String(sessionText2 || '').substring(0, 120)}`);
            }
            session.id = createdSessionId2;
            session.accountId = account.id;
            session.parentMessageId = null;
            session.createdAt = Date.now();
            console.log(`${agentTag} Created new session: ${session.id}`);

            const newPowB64 = Buffer.from(JSON.stringify({
                algorithm: challenge.algorithm, challenge: challenge.challenge,
                salt: challenge.salt, answer: answer,
                signature: challenge.signature, target_path: '/api/v0/chat/completion'
            })).toString('base64');
            const resp2 = await fetch('https://chat.deepseek.com/api/v0/chat/completion', {
                method: 'POST',
                headers: { ...dsHeaders, 'X-DS-PoW-Response': newPowB64 },
                body: JSON.stringify({
                    chat_session_id: session.id,
                    parent_message_id: null,
                    model_type: modelCfg.model_type,
                    prompt: prompt, ref_file_ids: [],
                    thinking_enabled: modelCfg.thinking_enabled, search_enabled: modelCfg.search_enabled,
                    action: null, preempt: false,
                })
            });
            return { resp: resp2, agentId };
        }
    }

    return { resp, agentId };
}

// === Tool Calling Support ===

function formatToolDefinitions(tools) {
    if (!tools || tools.length === 0) return '';
    let text = '\n\n--- TOOL REQUEST SYSTEM ---\n';
    text += 'You are an AI that ONLY REASONS and REQUESTS tool executions. You do NOT run any commands yourself.\n';
    text += 'When you need data from the local server, REQUEST exactly ONE tool call per response. Prefer strict JSON:\n';
    text += '{"tool_call":{"name":"<function_name>","arguments":{...}}}\n\n';
    text += 'Other accepted formats:\n';
    text += '[调用 <function_name>] {"arg1":"value1"}\n';
    text +=('[Call <function_name>] {"arg1":"value1"}\n');
    text += 'TOOL_CALL: <function_name>\narguments: <JSON arguments>\n\n';
    text += 'CRITICAL RULES:\n';
    text += '1. You ONLY output the tool request — you NEVER run anything yourself\n';
    text += '2. Do NOT simulate, guess, or fabricate command output — wait for the actual result\n';
    text += '3. Do NOT write [Tool Result] blocks — the gateway provides real results\n';
    text += '4. Request ONLY ONE tool per response — the gateway will execute it and return the result\n';
    text += '5. The tool runs on ' + SERVER_HOST + ' (' + SERVER_PUBLIC_IP + '), the local server — NOT on DeepSeek\n';
    text += '6. After the tool executes, the result will be sent to you as a new user/tool message\n';
    text += '7. Never add explanation before or after the tool request when requesting a tool\n';
    text += '8. Keep arguments compact. Do not include large file contents unless the tool schema requires it.\n\n';
    text += 'Available functions:\n';
    for (const tool of tools) {
        if (tool.type === 'function' && tool.function) {
            const fn = tool.function;
            text += `\n## ${fn.name}\n`;
            text += `${fn.description || ''}\n`;
            if (fn.parameters) {
                text += `Parameters: ${JSON.stringify(fn.parameters)}\n`;
            }
        }
    }
    text += '\n--- END TOOL REQUEST SYSTEM ---\n';
    text += '\nREMEMBER: Request ONE tool per response using strict JSON, [调用], [Call], or TOOL_CALL format. Never simulate results. Never write [Tool Result] blocks.';
    return text;
}

function extractBalancedJsonAt(text, startIndex) {
    let braceDepth = 0;
    let inString = false;
    let escape = false;
    for (let i = startIndex; i < text.length; i++) {
        const ch = text[i];
        if (escape) { escape = false; continue; }
        if (ch === '\\' && inString) { escape = true; continue; }
        if (ch === '"') { inString = !inString; continue; }
        if (!inString) {
            if (ch === '{') braceDepth++;
            if (ch === '}') {
                braceDepth--;
                if (braceDepth === 0) return text.substring(startIndex, i + 1);
            }
        }
    }
    return null;
}

function coerceToolCallObject(obj) {
    if (!obj || typeof obj !== 'object') return null;

    // Handle {"tool": "Bash", "arguments": {...}} where "tool" is a string
    // DeepSeek sometimes uses this format in fenced JSON blocks
    if (typeof obj.tool === 'string' && obj.arguments && typeof obj.arguments === 'object') {
        const name = obj.tool;
        let args = obj.arguments;
        if (typeof args === 'string') {
            try { args = JSON.parse(args); } catch (e) { args = { raw: args }; }
        }
        if (!args || typeof args !== 'object' || Array.isArray(args)) args = { value: args };
        return { name, arguments: JSON.stringify(args) };
    }

    const candidate = obj.tool_call || (typeof obj.tool === 'object' ? obj.tool : null) || obj.function_call || obj;
    if (!candidate || typeof candidate !== 'object') return null;
    const fn = candidate.function && typeof candidate.function === 'object' ? candidate.function : candidate;
    const name = fn.name || candidate.name || obj.name;
    let args = fn.arguments ?? candidate.arguments ?? candidate.input ?? obj.arguments ?? obj.input ?? {};
    if (!name || typeof name !== 'string') return null;
    if (typeof args === 'string') {
        try { args = JSON.parse(args); } catch (e) { args = { raw: args }; }
    }
    if (!args || typeof args !== 'object' || Array.isArray(args)) args = { value: args };
    return { name, arguments: JSON.stringify(args) };
}

function parseJsonToolCandidate(raw, label = 'json') {
    if (!raw) return null;
    try {
        const parsed = JSON.parse(raw);
        const tc = coerceToolCallObject(parsed);
        if (tc) {
            console.log(`[parseToolCall] SUCCESS ${label}: ${tc.name} (args=${tc.arguments.length} chars)`);
            return tc;
        }
    } catch (e) {
        console.log(`[parseToolCall] ${label} JSON.parse failed: ${e.message.substring(0, 100)}`);
    }
    return null;
}

/**
 * Parse DeepSeek XML-style tool calls with <parameter> tags.
 * DeepSeek sometimes emits tool calls in this format instead of JSON:
 *   <tool_call name="Bash">\n{"command":"ls"}\n</tool_call)>   (most common)
 *   <tool_calls>\n<invoke name="Bash">\n<parameter name="command" string="true">ls</parameter>\n</invoke>\n</tool_calls>
 *   <tool_call}>\n<name>function_name</name>\n<parameter name="param1">value1</parameter>\n</tool_call)>
 *
 * Also handles variants:
 *   <function_call}><function>name</function><parameter>...</parameter></function_call)>
 *   <tool_call}><name>...</name><arguments><arg1>...</arg1></arguments></tool_call)>
 */
function parseXmlToolCall(text) {
    if (!text || typeof text !== 'string') return null;

    // DeepSeek emits tool calls in XML-ish format. Observed variants:
    //   <tool_call name="Bash">\n{"command":"ls"}\n</tool_call)>   (most common)
    //   <tool_calls>\n<invoke name="Bash">\n<parameter name="command" string="true">ls</parameter>\n</invoke>\n</tool_calls>
    //   <tool_call}>\n<name>func</name>\n<parameter name="x">1</parameter>\n</tool_call)>
    //   <tool_call} (no >, just newline)
    //   <function_call}><function>name</function>...</function_call)>
    //   <bash>\n  description="List project files"\n  command="ls -la"\n</bash>  (tag name = tool name)
    // The opening tag can have name as attribute OR as child <name>/<invoke> element.
    // Arguments can be JSON directly inside, or <parameter>/<arguments> children, or key="value" attribute lines.
    // Note: <tool_calls> (plural) wraps <invoke> elements — we extract the FIRST one.

    // Step 0: Handle <tagname>key="value"...</tagname> format
    // DeepSeek sometimes emits: <bash>\n  description="..."\n  command="..."\n</bash>
    // where the tag name IS the tool name and content has attribute-style key="value" pairs.
    // Values can contain embedded quotes — greedy (.*) handles this by matching to the last " on each line.
    {
        const structuralTags = new Set([
            'tool_call', 'function_call', 'tool_calls', 'invoke', 'parameter',
            'arguments', 'name', 'function', 'reasoning', 'think', 'scratchpad',
            'think_tag', 'reflection', 'plan', 'step', 'output', 'result', 'response',
            'code', 'pre', 'div', 'span', 'p', 'br', 'hr', 'h1', 'h2', 'h3', 'ul', 'ol', 'li',
            'table', 'tr', 'td', 'th', 'a', 'img', 'em', 'strong', 'b', 'i', 'u', 's',
            'details', 'summary', 'blockquote', 'sup', 'sub', 'abbr',
        ]);
        const attrTagRe = /<([a-zA-Z_][a-zA-Z0-9_-]*)>([\s\S]*?)<\/\1>/g;
        let attrTagMatch;
        while ((attrTagMatch = attrTagRe.exec(text)) !== null) {
            const tag = attrTagMatch[1];
            if (structuralTags.has(tag.toLowerCase())) continue;
            // Skip tags that look like HTML/XML structural elements with lowercase names > 10 chars
            if (tag.length > 30) continue;

            const innerContent = attrTagMatch[2].trim();
            if (!innerContent) continue;

            // Check if content looks like key="value" attribute pairs (each on its own line or inline)
            const args = {};
            let attrCount = 0;
            const attrLineRe = /^\s*(\w+)\s*=\s*"(.*)"\s*$/gm;
            let attrLineMatch;
            while ((attrLineMatch = attrLineRe.exec(innerContent)) !== null) {
                const key = attrLineMatch[1];
                let val = attrLineMatch[2];
                // Try to parse as JSON (for numbers, booleans, arrays, objects), fallback to string
                try { const parsed = JSON.parse(val); if (typeof parsed !== 'object' || parsed === null) val = parsed; } catch (e) { /* keep as string */ }
                args[key] = val;
                attrCount++;
            }

            // Also try key="value" pairs on a single line (e.g. <bash command="ls -la" description="list"/>)
            if (attrCount === 0) {
                const inlineAttrRe = /(\w+)\s*=\s*"([^"]*)"/g;
                let inlineMatch;
                while ((inlineMatch = inlineAttrRe.exec(innerContent)) !== null) {
                    const key = inlineMatch[1];
                    let val = inlineMatch[2];
                    try { const parsed = JSON.parse(val); if (typeof parsed !== 'object' || parsed === null) val = parsed; } catch (e) { /* keep as string */ }
                    args[key] = val;
                    attrCount++;
                }
                // Also check the opening tag itself for attributes
                if (attrCount === 0) {
                    const tagFull = text.substring(attrTagMatch.index, attrTagMatch.index + attrTagMatch[0].length);
                    const openTag = tagFull.substring(0, tagFull.indexOf('>'));
                    let openAttrMatch;
                    while ((openAttrMatch = inlineAttrRe.exec(openTag)) !== null) {
                        const key = openAttrMatch[1];
                        let val = openAttrMatch[2];
                        try { const parsed = JSON.parse(val); if (typeof parsed !== 'object' || parsed === null) val = parsed; } catch (e) { /* keep as string */ }
                        args[key] = val;
                        attrCount++;
                    }
                }
            }

            if (attrCount >= 1) {
                // Capitalize first letter: bash → Bash, Read → Read
                const name = tag.charAt(0).toUpperCase() + tag.slice(1);
                console.log(`[parseXmlToolCall] SUCCESS attr-tag: ${name} (${attrCount} params)`);
                return { name, arguments: JSON.stringify(args) };
            }
        }
    }

    // Step 1: Check for <tool_calls> (plural) wrapper — two sub-formats:
    //   1a) <tool_calls><invoke name="Bash"><parameter name="cmd">val</parameter></invoke></tool_calls>
    //   1b) <tool_calls><parameter name="command">val</parameter><parameter name="description">val</parameter></tool_calls>
    //       (no <invoke>, no function name — infer from parameter names)
    // Use indexOf-based parsing to handle malformed tags like <tool_calls}> or </tool_calls)>
    {
        const tcPluralIdx = text.indexOf('<tool_calls');
        if (tcPluralIdx !== -1) {
            // Find end of opening tag (may be malformed like <tool_calls}>)
            let contentStart = -1;
            const firstGt = text.indexOf('>', tcPluralIdx + 11);
            const firstNewline = text.indexOf('\n', tcPluralIdx + 11);
            if (firstGt !== -1 && (firstNewline === -1 || firstGt < firstNewline)) {
                contentStart = firstGt + 1;
            } else if (firstNewline !== -1) {
                contentStart = firstNewline + 1;
            }
            // Find closing tag (may be malformed)
            const closeIdx = text.indexOf('</tool_calls', contentStart > 0 ? contentStart : tcPluralIdx + 12);
            if (contentStart > 0 && closeIdx > contentStart) {
                const outerInner = text.substring(contentStart, closeIdx);

                // Helper: parse <parameter> elements from a string into an args object
                function parseParametersFrom(src) {
                    const args = {};
                    let searchFrom = 0;
                    while (true) {
                        const paramOpen = src.indexOf('<parameter', searchFrom);
                        if (paramOpen === -1) break;
                        const paramGt = src.indexOf('>', paramOpen + 10);
                        const paramClose = src.indexOf('</parameter', paramGt > 0 ? paramGt : paramOpen + 10);
                        if (paramGt === -1 || paramClose === -1 || paramClose <= paramGt) break;
                        const paramTag = src.substring(paramOpen, paramGt + 1);
                        const paramVal = src.substring(paramGt + 1, paramClose).trim();
                        const pNameIdx = paramTag.indexOf('name=');
                        if (pNameIdx !== -1) {
                            const pQuoteStart = paramTag.indexOf('"', pNameIdx) + 1;
                            const pQuoteEnd = paramTag.indexOf('"', pQuoteStart);
                            if (pQuoteStart > 0 && pQuoteEnd > pQuoteStart) {
                                const key = paramTag.substring(pQuoteStart, pQuoteEnd).trim();
                                let val = paramVal;
                                try { val = JSON.parse(val); } catch (e) { /* keep as string */ }
                                args[key] = val;
                            }
                        }
                        searchFrom = paramClose + 11;
                    }
                    return args;
                }

                // Helper: infer tool name from parameter keys
                function inferToolName(args) {
                    const keys = Object.keys(args).map(k => k.toLowerCase());
                    if (keys.includes('command')) return 'Bash';
                    if (keys.includes('file_path') && !keys.includes('content') && !keys.includes('write')) return 'Read';
                    if (keys.includes('file_path') && keys.includes('content')) return 'Write';
                    if (keys.includes('pattern')) return 'Glob';
                    if (keys.includes('pattern') && keys.includes('path')) return 'Glob';
                    if (keys.includes('old_string') || keys.includes('new_string')) return 'Edit';
                    return null;
                }

                // 1a: Try <invoke name="...">
                const invokeIdx = outerInner.indexOf('<invoke');
                if (invokeIdx !== -1) {
                    const nameAttrIdx = outerInner.indexOf('name=', invokeIdx);
                    let invokeName = null;
                    if (nameAttrIdx !== -1 && nameAttrIdx < outerInner.indexOf('>', invokeIdx)) {
                        const quoteStart = outerInner.indexOf('"', nameAttrIdx) + 1;
                        const quoteEnd = outerInner.indexOf('"', quoteStart);
                        if (quoteStart > 0 && quoteEnd > quoteStart) {
                            invokeName = outerInner.substring(quoteStart, quoteEnd).trim();
                        }
                    }
                    const invokeGtIdx = outerInner.indexOf('>', invokeIdx);
                    const invokeCloseIdx = outerInner.indexOf('</invoke', invokeGtIdx > 0 ? invokeGtIdx : invokeIdx + 7);
                    if (invokeName && invokeGtIdx > 0 && invokeCloseIdx > invokeGtIdx) {
                        const invokeInner = outerInner.substring(invokeGtIdx + 1, invokeCloseIdx);
                        const args = parseParametersFrom(invokeInner);
                        console.log(`[parseXmlToolCall] SUCCESS xml-invoke: ${invokeName} (${Object.keys(args).length} params)`);
                        return { name: invokeName, arguments: JSON.stringify(args) };
                    }
                }

                // 1b: No <invoke> — parse <parameter> directly inside <tool_calls>
                //     Infer tool name from parameter names
                const args = parseParametersFrom(outerInner);
                if (Object.keys(args).length > 0) {
                    const inferredName = inferToolName(args);
                    if (inferredName) {
                        console.log(`[parseXmlToolCall] SUCCESS xml-plural-infer: ${inferredName} (${Object.keys(args).length} params, inferred from keys)`);
                        return { name: inferredName, arguments: JSON.stringify(args) };
                    }
                    // Has parameters but can't infer name — check for <name> element
                    const nameMatch = outerInner.match(/<name>([\s\S]*?)<\/name>/i);
                    if (nameMatch) {
                        const name = nameMatch[1].trim();
                        console.log(`[parseXmlToolCall] SUCCESS xml-plural-name: ${name} (${Object.keys(args).length} params)`);
                        return { name, arguments: JSON.stringify(args) };
                    }
                    console.log(`[parseXmlToolCall] <tool_calls> with params but can't infer name: ${Object.keys(args).join(', ')}`);
                }
            }
        }
    }

    // Step 1c: Bare <parameter> tags without any wrapper
    // DeepSeek sometimes emits: <parameter name="file_path">/some/path</parameter>
    // with NO <tool_call/tool_calls/invoke> wrapper at all. Infer tool name from parameter keys.
    {
        const args = {};
        let searchFrom = 0;
        let paramCount = 0;
        while (true) {
            const paramOpen = text.indexOf('<parameter', searchFrom);
            if (paramOpen === -1) break;
            const paramGt = text.indexOf('>', paramOpen + 10);
            const paramClose = text.indexOf('</parameter', paramGt > 0 ? paramGt : paramOpen + 10);
            if (paramGt === -1 || paramClose === -1 || paramClose <= paramGt) break;
            const paramTag = text.substring(paramOpen, paramGt + 1);
            const paramVal = text.substring(paramGt + 1, paramClose).trim();
            const pNameIdx = paramTag.indexOf('name=');
            if (pNameIdx !== -1) {
                const pQuoteStart = paramTag.indexOf('"', pNameIdx) + 1;
                const pQuoteEnd = paramTag.indexOf('"', pQuoteStart);
                if (pQuoteStart > 0 && pQuoteEnd > pQuoteStart) {
                    const key = paramTag.substring(pQuoteStart, pQuoteEnd).trim();
                    let val = paramVal;
                    try { val = JSON.parse(val); } catch (e) { /* keep as string */ }
                    args[key] = val;
                    paramCount++;
                }
            }
            searchFrom = paramClose + 11;
        }
        if (paramCount > 0) {
            const keys = Object.keys(args).map(k => k.toLowerCase());
            let inferredName = null;
            if (keys.includes('command')) inferredName = 'Bash';
            else if (keys.includes('file_path') && !keys.includes('content')) inferredName = 'Read';
            else if (keys.includes('file_path') && keys.includes('content')) inferredName = 'Write';
            else if (keys.includes('pattern')) inferredName = 'Glob';
            else if (keys.includes('old_string') || keys.includes('new_string')) inferredName = 'Edit';
            if (inferredName) {
                console.log(`[parseXmlToolCall] SUCCESS bare-parameter: ${inferredName} (${paramCount} params)`);
                return { name: inferredName, arguments: JSON.stringify(args) };
            }
        }
    }

    // Step 2: Original <tool_call/function_call> parsing
    const tagNames = ['tool_call', 'function_call'];
    let tagName = null;
    let contentStart = -1;
    let openingTag = '';

    for (const tn of tagNames) {
        const openIdx = text.indexOf('<' + tn);
        if (openIdx === -1) continue;
        // Skip if it's actually <tool_calls> (plural) — already handled above
        if (text[openIdx + tn.length] === 's' || text[openIdx + tn.length] === 'S') continue;

        const firstGtIdx = text.indexOf('>', openIdx + tn.length + 1);
        const newlineAfterOpen = text.indexOf('\n', openIdx);

        if (firstGtIdx !== -1 && (newlineAfterOpen === -1 || firstGtIdx < newlineAfterOpen)) {
            tagName = tn;
            contentStart = firstGtIdx + 1;
            openingTag = text.substring(openIdx, firstGtIdx + 1);
        } else {
            if (newlineAfterOpen !== -1) {
                tagName = tn;
                contentStart = newlineAfterOpen + 1;
                openingTag = text.substring(openIdx, newlineAfterOpen);
            }
        }
        if (tagName) break;
    }
    if (!tagName || contentStart === -1) return null;

    const closeTag = '</' + tagName;
    const closeIdx = text.indexOf(closeTag, contentStart);
    if (closeIdx === -1) return null;

    const inner = text.substring(contentStart, closeIdx).trim();

    // Extract function name — try multiple sources:
    let name = null;

    // Source 1: name as attribute on opening tag: <tool_call name="Bash">
    const nameAttrMatch = openingTag.match(/name\s*=\s*"([^"]*)"/i);
    if (nameAttrMatch) {
        name = nameAttrMatch[1].trim();
    }

    // Source 2: <name>...</name> or <function>...</function> child element
    if (!name) {
        const nameMatch = inner.match(/<(?:name|function)>([\s\S]*?)<\/(?:name|function)>/i);
        if (nameMatch) name = nameMatch[1].trim();
    }

    // Extract arguments — multiple patterns:
    const args = {};
    let paramCount = 0;

    // Pattern 1: JSON object directly inside the tag (most common DeepSeek format)
    if (paramCount === 0) {
        const jsonIdx = inner.indexOf('{');
        if (jsonIdx !== -1) {
            const rawJson = extractBalancedJsonAt(inner, jsonIdx);
            if (rawJson) {
                try {
                    const parsed = JSON.parse(rawJson);
                    if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
                        Object.assign(args, parsed);
                        paramCount = Object.keys(args).length;
                    }
                } catch (e) { /* not JSON, try other patterns */ }
            }
        }
    }

    // Pattern 2: <parameter name="key">value</parameter> (with or without string="true")
    if (paramCount === 0) {
        const paramRe = /<parameter\s+name\s*=\s*"([^"]*)"[^>]*>([\s\S]*?)<\/parameter>/gi;
        let paramMatch;
        while ((paramMatch = paramRe.exec(inner)) !== null) {
            const key = paramMatch[1].trim();
            let val = paramMatch[2].trim();
            try { val = JSON.parse(val); } catch (e) { /* keep as string */ }
            args[key] = val;
            paramCount++;
        }
    }

    // Pattern 3: <parameter>value</parameter> without name attr (positional)
    if (paramCount === 0) {
        const posParamRe = /<parameter(?:\s*[^>]*)?>([\s\S]*?)<\/parameter>/gi;
        let posIdx = 0;
        let paramMatch;
        while ((paramMatch = posParamRe.exec(inner)) !== null) {
            let val = paramMatch[1].trim();
            try { val = JSON.parse(val); } catch (e) { /* keep as string */ }
            args[`arg${posIdx}`] = val;
            posIdx++;
            paramCount++;
        }
    }

    // Pattern 4: <arguments>...</arguments> with nested <key>value</key> or JSON
    if (paramCount === 0) {
        const argsMatch = inner.match(/<arguments>([\s\S]*?)<\/arguments>/i);
        if (argsMatch) {
            const argsInner = argsMatch[1];
            const jsonInArgs = extractBalancedJsonAt(argsInner, argsInner.indexOf('{'));
            if (jsonInArgs) {
                try {
                    const parsed = JSON.parse(jsonInArgs);
                    if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
                        Object.assign(args, parsed);
                        paramCount = Object.keys(args).length;
                    }
                } catch (e) { /* fallback to XML */ }
            }
            if (paramCount === 0) {
                const kvRe = /<(\w+)>([\s\S]*?)<\/\1>/gi;
                let kvMatch;
                while ((kvMatch = kvRe.exec(argsInner)) !== null) {
                    const key = kvMatch[1];
                    if (key.toLowerCase() === 'name' || key.toLowerCase() === 'function') continue;
                    let val = kvMatch[2].trim();
                    try { val = JSON.parse(val); } catch (e) { /* keep as string */ }
                    args[key] = val;
                    paramCount++;
                }
            }
        }
    }

    if (!name) return null;

    console.log(`[parseXmlToolCall] SUCCESS xml: ${name} (${Object.keys(args).length} params)`);
    return { name, arguments: JSON.stringify(args) };
}

function parseToolCall(text) {
    if (!text || (typeof text === 'string' && text.length === 0)) return null;

    // NEW: Bracket-style tool calls: [调用 ToolName] {json}, [Call ToolName] {json}, [ToolName] {json}
    // DeepSeek sometimes emits tool calls in this format (especially in Chinese):
    //   [调用 Read] {"file_path": "/some/path"}
    //   [Call Read] {"file_path": "/some/path"}
    //   [Read] {"file_path": "/some/path"}
    // It may also emit multiple such calls in one response, sometimes with hallucinated [Tool Result] blocks.
    // We parse the FIRST valid one as the actual tool call.
    {
        // Known tool names for direct bracket matching (e.g. [Read], [Bash], [Write])
        const knownTools = ['Bash', 'Read', 'Write', 'Edit', 'Glob', 'Grep', 'MultiEdit',
            'TodoRead', 'TodoWrite', 'Task', 'Skill', 'LS', 'WebFetch', 'WebSearch',
            'NotebookRead', 'NotebookEdit', 'Complete', 'VLM', 'TTS', 'ASR', 'LLM'];
        const knownToolsLower = new Set(knownTools.map(t => t.toLowerCase()));

        // Pattern 1: [调用 ToolName] or [Call ToolName] — "调用" (Chinese) or "Call" prefix
        const callPrefixRe = /\[(?:调用|Call)\s+([\w-]+)\s*\]\s*(\{[\s\S]*?\})/gi;
        let callMatch;
        while ((callMatch = callPrefixRe.exec(text)) !== null) {
            let name = callMatch[1];
            // Capitalize first letter
            name = name.charAt(0).toUpperCase() + name.slice(1);
            const jsonStr = callMatch[2];
            let args;
            try { args = JSON.parse(jsonStr); } catch (e) {
                // Try extracting balanced JSON
                const braceStart = text.indexOf('{', callMatch.index + callMatch[0].indexOf('{'));
                const balanced = extractBalancedJsonAt(text, braceStart);
                if (balanced) {
                    try { args = JSON.parse(balanced); } catch (e2) {
                        console.log(`[parseToolCall] bracket-call JSON parse failed for ${name}: ${e2.message.substring(0, 80)}`);
                        continue;
                    }
                } else {
                    console.log(`[parseToolCall] bracket-call JSON parse failed for ${name}: ${e.message.substring(0, 80)}`);
                    continue;
                }
            }
            if (args && typeof args === 'object' && !Array.isArray(args)) {
                console.log(`[parseToolCall] SUCCESS bracket-call: ${name} (args=${JSON.stringify(args).length} chars)`);
                return { name, arguments: JSON.stringify(args) };
            }
        }

        // Pattern 2: [ToolName] {json} — direct tool name in brackets (no 调用/Call prefix)
        // Only match known tool names to avoid false positives on markdown links, etc.
        const directBracketRe = /\[([\w-]+)\]\s*(\{[\s\S]*?\})/gi;
        let directMatch;
        while ((directMatch = directBracketRe.exec(text)) !== null) {
            const candidate = directMatch[1];
            // Only accept known tool names (case-insensitive)
            if (!knownToolsLower.has(candidate.toLowerCase())) continue;
            // Skip if this is actually a [调用] or [Call] prefix (already handled above)
            if (candidate.toLowerCase() === '调用' || candidate.toLowerCase() === 'call') continue;
            let name = candidate.charAt(0).toUpperCase() + candidate.slice(1);
            const jsonStr = directMatch[2];
            let args;
            try { args = JSON.parse(jsonStr); } catch (e) {
                const braceStart = text.indexOf('{', directMatch.index + directMatch[0].indexOf('{'));
                const balanced = extractBalancedJsonAt(text, braceStart);
                if (balanced) {
                    try { args = JSON.parse(balanced); } catch (e2) {
                        console.log(`[parseToolCall] bracket-direct JSON parse failed for ${name}: ${e2.message.substring(0, 80)}`);
                        continue;
                    }
                } else {
                    console.log(`[parseToolCall] bracket-direct JSON parse failed for ${name}: ${e.message.substring(0, 80)}`);
                    continue;
                }
            }
            if (args && typeof args === 'object' && !Array.isArray(args)) {
                console.log(`[parseToolCall] SUCCESS bracket-direct: ${name} (args=${JSON.stringify(args).length} chars)`);
                return { name, arguments: JSON.stringify(args) };
            }
        }
    }

    // NEW: DeepSeek XML <tool_call}> with <parameter> tags (must check BEFORE JSON-based XML parser)
    const xmlTc = parseXmlToolCall(text);
    if (xmlTc) return xmlTc;

    // XML-ish wrappers used by some agent prompts (expects JSON inside <tool_call/>).
    const xmlMatch = text.match(/<tool_call[^>]*>([\s\S]*?)<\/tool_call>/i);
    if (xmlMatch) {
        const inner = xmlMatch[1].trim();
        const tc = parseJsonToolCandidate(inner, 'xml');
        if (tc) return tc;
    }

    // Fenced bash/sh/zsh blocks — DeepSeek emits these as tool calls:
    //   ```bash\nls -la\n```
    // The content becomes the "command" argument for Bash tool.
    // Only treat as tool call if the fenced block is the MAIN content
    // (not just an example in a longer explanation).
    const shellFenceRe = /```(?:bash|sh|zsh|shell)\s*\n?([\s\S]*?)```/gi;
    let shellFence;
    const shellCommands = [];
    while ((shellFence = shellFenceRe.exec(text)) !== null) {
        const command = shellFence[1].trim();
        if (command && !command.startsWith('{')) {
            shellCommands.push(command);
        }
    }
    if (shellCommands.length > 0) {
        // Heuristic: if there are fenced bash blocks AND the text is relatively short
        // (no long explanations before/after), treat the first one as a Bash tool call.
        // Long explanations with multiple code blocks are usually informational, not tool calls.
        const strippedText = text.replace(/```[\s\S]*?```/g, '').trim();
        const explanationLen = strippedText.length;
        // If explanation is short (< 200 chars) or there's only one shell block, it's likely a tool call
        if (explanationLen < 200 || shellCommands.length === 1) {
            const command = shellCommands[0];
            const args = { command };
            console.log(`[parseToolCall] SUCCESS shell-fence: Bash (command=${command.length} chars, explanation=${explanationLen} chars)`);
            return { name: 'Bash', arguments: JSON.stringify(args) };
        }
    }

    // Fenced JSON blocks.
    const fenceRe = /```(?:json)?\s*([\s\S]*?)```/gi;
    let fence;
    while ((fence = fenceRe.exec(text)) !== null) {
        const tc = parseJsonToolCandidate(fence[1].trim(), 'fenced');
        if (tc) return tc;
    }

    // Legacy TOOL_CALL: name + first balanced JSON object after it.
    const match = text.match(/TOOL_CALL:\s*([\w-]+)\s*/i);
    if (match) {
        const name = match[1];
        const afterMatch = text.substring(match.index + match[0].length);
        const braceIdx = afterMatch.indexOf('{');
        if (braceIdx !== -1) {
            const rawJson = extractBalancedJsonAt(afterMatch, braceIdx);
            if (rawJson) {
                try {
                    const args = JSON.parse(rawJson);
                    console.log(`[parseToolCall] SUCCESS legacy: ${name} (args=${rawJson.length} chars)`);
                    return { name, arguments: JSON.stringify(args) };
                } catch (e) {
                    console.log(`[parseToolCall] legacy JSON.parse failed: ${e.message.substring(0,100)}`);
                }
            } else {
                console.log(`[parseToolCall] TOOL_CALL:${name} found but JSON braces are unbalanced`);
            }
        } else {
            console.log(`[parseToolCall] TOOL_CALL:${name} found but no { after it`);
        }
    }

    // First balanced JSON object in the whole response. Supports:
    // {"tool_call":{"name":"...","arguments":{...}}}, {"name":"...","arguments":{...}}, etc.
    for (let i = 0; i < text.length; i++) {
        if (text[i] !== '{') continue;
        const rawJson = extractBalancedJsonAt(text, i);
        if (!rawJson) continue;
        const tc = parseJsonToolCandidate(rawJson, 'inline');
        if (tc) return tc;
    }

    console.log(`[parseToolCall] No tool call match in ${text.length} chars`);
    console.log(`[parseToolCall] DEBUG full text: ${text.substring(0, 2000)}`);
    return null;
}

/**
 * Strip surrogate characters and other problematic Unicode from text
 * to prevent httpx/urlencode crashes when the gateway sends to Telegram.
 */
function sanitizeContent(text) {
    return text.replace(/[\ud800-\udfff]/g, '');
}

function estimateTokens(text) {
    return text ? Math.ceil(String(text).length / 4) : 0;
}

function buildUsage(prompt, content, reasoningContent = '') {
    const promptTokens = estimateTokens(prompt);
    const contentTokens = estimateTokens(content);
    const reasoningTokens = estimateTokens(reasoningContent);
    const completionTokens = contentTokens + reasoningTokens;
    return {
        prompt_tokens: promptTokens,
        completion_tokens: completionTokens,
        total_tokens: promptTokens + completionTokens,
        completion_tokens_details: {
            reasoning_tokens: reasoningTokens
        }
    };
}

/**
 * Sanitize tool call arguments to only include parameters that exist in the tool schema.
 * DeepSeek often emits extra parameters (description, timeout, etc.) that aren't in
 * the actual tool schema, causing "Invalid tool parameters" errors in Claude Code.
 */
function sanitizeToolCallArgs(toolCall, tools) {
    if (!toolCall || !tools || tools.length === 0) return toolCall;
    
    // Find the matching tool definition
    const toolDef = tools.find(t => 
        t.type === 'function' && t.function && t.function.name === toolCall.name
    );
    if (!toolDef || !toolDef.function || !toolDef.function.parameters) return toolCall;
    
    const schema = toolDef.function.parameters;
    const allowedKeys = new Set();
    
    // Collect allowed parameter names from the schema
    if (schema.properties) {
        for (const key of Object.keys(schema.properties)) {
            allowedKeys.add(key);
        }
    }
    
    if (allowedKeys.size === 0) return toolCall;
    
    // Parse arguments, filter, and re-serialize
    try {
        const args = JSON.parse(toolCall.arguments);
        if (!args || typeof args !== 'object' || Array.isArray(args)) return toolCall;
        
        const filtered = {};
        let removed = [];
        for (const [key, value] of Object.entries(args)) {
            if (allowedKeys.has(key)) {
                filtered[key] = value;
            } else {
                removed.push(key);
            }
        }
        
        if (removed.length > 0) {
            console.log(`[sanitizeToolCallArgs] Removed extra params from ${toolCall.name}: ${removed.join(', ')} (allowed: ${[...allowedKeys].join(', ')})`);
            return { name: toolCall.name, arguments: JSON.stringify(filtered) };
        }
    } catch (e) { /* can't parse, return as-is */ }
    
    return toolCall;
}

function buildToolCallResponse(toolCall, model = 'deepseek-default', prompt = '', reasoningContent = '') {
    const id = 'call_' + Date.now() + '_' + Math.random().toString(36).substring(2, 8);
    const message = {
        role: 'assistant',
        content: null,
        tool_calls: [{
            id: id,
            type: 'function',
            function: { name: toolCall.name, arguments: toolCall.arguments }
        }]
    };
    // Do not attach reasoning to tool-call turns. Some agent clients treat any
    // reasoning/text payload as a final assistant answer and stop their tool loop.
    return {
        id: 'ds-' + Date.now(),
        object: 'chat.completion',
        created: Math.floor(Date.now() / 1000),
        model,
        choices: [{
            index: 0,
            message,
            finish_reason: 'tool_calls'
        }],
        usage: buildUsage(prompt, '', reasoningContent),
        watermark: FORGETMEAI_WATERMARK
    };
}

function buildTextResponse(content, prompt, model = 'deepseek-default', reasoningContent = '') {
    const message = { role: 'assistant', content };
    if (reasoningContent) message.reasoning_content = reasoningContent;
    return {
        id: 'ds-' + Date.now(),
        object: 'chat.completion',
        created: Math.floor(Date.now() / 1000),
        model,
        choices: [{
            index: 0,
            message,
            finish_reason: 'stop'
        }],
        usage: buildUsage(prompt, content, reasoningContent),
        watermark: FORGETMEAI_WATERMARK
    };
}

function normalizeMessageContent(content) {
    if (content === null || content === undefined) return '';
    if (typeof content === 'string') return content;
    if (Array.isArray(content)) {
        return content.map(part => {
            if (typeof part === 'string') return part;
            if (!part || typeof part !== 'object') return '';
            if (part.type === 'text' || part.type === 'input_text' || part.type === 'output_text') return part.text || '';
            if (part.type === 'tool_result') return `[Tool Result ${part.tool_use_id || ''}]\n${normalizeMessageContent(part.content)}`;
            if (part.type === 'image_url') return `[Image: ${part.image_url?.url || ''}]`;
            return part.text || part.content || JSON.stringify(part);
        }).filter(Boolean).join('\n');
    }
    return String(content);
}

function normalizeAnthropicTools(tools = []) {
    return (tools || []).map(tool => ({
        type: 'function',
        function: {
            name: tool.name,
            description: tool.description || '',
            parameters: tool.input_schema || tool.parameters || { type: 'object', properties: {} }
        }
    })).filter(tool => tool.function.name);
}

function normalizeResponsesTools(tools = []) {
    return (tools || []).map(tool => {
        if (tool.type === 'function' && tool.function) return tool;
        if (tool.type === 'function' && tool.name) {
            return { type: 'function', function: { name: tool.name, description: tool.description || '', parameters: tool.parameters || { type: 'object', properties: {} } } };
        }
        return null;
    }).filter(Boolean);
}

function normalizeResponsesInput(input) {
    if (typeof input === 'string') return [{ role: 'user', content: input }];
    if (!Array.isArray(input)) return [];
    const messages = [];
    for (const item of input) {
        if (!item || typeof item !== 'object') continue;
        if (item.type === 'message') {
            messages.push({ role: item.role || 'user', content: normalizeMessageContent(item.content) });
        } else if (item.role) {
            messages.push({ role: item.role, content: normalizeMessageContent(item.content) });
        } else if (item.type === 'function_call_output') {
            messages.push({ role: 'tool', tool_call_id: item.call_id, content: item.output || '' });
        } else if (item.type === 'input_text') {
            messages.push({ role: 'user', content: item.text || '' });
        }
    }
    return messages;
}

function normalizeApiParams(params, apiMode) {
    if (apiMode === 'anthropic') {
        const messages = [];
        if (params.system) messages.push({ role: 'system', content: normalizeMessageContent(params.system) });
        for (const msg of params.messages || []) {
            if (msg.role === 'assistant' && Array.isArray(msg.content)) {
                const toolUses = msg.content.filter(part => part && part.type === 'tool_use');
                const text = normalizeMessageContent(msg.content.filter(part => !part || part.type !== 'tool_use'));
                if (text) messages.push({ role: 'assistant', content: text });
                for (const tu of toolUses) {
                    messages.push({ role: 'assistant', content: null, tool_calls: [{ id: tu.id, type: 'function', function: { name: tu.name, arguments: JSON.stringify(tu.input || {}) } }] });
                }
            } else if (msg.role === 'user' && Array.isArray(msg.content) && msg.content.some(part => part && part.type === 'tool_result')) {
                for (const part of msg.content) {
                    if (part && part.type === 'tool_result') messages.push({ role: 'tool', tool_call_id: part.tool_use_id, content: normalizeMessageContent(part.content) });
                    else messages.push({ role: 'user', content: normalizeMessageContent(part) });
                }
            } else {
                messages.push({ role: msg.role || 'user', content: normalizeMessageContent(msg.content) });
            }
        }
        return {
            ...params,
            model: params.model || 'deepseek-chat',
            messages,
            tools: normalizeAnthropicTools(params.tools || []),
            stream: params.stream === true,
            user: params.metadata?.user_id || params.user,
        };
    }
    if (apiMode === 'responses') {
        const messages = normalizeResponsesInput(params.input);
        if (params.instructions) messages.unshift({ role: 'system', content: params.instructions });
        return {
            ...params,
            model: params.model || 'deepseek-chat',
            messages,
            tools: normalizeResponsesTools(params.tools || []),
            stream: params.stream === true,
            user: params.user,
        };
    }
    return params;
}

function safeJsonParseObject(text, fallback = {}) {
    try {
        const parsed = JSON.parse(text || '{}');
        return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : fallback;
    } catch (e) {
        return fallback;
    }
}

function toAnthropicResponse(openaiResp) {
    const choice = openaiResp.choices[0];
    const msg = choice.message || {};
    const hasToolCalls = msg.tool_calls && msg.tool_calls.length > 0;
    const content = [];
    if (hasToolCalls) {
        for (const tc of msg.tool_calls) {
            content.push({ type: 'tool_use', id: tc.id, name: tc.function.name, input: safeJsonParseObject(tc.function.arguments) });
        }
    } else {
        content.push({ type: 'text', text: msg.content || '' });
    }
    const response = {
        id: 'msg_' + openaiResp.id,
        type: 'message',
        role: 'assistant',
        model: openaiResp.model,
        content,
        stop_reason: choice.finish_reason === 'tool_calls' ? 'tool_use' : 'end_turn',
        stop_sequence: null,
        usage: {
            input_tokens: openaiResp.usage?.prompt_tokens || 0,
            output_tokens: openaiResp.usage?.completion_tokens || 0,
        },
        watermark: FORGETMEAI_WATERMARK,
    };
    if (!hasToolCalls && msg.reasoning_content) response.reasoning_content = msg.reasoning_content;
    return response;
}

function writeSse(res, event, data) {
    if (event) res.write(`event: ${event}\n`);
    res.write(`data: ${JSON.stringify(data)}\n\n`);
}

function sendAnthropicStream(res, openaiResp) {
    res.writeHead(200, { 'Content-Type': 'text/event-stream', 'Cache-Control': 'no-cache', 'Connection': 'keep-alive', 'Access-Control-Allow-Origin': '*' });
    const choice = openaiResp.choices[0];
    const msg = choice.message || {};
    const message = toAnthropicResponse(openaiResp);
    const hasToolCalls = msg.tool_calls && msg.tool_calls.length > 0;
    writeSse(res, 'message_start', { type: 'message_start', message: { ...message, content: [] } });

    // Anthropic-compatible clients expect a tool turn to be made of tool_use
    // content blocks. If we emit DeepSeek reasoning as a text block before the
    // tool_use block, some agents treat the turn as a normal text answer and do
    // not execute the tool. Keep tool streaming clean: tool_use blocks only.
    if (hasToolCalls) {
        msg.tool_calls.forEach((tc, i) => {
            writeSse(res, 'content_block_start', { type: 'content_block_start', index: i, content_block: { type: 'tool_use', id: tc.id, name: tc.function.name, input: {} } });
            writeSse(res, 'content_block_delta', { type: 'content_block_delta', index: i, delta: { type: 'input_json_delta', partial_json: tc.function.arguments || '{}' } });
            writeSse(res, 'content_block_stop', { type: 'content_block_stop', index: i });
        });
        writeSse(res, 'message_delta', { type: 'message_delta', delta: { stop_reason: 'tool_use', stop_sequence: null }, usage: message.usage });
    } else {
        if (msg.reasoning_content) {
            writeSse(res, 'content_block_start', { type: 'content_block_start', index: 0, content_block: { type: 'text', text: '' } });
            writeSse(res, 'content_block_delta', { type: 'content_block_delta', index: 0, delta: { type: 'text_delta', text: `[reasoning]\n${msg.reasoning_content}\n[/reasoning]\n` } });
            writeSse(res, 'content_block_stop', { type: 'content_block_stop', index: 0 });
        }
        const offset = msg.reasoning_content ? 1 : 0;
        writeSse(res, 'content_block_start', { type: 'content_block_start', index: offset, content_block: { type: 'text', text: '' } });
        const text = msg.content || '';
        for (let i = 0; i < text.length; i += 80) {
            writeSse(res, 'content_block_delta', { type: 'content_block_delta', index: offset, delta: { type: 'text_delta', text: text.substring(i, i + 80) } });
        }
        writeSse(res, 'content_block_stop', { type: 'content_block_stop', index: offset });
        writeSse(res, 'message_delta', { type: 'message_delta', delta: { stop_reason: 'end_turn', stop_sequence: null }, usage: message.usage });
    }
    writeSse(res, 'message_stop', { type: 'message_stop' });
    res.end();
}

function toResponsesResponse(openaiResp) {
    const choice = openaiResp.choices[0];
    const msg = choice.message || {};
    const hasToolCalls = msg.tool_calls && msg.tool_calls.length > 0;
    const output = [];
    if (!hasToolCalls && msg.reasoning_content) {
        output.push({ id: 'rs_' + Date.now(), type: 'reasoning', summary: [{ type: 'summary_text', text: msg.reasoning_content }] });
    }
    if (hasToolCalls) {
        for (const tc of msg.tool_calls) {
            output.push({ type: 'function_call', id: 'fc_' + tc.id, call_id: tc.id, name: tc.function.name, arguments: tc.function.arguments || '{}' });
        }
    } else {
        output.push({ id: 'msg_' + Date.now(), type: 'message', role: 'assistant', status: 'completed', content: [{ type: 'output_text', text: msg.content || '', annotations: [] }] });
    }
    return {
        id: openaiResp.id.replace(/^ds-/, 'resp_'),
        object: 'response',
        created_at: openaiResp.created,
        status: 'completed',
        model: openaiResp.model,
        output,
        output_text: msg.content || '',
        usage: {
            input_tokens: openaiResp.usage?.prompt_tokens || 0,
            output_tokens: openaiResp.usage?.completion_tokens || 0,
            total_tokens: openaiResp.usage?.total_tokens || 0,
            output_tokens_details: { reasoning_tokens: openaiResp.usage?.completion_tokens_details?.reasoning_tokens || 0 },
        },
        watermark: FORGETMEAI_WATERMARK,
    };
}

function sendResponsesStream(res, openaiResp) {
    res.writeHead(200, { 'Content-Type': 'text/event-stream', 'Cache-Control': 'no-cache', 'Connection': 'keep-alive', 'Access-Control-Allow-Origin': '*' });
    const response = toResponsesResponse(openaiResp);
    const choice = openaiResp.choices[0];
    const msg = choice.message || {};
    const hasToolCalls = msg.tool_calls && msg.tool_calls.length > 0;
    writeSse(res, 'response.created', { type: 'response.created', response: { ...response, status: 'in_progress', output: [] } });
    writeSse(res, 'response.in_progress', { type: 'response.in_progress', response: { ...response, status: 'in_progress', output: [] } });
    let outputIndex = 0;
    if (!hasToolCalls && msg.reasoning_content) {
        const reasoningItem = { id: 'rs_' + Date.now(), type: 'reasoning', summary: [], status: 'completed' };
        writeSse(res, 'response.output_item.added', { type: 'response.output_item.added', output_index: outputIndex, item: { ...reasoningItem, status: 'in_progress' } });
        writeSse(res, 'response.reasoning_summary_text.delta', { type: 'response.reasoning_summary_text.delta', output_index: outputIndex, summary_index: 0, delta: msg.reasoning_content });
        writeSse(res, 'response.output_item.done', { type: 'response.output_item.done', output_index: outputIndex, item: { ...reasoningItem, summary: [{ type: 'summary_text', text: msg.reasoning_content }] } });
        outputIndex++;
    }
    if (hasToolCalls) {
        msg.tool_calls.forEach((tc) => {
            const item = { type: 'function_call', id: 'fc_' + tc.id, call_id: tc.id, name: tc.function.name, arguments: tc.function.arguments || '{}', status: 'completed' };
            writeSse(res, 'response.output_item.added', { type: 'response.output_item.added', output_index: outputIndex, item: { ...item, arguments: '', status: 'in_progress' } });
            writeSse(res, 'response.function_call_arguments.delta', { type: 'response.function_call_arguments.delta', output_index: outputIndex, item_id: item.id, delta: item.arguments });
            writeSse(res, 'response.function_call_arguments.done', { type: 'response.function_call_arguments.done', output_index: outputIndex, item_id: item.id, arguments: item.arguments });
            writeSse(res, 'response.output_item.done', { type: 'response.output_item.done', output_index: outputIndex, item });
            outputIndex++;
        });
    } else {
        const text = msg.content || '';
        const item = { id: 'msg_' + Date.now(), type: 'message', role: 'assistant', status: 'completed', content: [{ type: 'output_text', text, annotations: [] }] };
        writeSse(res, 'response.output_item.added', { type: 'response.output_item.added', output_index: outputIndex, item: { ...item, status: 'in_progress', content: [] } });
        writeSse(res, 'response.content_part.added', { type: 'response.content_part.added', output_index: outputIndex, content_index: 0, item_id: item.id, part: { type: 'output_text', text: '', annotations: [] } });
        for (let i = 0; i < text.length; i += 80) {
            writeSse(res, 'response.output_text.delta', { type: 'response.output_text.delta', output_index: outputIndex, content_index: 0, item_id: item.id, delta: text.substring(i, i + 80) });
        }
        writeSse(res, 'response.output_text.done', { type: 'response.output_text.done', output_index: outputIndex, content_index: 0, item_id: item.id, text });
        writeSse(res, 'response.content_part.done', { type: 'response.content_part.done', output_index: outputIndex, content_index: 0, item_id: item.id, part: item.content[0] });
        writeSse(res, 'response.output_item.done', { type: 'response.output_item.done', output_index: outputIndex, item });
    }
    writeSse(res, 'response.completed', { type: 'response.completed', response });
    res.write('data: [DONE]\n\n');
    res.end();
}

function sendOpenAIStream(res, openaiResp) {
    res.writeHead(200, { 'Content-Type': 'text/event-stream', 'Cache-Control': 'no-cache', 'Connection': 'keep-alive', 'Access-Control-Allow-Origin': '*' });
    const choice = openaiResp.choices[0];
    const msg = choice.message || {};
    const id = openaiResp.id;
    const created = openaiResp.created;
    const model = openaiResp.model;
    const hasToolCalls = msg.tool_calls && msg.tool_calls.length > 0;
    if (!hasToolCalls && msg.reasoning_content) {
        for (let i = 0; i < msg.reasoning_content.length; i += 50) {
            const chunk = msg.reasoning_content.substring(i, i + 50);
            res.write(`data: ${JSON.stringify({ id, object: 'chat.completion.chunk', created, model, choices: [{ index: 0, delta: { reasoning_content: chunk }, finish_reason: null }] })}\n\n`);
        }
    }
    if (hasToolCalls) {
        res.write(`data: ${JSON.stringify({ id, object: 'chat.completion.chunk', created, model, choices: [{ index: 0, delta: { role: 'assistant', content: null, tool_calls: msg.tool_calls }, finish_reason: null }] })}\n\n`);
        res.write(`data: ${JSON.stringify({ id, object: 'chat.completion.chunk', created, model, choices: [{ index: 0, delta: {}, finish_reason: 'tool_calls' }] })}\n\ndata: [DONE]\n\n`);
    } else {
        for (let i = 0; i < (msg.content || '').length; i += 50) {
            const chunk = msg.content.substring(i, i + 50);
            res.write(`data: ${JSON.stringify({ id, object: 'chat.completion.chunk', created, model, choices: [{ index: 0, delta: { content: chunk }, finish_reason: null }] })}\n\n`);
        }
        res.write(`data: ${JSON.stringify({ id, object: 'chat.completion.chunk', created, model, choices: [{ index: 0, delta: {}, finish_reason: 'stop' }] })}\n\ndata: [DONE]\n\n`);
    }
    res.end();
}

function storeHistory(agentId, prompt, content, toolCall) {
    const session = getOrCreateAgentSession(agentId);
    const assistantResponse = toolCall
        ? `TOOL_CALL: ${toolCall.name}\narguments: ${toolCall.arguments}`
        : content;
    // Save last 500 chars of the prompt for history context
    const shortPrompt = prompt.length > 500 ? '...' + prompt.substring(prompt.length - 500) : prompt;
    session.history.push({ user: shortPrompt, assistant: assistantResponse });
    while (session.history.length > MAX_HISTORY_LENGTH) session.history.shift();
    let historyChars = session.history.reduce((sum, e) => sum + e.user.length + e.assistant.length, 0);
    while (historyChars > MAX_HISTORY_CHARS && session.history.length > 1) {
        const removed = session.history.shift();
        historyChars -= removed.user.length + removed.assistant.length;
    }
}

// Extract MEDIA: paths from tool results that contain screenshot paths
function extractScreenshotPaths(messages) {
    const paths = [];
    const fs = require('fs');
    for (const msg of messages) {
        if (msg.role === 'tool' && msg.content) {
            // Look for screenshot_path or path fields in JSON tool results
            // These come DIRECTLY from browser_vision — always the real path
            const pngMatch = msg.content.match(/["'](screenshot_path|path)["']\s*:\s*["']([^"']+\.(?:png|jpg|jpeg|webp|gif))["']/i);
            if (pngMatch) {
                const filePath = pngMatch[2];
                if (filePath.startsWith('/') && fs.existsSync(filePath)) {
                    paths.push(`MEDIA:${filePath}`);
                }
            }
            // Also catch plain MEDIA: tags
            const mediaMatch = msg.content.match(/MEDIA:(\S+)/g);
            if (mediaMatch) {
                for (const tag of mediaMatch) {
                    const extractedPath = tag.replace(/^MEDIA:/, '');
                    if (fs.existsSync(extractedPath) && !paths.includes(tag)) {
                        paths.push(tag);
                    }
                }
            }
        }
        // Check user/assistant messages for paths mentioned in conversation text
        // Only include if the file ACTUALLY EXISTS (DeepSeek hallucinates paths)
        if ((msg.role === 'user' || msg.role === 'assistant') && msg.content) {
            const content = typeof msg.content === 'string' ? msg.content : '';
            const pathRegex = /(\/[^\s<>"']+\.(?:png|jpg|jpeg|webp|gif))/gi;
            let match;
            while ((match = pathRegex.exec(content)) !== null) {
                const filePath = match[1];
                if (filePath.startsWith('/') && fs.existsSync(filePath) && !paths.includes(`MEDIA:${filePath}`)) {
                    paths.push(`MEDIA:${filePath}`);
                }
            }
        }
    }
    return paths;
}

function formatMessages(messages, tools) {
    let systemPrompt = '';
    for (const msg of messages) {
        if (msg.role === 'system' && msg.content) {
            systemPrompt += msg.content + '\n';
        }
    }
    systemPrompt += formatToolDefinitions(tools);

    // Build full conversation history for DeepSeek's context
    let conversation = '';
    for (const msg of messages) {
        if (msg.role === 'system') continue;  // already in systemPrompt
        if (msg.role === 'user' && msg.content) {
            conversation += `User: ${msg.content}\n\n`;
        } else if (msg.role === 'assistant') {
            if (msg.tool_calls && msg.tool_calls.length > 0) {
                // This was a tool call response from a previous turn
                for (const tc of msg.tool_calls) {
                    conversation += `Assistant: TOOL_CALL: ${tc.function.name}\narguments: ${tc.function.arguments}\n\n`;
                }
            } else if (msg.content) {
                conversation += `Assistant: ${msg.content}\n\n`;
            }
        } else if (msg.role === 'tool' && msg.content) {
            // Tool execution result — send back to DeepSeek as context
            const truncated = msg.content.length > 8000
                ? msg.content.substring(0, 8000) + '\n...[truncated]'
                : msg.content;
            conversation += `[Tool Result]\n${truncated}\n\n`;
        }
    }
    // The last user message + full conversation context
    return { prompt: conversation.trim(), systemPrompt: systemPrompt.trim() };
}

// === HTTP Server ===
const server = http.createServer(async (req, res) => {
    res.setHeader('Access-Control-Allow-Origin', '*');
    res.setHeader('Access-Control-Allow-Methods', 'POST, GET, OPTIONS');
    res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');
    if (req.method === 'OPTIONS') { res.writeHead(204); res.end(); return; }

    const url = new URL(req.url, `http://${req.headers.host || 'localhost'}`);

    // Health check
    if (req.method === 'GET' && (url.pathname === '/' || url.pathname === '/health')) {
        res.writeHead(200, { 'Content-Type': 'application/json' });
        res.end(JSON.stringify({ status: 'ok', service: 'FreeDeepseekAPI', watermark: FORGETMEAI_WATERMARK, models: SUPPORTED_MODEL_IDS, unsupported_models: Object.keys(MODEL_CONFIGS).filter(id => !MODEL_CONFIGS[id].supported), agents: sessions.size, accounts: accounts.map(accountStatus), config_ready: hasAuthConfig(), session_reuse: { strategy: 'sticky per x-agent-session/user', ttl_minutes: Math.round(SESSION_TTL_MS / 60000), max_messages: MAX_MESSAGE_DEPTH, reset_all: 'POST /reset-session?agent=all' } }));
        return;
    }

    // Models: OpenAI-compatible list exposes only aliases verified to work through this proxy.
    if (req.method === 'GET' && url.pathname === '/v1/models') {
        res.writeHead(200, { 'Content-Type': 'application/json' });
        res.end(JSON.stringify({ object: 'list', data: SUPPORTED_MODEL_IDS.map(id => ({ id, object: 'model', created: 1700000000, owned_by: 'deepseek-web', real_model: MODEL_CONFIGS[id].real_model, capabilities: MODEL_CONFIGS[id].capabilities })) }));
        return;
    }

    // Full mapping, including Web models observed but not currently usable through the direct API.
    if (req.method === 'GET' && (url.pathname === '/v1/model-capabilities' || url.pathname === '/api/model-capabilities')) {
        res.writeHead(200, { 'Content-Type': 'application/json' });
        res.end(JSON.stringify({ object: 'model_capabilities', watermark: FORGETMEAI_WATERMARK, data: ALL_MODEL_CAPABILITIES }));
        return;
    }

    // Sessions status
    if (req.method === 'GET' && url.pathname === '/v1/sessions') {
        const agentList = [];
        for (const [agentId, session] of sessions) {
            agentList.push({
                agent: agentId,
                session_id: session.id,
                message_count: session.messageCount,
                account: session.accountId,
                history_size: session.history.length,
                age_min: session.createdAt ? Math.round((Date.now() - session.createdAt) / 60000) : 0,
            });
        }
        res.writeHead(200, { 'Content-Type': 'application/json' });
        res.end(JSON.stringify({ agents: agentList, total: agentList.length }));
        return;
    }

    // Reset session for a specific agent (or all if no agent specified)
    if (req.method === 'POST' && url.pathname === '/reset-session') {
        const agentId = url.searchParams.get('agent') || 'default';
        if (agentId === 'all') {
            const count = sessions.size;
            sessions.clear();
            res.writeHead(200, { 'Content-Type': 'application/json' });
            res.end(JSON.stringify({ status: 'all_sessions_cleared', count }));
            return;
        }
        const session = sessions.get(agentId);
        if (!session) {
            res.writeHead(404, { 'Content-Type': 'application/json' });
            res.end(JSON.stringify({ error: `No session for agent: ${agentId}` }));
            return;
        }
        const historyCount = session.history.length;
        const historyPreview = session.history.map(e => e.user.substring(0, 40)).join(' | ');
        session.id = null;
        session.parentMessageId = null;
        session.createdAt = null;
        session.messageCount = 0;
        res.writeHead(200, { 'Content-Type': 'application/json' });
        res.end(JSON.stringify({ status: 'session_reset', agent: agentId, history_preserved: historyCount, history: historyPreview }));
        return;
    }

    const apiMode = url.pathname === '/v1/messages'
        ? 'anthropic'
        : (url.pathname === '/v1/responses' ? 'responses' : 'openai');
    const acceptedPostPaths = ['/v1/chat/completions', '/v1/messages', '/v1/responses'];
    if (req.method !== 'POST' || !acceptedPostPaths.includes(url.pathname)) {
        res.writeHead(404); res.end('Not found'); return;
    }

    let body = '';
    req.on('data', chunk => body += chunk);
    req.on('end', async () => {
        try {
            const rawParams = JSON.parse(body || '{}');
            const params = normalizeApiParams(rawParams, apiMode);
            const messages = params.messages || [];
            const tools = params.tools || [];
            const stream = params.stream === true;
            const requestedModel = String(params.model || 'deepseek-chat').toLowerCase();
            if (!isKnownModel(requestedModel)) {
                res.writeHead(400, { 'Content-Type': 'application/json' });
                res.end(JSON.stringify({ error: { message: `Unknown model: ${requestedModel}`, type: 'invalid_model', supported_models: SUPPORTED_MODEL_IDS, model_capabilities_url: '/v1/model-capabilities' } }));
                return;
            }
            if (!isSupportedModel(requestedModel)) {
                const cfg = resolveModelConfig(requestedModel);
                res.writeHead(400, { 'Content-Type': 'application/json' });
                res.end(JSON.stringify({ error: { message: `${requestedModel} is not currently supported through this DeepSeek Web API path`, type: 'unsupported_model', model: requestedModel, real_model: cfg.real_model, reason: cfg.unavailable_reason, capabilities: cfg.capabilities, supported_models: SUPPORTED_MODEL_IDS } }));
                return;
            }
            // Use remote IP for session isolation (local gets 'dev-agent', external per-IP)
            const remoteAddr = req.socket.remoteAddress || 'unknown';
            const requestedSession = req.headers['x-agent-session'] || params.session || params.user;
            const agentId = requestedSession
                ? String(requestedSession)
                : ((remoteAddr === '127.0.0.1' || remoteAddr === '::1' || remoteAddr === '::ffff:127.0.0.1') ? 'dev-agent' : remoteAddr);
            const agentTag = `[${agentId}]`;
            const { prompt, systemPrompt } = formatMessages(messages, tools);

            const session = getOrCreateAgentSession(agentId);

            // Build history prefix if starting fresh
            let historyPrefix = '';
            if (!session.id && session.history.length > 0) {
                historyPrefix = '[Previous conversation]\n';
                for (const exchange of session.history) {
                    historyPrefix += `User: ${exchange.user}\nAssistant: ${exchange.assistant}\n\n`;
                }
                historyPrefix += '[Continue from here]\n\n';
            }

            const fullPrompt = systemPrompt
                ? `${systemPrompt}\n\n${historyPrefix}${prompt}`
                : `${historyPrefix}${prompt}`;

            const startTime = Date.now();
            const { resp: dsResp } = await askDeepSeekStream(fullPrompt, agentId, requestedModel);

            // Process streaming response from DeepSeek — returns { content, reasoningContent, messageId, finishReason }
            async function readDeepSeekResponse(readable) {
                let buffer = '';
                let lastPath = null;
                const fragments = [];
                let fullContent = '';
                let reasoningContent = '';
                let newMessageId = null;
                let finishReason = null;
                let modelError = null;

                const rebuildFragmentText = () => {
                    const responseText = fragments
                        .filter(f => f && f.type === 'RESPONSE' && typeof f.content === 'string')
                        .map(f => f.content)
                        .join('');
                    const thinkText = fragments
                        .filter(f => f && (f.type === 'THINK' || f.type === 'REASONING') && typeof f.content === 'string')
                        .map(f => f.content)
                        .join('');
                    if (responseText) fullContent = responseText;
                    reasoningContent = thinkText;
                };

                const appendFragments = (value) => {
                    const incoming = Array.isArray(value) ? value : [value];
                    for (const fragment of incoming) {
                        if (fragment && typeof fragment === 'object') fragments.push({ ...fragment });
                    }
                    rebuildFragmentText();
                };

                for await (const chunk of readable) {
                    buffer += new TextDecoder().decode(chunk, { stream: true });
                    const lines = buffer.split('\n');
                    buffer = lines.pop() || '';
                    for (const line of lines) {
                        if (line.startsWith('data: ')) {
                            try {
                                const d = JSON.parse(line.slice(6));
                                if (d.response_message_id !== undefined && !newMessageId) newMessageId = d.response_message_id;
                                if (d.type === 'error' || d.finish_reason || d.content) {
                                    modelError = { type: d.type || 'error', content: d.content || '', finish_reason: d.finish_reason || null };
                                    if (d.finish_reason) finishReason = d.finish_reason;
                                }
                                if (d.p !== undefined) lastPath = d.p;
                                if (d.v && typeof d.v === 'object' && d.v.response) {
                                    if (d.v.response.message_id !== undefined) {
                                        newMessageId = d.v.response.message_id;
                                    }
                                    if (d.v.response.content !== undefined) {
                                        fullContent = d.v.response.content;
                                    }
                                    if (Array.isArray(d.v.response.fragments)) {
                                        fragments.length = 0;
                                        appendFragments(d.v.response.fragments);
                                    }
                                    if (d.v.response.finish_reason !== undefined) {
                                        finishReason = d.v.response.finish_reason;
                                    }
                                }
                                if (lastPath === 'response/fragments' && d.v !== undefined) {
                                    appendFragments(d.v);
                                }
                                if (lastPath === 'response/fragments/-1/content' && d.v !== undefined && typeof d.v !== 'object') {
                                    if (fragments.length > 0) {
                                        const lastFragment = fragments[fragments.length - 1];
                                        lastFragment.content = `${lastFragment.content || ''}${d.v}`;
                                        rebuildFragmentText();
                                    }
                                }
                                if (lastPath === 'response/content' && d.v !== undefined && typeof d.v !== 'object') {
                                    fullContent += d.v;
                                }
                                if (lastPath === 'response/finish_reason' && d.v !== undefined) {
                                    finishReason = d.v;
                                }
                                if (lastPath === 'response/status' && d.v !== undefined && d.v !== 'FINISHED') {
                                    finishReason = d.v;
                                }
                            } catch (e) { }
                        }
                    }
                }

                if (newMessageId) {
                    session.parentMessageId = newMessageId;
                    session.messageCount++;
                } else {
                    console.log(`${agentTag} WARNING: could not extract message_id`);
                }

                return { content: fullContent, reasoningContent, messageId: newMessageId, finishReason, modelError };
            }

            let { content: fullContent, reasoningContent, finishReason, modelError } = await readDeepSeekResponse(dsResp.body);
            fullContent = sanitizeContent(fullContent);
            reasoningContent = sanitizeContent(reasoningContent || '');
            const elapsed = Date.now() - startTime;
            console.log(`${agentTag} Got ${fullContent.length} chars (+${reasoningContent.length} reasoning chars) in ${elapsed}ms (msg#${session.messageCount})`);

            if ((!fullContent || fullContent.trim().length === 0) && modelError) {
                res.writeHead(502, { 'Content-Type': 'application/json' });
                res.end(JSON.stringify({ error: { message: modelError.content || 'DeepSeek returned an error without content', type: modelError.finish_reason || modelError.type || 'deepseek_model_error', model: requestedModel, real_model: resolveModelConfig(requestedModel).real_model } }));
                return;
            }

            // Empty response — retry loop with fresh sessions
            let retryAttempt = 0;
            const MAX_RETRIES = 10;
            while (!fullContent || fullContent.trim().length === 0) {
                retryAttempt++;
                if (retryAttempt > MAX_RETRIES) {
                    console.log(`${agentTag} Empty after ${MAX_RETRIES} retries. Giving up.`);
                    res.writeHead(502, { 'Content-Type': 'application/json' });
                    res.end(JSON.stringify({ 
                        error: { 
                            message: `DeepSeek returned empty content after ${MAX_RETRIES} retries`, 
                            type: 'empty_response',
                            agent: agentId,
                            session_id: session.id,
                            message_count: session.messageCount,
                            history_length: session.history.length,
                            retry_attempts: retryAttempt - 1,
                        } 
                    }));
                    return;
                }
                console.log(`${agentTag} Empty response (msg#${session.messageCount}, retry ${retryAttempt}/${MAX_RETRIES}). Resetting session...`);
                session.id = null;
                session.parentMessageId = null;
                session.createdAt = null;
                session.messageCount = 0;
                // Brief delay before retry to let DeepSeek breathe
                await new Promise(r => setTimeout(r, Math.min(1000 * retryAttempt, 5000)));
                const { resp: retryResp } = await askDeepSeekStream(fullPrompt, agentId, requestedModel);
                const retryResult = await readDeepSeekResponse(retryResp.body);
                const retryContent = retryResult && retryResult.content ? sanitizeContent(retryResult.content) : '';
                const retryReasoning = retryResult && retryResult.reasoningContent ? sanitizeContent(retryResult.reasoningContent) : '';
                if (retryContent && retryContent.trim().length > 0) {
                    console.log(`${agentTag} Retry ${retryAttempt} succeeded`);
                    fullContent = retryContent;
                    reasoningContent = retryReasoning;
                }
            }

            // Auto-continuation: if finish_reason is 'length' or content is very long (>25000 chars),
            // send a continuation request to get the rest of the response
            let continuationRounds = 0;
            const MAX_CONTINUATION = 2;
            while ((finishReason === 'length' || fullContent.length > 25000) && continuationRounds < MAX_CONTINUATION) {
                continuationRounds++;
                console.log(`${agentTag} Response ${fullContent.length} chars (finish=${finishReason}). Auto-continuing (${continuationRounds}/${MAX_CONTINUATION})...`);
                await new Promise(r => setTimeout(r, 500));
                const { resp: contResp } = await askDeepSeekStream('continue', agentId, requestedModel);
                const contResult = await readDeepSeekResponse(contResp.body);
                const contContent = contResult && contResult.content ? sanitizeContent(contResult.content) : '';
                const contReasoning = contResult && contResult.reasoningContent ? sanitizeContent(contResult.reasoningContent) : '';
                if (contContent && contContent.trim().length > 0 && !contContent.includes('I am an AI')) {
                    fullContent += '\n' + contContent;
                    if (contReasoning) reasoningContent += (reasoningContent ? '\n' : '') + contReasoning;
                    finishReason = contResult.finishReason;
                    console.log(`${agentTag} Continuation added ${contContent.length} chars (total: ${fullContent.length})`);
                } else {
                    console.log(`${agentTag} Continuation returned nothing useful, stopping`);
                    break;
                }
            }

            let toolCall = parseToolCall(fullContent);
            
            // Retry if TOOL_CALL was found but JSON was truncated/invalid
            if (!toolCall && /TOOL_CALL:\s*\w/i.test(fullContent)) {
                console.log(`${agentTag} TOOL_CALL detected but JSON invalid/truncated (${fullContent.length} chars). Retrying with stricter prompt...`);
                session.id = null;
                session.parentMessageId = null;
                session.createdAt = null;
                session.messageCount = 0;
                await new Promise(r => setTimeout(r, 1000));
                const strictPrompt = fullPrompt + '\n\n[STRICT INSTRUCTION] Your previous response had a TOOL_CALL but the arguments were too long and got cut off. Keep the arguments SHORT — no large file contents. Just use a minimal example or reference the file by name. Output ONLY: TOOL_CALL: <function>\narguments: <short JSON>';
                const { resp: retryResp2 } = await askDeepSeekStream(strictPrompt, agentId, requestedModel);
                const retryResult2 = await readDeepSeekResponse(retryResp2.body);
                const retryContent2 = retryResult2 && retryResult2.content ? sanitizeContent(retryResult2.content) : '';
                if (retryContent2 && retryContent2.trim()) {
                    const retryTc = parseToolCall(retryContent2);
                    if (retryTc) {
                        console.log(`${agentTag} Retry with strict prompt succeeded: ${retryTc.name}`);
                        fullContent = retryContent2;
                        reasoningContent = retryResult2.reasoningContent ? sanitizeContent(retryResult2.reasoningContent) : '';
                        toolCall = retryTc;
                    } else {
                        console.log(`${agentTag} Retry still has broken JSON. Sending as text.`);
                        reasoningContent = retryResult2.reasoningContent ? sanitizeContent(retryResult2.reasoningContent) : reasoningContent;
                    }
                }
            }
            
            // Check if any tool results in the current conversation contained a screenshot path.
            // If so, and the response doesn't already have MEDIA:, inject it so the gateway
            // delivers the file to Telegram.
            if (!fullContent.includes('MEDIA:')) {
                const screenshotPaths = extractScreenshotPaths(messages);
                if (screenshotPaths.length > 0) {
                    fullContent += '\n\n' + screenshotPaths.join('\n');
                    console.log(`${agentTag} Injected MEDIA paths into response: ${screenshotPaths.join(', ')}`);
                }
            }

            storeHistory(agentId, prompt, fullContent, toolCall);

            // Sanitize tool call args — remove params not in the tool schema
            // to prevent "Invalid tool parameters" errors from Claude Code
            if (toolCall) {
                toolCall = sanitizeToolCallArgs(toolCall, tools);
            }

            const openaiResponse = toolCall
                ? buildToolCallResponse(toolCall, requestedModel, fullPrompt, reasoningContent)
                : buildTextResponse(fullContent, fullPrompt, requestedModel, reasoningContent);

            if (stream) {
                if (apiMode === 'anthropic') {
                    sendAnthropicStream(res, openaiResponse);
                } else if (apiMode === 'responses') {
                    sendResponsesStream(res, openaiResponse);
                } else {
                    sendOpenAIStream(res, openaiResponse);
                }
                console.log(`${agentTag} Streamed ${apiMode} (tool=${!!toolCall}) in ${elapsed}ms`);
            } else {
                res.writeHead(200, { 'Content-Type': 'application/json' });
                if (apiMode === 'anthropic') {
                    res.end(JSON.stringify(toAnthropicResponse(openaiResponse)));
                } else if (apiMode === 'responses') {
                    res.end(JSON.stringify(toResponsesResponse(openaiResponse)));
                } else {
                    res.end(JSON.stringify(openaiResponse));
                }
                console.log(`${agentTag} Response ${apiMode} (tool=${!!toolCall}, ${elapsed}ms, ${fullContent.length} chars)`);
            }
        } catch (e) {
            console.log('[DS-API] Error:', e.message);
            res.writeHead(500, { 'Content-Type': 'application/json' });
            res.end(JSON.stringify({ error: { message: e.message, type: 'server_error' } }));
        }
    });
});

async function runAuthScript() {
    const script = path.join(__dirname, 'scripts', 'deepseek_chrome_auth.js');
    const result = spawnSync(process.execPath, [script], { stdio: 'inherit', env: process.env });
    loadDeepSeekConfig({ fatal: false });
    return result.status === 0 && hasAuthConfig();
}

function printStatus() {
    console.log(`\n${formatWatermark()}`);
    console.log(`Auth: ${hasAuthConfig() ? '✅ OK' : '❌ не найден deepseek-auth.json'}`);
    console.log(`Auth source: ${process.env.DEEPSEEK_AUTH_DIR || DS_CONFIG_PATH}`);
    console.log(`Аккаунты: ${accounts.length ? accounts.map(a => `${a.id}${a.cooldownUntil > Date.now() ? ' (cooldown)' : ''}`).join(', ') : 'нет'}`);
    console.log(`Рабочие модели: ${SUPPORTED_MODEL_IDS.join(', ')}`);
    console.log('Нерабочие/скрытые aliases: ' + Object.keys(MODEL_CONFIGS).filter(id => !MODEL_CONFIGS[id].supported).join(', '));
    console.log('Capabilities: GET /v1/model-capabilities');
}

async function showStartupMenu() {
    if (isTruthy(process.env.SKIP_ACCOUNT_MENU) || isTruthy(process.env.NON_INTERACTIVE)) {
        if (!hasAuthConfig()) loadDeepSeekConfig({ fatal: true });
        return true;
    }
    while (true) {
        printStatus();
        console.log('\n=== Меню ===');
        console.log(`ForgetMeAI: ${FORGETMEAI_WATERMARK}`);
        console.log('1 - Авторизоваться / обновить DeepSeek login');
        console.log('2 - Импортировать auth-файл / cookies');
        console.log('3 - Показать модели и статусы');
        console.log('4 - Запустить прокси (по умолчанию)');
        console.log('5 - Выход');
        let choice = await prompt('Ваш выбор (Enter = 4): ');
        if (!choice) choice = '4';
        if (choice === '1') {
            await runAuthScript();
        } else if (choice === '2') {
            spawnSync(process.execPath, [path.join(__dirname, 'scripts', 'auth_import.js')], { stdio: 'inherit', env: process.env });
            loadDeepSeekConfig({ fatal: false });
        } else if (choice === '3') {
            console.log(JSON.stringify(ALL_MODEL_CAPABILITIES, null, 2));
            await prompt('\nНажмите Enter, чтобы вернуться в меню...');
        } else if (choice === '4') {
            if (!hasAuthConfig()) {
                console.log('Нужен deepseek-auth.json. Запустите пункт 1 или 2.');
                continue;
            }
            return true;
        } else if (choice === '5') {
            return false;
        }
    }
}

async function main() {
    printBanner();
    const shouldStart = await showStartupMenu();
    if (!shouldStart) process.exit(0);
    server.listen(PORT, HOST, () => {
        console.log(`[DS-API] Server on http://${HOST}:${PORT} (multi-agent sessions enabled)`);
        console.log(`[DS-API] ${formatWatermark()}`);
        console.log('[DS-API] POST /v1/chat/completions (OpenAI Chat Completions, stream=true|false)');
        console.log('[DS-API] POST /v1/messages — Anthropic Messages shim for Claude Code');
        console.log('[DS-API] POST /v1/responses — OpenAI Responses API shim');
        console.log('[DS-API] GET  /v1/models — supported OpenAI-compatible models');
        console.log('[DS-API] GET  /v1/model-capabilities — real model mapping and capabilities');
        console.log('[DS-API] GET  /v1/sessions — list active agent sessions');
        console.log('[DS-API] POST /reset-session?agent=<id> — reset agent session');
        console.log('[DS-API] POST /reset-session?agent=all — reset ALL sessions');
    });
}

main().catch(err => { console.error('[DS-API] FATAL:', err); process.exit(1); });