@jsonstudio/rcc 0.90.323 → 0.90.364

package/vendor/@jsonstudio/llms/dist/router/virtual-router/pre-command-file-resolver.js

@@ -0,0 +1,117 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { resolveRccUserDir } from '../../runtime/user-data-paths.js';
+const DEFAULT_PRECOMMAND_SCRIPT = 'default.sh';
+const DEFAULT_PRECOMMAND_SCRIPT_CONTENT = [
+    '#!/usr/bin/env bash',
+    '# RouteCodex default precommand hook (no-op).',
+    '# You can edit this file to customize precommand behavior.',
+    'exit 0',
+    ''
+].join('\n');
+function resolvePreCommandBaseDir() {
+    return path.resolve(resolveRccUserDir(), 'precommand');
+}
+function normalizeRelativePath(raw) {
+    const normalized = path.posix.normalize(raw.replace(/\\/g, '/'));
+    if (!normalized || normalized === '.' || normalized === '..' || normalized.startsWith('../')) {
+        throw new Error('precommand: invalid relative path');
+    }
+    return normalized;
+}
+function normalizePreCommandRelativePath(raw, fromFileScheme) {
+    const normalized = normalizeRelativePath(raw);
+    if (normalized === 'precommand') {
+        throw new Error('precommand: expected script file under ~/.rcc/precommand');
+    }
+    if (normalized.startsWith('precommand/')) {
+        return normalized.slice('precommand/'.length);
+    }
+    if (fromFileScheme) {
+        throw new Error('precommand file://: path must be under file://precommand/...');
+    }
+    return normalized;
+}
+export function resolvePreCommandScriptPath(raw) {
+    let text = typeof raw === 'string' ? raw.trim() : '';
+    if (!text) {
+        throw new Error('precommand: missing script path');
+    }
+    if (text.startsWith('<') && text.endsWith('>') && text.length >= 3) {
+        text = text.slice(1, -1).trim();
+    }
+    const fromFileScheme = /^file:\/\//i.test(text);
+    const relRaw = fromFileScheme ? text.slice('file://'.length).trim() : text;
+    if (!relRaw) {
+        throw new Error('precommand file://: missing relative path');
+    }
+    if (relRaw.startsWith('/') || relRaw.startsWith('\\') || /^[a-zA-Z]:[\\/]/.test(relRaw)) {
+        throw new Error('precommand: only supports paths relative to ~/.rcc/precommand');
+    }
+    const relToPreCommand = normalizePreCommandRelativePath(relRaw, fromFileScheme);
+    const selectedBase = resolvePreCommandBaseDir();
+    const abs = path.resolve(selectedBase, relToPreCommand);
+    if (abs !== selectedBase && !abs.startsWith(`${selectedBase}${path.sep}`)) {
+        throw new Error('precommand: path escapes ~/.rcc/precommand');
+    }
+    let stat;
+    try {
+        stat = fs.statSync(abs);
+    }
+    catch (err) {
+        if (shouldAutoCreateDefaultScript(relToPreCommand, err)) {
+            tryCreateDefaultPreCommandScript(selectedBase, abs);
+            try {
+                stat = fs.statSync(abs);
+            }
+            catch (retryErr) {
+                const retryMessage = retryErr && typeof retryErr.message === 'string' ? retryErr.message : String(retryErr || 'unknown error');
+                throw new Error(`precommand: cannot stat ${abs}: ${retryMessage}`);
+            }
+        }
+        else {
+            const message = err && typeof err.message === 'string' ? err.message : String(err || 'unknown error');
+            throw new Error(`precommand: cannot stat ${abs}: ${message}`);
+        }
+    }
+    if (!stat.isFile()) {
+        throw new Error(`precommand: not a file: ${abs}`);
+    }
+    return abs;
+}
+function shouldAutoCreateDefaultScript(relToPreCommand, err) {
+    const code = err?.code;
+    if (code !== 'ENOENT') {
+        return false;
+    }
+    return relToPreCommand === DEFAULT_PRECOMMAND_SCRIPT;
+}
+function tryCreateDefaultPreCommandScript(baseDir, scriptPath) {
+    try {
+        fs.mkdirSync(baseDir, { recursive: true });
+        if (!fs.existsSync(scriptPath)) {
+            fs.writeFileSync(scriptPath, DEFAULT_PRECOMMAND_SCRIPT_CONTENT, { encoding: 'utf8', mode: 0o755 });
+        }
+    }
+    catch {
+        // Keep original resolver contract: caller gets a stat error on failure.
+    }
+}
+export function isPreCommandScriptPathAllowed(rawPath) {
+    const scriptPath = typeof rawPath === 'string' ? rawPath.trim() : '';
+    if (!scriptPath) {
+        return false;
+    }
+    const base = resolvePreCommandBaseDir();
+    const abs = path.resolve(scriptPath);
+    if (abs !== base && !abs.startsWith(`${base}${path.sep}`)) {
+        return false;
+    }
+    try {
+        const stat = fs.statSync(abs);
+        return stat.isFile();
+    }
+    catch {
+        return false;
+    }
+}

