@jsonstudio/llms 0.6.2172 → 0.6.3214

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

@@ -0,0 +1,245 @@
+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
+    };
+    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 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;
+}

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

@@ -0,0 +1,70 @@
+export declare const ROUTING_INSTRUCTION_MARKER_PATTERN: RegExp;
+export declare const ROUTING_INSTRUCTION_MARKER_GLOBAL_PATTERN: RegExp;
+export interface RoutingInstruction {
+    type: 'force' | 'sticky' | 'prefer' | 'disable' | 'enable' | 'clear' | 'allow' | 'stopMessageSet' | 'stopMessageMode' | 'stopMessageClear' | 'preCommandSet' | 'preCommandClear';
+    provider?: string;
+    keyAlias?: string;
+    keyIndex?: number;
+    model?: string;
+    pathLength?: number;
+    processMode?: 'chat' | 'passthrough';
+    stopMessageText?: string;
+    stopMessageMaxRepeats?: number;
+    stopMessageStageMode?: 'on' | 'off' | 'auto';
+    stopMessageAiMode?: 'on' | 'off';
+    stopMessageSource?: string;
+    /**
+     * True when the instruction is parsed from an older user message
+     * (not the latest user turn in current request).
+     */
+    fromHistoricalUserMessage?: boolean;
+    preCommandScriptPath?: string;
+}
+export interface RoutingInstructionState {
+    forcedTarget?: {
+        provider?: string;
+        keyAlias?: string;
+        keyIndex?: number;
+        model?: string;
+        pathLength?: number;
+        processMode?: 'chat' | 'passthrough';
+    };
+    stickyTarget?: {
+        provider?: string;
+        keyAlias?: string;
+        keyIndex?: number;
+        model?: string;
+        pathLength?: number;
+        processMode?: 'chat' | 'passthrough';
+    };
+    preferTarget?: {
+        provider?: string;
+        keyAlias?: string;
+        keyIndex?: number;
+        model?: string;
+        pathLength?: number;
+        processMode?: 'chat' | 'passthrough';
+    };
+    allowedProviders: Set<string>;
+    disabledProviders: Set<string>;
+    disabledKeys: Map<string, Set<string | number>>;
+    disabledModels: Map<string, Set<string>>;
+    /**
+     * Source of the current stopMessage configuration.
+     * - 'explicit'：由用户通过 <** stopMessage:"..." **> 指令显式设置
+     * - 'auto'：由系统基于空响应/错误自动推导（例如 Gemini 空回复）
+     */
+    stopMessageSource?: string;
+    stopMessageText?: string;
+    stopMessageMaxRepeats?: number;
+    stopMessageUsed?: number;
+    stopMessageUpdatedAt?: number;
+    stopMessageLastUsedAt?: number;
+    stopMessageStageMode?: 'on' | 'off' | 'auto';
+    stopMessageAiMode?: 'on' | 'off';
+    stopMessageAiSeedPrompt?: string;
+    stopMessageAiHistory?: Array<Record<string, unknown>>;
+    preCommandSource?: string;
+    preCommandScriptPath?: string;
+    preCommandUpdatedAt?: number;
+}

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

@@ -0,0 +1,2 @@
+export const ROUTING_INSTRUCTION_MARKER_PATTERN = /<\*\*[\s\S]*?\*\*>/;
+export const ROUTING_INSTRUCTION_MARKER_GLOBAL_PATTERN = /<\*\*[\s\S]*?\*\*>/g;

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

@@ -1,91 +1,5 @@
-import type { StandardizedMessage } from '../../conversion/hub/types/standardized.js';
-export interface RoutingInstruction {
-    type: 'force' | 'sticky' | 'prefer' | 'disable' | 'enable' | 'clear' | 'allow' | 'stopMessageSet' | 'stopMessageMode' | 'stopMessageClear' | 'preCommandSet' | 'preCommandClear';
-    provider?: string;
-    keyAlias?: string;
-    keyIndex?: number;
-    model?: string;
-    pathLength?: number;
-    processMode?: 'chat' | 'passthrough';
-    stopMessageText?: string;
-    stopMessageMaxRepeats?: number;
-    stopMessageStageMode?: 'on' | 'off' | 'auto';
-    /**
-     * True when the instruction is parsed from an older user message
-     * (not the latest user turn in current request).
-     */
-    fromHistoricalUserMessage?: boolean;
-    preCommandScriptPath?: string;
-}
-export interface RoutingInstructionState {
-    forcedTarget?: {
-        provider?: string;
-        keyAlias?: string;
-        keyIndex?: number;
-        model?: string;
-        pathLength?: number;
-        processMode?: 'chat' | 'passthrough';
-    };
-    stickyTarget?: {
-        provider?: string;
-        keyAlias?: string;
-        keyIndex?: number;
-        model?: string;
-        pathLength?: number;
-        processMode?: 'chat' | 'passthrough';
-    };
-    preferTarget?: {
-        provider?: string;
-        keyAlias?: string;
-        keyIndex?: number;
-        model?: string;
-        pathLength?: number;
-        processMode?: 'chat' | 'passthrough';
-    };
-    allowedProviders: Set<string>;
-    disabledProviders: Set<string>;
-    disabledKeys: Map<string, Set<string | number>>;
-    disabledModels: Map<string, Set<string>>;
-    /**
-     * Source of the current stopMessage configuration.
-     * - 'explicit'：由用户通过 <** stopMessage:"..." **> 指令显式设置
-     * - 'auto'：由系统基于空响应/错误自动推导（例如 Gemini 空回复）
-     */
-    stopMessageSource?: string;
-    stopMessageText?: string;
-    stopMessageMaxRepeats?: number;
-    stopMessageUsed?: number;
-    stopMessageUpdatedAt?: number;
-    stopMessageLastUsedAt?: number;
-    stopMessageStage?: string;
-    stopMessageStageMode?: 'on' | 'off' | 'auto';
-    stopMessageObservationHash?: string;
-    stopMessageObservationStableCount?: number;
-    stopMessageBdWorkState?: string;
-    stopMessageAssignedIssueId?: string;
-    stopMessageAssignedIssueSource?: 'in_progress' | 'ready' | 'open';
-    stopMessageNoTaskSummaryUsed?: boolean;
-    preCommandSource?: string;
-    preCommandScriptPath?: string;
-    preCommandUpdatedAt?: number;
-}
-export declare function parseRoutingInstructions(messages: StandardizedMessage[]): RoutingInstruction[];
-/**
- * 解析并预处理路由指令，优先处理 clear 指令，确保新指令能够覆盖旧状态。
- * 返回清理后的指令列表，移除冗余的 stopMessageSet 指令。
- */
-export declare function parseAndPreprocessRoutingInstructions(messages: StandardizedMessage[]): RoutingInstruction[];
-/**
- * 提取 clear 指令（如果存在）。用于在路由选择前优先执行清理操作。
- * @returns 是否存在 clear 指令
- */
-export declare function extractClearInstruction(messages: StandardizedMessage[]): boolean;
-/**
- * 提取 stopMessageClear 指令（如果存在）。
- * @returns 是否存在 stopMessageClear 指令
- */
-export declare function extractStopMessageClearInstruction(messages: StandardizedMessage[]): boolean;
-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;
+export type { RoutingInstruction, RoutingInstructionState } from './routing-instructions/types.js';
+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';