// @ts-nocheck
import { oai_settings, chat_completion_sources, getChatCompletionModel, promptManager } from "../../../../openai.js";
import { ChatCompletionService } from "../../../../custom-request.js";
import { eventSource, event_types } from "../../../../../script.js";
import { getContext } from "../../../../st-context.js";
import { xbLog } from "../core/debug-core.js";

const SOURCE_TAG = 'xiaobaix-host';

const POSITIONS = Object.freeze({ BEFORE_PROMPT: 'BEFORE_PROMPT', IN_PROMPT: 'IN_PROMPT', IN_CHAT: 'IN_CHAT', AFTER_COMPONENT: 'AFTER_COMPONENT' });
const KNOWN_KEYS = Object.freeze(new Set([
    'main', 'chatHistory', 'worldInfo', 'worldInfoBefore', 'worldInfoAfter',
    'charDescription', 'charPersonality', 'scenario', 'personaDescription',
    'dialogueExamples', 'authorsNote', 'vectorsMemory', 'vectorsDataBank',
    'smartContext', 'jailbreak', 'nsfw', 'summary', 'bias', 'impersonate', 'quietPrompt',
]));
const resolveTargetOrigin = (origin) => {
    if (typeof origin === 'string' && origin) return origin;
    try { return window.location.origin; } catch { return '*'; }
};

// @ts-nocheck
class CallGenerateService {
    constructor() {
        /** @type {Map<string, { id: string, abortController: AbortController, accumulated: string, startedAt: number }>} */
        this.sessions = new Map();
        this._toggleBusy = false;
        this._lastToggleSnapshot = null;
        this._toggleQueue = Promise.resolve();
    }

    // ===== 通用错误处理 =====
    normalizeError(err, fallbackCode = 'API_ERROR', details = null) {
        try {
            if (!err) return { code: fallbackCode, message: 'Unknown error', details };
            if (typeof err === 'string') return { code: fallbackCode, message: err, details };
            const msg = err?.message || String(err);
            // Map known cases
            if (msg === 'INVALID_OPTIONS') return { code: 'INVALID_OPTIONS', message: 'Invalid options', details };
            if (msg === 'MISSING_MESSAGES') return { code: 'MISSING_MESSAGES', message: 'Missing messages', details };
            if (msg === 'INVALID_COMPONENT_REF') return { code: 'INVALID_COMPONENT_REF', message: 'Invalid component reference', details };
            if (msg === 'AMBIGUOUS_COMPONENT_NAME') return { code: 'AMBIGUOUS_COMPONENT_NAME', message: 'Ambiguous component name', details };
            if (msg === 'Unsupported provider') return { code: 'PROVIDER_UNSUPPORTED', message: msg, details };
            if (err?.name === 'AbortError') return { code: 'CANCELLED', message: 'Request cancelled', details };
            return { code: fallbackCode, message: msg, details };
        } catch {
            return { code: fallbackCode, message: 'Error serialization failed', details };
        }
    }

    sendError(sourceWindow, requestId, streamingEnabled, err, fallbackCode = 'API_ERROR', details = null, targetOrigin = null) {
        const e = this.normalizeError(err, fallbackCode, details);
        const type = streamingEnabled ? 'generateStreamError' : 'generateError';
        try { sourceWindow?.postMessage({ source: SOURCE_TAG, type, id: requestId, error: e }, resolveTargetOrigin(targetOrigin)); } catch {}
    }

    /**
     * @param {string|undefined} rawId
     * @returns {string}
     */
    normalizeSessionId(rawId) {
        if (!rawId) return 'xb1';
        const m = String(rawId).match(/^xb(\d{1,2})$/i);
        if (m) {
            const n = Math.max(1, Math.min(10, Number(m[1]) || 1));
            return `xb${n}`;
        }
        const n = Math.max(1, Math.min(10, parseInt(String(rawId), 10) || 1));
        return `xb${n}`;
    }

    /**
     * @param {string} sessionId
     */
    ensureSession(sessionId) {
        const id = this.normalizeSessionId(sessionId);
        if (!this.sessions.has(id)) {
            this.sessions.set(id, {
                id,
                abortController: new AbortController(),
                accumulated: '',
                startedAt: Date.now(),
            });
        }
        return this.sessions.get(id);
    }

    /**
     * 选项校验（宽松）。
     * 支持仅 injections 或仅 userInput 构建场景。
     * @param {Object} options
     * @throws {Error} INVALID_OPTIONS 当 options 非对象
     */
    validateOptions(options) {
        if (!options || typeof options !== 'object') throw new Error('INVALID_OPTIONS');
        // 允许仅凭 injections 或 userInput 构建
        const hasComponents = options.components && Array.isArray(options.components.list);
        const hasInjections = Array.isArray(options.injections) && options.injections.length > 0;
        const hasUserInput = typeof options.userInput === 'string' && options.userInput.length >= 0;
        if (!hasComponents && !hasInjections && !hasUserInput) {
            // 仍允许空配置，但会构建空 + userInput
            return;
        }
    }

    /**
     * @param {string} provider
     */
    mapProviderToSource(provider) {
        const p = String(provider || '').toLowerCase();
        const map = {
            openai: chat_completion_sources.OPENAI,
            claude: chat_completion_sources.CLAUDE,
            gemini: chat_completion_sources.MAKERSUITE,
            google: chat_completion_sources.MAKERSUITE,
            vertexai: chat_completion_sources.VERTEXAI,
            cohere: chat_completion_sources.COHERE,
            deepseek: chat_completion_sources.DEEPSEEK,
            xai: chat_completion_sources.XAI,
            groq: chat_completion_sources.GROQ,
            openrouter: chat_completion_sources.OPENROUTER,
            custom: chat_completion_sources.CUSTOM,
        };
        return map[p] || null;
    }

    /**
     * 解析 API 与模型的继承/覆写，并注入代理/自定义地址
     * @param {any} api
     */
    resolveApiConfig(api) {
        const inherit = api?.inherit !== false;
        let source = oai_settings?.chat_completion_source;
        let model = getChatCompletionModel ? getChatCompletionModel() : undefined;
        let overrides = api?.overrides || {};

        if (!inherit) {
            if (api?.provider) source = this.mapProviderToSource(api.provider);
            if (api?.model) model = api.model;
        } else {
            if (overrides?.provider) source = this.mapProviderToSource(overrides.provider);
            if (overrides?.model) model = overrides.model;
        }

        if (!source) throw new Error(`Unsupported provider`);
        if (!model) throw new Error('Model not specified');

        const temperature = inherit ? Number(oai_settings?.temp_openai ?? '') : undefined;
        const max_tokens = inherit ? (Number(oai_settings?.openai_max_tokens ?? 0) || 1024) : undefined;
        const top_p = inherit ? Number(oai_settings?.top_p_openai ?? '') : undefined;
        const frequency_penalty = inherit ? Number(oai_settings?.freq_pen_openai ?? '') : undefined;
        const presence_penalty = inherit ? Number(oai_settings?.pres_pen_openai ?? '') : undefined;

        const resolved = {
            chat_completion_source: source,
            model,
            temperature,
            max_tokens,
            top_p,
            frequency_penalty,
            presence_penalty,
            // 代理/自定义地址占位
            reverse_proxy: undefined,
            proxy_password: undefined,
            custom_url: undefined,
            custom_include_body: undefined,
            custom_exclude_body: undefined,
            custom_include_headers: undefined,
        };

        // 继承代理/自定义配置
        if (inherit) {
            const proxySupported = new Set([
                chat_completion_sources.CLAUDE,
                chat_completion_sources.OPENAI,
                chat_completion_sources.MISTRALAI,
                chat_completion_sources.MAKERSUITE,
                chat_completion_sources.VERTEXAI,
                chat_completion_sources.DEEPSEEK,
                chat_completion_sources.XAI,
            ]);
            if (proxySupported.has(source) && oai_settings?.reverse_proxy) {
                resolved.reverse_proxy = String(oai_settings.reverse_proxy).replace(/\/?$/, '');
                if (oai_settings?.proxy_password) resolved.proxy_password = String(oai_settings.proxy_password);
            }
            if (source === chat_completion_sources.CUSTOM) {
                if (oai_settings?.custom_url) resolved.custom_url = String(oai_settings.custom_url);
                if (oai_settings?.custom_include_body) resolved.custom_include_body = oai_settings.custom_include_body;
                if (oai_settings?.custom_exclude_body) resolved.custom_exclude_body = oai_settings.custom_exclude_body;
                if (oai_settings?.custom_include_headers) resolved.custom_include_headers = oai_settings.custom_include_headers;
            }
        }

        // 显式 baseURL 覆写
        const baseURL = overrides?.baseURL || api?.baseURL;
        if (baseURL) {
            if (resolved.chat_completion_source === chat_completion_sources.CUSTOM) {
                resolved.custom_url = String(baseURL);
            } else {
                resolved.reverse_proxy = String(baseURL).replace(/\/?$/, '');
            }
        }

        const ovw = inherit ? (api?.overrides || {}) : api || {};
        ['temperature', 'maxTokens', 'topP', 'topK', 'frequencyPenalty', 'presencePenalty', 'repetitionPenalty', 'stop', 'responseFormat', 'seed']
            .forEach((k) => {
                const keyMap = {
                    maxTokens: 'max_tokens',
                    topP: 'top_p',
                    topK: 'top_k',
                    frequencyPenalty: 'frequency_penalty',
                    presencePenalty: 'presence_penalty',
                    repetitionPenalty: 'repetition_penalty',
                    responseFormat: 'response_format',
                };
                const targetKey = keyMap[k] || k;
                if (ovw[k] !== undefined) resolved[targetKey] = ovw[k];
            });

        return resolved;
    }