package/vendor/@jsonstudio/llms/dist/router/virtual-router/provider-registry.d.ts

@@ -0,0 +1,17 @@
+import type { ProviderProfile, TargetMetadata, ModelCapability } from './types.js';
+export declare class ProviderRegistry {
+    private readonly providers;
+    constructor(profiles?: Record<string, ProviderProfile>);
+    load(profiles: Record<string, ProviderProfile>): void;
+    get(providerKey: string): ProviderProfile;
+    has(providerKey: string): boolean;
+    listKeys(): string[];
+    getModelCapabilities(providerKey: string): Set<ModelCapability>;
+    hasCapability(providerKey: string, capability: ModelCapability): boolean;
+    resolveRuntimeKeyByAlias(providerId: string, keyAlias: string): string | null;
+    resolveRuntimeKeyByIndex(providerId: string, keyIndex: number): string | null;
+    listProviderKeys(providerId: string): string[];
+    resolveRuntimeKeyByModel(providerId: string, modelId: string): string | null;
+    buildTarget(providerKey: string): TargetMetadata;
+    private static normalizeProfile;
+}

package/vendor/@jsonstudio/llms/dist/router/virtual-router/provider-registry.js

@@ -0,0 +1,145 @@
+import { VirtualRouterError, VirtualRouterErrorCode } from './types.js';
+export class ProviderRegistry {
+    providers = new Map();
+    constructor(profiles) {
+        if (profiles) {
+            this.load(profiles);
+        }
+    }
+    load(profiles) {
+        this.providers.clear();
+        for (const [key, profile] of Object.entries(profiles)) {
+            const normalized = ProviderRegistry.normalizeProfile(key, profile);
+            this.providers.set(normalized.providerKey, normalized);
+        }
+    }
+    get(providerKey) {
+        const profile = this.providers.get(providerKey);
+        if (!profile) {
+            throw new VirtualRouterError(`Provider ${providerKey} is not registered`, VirtualRouterErrorCode.CONFIG_ERROR, {
+                providerKey
+            });
+        }
+        return profile;
+    }
+    has(providerKey) {
+        return this.providers.has(providerKey);
+    }
+    listKeys() {
+        return Array.from(this.providers.keys());
+    }
+    getModelCapabilities(providerKey) {
+        const profile = this.providers.get(providerKey);
+        if (!profile) {
+            return new Set();
+        }
+        const modelId = profile.modelId ?? deriveModelId(providerKey);
+        if (!modelId) {
+            return new Set();
+        }
+        const capabilities = profile.modelCapabilities?.[modelId];
+        if (!capabilities || !Array.isArray(capabilities)) {
+            return new Set();
+        }
+        return new Set(capabilities.filter((c) => typeof c === 'string'));
+    }
+    hasCapability(providerKey, capability) {
+        return this.getModelCapabilities(providerKey).has(capability);
+    }
+    resolveRuntimeKeyByAlias(providerId, keyAlias) {
+        const pattern = new RegExp(`^${providerId.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\.${keyAlias.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(?:\\.|$)`);
+        for (const key of this.providers.keys()) {
+            if (pattern.test(key)) {
+                return key;
+            }
+        }
+        return null;
+    }
+    resolveRuntimeKeyByIndex(providerId, keyIndex) {
+        const index = keyIndex - 1;
+        if (index < 0)
+            return null;
+        const keys = this.listProviderKeys(providerId);
+        if (index >= keys.length)
+            return null;
+        return keys[index];
+    }
+    listProviderKeys(providerId) {
+        const pattern = new RegExp(`^${providerId.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\.`);
+        return this.listKeys().filter(key => pattern.test(key));
+    }
+    resolveRuntimeKeyByModel(providerId, modelId) {
+        if (!providerId || !modelId) {
+            return null;
+        }
+        const normalizedModel = modelId.trim();
+        if (!normalizedModel) {
+            return null;
+        }
+        const providerKeys = this.listProviderKeys(providerId);
+        for (const key of providerKeys) {
+            const profile = this.providers.get(key);
+            const candidate = profile?.modelId ?? deriveModelId(key);
+            if (candidate === normalizedModel) {
+                return key;
+            }
+        }
+        return null;
+    }
+    buildTarget(providerKey) {
+        const profile = this.get(providerKey);
+        const modelId = profile.modelId ?? deriveModelId(profile.providerKey);
+        if (!modelId) {
+            throw new VirtualRouterError(`Provider ${providerKey} is missing model identifier`, VirtualRouterErrorCode.CONFIG_ERROR, { providerKey });
+        }
+        return {
+            providerKey: profile.providerKey,
+            providerType: profile.providerType,
+            outboundProfile: profile.outboundProfile,
+            compatibilityProfile: profile.compatibilityProfile,
+            runtimeKey: profile.runtimeKey,
+            modelId,
+            processMode: profile.processMode || 'chat',
+            responsesConfig: profile.responsesConfig,
+            streaming: profile.streaming,
+            maxOutputTokens: profile.maxOutputTokens,
+            maxContextTokens: profile.maxContextTokens,
+            ...(profile.deepseek ? { deepseek: profile.deepseek } : {})
+        };
+    }
+    static normalizeProfile(key, profile) {
+        const providerKey = profile.providerKey ?? key;
+        const modelId = profile.modelId ?? deriveModelId(providerKey);
+        return {
+            providerKey,
+            providerType: profile.providerType,
+            endpoint: profile.endpoint,
+            auth: profile.auth,
+            ...(profile.enabled !== undefined ? { enabled: profile.enabled } : {}),
+            outboundProfile: profile.outboundProfile,
+            compatibilityProfile: profile.compatibilityProfile,
+            runtimeKey: profile.runtimeKey,
+            modelId,
+            processMode: profile.processMode || 'chat',
+            responsesConfig: profile.responsesConfig,
+            streaming: profile.streaming,
+            maxOutputTokens: profile.maxOutputTokens,
+            maxContextTokens: profile.maxContextTokens,
+            ...(profile.deepseek ? { deepseek: profile.deepseek } : {}),
+            ...(profile.serverToolsDisabled ? { serverToolsDisabled: true } : {}),
+            ...(profile.modelCapabilities ? { modelCapabilities: profile.modelCapabilities } : {})
+        };
+    }
+}
+function deriveModelId(providerKey) {
+    if (!providerKey)
+        return undefined;
+    const firstDot = providerKey.indexOf('.');
+    if (firstDot <= 0 || firstDot === providerKey.length - 1)
+        return undefined;
+    const remainder = providerKey.slice(firstDot + 1);
+    const secondDot = remainder.indexOf('.');
+    if (secondDot <= 0 || secondDot === remainder.length - 1)
+        return remainder.trim() || undefined;
+    return remainder.slice(secondDot + 1).trim() || undefined;
+}

