@jsonstudio/llms 0.6.2979 → 0.6.3238

package/dist/router/virtual-router/routing-instructions.js

@@ -1,655 +1,4 @@
-import { extractMessageText } from './message-utils.js';
-import { parseStopMessageInstruction } from './routing-stop-message-parser.js';
-import { applyStopMessageInstructionToState } from './routing-stop-message-actions.js';
-import { parsePreCommandInstruction } from './routing-pre-command-parser.js';
-import { applyPreCommandInstructionToState, clearPreCommandState } from './routing-pre-command-actions.js';
-import { deserializeStopMessageState, serializeStopMessageState } from './routing-stop-message-state-codec.js';
-import { deserializePreCommandState, serializePreCommandState } from './routing-pre-command-state-codec.js';
-const ROUTING_INSTRUCTION_MARKER_PATTERN = /<\*\*[\s\S]*?\*\*>/;
-const ROUTING_INSTRUCTION_MARKER_GLOBAL_PATTERN = /<\*\*[\s\S]*?\*\*>/g;
-export function parseRoutingInstructions(messages) {
-    const instructions = [];
-    // 只解析“当前最新一条消息”中的 marker，避免历史 user marker 在后续轮次被重复回放。
-    const latestMessage = messages.length > 0 ? messages[messages.length - 1] : undefined;
-    if (!latestMessage || latestMessage.role !== 'user') {
-        return instructions;
-    }
-    const content = extractMessageText(latestMessage);
-    if (!content) {
-        return instructions;
-    }
-    const sanitized = stripCodeSegments(content);
-    if (!sanitized || !ROUTING_INSTRUCTION_MARKER_PATTERN.test(sanitized)) {
-        return instructions;
-    }
-    const regex = /<\*\*([\s\S]*?)\*\*>/g;
-    let match;
-    while ((match = regex.exec(sanitized)) !== null) {
-        const instruction = match[1].trim();
-        if (!instruction) {
-            continue;
-        }
-        const segments = expandInstructionSegments(instruction);
-        for (const segment of segments) {
-            const parsed = parseSingleInstruction(segment);
-            if (parsed) {
-                instructions.push(parsed);
-            }
-        }
-    }
-    return normalizeStopMessageInstructionPrecedence(instructions);
-}
-/**
- * 解析并预处理路由指令，优先处理 clear 指令，确保新指令能够覆盖旧状态。
- * 返回清理后的指令列表，移除冗余的 stopMessageSet 指令。
- */
-export function parseAndPreprocessRoutingInstructions(messages) {
-    const rawInstructions = parseRoutingInstructions(messages);
-    if (rawInstructions.length === 0) {
-        return [];
-    }
-    // 检查是否有 clear 指令
-    const hasClear = rawInstructions.some(inst => inst.type === 'clear');
-    if (!hasClear) {
-        return rawInstructions;
-    }
-    // 如果有 clear 指令，clear 之后的指令才有效，clear 之前的指令被清除
-    const clearIndex = rawInstructions.findIndex(inst => inst.type === 'clear');
-    const effectiveInstructions = rawInstructions.slice(clearIndex + 1);
-    // 移除 clear 后冗余的 stopMessageSet 指令（如果与原指令相同）
-    // 这里的逻辑会在 applyRoutingInstructions 中处理，
-    // 所以我们只需要返回 clear 之后的指令即可
-    return effectiveInstructions;
-}
-/**
- * 提取 clear 指令（如果存在）。用于在路由选择前优先执行清理操作。
- * @returns 是否存在 clear 指令
- */
-export function extractClearInstruction(messages) {
-    const instructions = parseRoutingInstructions(messages);
-    return instructions.some((inst) => inst.type === 'clear');
-}
-/**
- * 提取 stopMessageClear 指令（如果存在）。
- * @returns 是否存在 stopMessageClear 指令
- */
-export function extractStopMessageClearInstruction(messages) {
-    const instructions = parseRoutingInstructions(messages);
-    return instructions.some((inst) => inst.type === 'stopMessageClear');
-}
-function expandInstructionSegments(instruction) {
-    const trimmed = instruction.trim();
-    if (!trimmed) {
-        return [];
-    }
-    const normalizedLeading = normalizeInstructionLeading(trimmed);
-    // stopMessage 指令需要整体解析，不能按逗号拆分，否则类似
-    // "<**stopMessage:\"继续\",3**>" 会被错误拆成 ["stopMessage:\"继续\"", "3"]。
-    if (/^(?:"|')?stopMessage(?:"|')?\s*[:,]/i.test(normalizedLeading)) {
-        return [normalizeStopMessageCommandPrefix(normalizedLeading)];
-    }
-    if (/^precommand(?:\s*:|$)/i.test(normalizedLeading)) {
-        return [normalizedLeading];
-    }
-    const prefix = trimmed[0];
-    if (prefix === '!' || prefix === '#' || prefix === '@') {
-        const tokens = splitInstructionTargets(trimmed.substring(1));
-        return tokens
-            .map((token) => token.replace(/^[!#@]+/, '').trim())
-            .filter((token) => token.length > 0)
-            .map((token) => `${prefix}${token}`);
-    }
-    const splitTokens = splitInstructionTargets(trimmed);
-    const recoveredStopMessage = recoverSplitStopMessageInstruction(splitTokens);
-    if (recoveredStopMessage) {
-        return [recoveredStopMessage];
-    }
-    return splitTokens;
-}
-function splitInstructionTargets(content) {
-    return content
-        .split(',')
-        .map((segment) => segment.trim())
-        .filter((segment) => segment.length > 0);
-}
-function normalizeInstructionLeading(content) {
-    // Remove common zero-width prefixes that may be injected by client/editor copies.
-    return content.replace(/^[\u200B-\u200D\u2060\uFEFF]+/, '').trimStart();
-}
-function normalizeStopMessageCommandPrefix(content) {
-    const normalized = normalizeInstructionLeading(content);
-    return normalized.replace(/^(?:"|')?stopMessage(?:"|')?\s*([:,])/i, 'stopMessage$1');
-}
-function normalizeSplitStopMessageHeadToken(token) {
-    return normalizeInstructionLeading(token)
-        .replace(/^["']+|["']+$/g, '')
-        .trim();
-}
-function recoverSplitStopMessageInstruction(tokens) {
-    if (!Array.isArray(tokens) || tokens.length < 2) {
-        return null;
-    }
-    const head = normalizeSplitStopMessageHeadToken(tokens[0]);
-    if (!/^stopmessage$/i.test(head)) {
-        return null;
-    }
-    const tail = tokens.slice(1).join(',').trim();
-    if (!tail) {
-        return null;
-    }
-    return `stopMessage:${tail}`;
-}
-function splitTargetAndProcessMode(rawTarget) {
-    const trimmed = typeof rawTarget === 'string' ? rawTarget.trim() : '';
-    if (!trimmed) {
-        return { target: '' };
-    }
-    const separatorIndex = trimmed.lastIndexOf(':');
-    if (separatorIndex <= 0 || separatorIndex === trimmed.length - 1) {
-        return { target: trimmed };
-    }
-    const target = trimmed.slice(0, separatorIndex).trim();
-    const modeToken = trimmed.slice(separatorIndex + 1).trim().toLowerCase();
-    if (!target) {
-        return { target: trimmed };
-    }
-    if (modeToken === 'passthrough') {
-        return { target, processMode: 'passthrough' };
-    }
-    if (modeToken === 'chat') {
-        return { target, processMode: 'chat' };
-    }
-    return { target };
-}
-function parseNamedTargetInstruction(instruction, prefix) {
-    const re = new RegExp('^' + prefix + '\\s*:', 'i');
-    if (!re.test(instruction)) {
-        return null;
-    }
-    const body = instruction.slice(instruction.indexOf(':') + 1).trim();
-    if (!body) {
-        return null;
-    }
-    const { target, processMode } = splitTargetAndProcessMode(body);
-    if (!target) {
-        return null;
-    }
-    const parsed = parseTarget(target);
-    if (!parsed) {
-        return null;
-    }
-    const normalized = normalizeStickyOrForceTarget(parsed);
-    return { type: prefix, ...normalized, ...(processMode ? { processMode } : {}) };
-}
-function parseSingleInstruction(instruction) {
-    if (/^clear$/i.test(instruction)) {
-        return { type: 'clear' };
-    }
-    const preCommandInstruction = parsePreCommandInstruction(instruction);
-    if (preCommandInstruction) {
-        return preCommandInstruction;
-    }
-    const stopMessageInstruction = parseStopMessageInstruction(instruction);
-    if (stopMessageInstruction) {
-        return stopMessageInstruction;
-    }
-    const stickyInstruction = parseNamedTargetInstruction(instruction, 'sticky');
-    if (stickyInstruction) {
-        return stickyInstruction;
-    }
-    const forceInstruction = parseNamedTargetInstruction(instruction, 'force');
-    if (forceInstruction) {
-        return forceInstruction;
-    }
-    const preferInstruction = parseNamedTargetInstruction(instruction, 'prefer');
-    if (preferInstruction) {
-        return preferInstruction;
-    }
-    if (instruction.startsWith('!')) {
-        const rawTarget = instruction.substring(1).trim();
-        const { target, processMode } = splitTargetAndProcessMode(rawTarget);
-        if (!target) {
-            return null;
-        }
-        const parsed = parseTarget(target);
-        if (!parsed) {
-            return null;
-        }
-        // 约定：
-        // - "!providerA,providerB"：允许列表（whitelist），用于快速限制可用 provider 集合；
-        // - "!provider.model" / "!provider[alias].model" / "!provider.2"：prefer 语义；
-        //   model 可用时只命中该 model（忽略路由），不可用则自动清除并回退到正常路由命中。
-        //
-        // 这样可以在不破坏既有 "!glm,openai" 语义的前提下，引入基于模型的优先命中行为。
-        if (!target.includes('.')) {
-            if (parsed.provider) {
-                return { type: 'allow', provider: parsed.provider, pathLength: parsed.pathLength };
-            }
-            return null;
-        }
-        const normalized = normalizeStickyOrForceTarget(parsed);
-        return { type: 'prefer', ...normalized, ...(processMode ? { processMode } : {}) };
-    }
-    else if (instruction.startsWith('#')) {
-        const target = instruction.substring(1).trim();
-        const parsed = parseTarget(target);
-        if (parsed) {
-            return { type: 'disable', ...parsed };
-        }
-    }
-    else if (instruction.startsWith('@')) {
-        const target = instruction.substring(1).trim();
-        const parsed = parseTarget(target);
-        if (parsed) {
-            return { type: 'enable', ...parsed };
-        }
-    }
-    else if (isValidProviderModel(instruction)) {
-        const parsed = parseTarget(instruction);
-        if (parsed) {
-            const normalized = normalizeStickyOrForceTarget(parsed);
-            return { type: 'force', ...normalized };
-        }
-    }
-    else if (isValidIdentifier(instruction)) {
-        // 仅 provider 标识（无 .）时，视为 provider 级白名单，等价于 "<**!provider**>"。
-        // 这样可以用 "<**antigravity**>" 快速激活当前 routing 中所有 antigravity 相关池子，
-        // 并保证路由仅命中该 provider 的所有模型/key。
-        return {
-            type: 'allow',
-            provider: instruction,
-            pathLength: 1
-        };
-    }
-    return null;
-}
-function normalizeStopMessageInstructionPrecedence(instructions) {
-    if (!Array.isArray(instructions) || instructions.length <= 1) {
-        return instructions;
-    }
-    const isStopDirective = (inst) => inst.type === 'stopMessageSet' || inst.type === 'stopMessageMode' || inst.type === 'stopMessageClear';
-    const hasGlobalClear = instructions.some((inst) => inst.type === 'clear');
-    const hasStopClear = instructions.some((inst) => inst.type === 'stopMessageClear');
-    if (hasGlobalClear) {
-        const lastGlobalClearIndex = instructions.map((inst) => inst.type).lastIndexOf('clear');
-        return lastGlobalClearIndex >= 0 ? [instructions[lastGlobalClearIndex]] : instructions;
-    }
-    if (hasStopClear) {
-        const lastStopClearIndex = instructions.map((inst) => inst.type).lastIndexOf('stopMessageClear');
-        return lastStopClearIndex >= 0 ? [instructions[lastStopClearIndex]] : instructions;
-    }
-    let lastStopIndex = -1;
-    for (let idx = instructions.length - 1; idx >= 0; idx -= 1) {
-        if (isStopDirective(instructions[idx])) {
-            lastStopIndex = idx;
-            break;
-        }
-    }
-    if (lastStopIndex < 0) {
-        return instructions;
-    }
-    return instructions.filter((inst, idx) => !isStopDirective(inst) || idx === lastStopIndex);
-}
-function parseTarget(target) {
-    if (!target) {
-        return null;
-    }
-    // Accept "provider[alias].model" (as printed in virtual-router-hit logs) to avoid users
-    // needing to translate bracket notation back to dot notation manually.
-    // With the alias disambiguated, allow dots in model ids (e.g. gpt-5.2) without ambiguity.
-    const bracketMatch = target.match(/^([a-zA-Z0-9_-]+)\[([a-zA-Z0-9_-]*)\](?:\.(.+))?$/);
-    if (bracketMatch) {
-        const provider = bracketMatch[1];
-        const keyAliasRaw = bracketMatch[2];
-        const keyAlias = typeof keyAliasRaw === 'string' ? keyAliasRaw.trim() : '';
-        const model = typeof bracketMatch[3] === 'string' ? bracketMatch[3].trim() : '';
-        if (!provider || !isValidIdentifier(provider)) {
-            return null;
-        }
-        // Allow omitting the alias: "provider[].model" means "provider.model across all aliases".
-        // This also enables disambiguating model ids that contain dots, without requiring the user
-        // to specify the alias.
-        if (!keyAlias) {
-            if (!model) {
-                return { provider, pathLength: 1 };
-            }
-            if (!/^[a-zA-Z0-9_.-]+$/.test(model)) {
-                return null;
-            }
-            return { provider, model, pathLength: 2 };
-        }
-        if (!isValidIdentifier(keyAlias)) {
-            return null;
-        }
-        if (!model) {
-            // Treat as explicit alias selection. Use pathLength=3 so engine resolves keyAlias directly.
-            return { provider, keyAlias, pathLength: 3 };
-        }
-        // Model ids may contain dots (e.g. gpt-5.2); allow them here because alias is already explicit.
-        if (!/^[a-zA-Z0-9_.-]+$/.test(model)) {
-            return null;
-        }
-        return { provider, keyAlias, model, pathLength: 3 };
-    }
-    // Dot syntax: align with config parsing used by routing entries.
-    // - "provider.modelId" -> modelId may contain dots; it always means model across all aliases.
-    // - Key/alias selection must use bracket syntax: "provider[alias]" or "provider[alias].modelId".
-    const firstDot = target.indexOf('.');
-    if (firstDot < 0) {
-        const provider = target.trim();
-        if (!provider || !isValidIdentifier(provider)) {
-            return null;
-        }
-        return { provider, pathLength: 1 };
-    }
-    const provider = target.slice(0, firstDot).trim();
-    const remainder = target.slice(firstDot + 1).trim();
-    if (!provider || !isValidIdentifier(provider) || !remainder) {
-        return null;
-    }
-    // Support "provider.2" key-index notation (only when remainder is a plain integer).
-    if (/^\d+$/.test(remainder)) {
-        const keyIndex = Number.parseInt(remainder, 10);
-        if (Number.isFinite(keyIndex) && keyIndex > 0) {
-            return { provider, keyIndex, pathLength: 2 };
-        }
-    }
-    // Treat everything after the first dot as the model id, allowing dots.
-    if (!/^[a-zA-Z0-9_.-]+$/.test(remainder)) {
-        return null;
-    }
-    return { provider, model: remainder, pathLength: 2 };
-}
-function normalizeStickyOrForceTarget(target) {
-    if (target &&
-        target.pathLength === 2 &&
-        typeof target.model === 'string' &&
-        typeof target.keyAlias === 'string' &&
-        target.model === target.keyAlias) {
-        const clone = { ...target };
-        delete clone.keyAlias;
-        return clone;
-    }
-    return target;
-}
-function isValidIdentifier(id) {
-    return /^[a-zA-Z0-9_-]+$/.test(id);
-}
-function isValidProviderModel(providerModel) {
-    const pattern = /^[a-zA-Z0-9_-]+(?:\.[a-zA-Z0-9_-]+)+$/;
-    return pattern.test(providerModel);
-}
-function stripCodeSegments(text) {
-    if (!text) {
-        return '';
-    }
-    // Remove fenced code blocks ```...``` or ~~~...~~~
-    let sanitized = text.replace(/```[\s\S]*?```/g, ' ');
-    sanitized = sanitized.replace(/~~~[\s\S]*?~~~/g, ' ');
-    // Remove inline code `...`
-    sanitized = sanitized.replace(/`[^`]*`/g, ' ');
-    return sanitized;
-}
-export function applyRoutingInstructions(instructions, currentState) {
-    const newState = {
-        forcedTarget: currentState.forcedTarget ? { ...currentState.forcedTarget } : undefined,
-        stickyTarget: currentState.stickyTarget ? { ...currentState.stickyTarget } : undefined,
-        preferTarget: currentState.preferTarget ? { ...currentState.preferTarget } : undefined,
-        allowedProviders: new Set(currentState.allowedProviders),
-        disabledProviders: new Set(currentState.disabledProviders),
-        disabledKeys: new Map(Array.from(currentState.disabledKeys.entries()).map(([k, v]) => [k, new Set(v)])),
-        disabledModels: new Map(Array.from(currentState.disabledModels.entries()).map(([k, v]) => [k, new Set(v)])),
-        stopMessageSource: currentState.stopMessageSource,
-        stopMessageText: currentState.stopMessageText,
-        stopMessageMaxRepeats: currentState.stopMessageMaxRepeats,
-        stopMessageUsed: currentState.stopMessageUsed,
-        stopMessageUpdatedAt: currentState.stopMessageUpdatedAt,
-        stopMessageLastUsedAt: currentState.stopMessageLastUsedAt,
-        stopMessageStageMode: currentState.stopMessageStageMode,
-        stopMessageAiMode: currentState.stopMessageAiMode,
-        stopMessageAiSeedPrompt: currentState.stopMessageAiSeedPrompt,
-        stopMessageAiHistory: Array.isArray(currentState.stopMessageAiHistory)
-            ? currentState.stopMessageAiHistory.map((entry) => entry && typeof entry === 'object' && !Array.isArray(entry)
-                ? { ...entry }
-                : {})
-            : undefined,
-        preCommandSource: currentState.preCommandSource,
-        preCommandScriptPath: currentState.preCommandScriptPath,
-        preCommandUpdatedAt: currentState.preCommandUpdatedAt
-    };
-    let allowReset = false;
-    let disableReset = false;
-    for (const instruction of instructions) {
-        switch (instruction.type) {
-            case 'force':
-                newState.forcedTarget = {
-                    provider: instruction.provider,
-                    keyAlias: instruction.keyAlias,
-                    keyIndex: instruction.keyIndex,
-                    model: instruction.model,
-                    pathLength: instruction.pathLength,
-                    processMode: instruction.processMode
-                };
-                // 保留 stickyTarget，允许单次 force 覆盖但不清除持久 sticky
-                // newState.stickyTarget = undefined;
-                break;
-            case 'sticky':
-                newState.stickyTarget = {
-                    provider: instruction.provider,
-                    keyAlias: instruction.keyAlias,
-                    keyIndex: instruction.keyIndex,
-                    model: instruction.model,
-                    pathLength: instruction.pathLength,
-                    processMode: instruction.processMode
-                };
-                newState.forcedTarget = undefined;
-                break;
-            case 'prefer':
-                newState.preferTarget = {
-                    provider: instruction.provider,
-                    keyAlias: instruction.keyAlias,
-                    keyIndex: instruction.keyIndex,
-                    model: instruction.model,
-                    pathLength: instruction.pathLength,
-                    processMode: instruction.processMode
-                };
-                newState.forcedTarget = undefined;
-                newState.stickyTarget = undefined;
-                break;
-            case 'allow':
-                if (!allowReset) {
-                    newState.allowedProviders.clear();
-                    allowReset = true;
-                }
-                if (instruction.provider) {
-                    newState.allowedProviders.add(instruction.provider);
-                }
-                break;
-            case 'disable': {
-                if (!disableReset) {
-                    newState.disabledProviders.clear();
-                    newState.disabledKeys.clear();
-                    newState.disabledModels.clear();
-                    disableReset = true;
-                }
-                if (instruction.provider) {
-                    const hasKeySpecifier = instruction.keyAlias || instruction.keyIndex !== undefined;
-                    const hasModelSpecifier = typeof instruction.model === 'string' && instruction.model.length > 0;
-                    if (hasKeySpecifier) {
-                        if (!newState.disabledKeys.has(instruction.provider)) {
-                            newState.disabledKeys.set(instruction.provider, new Set());
-                        }
-                        const keySet = newState.disabledKeys.get(instruction.provider);
-                        if (instruction.keyAlias) {
-                            keySet.add(instruction.keyAlias);
-                        }
-                        if (instruction.keyIndex !== undefined) {
-                            keySet.add(instruction.keyIndex);
-                        }
-                    }
-                    if (hasModelSpecifier) {
-                        if (!newState.disabledModels.has(instruction.provider)) {
-                            newState.disabledModels.set(instruction.provider, new Set());
-                        }
-                        newState.disabledModels.get(instruction.provider).add(instruction.model);
-                    }
-                    if (!hasKeySpecifier && !hasModelSpecifier) {
-                        newState.disabledProviders.add(instruction.provider);
-                    }
-                }
-                break;
-            }
-            case 'enable': {
-                if (instruction.provider) {
-                    const hasKeySpecifier = instruction.keyAlias || instruction.keyIndex !== undefined;
-                    const hasModelSpecifier = typeof instruction.model === 'string' && instruction.model.length > 0;
-                    if (hasKeySpecifier) {
-                        const keySet = newState.disabledKeys.get(instruction.provider);
-                        if (keySet) {
-                            if (instruction.keyAlias) {
-                                keySet.delete(instruction.keyAlias);
-                            }
-                            if (instruction.keyIndex !== undefined) {
-                                keySet.delete(instruction.keyIndex);
-                            }
-                            if (keySet.size === 0) {
-                                newState.disabledKeys.delete(instruction.provider);
-                            }
-                        }
-                    }
-                    if (hasModelSpecifier) {
-                        const modelSet = newState.disabledModels.get(instruction.provider);
-                        if (modelSet) {
-                            modelSet.delete(instruction.model);
-                            if (modelSet.size === 0) {
-                                newState.disabledModels.delete(instruction.provider);
-                            }
-                        }
-                    }
-                    if (!hasKeySpecifier && !hasModelSpecifier) {
-                        newState.disabledProviders.delete(instruction.provider);
-                        newState.disabledKeys.delete(instruction.provider);
-                        newState.disabledModels.delete(instruction.provider);
-                    }
-                }
-                break;
-            }
-            case 'clear':
-                newState.forcedTarget = undefined;
-                newState.stickyTarget = undefined;
-                newState.preferTarget = undefined;
-                newState.allowedProviders.clear();
-                newState.disabledProviders.clear();
-                newState.disabledKeys.clear();
-                newState.disabledModels.clear();
-                applyStopMessageInstructionToState({ type: 'stopMessageClear' }, newState);
-                clearPreCommandState(newState);
-                break;
-            case 'stopMessageSet':
-            case 'stopMessageMode':
-            case 'stopMessageClear':
-                applyStopMessageInstructionToState(instruction, newState);
-                break;
-            case 'preCommandSet':
-            case 'preCommandClear':
-                applyPreCommandInstructionToState(instruction, newState);
-                break;
-        }
-    }
-    return newState;
-}
-export function cleanMessagesFromRoutingInstructions(messages) {
-    return messages
-        .map((message) => {
-        if (message.role !== 'user' || typeof message.content !== 'string') {
-            return message;
-        }
-        const cleanedContent = message.content.replace(ROUTING_INSTRUCTION_MARKER_GLOBAL_PATTERN, '').trim();
-        return {
-            ...message,
-            content: cleanedContent
-        };
-    })
-        .filter((message) => {
-        if (message.role !== 'user') {
-            return true;
-        }
-        if (typeof message.content !== 'string') {
-            return true;
-        }
-        return message.content.trim().length > 0;
-    });
-}
-export function serializeRoutingInstructionState(state) {
-    return {
-        forcedTarget: state.forcedTarget,
-        stickyTarget: state.stickyTarget,
-        preferTarget: state.preferTarget,
-        allowedProviders: Array.from(state.allowedProviders),
-        disabledProviders: Array.from(state.disabledProviders),
-        disabledKeys: Array.from(state.disabledKeys.entries()).map(([provider, keys]) => ({
-            provider,
-            keys: Array.from(keys)
-        })),
-        disabledModels: Array.from(state.disabledModels.entries()).map(([provider, models]) => ({
-            provider,
-            models: Array.from(models)
-        })),
-        ...serializeStopMessageState(state),
-        ...serializePreCommandState(state)
-    };
-}
-export function deserializeRoutingInstructionState(data) {
-    const state = {
-        forcedTarget: undefined,
-        stickyTarget: undefined,
-        preferTarget: undefined,
-        allowedProviders: new Set(),
-        disabledProviders: new Set(),
-        disabledKeys: new Map(),
-        disabledModels: new Map(),
-        stopMessageText: undefined,
-        stopMessageSource: undefined,
-        stopMessageMaxRepeats: undefined,
-        stopMessageUsed: undefined,
-        stopMessageStageMode: undefined,
-        stopMessageAiMode: undefined,
-        stopMessageAiSeedPrompt: undefined,
-        stopMessageAiHistory: undefined,
-        preCommandSource: undefined,
-        preCommandScriptPath: undefined,
-        preCommandUpdatedAt: undefined
-    };
-    if (data.forcedTarget && typeof data.forcedTarget === 'object') {
-        state.forcedTarget = data.forcedTarget;
-    }
-    if (data.stickyTarget && typeof data.stickyTarget === 'object') {
-        state.stickyTarget = data.stickyTarget;
-    }
-    if (data.preferTarget && typeof data.preferTarget === 'object') {
-        state.preferTarget = data.preferTarget;
-    }
-    if (Array.isArray(data.allowedProviders)) {
-        state.allowedProviders = new Set(data.allowedProviders);
-    }
-    if (Array.isArray(data.disabledProviders)) {
-        state.disabledProviders = new Set(data.disabledProviders);
-    }
-    if (Array.isArray(data.disabledKeys)) {
-        for (const entry of data.disabledKeys) {
-            if (entry.provider && Array.isArray(entry.keys)) {
-                state.disabledKeys.set(entry.provider, new Set(entry.keys));
-            }
-        }
-    }
-    if (Array.isArray(data.disabledModels)) {
-        for (const entry of data.disabledModels) {
-            if (entry.provider && Array.isArray(entry.models)) {
-                state.disabledModels.set(entry.provider, new Set(entry.models));
-            }
-        }
-    }
-    deserializeStopMessageState(data, state);
-    deserializePreCommandState(data, state);
-    return state;
-}
+export { ROUTING_INSTRUCTION_MARKER_PATTERN, ROUTING_INSTRUCTION_MARKER_GLOBAL_PATTERN } from './routing-instructions/types.js';
+export { parseRoutingInstructions, parseAndPreprocessRoutingInstructions, extractClearInstruction, extractStopMessageClearInstruction } from './routing-instructions/parse.js';
+export { applyRoutingInstructions, serializeRoutingInstructionState, deserializeRoutingInstructionState } from './routing-instructions/state.js';
+export { cleanMessagesFromRoutingInstructions } from './routing-instructions/clean.js';

package/dist/router/virtual-router/sticky-session-store.d.ts

@@ -1,4 +1,8 @@
 import type { RoutingInstructionState } from './routing-instructions.js';
+export declare class StickySessionKeyMissingError extends Error {
+    readonly key: string | undefined;
+    constructor(key: string | undefined, message: string);
+}
 export declare function loadRoutingInstructionStateSync(key: string | undefined): RoutingInstructionState | null;
 export declare function saveRoutingInstructionStateAsync(key: string | undefined, state: RoutingInstructionState | null): void;
 export declare function saveRoutingInstructionStateSync(key: string | undefined, state: RoutingInstructionState | null): void;