    /**
     * @param {any[]} messages
     * @param {any} apiCfg
     * @param {boolean} stream
     */
    buildChatPayload(messages, apiCfg, stream) {
        const payload = {
            stream: !!stream,
            messages,
            model: apiCfg.model,
            chat_completion_source: apiCfg.chat_completion_source,
            max_tokens: apiCfg.max_tokens,
            temperature: apiCfg.temperature,
            top_p: apiCfg.top_p,
            top_k: apiCfg.top_k,
            frequency_penalty: apiCfg.frequency_penalty,
            presence_penalty: apiCfg.presence_penalty,
            repetition_penalty: apiCfg.repetition_penalty,
            stop: Array.isArray(apiCfg.stop) ? apiCfg.stop : undefined,
            response_format: apiCfg.response_format,
            seed: apiCfg.seed,
            // 代理/自定义地址透传
            reverse_proxy: apiCfg.reverse_proxy,
            proxy_password: apiCfg.proxy_password,
            custom_url: apiCfg.custom_url,
            custom_include_body: apiCfg.custom_include_body,
            custom_exclude_body: apiCfg.custom_exclude_body,
            custom_include_headers: apiCfg.custom_include_headers,
        };
        return ChatCompletionService.createRequestData(payload);
    }

    /**
     * @param {Window} target
     * @param {string} type
     * @param {object} body
     */
    postToTarget(target, type, body, targetOrigin = null) {
        try {
            target?.postMessage({ source: SOURCE_TAG, type, ...body }, resolveTargetOrigin(targetOrigin));
        } catch (e) {}
    }

    // ===== ST Prompt 干跑捕获与组件切换 =====

    _computeEnableIds(includeConfig) {
        const ids = new Set();
        if (!includeConfig || typeof includeConfig !== 'object') return ids;
        const c = includeConfig;
        if (c.chatHistory?.enabled) ids.add('chatHistory');
        if (c.worldInfo?.enabled || c.worldInfo?.beforeHistory || c.worldInfo?.afterHistory) {
            if (c.worldInfo?.beforeHistory !== false) ids.add('worldInfoBefore');
            if (c.worldInfo?.afterHistory !== false) ids.add('worldInfoAfter');
        }
        if (c.character?.description) ids.add('charDescription');
        if (c.character?.personality) ids.add('charPersonality');
        if (c.character?.scenario) ids.add('scenario');
        if (c.persona?.description) ids.add('personaDescription');
        return ids;
    }

    async _withTemporaryPromptToggles(includeConfig, fn) { return await this._withPromptToggle({ includeConfig }, fn); }

    async _capturePromptMessages({ includeConfig = null, quietText = '', skipWIAN = false }) {
        const ctx = getContext();
        /** @type {any} */
        let capturedData = null;
        const listener = (data) => {
            if (data && typeof data === 'object' && Array.isArray(data.prompt)) {
                capturedData = { ...data, prompt: data.prompt.slice() };
            } else if (Array.isArray(data)) {
                capturedData = data.slice();
            }
        };
        eventSource.on(event_types.GENERATE_AFTER_DATA, listener);
        try {
            const run = async () => {
                await ctx.generate('normal', { quiet_prompt: String(quietText || ''), quietToLoud: false, skipWIAN, force_name2: true }, true);
            };
            if (includeConfig) {
                await this._withTemporaryPromptToggles(includeConfig, run);
            } else {
                await run();
            }
        } finally {
            eventSource.removeListener(event_types.GENERATE_AFTER_DATA, listener);
        }
        if (!capturedData) return [];
        if (capturedData && typeof capturedData === 'object' && Array.isArray(capturedData.prompt)) return capturedData.prompt.slice();
        if (Array.isArray(capturedData)) return capturedData.slice();
        return [];
    }

    /** 使用 identifier 集合进行临时启停捕获 */
    async _withPromptEnabledSet(enableSet, fn) { return await this._withPromptToggle({ enableSet }, fn); }

    /** 统一启停切换：支持 includeConfig（标识集）或 enableSet（组件键集合） */
    async _withPromptToggle({ includeConfig = null, enableSet = null } = {}, fn) {
        if (!promptManager || typeof promptManager.getPromptOrderForCharacter !== 'function') {
            return await fn();
        }
        // 使用队列保证串行执行，避免忙等
        const runExclusive = async () => {
            this._toggleBusy = true;
            let snapshot = [];
            try {
                const pm = promptManager;
                const activeChar = pm?.activeCharacter ?? null;
                const order = pm?.getPromptOrderForCharacter(activeChar) ?? [];
                snapshot = order.map(e => ({ identifier: e.identifier, enabled: !!e.enabled }));
                this._lastToggleSnapshot = snapshot.map(s => ({ ...s }));

                if (includeConfig) {
                    const enableIds = this._computeEnableIds(includeConfig);
                    order.forEach(e => { e.enabled = enableIds.has(e.identifier); });
                } else if (enableSet) {
                    const allow = enableSet instanceof Set ? enableSet : new Set(enableSet);
                    order.forEach(e => {
                        let ok = false;
                        for (const k of allow) { if (this._identifierMatchesKey(e.identifier, k)) { ok = true; break; } }
                        e.enabled = ok;
                    });
                }

                return await fn();
            } finally {
                try {
                    const pm = promptManager;
                    const activeChar = pm?.activeCharacter ?? null;
                    const order = pm?.getPromptOrderForCharacter(activeChar) ?? [];
                    const mapSnap = new Map((this._lastToggleSnapshot || snapshot).map(s => [s.identifier, s.enabled]));
                    order.forEach(e => { if (mapSnap.has(e.identifier)) e.enabled = mapSnap.get(e.identifier); });
                } catch {}
                this._toggleBusy = false;
                this._lastToggleSnapshot = null;
            }
        };
        this._toggleQueue = this._toggleQueue.then(runExclusive, runExclusive);
        return await this._toggleQueue;
    }

    async _captureWithEnabledSet(enableSet, quietText = '', skipWIAN = false) {
        const ctx = getContext();
        /** @type {any} */
        let capturedData = null;
        const listener = (data) => {
            if (data && typeof data === 'object' && Array.isArray(data.prompt)) {
                capturedData = { ...data, prompt: data.prompt.slice() };
            } else if (Array.isArray(data)) {
                capturedData = data.slice();
            }
        };
        eventSource.on(event_types.GENERATE_AFTER_DATA, listener);
        try {
            await this._withPromptToggle({ enableSet }, async () => {
                await ctx.generate('normal', { quiet_prompt: String(quietText || ''), quietToLoud: false, skipWIAN, force_name2: true }, true);
            });
        } finally {
            eventSource.removeListener(event_types.GENERATE_AFTER_DATA, listener);
        }
        if (!capturedData) return [];
        if (capturedData && typeof capturedData === 'object' && Array.isArray(capturedData.prompt)) return capturedData.prompt.slice();
        if (Array.isArray(capturedData)) return capturedData.slice();
        return [];
    }