package/vendor/@jsonstudio/llms/dist/router/virtual-router/routing-instructions/clean.d.ts

@@ -0,0 +1,3 @@
+import type { StandardizedMessage } from '../../../conversion/hub/types/standardized.js';
+export declare function stripCodeSegments(text: string): string;
+export declare function cleanMessagesFromRoutingInstructions(messages: StandardizedMessage[]): StandardizedMessage[];

package/vendor/@jsonstudio/llms/dist/router/virtual-router/routing-instructions/clean.js

@@ -0,0 +1,34 @@
+import { ROUTING_INSTRUCTION_MARKER_GLOBAL_PATTERN } from './types.js';
+export 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 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;
+    });
+}

package/vendor/@jsonstudio/llms/dist/router/virtual-router/routing-instructions/parse.d.ts

@@ -0,0 +1,6 @@
+import type { StandardizedMessage } from '../../../conversion/hub/types/standardized.js';
+import type { RoutingInstruction } from './types.js';
+export declare function parseRoutingInstructions(messages: StandardizedMessage[]): RoutingInstruction[];
+export declare function parseAndPreprocessRoutingInstructions(messages: StandardizedMessage[]): RoutingInstruction[];
+export declare function extractClearInstruction(messages: StandardizedMessage[]): boolean;
+export declare function extractStopMessageClearInstruction(messages: StandardizedMessage[]): boolean;

package/vendor/@jsonstudio/llms/dist/router/virtual-router/routing-instructions/parse.js

