@jsonstudio/llms 0.6.230 → 0.6.467

package/dist/router/virtual-router/features.js

@@ -14,7 +14,7 @@ export function buildRoutingFeatures(request, metadata) {
     const estimatedTokens = computeRequestTokens(request, latestUserText);
     const hasThinking = detectKeyword(normalizedUserText, THINKING_KEYWORDS);
     const hasVisionTool = detectVisionTool(request);
-    const hasImageAttachment = hasVisionTool && detectImageAttachment(latestUserMessage);
+    const hasImageAttachment = detectImageAttachment(latestUserMessage);
     const hasCodingTool = detectCodingTool(request);
     const hasWebTool = detectWebTool(request);
     const hasThinkingKeyword = hasThinking || detectExtendedThinkingKeyword(normalizedUserText);

package/dist/router/virtual-router/message-utils.js

@@ -37,30 +37,42 @@ export function detectExtendedThinkingKeyword(text) {
 export function detectImageAttachment(message) {
     if (!message)
         return false;
-    if (!message.metadata || typeof message.metadata !== 'object') {
-        return false;
-    }
-    const meta = message.metadata;
-    const attachments = (meta.attachments ?? null);
-    if (Array.isArray(attachments)) {
-        return attachments.some((attachment) => {
-            const candidate = attachment;
-            const typeValue = typeof candidate.type === 'string' ? candidate.type.toLowerCase() : '';
-            const urlValue = typeof candidate.url === 'string'
-                ? candidate.url
-                : typeof candidate.src === 'string'
-                    ? candidate.src
-                    : typeof candidate.image_url === 'string'
-                        ? candidate.image_url
-                        : typeof candidate.image_url?.url === 'string'
-                            ? candidate.image_url.url
-                            : '';
-            return typeValue.includes('image') && urlValue.trim().length > 0;
-        });
-    }
-    if (typeof meta.attachmentType === 'string' && meta.attachmentType.toLowerCase().includes('image')) {
-        const urlCandidate = typeof meta.attachmentUrl === 'string' ? meta.attachmentUrl : '';
-        return urlCandidate.trim().length > 0;
+    // 仅基于标准 Chat 语义判断是否携带图片：
+    // - content 为数组时查找 { type: 'image' | 'image_url' | 'input_image', ... } 块；
+    // - 不再依赖 metadata.attachments，也不再用纯文本关键字或剪贴板标记作为信号。
+    if (Array.isArray(message.content)) {
+        for (const part of message.content) {
+            if (!part || typeof part !== 'object') {
+                continue;
+            }
+            const record = part;
+            const typeValue = typeof record.type === 'string' ? record.type.toLowerCase() : '';
+            // For chat/standardized content, images may appear as:
+            // - { type: "image_url", image_url: { url } }
+            // - { type: "image", uri: "...", data: "...", url: "..." }
+            // - { type: "input_image", image_url: "data:..." }
+            // Treat any non-empty URL/URI/data on an image-* block as a signal.
+            let imageCandidate = '';
+            if (typeof record.image_url === 'string') {
+                imageCandidate = record.image_url ?? '';
+            }
+            else if (record.image_url &&
+                typeof record.image_url?.url === 'string') {
+                imageCandidate = record.image_url?.url ?? '';
+            }
+            else if (typeof record.url === 'string') {
+                imageCandidate = record.url ?? '';
+            }
+            else if (typeof record.uri === 'string') {
+                imageCandidate = record.uri ?? '';
+            }
+            else if (typeof record.data === 'string') {
+                imageCandidate = record.data ?? '';
+            }
+            if (typeValue.includes('image') && imageCandidate.trim().length > 0) {
+                return true;
+            }
+        }
     }
     return false;
 }

package/dist/router/virtual-router/provider-registry.d.ts

@@ -0,0 +1,15 @@
+import type { ProviderProfile, TargetMetadata } 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[];
+    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/dist/router/virtual-router/provider-registry.js

@@ -28,6 +28,46 @@ export class ProviderRegistry {
     listKeys() {
         return Array.from(this.providers.keys());
     }
+    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);
@@ -62,7 +102,8 @@ export class ProviderRegistry {
             processMode: profile.processMode || 'chat',
             responsesConfig: profile.responsesConfig,
             streaming: profile.streaming,
-            maxContextTokens: profile.maxContextTokens
+            maxContextTokens: profile.maxContextTokens,
+            ...(profile.serverToolsDisabled ? { serverToolsDisabled: true } : {})
         };
     }
 }

package/dist/router/virtual-router/routing-instructions.d.ts

@@ -0,0 +1,34 @@
+import type { StandardizedMessage } from '../../conversion/hub/types/standardized.js';
+export interface RoutingInstruction {
+    type: 'force' | 'sticky' | 'disable' | 'enable' | 'clear' | 'allow';
+    provider?: string;
+    keyAlias?: string;
+    keyIndex?: number;
+    model?: string;
+    pathLength?: number;
+}
+export interface RoutingInstructionState {
+    forcedTarget?: {
+        provider?: string;
+        keyAlias?: string;
+        keyIndex?: number;
+        model?: string;
+        pathLength?: number;
+    };
+    stickyTarget?: {
+        provider?: string;
+        keyAlias?: string;
+        keyIndex?: number;
+        model?: string;
+        pathLength?: number;
+    };
+    allowedProviders: Set<string>;
+    disabledProviders: Set<string>;
+    disabledKeys: Map<string, Set<string | number>>;
+    disabledModels: Map<string, Set<string>>;
+}
+export declare function parseRoutingInstructions(messages: StandardizedMessage[]): RoutingInstruction[];
+export declare function applyRoutingInstructions(instructions: RoutingInstruction[], currentState: RoutingInstructionState): RoutingInstructionState;
+export declare function cleanMessagesFromRoutingInstructions(messages: StandardizedMessage[]): StandardizedMessage[];
+export declare function serializeRoutingInstructionState(state: RoutingInstructionState): Record<string, unknown>;
+export declare function deserializeRoutingInstructionState(data: Record<string, unknown>): RoutingInstructionState;

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

@@ -0,0 +1,383 @@
+import { extractMessageText } from './message-utils.js';
+export function parseRoutingInstructions(messages) {
+    const instructions = [];
+    // 从最新一条携带路由指令标记（<** ... **>）的 user 消息中解析指令，
+    // 而不是简单地取“最后一条 user 消息”。这样可以在服务重启后，通过完整
+    // 会话历史恢复 sticky/黑名单状态，同时保持“最后一次指令生效”的语义。
+    let sanitized = null;
+    for (let idx = messages.length - 1; idx >= 0; idx -= 1) {
+        const message = messages[idx];
+        if (!message || message.role !== 'user') {
+            continue;
+        }
+        const content = extractMessageText(message);
+        if (!content) {
+            continue;
+        }
+        const candidate = stripCodeSegments(content);
+        if (!candidate) {
+            continue;
+        }
+        if (!/<\*\*[^*]+\*\*>/.test(candidate)) {
+            continue;
+        }
+        sanitized = candidate;
+        break;
+    }
+    if (!sanitized) {
+        return instructions;
+    }
+    const regex = /<\*\*([^*]+)\*\*>/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 instructions;
+}
+function expandInstructionSegments(instruction) {
+    const trimmed = instruction.trim();
+    if (!trimmed) {
+        return [];
+    }
+    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}`);
+    }
+    return splitInstructionTargets(trimmed);
+}
+function splitInstructionTargets(content) {
+    return content
+        .split(',')
+        .map((segment) => segment.trim())
+        .filter((segment) => segment.length > 0);
+}
+function parseSingleInstruction(instruction) {
+    if (instruction === 'clear') {
+        return { type: 'clear' };
+    }
+    if (instruction.startsWith('!')) {
+        const target = instruction.substring(1).trim();
+        if (!target) {
+            return null;
+        }
+        const parsed = parseTarget(target);
+        if (!parsed) {
+            return null;
+        }
+        // 约定：
+        // - "!providerA,providerB"：允许列表（whitelist），用于快速限制可用 provider 集合；
+        // - "!provider.model" / "!provider.alias.model" / "!provider.2"：sticky 语义，按 provider / alias / model 过滤当前路由池。
+        //
+        // 这样可以在不破坏既有 "!glm,openai" 语义的前提下，引入基于模型 / alias 的 sticky 行为。
+        if (!target.includes('.')) {
+            if (parsed.provider) {
+                return { type: 'allow', provider: parsed.provider, pathLength: parsed.pathLength };
+            }
+            return null;
+        }
+        const normalized = normalizeStickyOrForceTarget(parsed);
+        return { type: 'sticky', ...normalized };
+    }
+    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 };
+        }
+    }
+    return null;
+}
+function parseTarget(target) {
+    if (!target) {
+        return null;
+    }
+    const parts = target.split('.');
+    const pathLength = parts.length;
+    if (parts.length === 0) {
+        return null;
+    }
+    const provider = parts[0];
+    if (!provider || !isValidIdentifier(provider)) {
+        return null;
+    }
+    if (parts.length === 1) {
+        return { provider, pathLength };
+    }
+    if (parts.length === 2) {
+        const second = parts[1];
+        const keyIndex = parseInt(second, 10);
+        if (!isNaN(keyIndex) && keyIndex > 0) {
+            return { provider, keyIndex, pathLength };
+        }
+        if (isValidIdentifier(second)) {
+            return { provider, model: second, keyAlias: second, pathLength };
+        }
+        return null;
+    }
+    if (parts.length === 3) {
+        const keyAlias = parts[1];
+        const model = parts[2];
+        if (isValidIdentifier(keyAlias) && isValidIdentifier(model)) {
+            return { provider, keyAlias, model, pathLength };
+        }
+        return null;
+    }
+    return null;
+}
+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,
+        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)]))
+    };
+    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
+                };
+                // 保留 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
+                };
+                newState.forcedTarget = 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.allowedProviders.clear();
+                newState.disabledProviders.clear();
+                newState.disabledKeys.clear();
+                newState.disabledModels.clear();
+                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(/<\*\*[^*]+\*\*>/g, '').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,
+        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)
+        }))
+    };
+}
+export function deserializeRoutingInstructionState(data) {
+    const state = {
+        forcedTarget: undefined,
+        stickyTarget: undefined,
+        allowedProviders: new Set(),
+        disabledProviders: new Set(),
+        disabledKeys: new Map(),
+        disabledModels: new Map()
+    };
+    if (data.forcedTarget && typeof data.forcedTarget === 'object') {
+        state.forcedTarget = data.forcedTarget;
+    }
+    if (data.stickyTarget && typeof data.stickyTarget === 'object') {
+        state.stickyTarget = data.stickyTarget;
+    }
+    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));
+            }
+        }
+    }
+    return state;
+}

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

@@ -0,0 +1,3 @@
+import type { RoutingInstructionState } from './routing-instructions.js';
+export declare function loadRoutingInstructionStateSync(key: string | undefined): RoutingInstructionState | null;
+export declare function saveRoutingInstructionStateAsync(key: string | undefined, state: RoutingInstructionState | null): void;

package/dist/router/virtual-router/sticky-session-store.js

@@ -0,0 +1,110 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import os from 'node:os';
+import { serializeRoutingInstructionState, deserializeRoutingInstructionState } from './routing-instructions.js';
+function isPersistentKey(key) {
+    if (!key)
+        return false;
+    return key.startsWith('session:') || key.startsWith('conversation:');
+}
+function resolveSessionDir() {
+    try {
+        const override = process.env.ROUTECODEX_SESSION_DIR;
+        if (override && override.trim()) {
+            return override.trim();
+        }
+        const home = os.homedir();
+        if (!home) {
+            return null;
+        }
+        return path.join(home, '.routecodex', 'sessions');
+    }
+    catch {
+        return null;
+    }
+}
+function keyToFilename(key) {
+    if (!isPersistentKey(key)) {
+        return null;
+    }
+    const idx = key.indexOf(':');
+    if (idx <= 0 || idx === key.length - 1) {
+        return null;
+    }
+    const scope = key.substring(0, idx); // "session" | "conversation"
+    const rawId = key.substring(idx + 1);
+    const safeId = rawId.replace(/[^a-zA-Z0-9_.-]/g, '_');
+    return `${scope}-${safeId}.json`;
+}
+export function loadRoutingInstructionStateSync(key) {
+    if (!isPersistentKey(key)) {
+        return null;
+    }
+    const dir = resolveSessionDir();
+    const filename = keyToFilename(key);
+    if (!dir || !filename) {
+        return null;
+    }
+    const filepath = path.join(dir, filename);
+    try {
+        if (!fs.existsSync(filepath)) {
+            return null;
+        }
+        const raw = fs.readFileSync(filepath, 'utf8');
+        if (!raw) {
+            return null;
+        }
+        const parsed = JSON.parse(raw);
+        const payload = parsed && typeof parsed.version === 'number'
+            ? parsed.state
+            : parsed;
+        if (!payload || typeof payload !== 'object') {
+            return null;
+        }
+        return deserializeRoutingInstructionState(payload);
+    }
+    catch {
+        return null;
+    }
+}
+export function saveRoutingInstructionStateAsync(key, state) {
+    if (!isPersistentKey(key)) {
+        return;
+    }
+    const dir = resolveSessionDir();
+    const filename = keyToFilename(key);
+    if (!dir || !filename) {
+        return;
+    }
+    const filepath = path.join(dir, filename);
+    // 空状态意味着清除持久化文件
+    if (!state) {
+        try {
+            fs.unlink(filepath, () => {
+                // ignore errors (e.g. ENOENT)
+            });
+        }
+        catch {
+            // ignore sync unlink failures
+        }
+        return;
+    }
+    const payload = {
+        version: 1,
+        state: serializeRoutingInstructionState(state)
+    };
+    try {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    catch {
+        // ignore mkdir errors; write below will fail silently
+    }
+    try {
+        fs.writeFile(filepath, JSON.stringify(payload), { encoding: 'utf8' }, () => {
+            // ignore async write errors
+        });
+    }
+    catch {
+        // ignore sync write failures
+    }
+}