    // ===== 工具函数：组件与消息辅助 =====

    /**
     * 获取消息的 component key（用于匹配与排序）。
     * chatHistory-* 归并为 chatHistory；dialogueExamples x-y 归并为 dialogueExamples。
     * @param {string} identifier
     * @returns {string}
     */
    _getComponentKeyFromIdentifier(identifier) {
        const id = String(identifier || '');
        if (id.startsWith('chatHistory')) return 'chatHistory';
        if (id.startsWith('dialogueExamples')) return 'dialogueExamples';
        return id;
    }

    /**
     * 判断具体 identifier 是否匹配某组件 key（处理聚合键）。
     * @param {string} identifier
     * @param {string} key
     * @returns {boolean}
     */
    _identifierMatchesKey(identifier, key) {
        const id = String(identifier || '');
        const k = String(key || '');
        if (!k || !id) return false;
        if (k === 'dialogueExamples') return id.startsWith('dialogueExamples');
        if (k === 'worldInfo') return id === 'worldInfoBefore' || id === 'worldInfoAfter';
        if (k === 'chatHistory') return id === 'chatHistory' || id.startsWith('chatHistory');
        return id === k;
    }

    /** 将组件键映射到创建锚点与角色，并生成稳定 identifier */
    _mapCreateAnchorForKey(key) {
        const k = String(key || '');
        const sys = { position: POSITIONS.IN_PROMPT, role: 'system' };
        const asst = { position: POSITIONS.IN_PROMPT, role: 'assistant' };
        if (k === 'bias') return { ...asst, identifier: 'bias' };
        if (k === 'worldInfo' || k === 'worldInfoBefore') return { ...sys, identifier: 'worldInfoBefore' };
        if (k === 'worldInfoAfter') return { ...sys, identifier: 'worldInfoAfter' };
        if (k === 'charDescription') return { ...sys, identifier: 'charDescription' };
        if (k === 'charPersonality') return { ...sys, identifier: 'charPersonality' };
        if (k === 'scenario') return { ...sys, identifier: 'scenario' };
        if (k === 'personaDescription') return { ...sys, identifier: 'personaDescription' };
        if (k === 'quietPrompt') return { ...sys, identifier: 'quietPrompt' };
        if (k === 'impersonate') return { ...sys, identifier: 'impersonate' };
        if (k === 'authorsNote') return { ...sys, identifier: 'authorsNote' };
        if (k === 'vectorsMemory') return { ...sys, identifier: 'vectorsMemory' };
        if (k === 'vectorsDataBank') return { ...sys, identifier: 'vectorsDataBank' };
        if (k === 'smartContext') return { ...sys, identifier: 'smartContext' };
        if (k === 'summary') return { ...sys, identifier: 'summary' };
        if (k === 'dialogueExamples') return { ...sys, identifier: 'dialogueExamples 0-0' };
        // 默认走 system+IN_PROMPT，并使用 key 作为 identifier
        return { ...sys, identifier: k };
    }

    /**
     * 将 name 解析为唯一 identifier。
     * 规则：
     * 1) 先快速命中已知原生键（直接返回同名 identifier）
     * 2) 扫描 PromptManager 的“订单列表”和“集合”，按 name/label/title 精确匹配（大小写不敏感），唯一命中返回其 identifier
     * 3) 失败时做一步 sanitize 对比（将非单词字符转为下划线）
     * 4) 多命中抛出 AMBIGUOUS_COMPONENT_NAME，零命中返回 null
     */
    _resolveNameToIdentifier(rawName) {
        try {
            const nm = String(rawName || '').trim();
            if (!nm) return null;

            // 1) 原生与常见聚合键的快速命中（支持用户用 name 指代这些键）
            if (KNOWN_KEYS.has(nm)) return nm;

            const eq = (a, b) => String(a || '').trim() === String(b || '').trim();
            const sanitize = (s) => String(s || '').replace(/\W/g, '_');

            const matches = new Set();

            // 缓存命中
            try {
                const nameCache = this._getNameCache();
                if (nameCache.has(nm)) return nameCache.get(nm);
            } catch {}

            // 2) 扫描 PromptManager 的订单（显示用）
            try {
                if (promptManager && typeof promptManager.getPromptOrderForCharacter === 'function') {
                    const pm = promptManager;
                    const activeChar = pm?.activeCharacter ?? null;
                    const order = pm.getPromptOrderForCharacter(activeChar) || [];
                    for (const e of order) {
                        const id = e?.identifier;
                        if (!id) continue;
                        const candidates = [e?.name, e?.label, e?.title, id].filter(Boolean);
                        if (candidates.some(x => eq(x, nm))) {
                            matches.add(id);
                            continue;
                        }
                    }
                }
            } catch {}

            // 3) 扫描 Prompt 集合（运行期合并后的集合）
            try {
                if (promptManager && typeof promptManager.getPromptCollection === 'function') {
                    const pc = promptManager.getPromptCollection();
                    const coll = pc?.collection || [];
                    for (const p of coll) {
                        const id = p?.identifier;
                        if (!id) continue;
                        const candidates = [p?.name, p?.label, p?.title, id].filter(Boolean);
                        if (candidates.some(x => eq(x, nm))) {
                            matches.add(id);
                            continue;
                        }
                    }
                }
            } catch {}

            // 4) 失败时尝试 sanitize 名称与 identifier 的弱匹配
            if (matches.size === 0) {
                const nmSan = sanitize(nm);
                try {
                    if (promptManager && typeof promptManager.getPromptCollection === 'function') {
                        const pc = promptManager.getPromptCollection();
                        const coll = pc?.collection || [];
                        for (const p of coll) {
                            const id = p?.identifier;
                            if (!id) continue;
                            if (sanitize(id) === nmSan) {
                                matches.add(id);
                            }
                        }
                    }
                } catch {}
            }

            if (matches.size === 1) {
                const id = Array.from(matches)[0];
                try { this._getNameCache().set(nm, id); } catch {}
                return id;
            }
            if (matches.size > 1) {
                const err = new Error('AMBIGUOUS_COMPONENT_NAME');
                throw err;
            }
            return null;
        } catch (e) {
            // 透传歧义错误，其它情况视为未命中
            if (String(e?.message) === 'AMBIGUOUS_COMPONENT_NAME') throw e;
            return null;
        }
    }

    /**
     * 解析组件引用 token：
     * - 'ALL' → 特殊标记
     * - 'id:identifier' → 直接返回 identifier
     * - 'name:xxx' → 通过名称解析为 identifier（大小写敏感）
     * - 'xxx' → 先按 name 精确匹配，未命中回退为 identifier
     * @param {string} token
     * @returns {string|null}
     */
    _parseComponentRefToken(token) {
        if (!token) return null;
        if (typeof token !== 'string') return null;
        const raw = token.trim();
        if (!raw) return null;
        if (raw.toLowerCase() === 'all') return 'ALL';
        // 特殊模式：仅启用预设中已开启的组件
        if (raw.toLowerCase() === 'all_preon') return 'ALL_PREON';
        if (raw.startsWith('id:')) return raw.slice(3).trim();
        if (raw.startsWith('name:')) {
            const nm = raw.slice(5).trim();
            const id = this._resolveNameToIdentifier(nm);
            if (id) return id;
            const err = new Error('INVALID_COMPONENT_REF');
            throw err;
        }
        // 默认按 name 精确匹配；未命中则回退当作 identifier 使用
        try {
            const byName = this._resolveNameToIdentifier(raw);
            if (byName) return byName;
        } catch (e) {
            if (String(e?.message) === 'AMBIGUOUS_COMPONENT_NAME') throw e;
        }
        return raw;
    }

    // ===== 轻量缓存：按 activeCharacter 维度缓存 name→identifier 与 footprint =====
    _getActiveCharacterIdSafe() {
        try {
            return promptManager?.activeCharacter ?? 'default';
        } catch { return 'default'; }
    }