@@ -0,0 +1,24 @@
+import { parseRoutingInstructionsWithNative } from '../engine-selection/native-virtual-router-routing-instructions-semantics.js';
+export function parseRoutingInstructions(messages) {
+    if (!Array.isArray(messages) || messages.length === 0) {
+        return [];
+    }
+    return parseRoutingInstructionsWithNative(messages);
+}
+export function parseAndPreprocessRoutingInstructions(messages) {
+    const rawInstructions = parseRoutingInstructions(messages);
+    if (rawInstructions.length === 0) {
+        return [];
+    }
+    const clearIndex = rawInstructions.findIndex((inst) => inst.type === 'clear');
+    if (clearIndex < 0) {
+        return rawInstructions;
+    }
+    return rawInstructions.slice(clearIndex + 1);
+}
+export function extractClearInstruction(messages) {
+    return parseRoutingInstructions(messages).some((inst) => inst.type === 'clear');
+}
+export function extractStopMessageClearInstruction(messages) {
+    return parseRoutingInstructions(messages).some((inst) => inst.type === 'stopMessageClear');
+}

package/vendor/@jsonstudio/llms/dist/router/virtual-router/routing-instructions/state.d.ts

@@ -0,0 +1,4 @@
+import type { RoutingInstruction, RoutingInstructionState } from './types.js';
+export declare function applyRoutingInstructions(instructions: RoutingInstruction[], currentState: RoutingInstructionState): RoutingInstructionState;
+export declare function serializeRoutingInstructionState(state: RoutingInstructionState): Record<string, unknown>;
+export declare function deserializeRoutingInstructionState(data: Record<string, unknown>): RoutingInstructionState;

package/vendor/@jsonstudio/llms/dist/router/virtual-router/routing-instructions/state.js

@@ -0,0 +1,284 @@
+import { applyStopMessageInstructionToState } from '../routing-stop-message-actions.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';
+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,
+        chatProcessLastTotalTokens: currentState.chatProcessLastTotalTokens,
+        chatProcessLastInputTokens: currentState.chatProcessLastInputTokens,
+        chatProcessLastMessageCount: currentState.chatProcessLastMessageCount,
+        chatProcessLastUpdatedAt: currentState.chatProcessLastUpdatedAt
+    };
+    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
+                };
+                // force 指令同时设置 stickyTarget，确保后续请求继续使用该 provider
+                newState.stickyTarget = {
+                    provider: instruction.provider,
+                    keyAlias: instruction.keyAlias,
+                    keyIndex: instruction.keyIndex,
+                    model: instruction.model,
+                    pathLength: instruction.pathLength,
+                    processMode: instruction.processMode
+                };
+                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 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),
+        ...(typeof state.chatProcessLastTotalTokens === 'number'
+            ? { chatProcessLastTotalTokens: state.chatProcessLastTotalTokens }
+            : {}),
+        ...(typeof state.chatProcessLastInputTokens === 'number'
+            ? { chatProcessLastInputTokens: state.chatProcessLastInputTokens }
+            : {}),
+        ...(typeof state.chatProcessLastMessageCount === 'number'
+            ? { chatProcessLastMessageCount: state.chatProcessLastMessageCount }
+            : {}),
+        ...(typeof state.chatProcessLastUpdatedAt === 'number'
+            ? { chatProcessLastUpdatedAt: state.chatProcessLastUpdatedAt }
+            : {})
+    };
+}
+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,
+        chatProcessLastTotalTokens: undefined,
+        chatProcessLastInputTokens: undefined,
+        chatProcessLastMessageCount: undefined,
+        chatProcessLastUpdatedAt: 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);
+    if (typeof data.chatProcessLastTotalTokens === 'number' && Number.isFinite(data.chatProcessLastTotalTokens)) {
+        state.chatProcessLastTotalTokens = Math.max(0, Math.round(data.chatProcessLastTotalTokens));
+    }
+    if (typeof data.chatProcessLastInputTokens === 'number' && Number.isFinite(data.chatProcessLastInputTokens)) {
+        state.chatProcessLastInputTokens = Math.max(0, Math.round(data.chatProcessLastInputTokens));
+    }
+    if (typeof data.chatProcessLastMessageCount === 'number' && Number.isFinite(data.chatProcessLastMessageCount)) {
+        state.chatProcessLastMessageCount = Math.max(0, Math.round(data.chatProcessLastMessageCount));
+    }
+    if (typeof data.chatProcessLastUpdatedAt === 'number' && Number.isFinite(data.chatProcessLastUpdatedAt)) {
+        state.chatProcessLastUpdatedAt = Math.max(0, Math.round(data.chatProcessLastUpdatedAt));
+    }
+    return state;
+}