@jsonstudio/llms 0.6.375 → 0.6.467

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);

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
+    }
+}

package/dist/router/virtual-router/tool-signals.js

@@ -85,22 +85,6 @@ const SHELL_WRITE_PATTERNS = [
     'go install',
     'make install'
 ];
-const SHELL_SEARCH_PATTERNS = [
-    'rg ',
-    'rg-',
-    'grep ',
-    'grep-',
-    'ripgrep',
-    'find ',
-    'fd ',
-    'locate ',
-    'search ',
-    'ack ',
-    'ag ',
-    'where ',
-    'which ',
-    'codesearch'
-];
 const SHELL_READ_PATTERNS = [
     'ls',
     'dir ',
@@ -362,9 +346,6 @@ function classifyShellCommand(command) {
     if (segments.some((segment) => matchesAnyPattern(segment, SHELL_WRITE_PATTERNS))) {
         return 'write';
     }
-    if (segments.some((segment) => matchesAnyPattern(segment, SHELL_SEARCH_PATTERNS))) {
-        return 'search';
-    }
     if (segments.some((segment) => matchesAnyPattern(segment, SHELL_READ_PATTERNS))) {
         return 'read';
     }
@@ -372,9 +353,6 @@ function classifyShellCommand(command) {
     if (matchesAnyPattern(stripped, SHELL_WRITE_PATTERNS)) {
         return 'write';
     }
-    if (matchesAnyPattern(stripped, SHELL_SEARCH_PATTERNS)) {
-        return 'search';
-    }
     if (matchesAnyPattern(stripped, SHELL_READ_PATTERNS)) {
         return 'read';
     }

package/dist/router/virtual-router/types.d.ts

@@ -5,6 +5,7 @@ import type { StandardizedRequest } from '../../conversion/hub/types/standardize
 export declare const DEFAULT_MODEL_CONTEXT_TOKENS = 200000;
 export declare const DEFAULT_ROUTE = "default";
 export declare const ROUTE_PRIORITY: string[];
+export type RoutingInstructionMode = 'force' | 'sticky' | 'none';
 export interface RoutePoolTier {
     id: string;
     targets: string[];
@@ -167,6 +168,40 @@ export interface RouterMetadataInput {
      * serverToolsDisabled when this flag is true.
      */
     serverToolRequired?: boolean;
+    /**
+     * 强制路由模式，从消息中的 <**...**> 指令解析得出
+     */
+    routingMode?: RoutingInstructionMode;
+    /**
+     * 允许的 provider 白名单
+     */
+    allowedProviders?: string[];
+    /**
+     * 强制使用的 provider model (格式: provider.model)
+     */
+    forcedProviderModel?: string;
+    /**
+     * 强制使用的 provider keyAlias
+     */
+    forcedProviderKeyAlias?: string;
+    /**
+     * 强制使用的 provider keyIndex (从 1 开始)
+     */
+    forcedProviderKeyIndex?: number;
+    /**
+     * 禁用的 provider model 列表
+     */
+    disabledProviderModels?: string[];
+    /**
+     * 禁用的 provider keyAlias 列表
+     */
+    disabledProviderKeyAliases?: string[];
+    /**
+     * 禁用的 provider keyIndex 列表 (从 1 开始)
+     */
+    disabledProviderKeyIndexes?: number[];
+    sessionId?: string;
+    conversationId?: string;
     responsesResume?: {
         previousRequestId?: string;
         restoredFromResponseId?: string;