    _getNameCache() {
        if (!this._nameCache) this._nameCache = new Map();
        const key = this._getActiveCharacterIdSafe();
        if (!this._nameCache.has(key)) this._nameCache.set(key, new Map());
        return this._nameCache.get(key);
    }

    _getFootprintCache() {
        if (!this._footprintCache) this._footprintCache = new Map();
        const key = this._getActiveCharacterIdSafe();
        if (!this._footprintCache.has(key)) this._footprintCache.set(key, new Map());
        return this._footprintCache.get(key);
    }

    /**
     * 解析统一 list：返回三元组
     * - references: 组件引用序列
     * - inlineInjections: 内联注入项（含原始索引）
     * - listOverrides: 行内覆写（以组件引用为键）
     * @param {Array<any>} list
     * @returns {{references:string[], inlineInjections:Array<{index:number,item:any}>, listOverrides:Object}}
     */
    _parseUnifiedList(list) {
        const references = [];
        const inlineInjections = [];
        const listOverrides = {};
        for (let i = 0; i < list.length; i++) {
            const item = list[i];
            if (typeof item === 'string') {
                references.push(item);
                continue;
            }
            if (item && typeof item === 'object' && item.role && item.content) {
                inlineInjections.push({ index: i, item });
                continue;
            }
            if (item && typeof item === 'object') {
                const keys = Object.keys(item);
                for (const k of keys) {
                    // k 是组件引用，如 'id:charDescription' / 'scenario' / 'chatHistory' / 'main'
                    references.push(k);
                    const cfg = item[k];
                    if (cfg && typeof cfg === 'object') {
                        listOverrides[k] = Object.assign({}, listOverrides[k] || {}, cfg);
                    }
                }
            }
        }
        return { references, inlineInjections, listOverrides };
    }

    /**
     * 基于原始 list 计算内联注入的邻接规则，映射到 position/depth。
     * 默认：紧跟前一组件（AFTER_COMPONENT）；首项+attach=prev → BEFORE_PROMPT；邻接 chatHistory → IN_CHAT。
     * @param {Array<any>} rawList
     * @param {Array<{index:number,item:any}>} inlineInjections
     * @returns {Array<{role:string,content:string,position:string,depth?:number,_afterRef?:string}>}
     */
    _mapInlineInjectionsUnified(rawList, inlineInjections) {
        const result = [];
        const getRefAt = (idx, dir) => {
            let j = idx + (dir < 0 ? -1 : 1);
            while (j >= 0 && j < rawList.length) {
                const it = rawList[j];
                if (typeof it === 'string') {
                    const token = this._parseComponentRefToken(it);
                    if (token && token !== 'ALL') return token;
                } else if (it && typeof it === 'object') {
                    if (it.role && it.content) {
                        // inline injection, skip
                    } else {
                        const ks = Object.keys(it);
                        if (ks.length) {
                            const tk = this._parseComponentRefToken(ks[0]);
                            if (tk) return tk;
                        }
                    }
                }
                j += (dir < 0 ? -1 : 1);
            }
            return null;
        };
        for (const { index, item } of inlineInjections) {
            const prevRef = getRefAt(index, -1);
            const nextRef = getRefAt(index, +1);
            const attach = item.attach === 'prev' || item.attach === 'next' ? item.attach : 'auto';
            // 显式 position 优先
            if (item.position && typeof item.position === 'string') {
                result.push({ role: item.role, content: item.content, position: item.position, depth: item.depth || 0 });
                continue;
            }
            // 有前邻组件 → 默认插到该组件之后（满足示例：位于 charDescription 之后、main 之前）
            if (prevRef) {
                result.push({ role: item.role, content: item.content, position: POSITIONS.AFTER_COMPONENT, _afterRef: prevRef });
                continue;
            }
            if (index === 0 && attach === 'prev') {
                result.push({ role: item.role, content: item.content, position: POSITIONS.BEFORE_PROMPT });
                continue;
            }
            if (prevRef === 'chatHistory' || nextRef === 'chatHistory') {
                result.push({ role: item.role, content: item.content, position: POSITIONS.IN_CHAT, depth: 0, _attach: attach === 'prev' ? 'before' : 'after' });
                continue;
            }
            result.push({ role: item.role, content: item.content, position: POSITIONS.IN_PROMPT });
        }
        return result;
    }

    /**
     * 根据组件集合过滤消息（当 list 不含 ALL）。
     * @param {Array<any>} messages
     * @param {Set<string>} wantedKeys
     * @returns {Array<any>}
     */
    _filterMessagesByComponents(messages, wantedKeys) {
        if (!wantedKeys || !wantedKeys.size) return [];
        return messages.filter(m => wantedKeys.has(this._getComponentKeyFromIdentifier(m?.identifier)));
    }

    /** 稳定重排：对目标子集按给定顺序排序，其他保持相对不变 */
    _stableReorderSubset(messages, orderedKeys) {
        if (!Array.isArray(messages) || !orderedKeys || !orderedKeys.length) return messages;
        const orderIndex = new Map();
        orderedKeys.forEach((k, i) => orderIndex.set(k, i));
        // 提取目标子集的元素与其原索引
        const targetIndices = [];
        const targetMessages = [];
        messages.forEach((m, idx) => {
            const key = this._getComponentKeyFromIdentifier(m?.identifier);
            if (orderIndex.has(key)) {
                targetIndices.push(idx);
                targetMessages.push({ m, ord: orderIndex.get(key) });
            }
        });
        if (!targetIndices.length) return messages;
        // 对目标子集按 ord 稳定排序
        targetMessages.sort((a, b) => a.ord - b.ord);
        // 将排序后的目标消息放回原有“子集槽位”，非目标元素完全不动
        const out = messages.slice();
        for (let i = 0; i < targetIndices.length; i++) {
            out[targetIndices[i]] = targetMessages[i].m;
        }
        return out;
    }

    // ===== 缺失 identifier 的兜底标注 =====
    _normalizeText(s) {
        return String(s || '').replace(/[\r\t\u200B\u00A0]/g, '').replace(/\s+/g, ' ').replace(/^[("']+|[("']+$/g, '').trim();
    }

    _stripNamePrefix(s) {
        return String(s || '').replace(/^\s*[^:]{1,32}:\s*/, '');
    }

    _normStrip(s) { return this._normalizeText(this._stripNamePrefix(s)); }

    _createIsFromChat() {
        try {
            const ctx = getContext();
            const chatArr = Array.isArray(ctx?.chat) ? ctx.chat : [];
            const chatNorms = chatArr.map(m => this._normStrip(m?.mes)).filter(Boolean);
            const chatSet = new Set(chatNorms);
            return (content) => {
                const n = this._normStrip(content);
                if (!n) return false;
                if (chatSet.has(n)) return true;
                for (const c of chatNorms) {
                    const a = n.length, b = c.length;
                    const minL = Math.min(a, b), maxL = Math.max(a, b);
                    if (minL < 20) continue;
                    if (((a >= b && n.includes(c)) || (b >= a && c.includes(n))) && minL / maxL >= 0.8) return true;
                }
                return false;
            };
        } catch {
            return () => false;
        }
    }

    async _annotateIdentifiersIfMissing(messages, targetKeys) {
        const arr = Array.isArray(messages) ? messages.map(m => ({ ...m })) : [];
        if (!arr.length) return arr;
        // 标注 chatHistory：依据 role + 来源判断
        const isFromChat = this._createIsFromChat();
        for (const m of arr) {
            if (!m?.identifier && (m?.role === 'user' || m?.role === 'assistant') && isFromChat(m.content)) {
                m.identifier = 'chatHistory-annotated';
            }
        }
        // 即使部分已有 identifier，也继续尝试为缺失者做 footprint 标注
        // 若仍缺失，按目标 keys 单独捕获来反向标注
        const keys = Array.from(new Set((Array.isArray(targetKeys) ? targetKeys : []).filter(Boolean)));
        if (!keys.length) return arr;
        const footprint = new Map(); // key -> Set of norm strings
        for (const key of keys) {
            try {
                if (key === 'chatHistory') continue; // 已在上面标注
                // footprint 缓存命中
                const fpCache = this._getFootprintCache();
                if (fpCache.has(key)) {
                    footprint.set(key, fpCache.get(key));
                } else {
                    const capture = await this._captureWithEnabledSet(new Set([key]), '', false);
                    const normSet = new Set(capture.map(x => `[${x.role}] ${this._normStrip(x.content)}`));
                    footprint.set(key, normSet);
                    try { fpCache.set(key, normSet); } catch {}
                }
            } catch {}
        }
        for (const m of arr) {
            if (m?.identifier) continue;
            const sig = `[${m?.role}] ${this._normStrip(m?.content)}`;
            for (const [key, set] of footprint.entries()) {
                if (set.has(sig)) { m.identifier = key; break; }
            }
        }
        return arr;
    }

    /** 覆写：通用组件 disable/replace（文本级），不影响采样参数 */
    _applyGeneralOverrides(messages, overridesByComponent) {
        if (!overridesByComponent) return messages;
        let out = messages.slice();
        for (const ref in overridesByComponent) {
            if (!Object.prototype.hasOwnProperty.call(overridesByComponent, ref)) continue;
            const cfg = overridesByComponent[ref];
            if (!cfg || typeof cfg !== 'object') continue;
            const key = this._parseComponentRefToken(ref);
            if (!key) continue;
            if (key === 'chatHistory') continue; // 历史专属逻辑另行处理
            const disable = !!cfg.disable;
            const replace = typeof cfg.replace === 'string' ? cfg.replace : null;
            if (disable) {
                out = out.filter(m => this._getComponentKeyFromIdentifier(m?.identifier) !== key);
                continue;
            }
            if (replace != null) {
                out = out.map(m => this._getComponentKeyFromIdentifier(m?.identifier) === key ? { ...m, content: replace } : m);
            }
        }
        return out;
    }

    /** 仅对 chatHistory 应用 selector/replaceAll/replace */
    _applyChatHistoryOverride(messages, historyCfg) {
        if (!historyCfg) return messages;
        const all = messages.slice();
        const indexes = [];
        for (let i = 0; i < all.length; i++) {
            const m = all[i];
            if (this._getComponentKeyFromIdentifier(m?.identifier) === 'chatHistory') indexes.push(i);
        }
        if (indexes.length === 0) return messages;
        if (historyCfg.disable) {
            // 直接移除全部历史
            return all.filter((m, idx) => !indexes.includes(idx));
        }
        const history = indexes.map(i => all[i]);

        // selector 过滤
        let selected = history.slice();
        if (historyCfg.selector) {
            // 在历史子集上应用 selector
            selected = this.applyChatHistorySelector(history, historyCfg.selector);
        }

        // 替换逻辑
        let replaced = selected.slice();
        if (historyCfg.replaceAll && Array.isArray(historyCfg.with)) {
            replaced = (historyCfg.with || []).map((w, idx) => ({ role: w.role, content: w.content, identifier: `chatHistory-replaceAll-${idx}` }));
        }
        if (Array.isArray(historyCfg.replace)) {
            // 在 replaced 上按顺序执行多段替换
            for (const step of historyCfg.replace) {
                const withArr = Array.isArray(step?.with) ? step.with : [];
                const newMsgs = withArr.map((w, idx) => ({ role: w.role, content: w.content, identifier: `chatHistory-replace-${Date.now()}-${idx}` }));
                let indices = [];
                if (step?.indices?.values && Array.isArray(step.indices.values) && step.indices.values.length) {
                    const n = replaced.length;
                    indices = step.indices.values.map(v0 => {
                        let v = Number(v0);
                        if (Number.isNaN(v)) return -1;
                        if (v < 0) v = n + v;
                        return (v >= 0 && v < n) ? v : -1;
                    }).filter(v => v >= 0);
                } else if (step?.range && (step.range.start !== undefined || step.range.end !== undefined)) {
                    let { start = 0, end = replaced.length - 1 } = step.range;
                    const n = replaced.length;
                    start = Number(start); end = Number(end);
                    if (Number.isNaN(start)) start = 0;
                    if (Number.isNaN(end)) end = n - 1;
                    if (start < 0) start = n + start;
                    if (end < 0) end = n + end;
                    start = Math.max(0, start); end = Math.min(n - 1, end);
                    if (start <= end) indices = Array.from({ length: end - start + 1 }, (_, k) => start + k);
                } else if (step?.last != null) {
                    const k = Math.max(0, Number(step.last) || 0);
                    const n = replaced.length;
                    indices = k > 0 ? Array.from({ length: Math.min(k, n) }, (_, j) => n - k + j) : [];
                }
                if (indices.length) {
                    // 按出现顺序处理：先删除这些索引，再按同位置插入（采用最小索引处插入）
                    const set = new Set(indices);
                    const kept = replaced.filter((_, idx) => !set.has(idx));
                    const insertAt = Math.min(...indices);
                    replaced = kept.slice(0, insertAt).concat(newMsgs).concat(kept.slice(insertAt));
                }
            }
        }

        // 将 replaced 合并回全量：找到历史的第一个索引，替换整个历史窗口
        const first = Math.min(...indexes);
        const last = Math.max(...indexes);
        const before = all.slice(0, first);
        const after = all.slice(last + 1);
        return before.concat(replaced).concat(after);
    }

    /** 将高级 injections 应用到 messages */
    _applyAdvancedInjections(messages, injections = []) {
        if (!Array.isArray(injections) || injections.length === 0) return messages;
        const out = messages.slice();
        // 计算 chatHistory 边界
        const historyIdx = [];
        for (let i = 0; i < out.length; i++) if (this._getComponentKeyFromIdentifier(out[i]?.identifier) === 'chatHistory') historyIdx.push(i);
        const hasHistory = historyIdx.length > 0;
        const historyStart = hasHistory ? Math.min(...historyIdx) : -1;
        const historyEnd = hasHistory ? Math.max(...historyIdx) : -1;
        for (const inj of injections) {
            const role = inj?.role; const content = inj?.content;
            if (!role || typeof content !== 'string') continue;
            const forcedId = inj && typeof inj.identifier === 'string' && inj.identifier.trim() ? String(inj.identifier).trim() : null;
            const msg = { role, content, identifier: forcedId || `injection-${inj.position || POSITIONS.IN_PROMPT}-${Date.now()}-${Math.random().toString(36).slice(2)}` };
            if (inj.position === POSITIONS.BEFORE_PROMPT) {
                out.splice(0, 0, msg);
                continue;
            }
            if (inj.position === POSITIONS.AFTER_COMPONENT) {
                const ref = inj._afterRef || null;
                let inserted = false;
                if (ref) {
                    for (let i = out.length - 1; i >= 0; i--) {
                        const id = out[i]?.identifier;
                        if (this._identifierMatchesKey(id, ref) || this._getComponentKeyFromIdentifier(id) === ref) {
                            out.splice(i + 1, 0, msg);
                            inserted = true; break;
                        }
                    }
                }
                if (!inserted) {
                    // 回退同 IN_PROMPT
                    if (hasHistory) {
                        const depth = Math.max(0, Number(inj.depth) || 0);
                        const insertPos = Math.max(0, historyStart - depth);
                        out.splice(insertPos, 0, msg);
                    } else {
                        out.splice(0, 0, msg);
                    }
                }
                continue;
            }
            if (inj.position === POSITIONS.IN_CHAT && hasHistory) {
                // depth=0 → 历史末尾后；depth>0 → 进入历史内部；
                const depth = Math.max(0, Number(inj.depth) || 0);
                if (inj._attach === 'before') {
                    const insertPos = Math.max(historyStart - depth, 0);
                    out.splice(insertPos, 0, msg);
                } else {
                    const insertPos = Math.min(out.length, historyEnd + 1 - depth);
                    out.splice(Math.max(historyStart, insertPos), 0, msg);
                }
                continue;
            }
            // IN_PROMPT 或无历史：在 chatHistory 之前插入，否则置顶后
            if (hasHistory) {
                const depth = Math.max(0, Number(inj.depth) || 0);
                const insertPos = Math.max(0, historyStart - depth);
                out.splice(insertPos, 0, msg);
            } else {
                out.splice(0, 0, msg);
            }
        }
        return out;
    }

    _mergeMessages(baseMessages, extraMessages) {
        const out = [];
        const seen = new Set();
        const norm = (s) => String(s || '').replace(/[\r\t\u200B\u00A0]/g, '').replace(/\s+/g, ' ').replace(/^[("']+|[("']+$/g, '').trim();
        const push = (m) => {
            if (!m || !m.content) return;
            const key = `${m.role}:${norm(m.content)}`;
            if (seen.has(key)) return;
            seen.add(key);
            out.push({ role: m.role, content: m.content });
        };
        baseMessages.forEach(push);
        (extraMessages || []).forEach(push);
        return out;
    }

    _splitMessagesForHistoryOps(messages) {
        // history: user/assistant; systemOther: 其余
        const history = [];
        const systemOther = [];
        for (const m of messages) {
            if (!m || typeof m.content !== 'string') continue;
            if (m.role === 'user' || m.role === 'assistant') history.push(m);
            else systemOther.push(m);
        }
        return { history, systemOther };
    }

    _applyRolesFilter(list, rolesCfg) {
        if (!rolesCfg || (!rolesCfg.include && !rolesCfg.exclude)) return list;
        const inc = Array.isArray(rolesCfg.include) && rolesCfg.include.length ? new Set(rolesCfg.include) : null;
        const exc = Array.isArray(rolesCfg.exclude) && rolesCfg.exclude.length ? new Set(rolesCfg.exclude) : null;
        return list.filter(m => {
            const r = m.role;
            if (inc && !inc.has(r)) return false;
            if (exc && exc.has(r)) return false;
            return true;
        });
    }

    _applyContentFilter(list, filterCfg) {
        if (!filterCfg) return list;
        const { contains, regex, fromUserNames } = filterCfg;
        let out = list.slice();
        if (contains) {
            const needles = Array.isArray(contains) ? contains : [contains];
            out = out.filter(m => needles.some(k => String(m.content).includes(String(k))));
        }
        if (regex) {
            try {
                const re = new RegExp(regex);
                out = out.filter(m => re.test(String(m.content)));
            } catch {}
        }
        if (fromUserNames && fromUserNames.length) {
            // 仅当 messages 中附带 name 时生效；否则忽略
            out = out.filter(m => !m.name || fromUserNames.includes(m.name));
        }
        // 时间戳过滤需要原始数据支持，这里忽略（占位）
        return out;
    }

    _applyAnchorWindow(list, anchorCfg) {
        if (!anchorCfg || !list.length) return list;
        const { anchor = 'lastUser', before = 0, after = 0 } = anchorCfg;
        // 找到锚点索引
        let idx = -1;
        if (anchor === 'lastUser') {
            for (let i = list.length - 1; i >= 0; i--) if (list[i].role === 'user') { idx = i; break; }
        } else if (anchor === 'lastAssistant') {
            for (let i = list.length - 1; i >= 0; i--) if (list[i].role === 'assistant') { idx = i; break; }
        } else if (anchor === 'lastSystem') {
            for (let i = list.length - 1; i >= 0; i--) if (list[i].role === 'system') { idx = i; break; }
        }
        if (idx === -1) return list;
        const start = Math.max(0, idx - Number(before || 0));
        const end = Math.min(list.length - 1, idx + Number(after || 0));
        return list.slice(start, end + 1);
    }

    _applyIndicesRange(list, selector) {
        let result = list.slice();
        // indices 优先
        if (Array.isArray(selector?.indices?.values) && selector.indices.values.length) {
            const vals = selector.indices.values;
            const picked = [];
            const n = list.length;
            for (const v0 of vals) {
                let v = Number(v0);
                if (Number.isNaN(v)) continue;
                if (v < 0) v = n + v; // 负索引
                if (v >= 0 && v < n) picked.push(list[v]);
            }
            result = picked;
            return result;
        }
        if (selector?.range && (selector.range.start !== undefined || selector.range.end !== undefined)) {
            let { start = 0, end = list.length - 1 } = selector.range;
            const n = list.length;
            start = Number(start); end = Number(end);
            if (Number.isNaN(start)) start = 0;
            if (Number.isNaN(end)) end = n - 1;
            if (start < 0) start = n + start;
            if (end < 0) end = n + end;
            start = Math.max(0, start); end = Math.min(n - 1, end);
            if (start > end) return [];
            return list.slice(start, end + 1);
        }
        if (selector?.last !== undefined && selector.last !== null) {
            const k = Math.max(0, Number(selector.last) || 0);
            if (k === 0) return [];
            const n = list.length;
            return list.slice(Math.max(0, n - k));
        }
        return result;
    }

    _applyTakeEvery(list, step) {
        const s = Math.max(1, Number(step) || 1);
        if (s === 1) return list;
        const out = [];
        for (let i = 0; i < list.length; i += s) out.push(list[i]);
        return out;
    }

    _applyLimit(list, limitCfg) {
        if (!limitCfg) return list;
        // 仅实现 count，tokenBudget 预留
        const count = Number(limitCfg.count || 0);
        if (count > 0 && list.length > count) {
            const how = limitCfg.truncateStrategy || 'last';
            if (how === 'first') return list.slice(0, count);
            if (how === 'middle') {
                const left = Math.floor(count / 2);
                const right = count - left;
                return list.slice(0, left).concat(list.slice(-right));
            }
            if (how === 'even') {
                const step = Math.ceil(list.length / count);
                const out = [];
                for (let i = 0; i < list.length && out.length < count; i += step) out.push(list[i]);
                return out;
            }
            // default: 'last' → 取末尾
            return list.slice(-count);
        }
        return list;
    }

    applyChatHistorySelector(messages, selector) {
        if (!selector || !Array.isArray(messages) || !messages.length) return messages;
        const { history, systemOther } = this._splitMessagesForHistoryOps(messages);
        let list = history;
        // roles/filter/anchor → indices/range/last → takeEvery → limit
        list = this._applyRolesFilter(list, selector.roles);
        list = this._applyContentFilter(list, selector.filter);
        list = this._applyAnchorWindow(list, selector.anchorWindow);
        list = this._applyIndicesRange(list, selector);
        list = this._applyTakeEvery(list, selector.takeEvery);
        list = this._applyLimit(list, selector.limit || (selector.last ? { count: Number(selector.last) } : null));
        // 合并非历史部分
        return systemOther.concat(list);
    }

    // ===== 发送实现（构建后的统一发送） =====

    async _sendMessages(messages, options, requestId, sourceWindow, targetOrigin = null) {
        const sessionId = this.normalizeSessionId(options?.session?.id || 'xb1');
        const session = this.ensureSession(sessionId);
        const streamingEnabled = options?.streaming?.enabled !== false; // 默认开
        const apiCfg = this.resolveApiConfig(options?.api || {});
        const payload = this.buildChatPayload(messages, apiCfg, streamingEnabled);

        try {
            const shouldExport = !!(options?.debug?.enabled || options?.debug?.exportPrompt);
            const already = options?.debug?._exported === true;
            if (shouldExport && !already) {
                this.postToTarget(sourceWindow, 'generatePromptPreview', { id: requestId, messages: (messages || []).map(m => ({ role: m.role, content: m.content })) }, targetOrigin);
            }

            if (streamingEnabled) {
                this.postToTarget(sourceWindow, 'generateStreamStart', { id: requestId, sessionId }, targetOrigin);
                const streamFn = await ChatCompletionService.sendRequest(payload, false, session.abortController.signal);
                let last = '';
                const generator = typeof streamFn === 'function' ? streamFn() : null;
                for await (const { text } of (generator || [])) {
                    const chunk = text.slice(last.length);
                    last = text;
                    session.accumulated = text;
                    this.postToTarget(sourceWindow, 'generateStreamChunk', { id: requestId, chunk, accumulated: text, metadata: {} }, targetOrigin);
                }
                const result = {
                    success: true,
                    result: session.accumulated,
                    sessionId,
                    metadata: { duration: Date.now() - session.startedAt, model: apiCfg.model, finishReason: 'stop' },
                };
                this.postToTarget(sourceWindow, 'generateStreamComplete', { id: requestId, result }, targetOrigin);
                return result;
            } else {
                const extracted = await ChatCompletionService.sendRequest(payload, true, session.abortController.signal);
                const result = {
                    success: true,
                    result: String((extracted && extracted.content) || ''),
                    sessionId,
                    metadata: { duration: Date.now() - session.startedAt, model: apiCfg.model, finishReason: 'stop' },
                };
                this.postToTarget(sourceWindow, 'generateResult', { id: requestId, result }, targetOrigin);
                return result;
            }
        } catch (err) {
            this.sendError(sourceWindow, requestId, streamingEnabled, err, 'API_ERROR', null, targetOrigin);
            return null;
        }
    }

    // ===== 主流程 =====
    async handleRequestInternal(options, requestId, sourceWindow, targetOrigin = null) {
        // 1) 校验
        this.validateOptions(options);

        // 2) 解析组件列表与内联注入
        const list = Array.isArray(options?.components?.list) ? options.components.list.slice() : undefined;
        let baseStrategy = 'EMPTY'; // EMPTY | ALL | ALL_PREON | SUBSET
        let orderedRefs = [];
        let inlineMapped = [];
        let listLevelOverrides = {};
        const unorderedKeys = new Set();
        if (list && list.length) {
            const { references, inlineInjections, listOverrides } = this._parseUnifiedList(list);
            listLevelOverrides = listOverrides || {};
            const parsedRefs = references.map(t => this._parseComponentRefToken(t));
            const containsAll = parsedRefs.includes('ALL');
            const containsAllPreOn = parsedRefs.includes('ALL_PREON');
            if (containsAll) {
                baseStrategy = 'ALL';
                // ALL 仅作为开关标识，子集重排目标为去除 ALL 后的引用列表
                orderedRefs = parsedRefs.filter(x => x && x !== 'ALL' && x !== 'ALL_PREON');
            } else if (containsAllPreOn) {
                baseStrategy = 'ALL_PREON';
                // ALL_PREON：仅启用“预设里已开启”的组件，子集重排目标为去除该标记后的引用列表
                orderedRefs = parsedRefs.filter(x => x && x !== 'ALL' && x !== 'ALL_PREON');
            } else {
                baseStrategy = 'SUBSET';
                orderedRefs = parsedRefs.filter(Boolean);
            }
            inlineMapped = this._mapInlineInjectionsUnified(list, inlineInjections);
            // 放宽：ALL 可出现在任意位置，作为“启用全部”的标志

            // 解析 order=false：不参与重排
            for (const rawKey in listLevelOverrides) {
                if (!Object.prototype.hasOwnProperty.call(listLevelOverrides, rawKey)) continue;
                const k = this._parseComponentRefToken(rawKey);
                if (!k) continue;
                if (listLevelOverrides[rawKey] && listLevelOverrides[rawKey].order === false) unorderedKeys.add(k);
            }
        }

        // 3) 干跑捕获（基座）
        let captured = [];
        if (baseStrategy === 'EMPTY') {
            captured = [];
        } else {
            // 不将 userInput 作为 quietText 干跑，以免把其注入到历史里
            if (baseStrategy === 'ALL') {
                // 路径B：ALL 时先全开启用集合再干跑，保证真实组件尽量出现
                // 读取 promptManager 订单并构造 allow 集合
                let allow = new Set();
                try {
                    if (promptManager && typeof promptManager.getPromptOrderForCharacter === 'function') {
                        const pm = promptManager;
                        const activeChar = pm?.activeCharacter ?? null;
                        const order = pm?.getPromptOrderForCharacter(activeChar) ?? [];
                        allow = new Set(order.map(e => e.identifier));
                    }
                } catch {}
                const run = async () => await this._capturePromptMessages({ includeConfig: null, quietText: '', skipWIAN: false });
                captured = await this._withPromptEnabledSet(allow, run);
            } else if (baseStrategy === 'ALL_PREON') {
                // 仅启用预设里已开启的组件
                let allow = new Set();
                try {
                    if (promptManager && typeof promptManager.getPromptOrderForCharacter === 'function') {
                        const pm = promptManager;
                        const activeChar = pm?.activeCharacter ?? null;
                        const order = pm?.getPromptOrderForCharacter(activeChar) ?? [];
                        allow = new Set(order.filter(e => !!e?.enabled).map(e => e.identifier));
                    }
                } catch {}
                const run = async () => await this._capturePromptMessages({ includeConfig: null, quietText: '', skipWIAN: false });
                captured = await this._withPromptEnabledSet(allow, run);
            } else {
                captured = await this._capturePromptMessages({ includeConfig: null, quietText: '', skipWIAN: false });
            }
        }

        // 4) 依据策略计算启用集合与顺序
        const annotateKeys = baseStrategy === 'SUBSET' ? orderedRefs : ((baseStrategy === 'ALL' || baseStrategy === 'ALL_PREON') ? orderedRefs : []);
        let working = await this._annotateIdentifiersIfMissing(captured.slice(), annotateKeys);
        working = this._applyOrderingStrategy(working, baseStrategy, orderedRefs, unorderedKeys);

        // 5) 覆写与创建
        working = this._applyInlineOverrides(working, listLevelOverrides);

        // 6) 注入（内联 + 高级）
        working = this._applyAllInjections(working, inlineMapped, options?.injections);

        // 7) 用户输入追加
        working = this._appendUserInput(working, options?.userInput);

        // 8) 调试导出
        this._exportDebugData({ sourceWindow, requestId, working, baseStrategy, orderedRefs, inlineMapped, listLevelOverrides, debug: options?.debug, targetOrigin });

        // 9) 发送
        return await this._sendMessages(working, { ...options, debug: { ...(options?.debug || {}), _exported: true } }, requestId, sourceWindow, targetOrigin);
    }

    _applyOrderingStrategy(messages, baseStrategy, orderedRefs, unorderedKeys) {
        let out = messages.slice();
        if (baseStrategy === 'SUBSET') {
            const want = new Set(orderedRefs);
            out = this._filterMessagesByComponents(out, want);
        } else if ((baseStrategy === 'ALL' || baseStrategy === 'ALL_PREON') && orderedRefs.length) {
            const targets = orderedRefs.filter(k => !unorderedKeys.has(k));
            if (targets.length) out = this._stableReorderSubset(out, targets);
        }
        return out;
    }

    _applyInlineOverrides(messages, byComp) {
        let out = messages.slice();
        if (!byComp) return out;
        out = this._applyGeneralOverrides(out, byComp);
        const ensureInjections = [];
        for (const ref in byComp) {
            if (!Object.prototype.hasOwnProperty.call(byComp, ref)) continue;
            const key = this._parseComponentRefToken(ref);
            if (!key || key === 'chatHistory') continue;
            const cfg = byComp[ref];
            if (!cfg || typeof cfg.replace !== 'string') continue;
            const exists = out.some(m => this._identifierMatchesKey(m?.identifier, key) || this._getComponentKeyFromIdentifier(m?.identifier) === key);
            if (exists) continue;
            const map = this._mapCreateAnchorForKey(key);
            ensureInjections.push({ position: map.position, role: map.role, content: cfg.replace, identifier: map.identifier });
        }
        if (ensureInjections.length) {
            out = this._applyAdvancedInjections(out, ensureInjections);
        }
        if (byComp['id:chatHistory'] || byComp['chatHistory']) {
            const cfg = byComp['id:chatHistory'] || byComp['chatHistory'];
            out = this._applyChatHistoryOverride(out, cfg);
        }
        return out;
    }

    _applyAllInjections(messages, inlineMapped, advancedInjections) {
        let out = messages.slice();
        if (inlineMapped && inlineMapped.length) {
            out = this._applyAdvancedInjections(out, inlineMapped);
        }
        if (Array.isArray(advancedInjections) && advancedInjections.length) {
            out = this._applyAdvancedInjections(out, advancedInjections);
        }
        return out;
    }

    _appendUserInput(messages, userInput) {
        const out = messages.slice();
        if (typeof userInput === 'string' && userInput.length >= 0) {
            out.push({ role: 'user', content: String(userInput || ''), identifier: 'userInput' });
        }
        return out;
    }

    _exportDebugData({ sourceWindow, requestId, working, baseStrategy, orderedRefs, inlineMapped, listLevelOverrides, debug, targetOrigin }) {
        const exportPrompt = !!(debug?.enabled || debug?.exportPrompt);
        if (exportPrompt) this.postToTarget(sourceWindow, 'generatePromptPreview', { id: requestId, messages: working.map(m => ({ role: m.role, content: m.content })) }, targetOrigin);
        if (debug?.exportBlueprint) {
            try {
                const bp = {
                    id: requestId,
                    components: { strategy: baseStrategy, order: orderedRefs },
                    injections: (debug?.injections || []).concat(inlineMapped || []),
                    overrides: listLevelOverrides || null,
                };
                this.postToTarget(sourceWindow, 'blueprint', bp, targetOrigin);
            } catch {}
        }
    }

    /**
     * 入口：处理 generateRequest（统一入口）
     */
    async handleGenerateRequest(options, requestId, sourceWindow, targetOrigin = null) {
        let streamingEnabled = false;
        try {
            streamingEnabled = options?.streaming?.enabled !== false;
            try {
                if (xbLog.isEnabled?.()) {
                    const comps = options?.components?.list;
                    const compsCount = Array.isArray(comps) ? comps.length : 0;
                    const userInputLen = String(options?.userInput || '').length;
                    xbLog.info('callGenerateBridge', `generateRequest id=${requestId} stream=${!!streamingEnabled} comps=${compsCount} userInputLen=${userInputLen}`);
                }
            } catch {}
            return await this.handleRequestInternal(options, requestId, sourceWindow, targetOrigin);
        } catch (err) {
            try { xbLog.error('callGenerateBridge', `generateRequest failed id=${requestId}`, err); } catch {}
            this.sendError(sourceWindow, requestId, streamingEnabled, err, 'BAD_REQUEST', null, targetOrigin);
            return null;
        }
    }

    /** 取消会话 */
    cancel(sessionId) {
        const s = this.sessions.get(this.normalizeSessionId(sessionId));
        try { s?.abortController?.abort(); } catch {}
    }

    /** 清理所有会话 */
    cleanup() {
        this.sessions.forEach(s => { try { s.abortController?.abort(); } catch {} });
        this.sessions.clear();
    }
}

const callGenerateService = new CallGenerateService();

export async function handleGenerateRequest(options, requestId, sourceWindow, targetOrigin = null) {
    return await callGenerateService.handleGenerateRequest(options, requestId, sourceWindow, targetOrigin);
}

// Host bridge for handling iframe generateRequest → respond via postMessage
let __xb_generate_listener_attached = false;
let __xb_generate_listener = null;

export function initCallGenerateHostBridge() {
    if (typeof window === 'undefined') return;
    if (__xb_generate_listener_attached) return;
    try { xbLog.info('callGenerateBridge', 'initCallGenerateHostBridge'); } catch {}
    __xb_generate_listener = async function (event) {
        try {
            const data = event && event.data || {};
            if (!data || data.type !== 'generateRequest') return;
            const id = data.id;
            const options = data.options || {};
            await handleGenerateRequest(options, id, event.source || window, event.origin);
        } catch (e) {
            try { xbLog.error('callGenerateBridge', 'generateRequest listener error', e); } catch {}
        }
    };
    // eslint-disable-next-line no-restricted-syntax -- bridge listener; origin can be null for sandboxed iframes.
    try { window.addEventListener('message', __xb_generate_listener); } catch (e) {}
    __xb_generate_listener_attached = true;
}

export function cleanupCallGenerateHostBridge() {
    if (typeof window === 'undefined') return;
    if (!__xb_generate_listener_attached) return;
    try { xbLog.info('callGenerateBridge', 'cleanupCallGenerateHostBridge'); } catch {}
    try { window.removeEventListener('message', __xb_generate_listener); } catch (e) {}
    __xb_generate_listener_attached = false;
    __xb_generate_listener = null;
    try { callGenerateService.cleanup(); } catch (e) {}
}

if (typeof window !== 'undefined') {
    Object.assign(window, { xiaobaixCallGenerateService: callGenerateService, initCallGenerateHostBridge, cleanupCallGenerateHostBridge });
    try { initCallGenerateHostBridge(); } catch (e) {}
    try {
        window.addEventListener('xiaobaixEnabledChanged', (e) => {
            try {
                const enabled = e && e.detail && e.detail.enabled === true;
                if (enabled) initCallGenerateHostBridge(); else cleanupCallGenerateHostBridge();
            } catch (_) {}
        });
        document.addEventListener('xiaobaixEnabledChanged', (e) => {
            try {
                const enabled = e && e.detail && e.detail.enabled === true;
                if (enabled) initCallGenerateHostBridge(); else cleanupCallGenerateHostBridge();
            } catch (_) {}
        });
        window.addEventListener('beforeunload', () => { try { cleanupCallGenerateHostBridge(); } catch (_) {} });
    } catch (_) {}

    // ===== 全局 API 暴露：与 iframe 调用方式完全一致 =====
    // 创建命名空间
    window.LittleWhiteBox = window.LittleWhiteBox || {};
    
    /**
     * 全局 callGenerate 函数
     * 使用方式与 iframe 中完全一致：await window.callGenerate(options)
     *
     * @param {Object} options - 生成选项
     * @returns {Promise<Object>} 生成结果
     *
     * @example
     * // iframe 中的调用方式：
     * const res = await window.callGenerate({
     *     components: { list: ['ALL_PREON'] },
     *     userInput: '你好',
     *     streaming: { enabled: true },
     *     api: { inherit: true }
     * });
     *
     * // 全局调用方式（完全一致）：
     * const res = await window.LittleWhiteBox.callGenerate({
     *     components: { list: ['ALL_PREON'] },
     *     userInput: '你好',
     *     streaming: { enabled: true },
     *     api: { inherit: true }
     * });
     */
    window.LittleWhiteBox.callGenerate = async function(options) {
        return new Promise((resolve, reject) => {
            const requestId = `global-${Date.now()}-${Math.random().toString(36).slice(2)}`;
            const streamingEnabled = options?.streaming?.enabled !== false;
            
            // 处理流式回调
            let onChunkCallback = null;
            if (streamingEnabled && typeof options?.streaming?.onChunk === 'function') {
                onChunkCallback = options.streaming.onChunk;
            }
            
            // 监听响应
            const listener = (event) => {
                const data = event.data;
                if (!data || data.source !== SOURCE_TAG || data.id !== requestId) return;
                
                if (data.type === 'generateStreamChunk' && onChunkCallback) {
                    // 流式文本块回调
                    try {
                        onChunkCallback(data.chunk, data.accumulated);
                    } catch (err) {
                        console.error('[callGenerate] onChunk callback error:', err);
                    }
                } else if (data.type === 'generateStreamComplete') {
                    window.removeEventListener('message', listener);
                    resolve(data.result);
                } else if (data.type === 'generateResult') {
                    window.removeEventListener('message', listener);
                    resolve(data.result);
                } else if (data.type === 'generateStreamError' || data.type === 'generateError') {
                    window.removeEventListener('message', listener);
                    reject(data.error);
                }
            };
            
            // eslint-disable-next-line no-restricted-syntax -- local listener for internal request flow.
            window.addEventListener('message', listener);
            
            // 发送请求
            handleGenerateRequest(options, requestId, window).catch(err => {
                window.removeEventListener('message', listener);
                reject(err);
            });
        });
    };
    
    /**
     * 取消指定会话
     * @param {string} sessionId - 会话 ID（如 'xb1', 'xb2' 等）
     */
    window.LittleWhiteBox.callGenerate.cancel = function(sessionId) {
        callGenerateService.cancel(sessionId);
    };
    
    /**
     * 清理所有会话
     */
    window.LittleWhiteBox.callGenerate.cleanup = function() {
        callGenerateService.cleanup();
    };
    
    // 保持向后兼容：保留原有的内部接口
    window.LittleWhiteBox._internal = {
        service: callGenerateService,
        handleGenerateRequest,
        init: initCallGenerateHostBridge,
        cleanup: cleanupCallGenerateHostBridge
    };
}