@jsonstudio/llms 0.6.1892 → 0.6.2172

package/dist/conversion/shared/tool-governor.js

@@ -107,6 +107,112 @@ function injectNestedApplyPatchPolicyNotice(messages, rewriteCount) {
         content: buildNestedApplyPatchPolicyNotice(rewriteCount)
     });
 }
+function shellSingleQuote(text) {
+    return `'${String(text || '').replace(/'/g, `'\\''`)}'`;
+}
+function buildExecCommandGuardScript(reason, message) {
+    const fallback = 'blocked by exec_command guard policy.';
+    const detail = reason === 'forbidden_git_reset_hard'
+        ? 'blocked by exec_command guard: git reset --hard is forbidden. Use git reset --mixed REF or git restore --source REF -- FILE.'
+        : reason === 'forbidden_git_checkout_scope'
+            ? 'blocked by exec_command guard: git checkout is allowed only for a single file. Use git checkout -- FILE or git checkout REF -- FILE.'
+            : message && message.trim()
+                ? `blocked by exec_command guard: ${message.trim()}`
+                : fallback;
+    const compact = detail.replace(/\s+/g, ' ').trim() || fallback;
+    return `bash -lc "printf '%s\\n' ${shellSingleQuote(compact)} >&2; exit 2"`;
+}
+function buildBlockedExecCommandArgs(rawArgs, reason, message) {
+    let parsed = {};
+    try {
+        const repaired = repairArgumentsToString(rawArgs);
+        try {
+            parsed = JSON.parse(repaired);
+        }
+        catch {
+            parsed = parseLenient(repaired);
+        }
+    }
+    catch {
+        parsed = {};
+    }
+    const out = {};
+    if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+        const workdir = typeof parsed.workdir === 'string'
+            ? parsed.workdir
+            : typeof parsed.cwd === 'string'
+                ? parsed.cwd
+                : undefined;
+        if (workdir && workdir.trim().length > 0) {
+            out.workdir = workdir.trim();
+        }
+    }
+    out.cmd = buildExecCommandGuardScript(reason, message);
+    try {
+        return JSON.stringify(out);
+    }
+    catch {
+        return JSON.stringify({
+            cmd: `bash -lc 'printf "%s\\n" "blocked by exec_command guard policy." >&2; exit 2'`
+        });
+    }
+}
+const EXEC_COMMAND_NAME_AS_COMMAND_PATTERN = /^(?:rg|wc|cat|ls|find|grep|git|sed|head|tail|awk|bash|sh|zsh|node|npm|pnpm|yarn|bd|echo|cp|mv|rm|mkdir|python|python3|perl|ruby)\b/i;
+function repairCommandNameAsExecToolCall(fn) {
+    try {
+        if (!fn)
+            return false;
+        const rawName = typeof fn.name === 'string' ? String(fn.name).trim() : '';
+        if (!rawName)
+            return false;
+        const lowered = rawName.toLowerCase();
+        if (lowered === 'exec_command' || lowered === 'shell_command' || lowered === 'shell' || lowered === 'bash') {
+            return false;
+        }
+        // Malformed shape seen in the wild: command string is put into function.name.
+        if (!EXEC_COMMAND_NAME_AS_COMMAND_PATTERN.test(rawName)) {
+            return false;
+        }
+        const repaired = repairArgumentsToString(fn.arguments);
+        let parsed;
+        try {
+            parsed = JSON.parse(repaired);
+        }
+        catch {
+            parsed = parseLenient(repaired);
+        }
+        const argsObj = parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+            ? { ...parsed }
+            : {};
+        const existingCmd = typeof argsObj.cmd === 'string' && String(argsObj.cmd).trim().length
+            ? String(argsObj.cmd).trim()
+            : typeof argsObj.command === 'string' && String(argsObj.command).trim().length
+                ? String(argsObj.command).trim()
+                : '';
+        const cmd = existingCmd || rawName;
+        argsObj.cmd = cmd;
+        argsObj.command = cmd;
+        if (typeof argsObj.cwd === 'string' && (!argsObj.workdir || typeof argsObj.workdir !== 'string')) {
+            argsObj.workdir = String(argsObj.cwd);
+        }
+        const validation = validateToolCall('exec_command', JSON.stringify(argsObj));
+        if (validation.ok && typeof validation.normalizedArgs === 'string') {
+            fn.arguments = validation.normalizedArgs;
+        }
+        else {
+            const fallback = { cmd, command: cmd };
+            if (typeof argsObj.workdir === 'string' && String(argsObj.workdir).trim().length > 0) {
+                fallback.workdir = String(argsObj.workdir).trim();
+            }
+            fn.arguments = JSON.stringify(fallback);
+        }
+        fn.name = 'exec_command';
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 function tryWriteSnapshot(options, stage, data) {
     try {
         // 仅在 verbose 级别保存快照（环境变量）
@@ -332,6 +438,7 @@ export function normalizeApplyPatchToolCallsOnResponse(chat) {
             for (const tc of tcs) {
                 try {
                     const fn = tc && tc.function ? tc.function : undefined;
+                    repairCommandNameAsExecToolCall(fn);
                     rewriteExecCommandApplyPatchCall(fn);
                     const name = typeof fn?.name === 'string' ? String(fn.name).trim().toLowerCase() : '';
                     if (name !== 'apply_patch')
@@ -409,6 +516,7 @@ function normalizeSpecialToolCallsOnRequest(request) {
             for (const tc of tcs) {
                 try {
                     const fn = tc && tc.function ? tc.function : undefined;
+                    repairCommandNameAsExecToolCall(fn);
                     if (rewriteExecCommandApplyPatchCall(fn)) {
                         rewrittenNestedApplyPatchCount += 1;
                     }
@@ -447,21 +555,30 @@ function normalizeSpecialToolCallsOnRequest(request) {
                     // exec_command 兼容：TOON / map / string 一律收敛为 { cmd, command, workdir, ... }
                     if (name === 'exec_command') {
                         const argsStr = repairArgumentsToString(rawArgs);
-                        let parsed;
-                        try {
-                            parsed = JSON.parse(argsStr);
+                        const validation = validateToolCall('exec_command', argsStr);
+                        if (validation && validation.ok && typeof validation.normalizedArgs === 'string') {
+                            fn.arguments = validation.normalizedArgs;
                         }
-                        catch {
-                            parsed = parseLenient(argsStr);
+                        else if (validation && !validation.ok) {
+                            fn.arguments = buildBlockedExecCommandArgs(rawArgs, validation.reason, validation.message);
                         }
-                        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
-                            const normalized = normalizeExecCommandArgs(parsed);
-                            const next = normalized.ok ? normalized.normalized : parsed;
+                        else {
+                            let parsed;
                             try {
-                                fn.arguments = JSON.stringify(next ?? {});
+                                parsed = JSON.parse(argsStr);
                             }
                             catch {
-                                fn.arguments = '{}';
+                                parsed = parseLenient(argsStr);
+                            }
+                            if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+                                const normalized = normalizeExecCommandArgs(parsed);
+                                const next = normalized.ok ? normalized.normalized : parsed;
+                                try {
+                                    fn.arguments = JSON.stringify(next ?? {});
+                                }
+                                catch {
+                                    fn.arguments = '{}';
+                                }
                             }
                         }
                     }
@@ -568,6 +685,15 @@ function enhanceResponseToolArguments(chat) {
                             }
                         }
                     }
+                    else if (name === 'exec_command') {
+                        const validation = validateToolCall('exec_command', repaired);
+                        if (validation.ok && typeof validation.normalizedArgs === 'string') {
+                            finalStr = validation.normalizedArgs;
+                        }
+                        else if (!validation.ok) {
+                            finalStr = buildBlockedExecCommandArgs(repaired, validation.reason, validation.message);
+                        }
+                    }
                     if (fn)
                         fn.arguments = finalStr;
                 }

package/dist/filters/utils/snapshot-writer.js

@@ -2,10 +2,10 @@ import os from 'node:os';
 import path from 'node:path';
 import * as fsp from 'node:fs/promises';
 function mapEndpointToFolder(ep) {
-    const e = String(ep || '').toLowerCase();
-    if (e.includes('/v1/responses'))
+    const e = String(ep || '').trim().toLowerCase();
+    if (e.includes('/v1/responses') || e.includes('/responses.submit'))
         return 'openai-responses';
-    if (e.includes('/v1/messages') || e.includes('anthropic'))
+    if (e.includes('/v1/messages'))
         return 'anthropic-messages';
     return 'openai-chat';
 }

package/dist/router/virtual-router/bootstrap/auth-utils.d.ts

@@ -0,0 +1,6 @@
+import { type ProviderAuthConfig } from '../types.js';
+export interface ProviderAuthEntry {
+    keyAlias: string;
+    auth: ProviderAuthConfig;
+}
+export declare function extractProviderAuthEntries(providerId: string, raw: unknown): ProviderAuthEntry[];

package/dist/router/virtual-router/bootstrap/auth-utils.js

@@ -0,0 +1,288 @@
+import { scanDeepSeekAccountTokenFiles, scanOAuthTokenFiles } from '../token-file-scanner.js';
+import { VirtualRouterError, VirtualRouterErrorCode } from '../types.js';
+import { asRecord, normalizeAlias, pushUnique, readOptionalString } from './utils.js';
+const MULTI_TOKEN_OAUTH_PROVIDERS = new Set(['iflow', 'qwen', 'gemini-cli', 'antigravity']);
+export function extractProviderAuthEntries(providerId, raw) {
+    const provider = asRecord(raw);
+    const auth = asRecord(provider.auth);
+    const entries = [];
+    const aliasSet = new Set();
+    const baseTypeInfo = interpretAuthType(auth.type);
+    const baseType = baseTypeInfo.type;
+    const baseTypeSource = typeof auth.type === 'string' ? auth.type : undefined;
+    const defaults = collectAuthDefaults(auth);
+    const buildAuthCandidate = (typeHint, extras = {}) => {
+        const source = typeof typeHint === 'string' && typeHint.trim() ? typeHint.trim() : baseTypeSource;
+        const typeInfo = interpretAuthType(source ?? baseType);
+        const rawType = typeInfo.raw ?? source ?? baseTypeSource;
+        return {
+            ...extras,
+            type: typeInfo.type,
+            rawType,
+            oauthProviderId: extras.oauthProviderId ?? typeInfo.oauthProviderId
+        };
+    };
+    const pushEntry = (candidateAlias, authConfig) => {
+        const alias = normalizeAlias(candidateAlias, aliasSet);
+        const typeSource = authConfig.rawType ?? authConfig.type ?? baseTypeSource ?? baseType;
+        const typeInfo = interpretAuthType(typeSource);
+        const entryType = typeInfo.type;
+        const oauthProviderId = authConfig.oauthProviderId ?? typeInfo.oauthProviderId ?? baseTypeInfo.oauthProviderId;
+        if (entryType === 'oauth' && !oauthProviderId) {
+            throw new VirtualRouterError(`Provider ${providerId} OAuth auth entries must declare provider-specific type (e.g. "qwen-oauth")`, VirtualRouterErrorCode.CONFIG_ERROR);
+        }
+        const normalized = {
+            type: entryType,
+            rawType: typeof typeSource === 'string' ? typeSource : undefined,
+            oauthProviderId,
+            value: readOptionalString(authConfig.value ?? authConfig.apiKey),
+            secretRef: readOptionalString(authConfig.secretRef)
+        };
+        normalized.tokenFile = readOptionalString(authConfig.tokenFile);
+        normalized.tokenUrl = readOptionalString(authConfig.tokenUrl ?? authConfig.token_url);
+        normalized.deviceCodeUrl = readOptionalString(authConfig.deviceCodeUrl ?? authConfig.device_code_url);
+        normalized.clientId = readOptionalString(authConfig.clientId ?? authConfig.client_id);
+        normalized.clientSecret = readOptionalString(authConfig.clientSecret ?? authConfig.client_secret);
+        normalized.authorizationUrl = readOptionalString(authConfig.authorizationUrl ??
+            authConfig.authorization_url ??
+            authConfig.authUrl);
+        normalized.userInfoUrl = readOptionalString(authConfig.userInfoUrl ?? authConfig.user_info_url);
+        normalized.refreshUrl = readOptionalString(authConfig.refreshUrl ?? authConfig.refresh_url);
+        normalized.scopes = normalizeScopeList(authConfig.scopes ?? authConfig.scope);
+        normalized.secretRef ??= defaults.secretRef;
+        normalized.tokenFile ??= defaults.tokenFile;
+        normalized.tokenUrl ??= defaults.tokenUrl;
+        normalized.deviceCodeUrl ??= defaults.deviceCodeUrl;
+        normalized.clientId ??= defaults.clientId;
+        normalized.clientSecret ??= defaults.clientSecret;
+        normalized.authorizationUrl ??= defaults.authorizationUrl;
+        normalized.userInfoUrl ??= defaults.userInfoUrl;
+        normalized.refreshUrl ??= defaults.refreshUrl;
+        normalized.scopes = mergeScopes(normalized.scopes, defaults.scopes);
+        if (entryType === 'apiKey' && !normalized.secretRef) {
+            normalized.secretRef = `${providerId}.${alias}`;
+        }
+        entries.push({ keyAlias: alias, auth: normalized });
+        aliasSet.add(alias);
+    };
+    const fromRecord = (record) => {
+        const data = asRecord(record);
+        const alias = readOptionalString(data.alias);
+        const typeValue = data.type ?? baseTypeSource ?? baseType;
+        pushEntry(alias, buildAuthCandidate(typeValue, {
+            value: data.value ?? data.apiKey,
+            secretRef: data.secretRef,
+            tokenFile: data.tokenFile,
+            tokenUrl: data.tokenUrl ?? data.token_url,
+            deviceCodeUrl: data.deviceCodeUrl ?? data.device_code_url,
+            clientId: data.clientId ?? data.client_id,
+            clientSecret: data.clientSecret ?? data.client_secret,
+            authorizationUrl: data.authorizationUrl ??
+                data.authorization_url ??
+                data.authUrl,
+            userInfoUrl: data.userInfoUrl ?? data.user_info_url,
+            refreshUrl: data.refreshUrl ?? data.refresh_url,
+            scopes: data.scopes ?? data.scope
+        }));
+    };
+    if (Array.isArray(auth.entries)) {
+        for (const entry of auth.entries) {
+            fromRecord(entry);
+        }
+    }
+    if (Array.isArray(auth.keys)) {
+        for (const entry of auth.keys) {
+            fromRecord(entry);
+        }
+    }
+    else {
+        const keysObject = asRecord(auth.keys);
+        for (const [alias, entry] of Object.entries(keysObject)) {
+            if (entry && typeof entry === 'object') {
+                fromRecord({ alias, ...entry });
+            }
+            else if (typeof entry === 'string') {
+                pushEntry(alias, buildAuthCandidate(baseTypeSource, { value: entry }));
+            }
+        }
+    }
+    const apiKeyField = provider.apiKey ?? provider.apiKeys ?? auth.apiKey;
+    if (Array.isArray(apiKeyField)) {
+        for (const item of apiKeyField) {
+            if (typeof item === 'string' && item.trim()) {
+                pushEntry(undefined, buildAuthCandidate(baseTypeSource, { value: item.trim() }));
+            }
+            else if (item && typeof item === 'object') {
+                fromRecord(item);
+            }
+        }
+    }
+    else if (typeof apiKeyField === 'string' && apiKeyField.trim()) {
+        pushEntry(undefined, buildAuthCandidate(baseTypeSource, { value: apiKeyField.trim() }));
+    }
+    const hasExplicitEntries = entries.length > 0;
+    if (baseType === 'oauth' && !hasExplicitEntries) {
+        const scanCandidates = new Set();
+        const pushCandidate = (value) => {
+            if (typeof value === 'string' && value.trim()) {
+                scanCandidates.add(value.trim().toLowerCase());
+            }
+        };
+        pushCandidate(auth.oauthProviderId);
+        pushCandidate(baseTypeInfo.oauthProviderId);
+        pushCandidate(providerId);
+        for (const candidate of scanCandidates) {
+            if (!MULTI_TOKEN_OAUTH_PROVIDERS.has(candidate)) {
+                continue;
+            }
+            const tokenFiles = scanOAuthTokenFiles(candidate);
+            if (!tokenFiles.length) {
+                continue;
+            }
+            const baseTypeAlias = baseTypeInfo.oauthProviderId?.toLowerCase();
+            for (const match of tokenFiles) {
+                const alias = match.alias && match.alias !== 'default'
+                    ? `${match.sequence}-${match.alias}`
+                    : String(match.sequence);
+                const typeHint = baseTypeSource && baseTypeAlias === candidate
+                    ? baseTypeSource
+                    : `${candidate}-oauth`;
+                const authConfig = {
+                    ...defaults,
+                    type: typeHint,
+                    tokenFile: match.filePath,
+                    oauthProviderId: candidate
+                };
+                pushEntry(alias, authConfig);
+            }
+        }
+    }
+    const baseRawType = String(baseTypeInfo.raw ?? baseTypeSource ?? '').trim().toLowerCase();
+    if (baseType === 'apiKey' && baseRawType === 'deepseek-account' && !hasExplicitEntries) {
+        const tokenFiles = scanDeepSeekAccountTokenFiles();
+        for (const match of tokenFiles) {
+            const authConfig = {
+                ...defaults,
+                type: baseTypeSource ?? 'deepseek-account',
+                tokenFile: match.filePath
+            };
+            pushEntry(match.alias, authConfig);
+        }
+    }
+    if (!entries.length) {
+        const fallbackExtras = {
+            value: readOptionalString(auth.value),
+            secretRef: readOptionalString(auth.secretRef),
+            tokenFile: readOptionalString(auth.tokenFile ?? auth.file),
+            tokenUrl: readOptionalString(auth.tokenUrl ?? auth.token_url),
+            deviceCodeUrl: readOptionalString(auth.deviceCodeUrl ?? auth.device_code_url),
+            clientId: readOptionalString(auth.clientId ?? auth.client_id),
+            clientSecret: readOptionalString(auth.clientSecret ?? auth.client_secret),
+            authorizationUrl: readOptionalString(auth.authorizationUrl ?? auth.authorization_url ?? auth.authUrl),
+            userInfoUrl: readOptionalString(auth.userInfoUrl ?? auth.user_info_url),
+            refreshUrl: readOptionalString(auth.refreshUrl ?? auth.refresh_url),
+            scopes: normalizeScopeList(auth.scopes ?? auth.scope),
+            cookieFile: readOptionalString(auth.cookieFile)
+        };
+        const fallbackHasData = Boolean(fallbackExtras.value ||
+            fallbackExtras.secretRef ||
+            fallbackExtras.tokenFile ||
+            fallbackExtras.tokenUrl ||
+            fallbackExtras.deviceCodeUrl ||
+            fallbackExtras.clientId ||
+            fallbackExtras.clientSecret ||
+            fallbackExtras.cookieFile ||
+            (fallbackExtras.scopes &&
+                Array.isArray(fallbackExtras.scopes) &&
+                fallbackExtras.scopes.length));
+        if (fallbackHasData) {
+            pushEntry(undefined, buildAuthCandidate(baseTypeSource, fallbackExtras));
+        }
+    }
+    if (!entries.length && baseType === 'apiKey') {
+        const authDeclared = Object.prototype.hasOwnProperty.call(provider, 'auth') ||
+            Object.prototype.hasOwnProperty.call(provider, 'apiKey') ||
+            Object.prototype.hasOwnProperty.call(provider, 'apiKeys') ||
+            Object.prototype.hasOwnProperty.call(provider, 'authType');
+        if (authDeclared) {
+            pushEntry(undefined, buildAuthCandidate(baseTypeSource, { value: '' }));
+        }
+    }
+    if (!entries.length) {
+        throw new VirtualRouterError(`Provider ${providerId} is missing auth configuration`, VirtualRouterErrorCode.CONFIG_ERROR);
+    }
+    return entries;
+}
+function collectAuthDefaults(auth) {
+    return {
+        secretRef: readOptionalString(auth.secretRef) ?? readOptionalString(auth.file),
+        tokenFile: readOptionalString(auth.tokenFile) ?? readOptionalString(auth.file),
+        tokenUrl: readOptionalString(auth.tokenUrl ?? auth.token_url),
+        deviceCodeUrl: readOptionalString(auth.deviceCodeUrl ?? auth.device_code_url),
+        clientId: readOptionalString(auth.clientId ?? auth.client_id),
+        clientSecret: readOptionalString(auth.clientSecret ?? auth.client_secret),
+        authorizationUrl: readOptionalString(auth.authorizationUrl ?? auth.authorization_url ?? auth.authUrl),
+        userInfoUrl: readOptionalString(auth.userInfoUrl ?? auth.user_info_url),
+        refreshUrl: readOptionalString(auth.refreshUrl ?? auth.refresh_url),
+        scopes: normalizeScopeList(auth.scopes ?? auth.scope)
+    };
+}
+function normalizeScopeList(value) {
+    if (Array.isArray(value)) {
+        const normalized = [];
+        for (const item of value) {
+            const str = readOptionalString(item);
+            if (str) {
+                pushUnique(normalized, str);
+            }
+        }
+        return normalized.length ? normalized : undefined;
+    }
+    if (typeof value === 'string' && value.trim()) {
+        const normalized = value
+            .split(/[,\s]+/)
+            .map((item) => item.trim())
+            .filter(Boolean);
+        return normalized.length ? normalized : undefined;
+    }
+    return undefined;
+}
+function mergeScopes(primary, fallback) {
+    if ((!primary || !primary.length) && (!fallback || !fallback.length)) {
+        return undefined;
+    }
+    const merged = new Set();
+    for (const scope of primary ?? []) {
+        if (scope.trim())
+            merged.add(scope.trim());
+    }
+    for (const scope of fallback ?? []) {
+        if (scope.trim())
+            merged.add(scope.trim());
+    }
+    return merged.size ? Array.from(merged) : undefined;
+}
+function interpretAuthType(value) {
+    if (typeof value !== 'string') {
+        return { type: 'apiKey' };
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return { type: 'apiKey' };
+    }
+    const lower = trimmed.toLowerCase();
+    if (lower === 'apikey' || lower === 'api-key') {
+        return { type: 'apiKey', raw: trimmed };
+    }
+    if (lower === 'oauth') {
+        return { type: 'oauth', raw: trimmed };
+    }
+    const match = lower.match(/^([a-z0-9._-]+)-oauth$/);
+    if (match) {
+        return { type: 'oauth', oauthProviderId: match[1], raw: trimmed };
+    }
+    if (lower.includes('oauth')) {
+        return { type: 'oauth', raw: trimmed };
+    }
+    return { type: 'apiKey', raw: trimmed };
+}

package/dist/router/virtual-router/bootstrap/claude-code-helpers.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Claude Code specific helpers for Virtual Router bootstrap.
+ */
+export declare const CLAUDE_CODE_DEFAULT_USER_AGENT = "claude-cli/2.0.76 (external, cli)";
+export declare const CLAUDE_CODE_DEFAULT_X_APP = "claude-cli";
+export declare const CLAUDE_CODE_DEFAULT_ANTHROPIC_BETA = "claude-code";
+/**
+ * Parse the Claude Code app version from a user agent string.
+ * Returns the version string (e.g., "2.0.76") or null if not found.
+ */
+export declare function parseClaudeCodeAppVersionFromUserAgent(userAgent: string): string | null;

package/dist/router/virtual-router/bootstrap/claude-code-helpers.js

@@ -0,0 +1,18 @@
+/**
+ * Claude Code specific helpers for Virtual Router bootstrap.
+ */
+export const CLAUDE_CODE_DEFAULT_USER_AGENT = 'claude-cli/2.0.76 (external, cli)';
+export const CLAUDE_CODE_DEFAULT_X_APP = 'claude-cli';
+export const CLAUDE_CODE_DEFAULT_ANTHROPIC_BETA = 'claude-code';
+/**
+ * Parse the Claude Code app version from a user agent string.
+ * Returns the version string (e.g., "2.0.76") or null if not found.
+ */
+export function parseClaudeCodeAppVersionFromUserAgent(userAgent) {
+    const ua = typeof userAgent === 'string' ? userAgent.trim() : '';
+    if (!ua)
+        return null;
+    // Example: 'claude-cli/2.0.76 (external, cli)'
+    const match = /claude-cli\/([\d.]+)/.exec(ua);
+    return match?.[1] ?? null;
+}

package/dist/router/virtual-router/bootstrap/config-defaults.d.ts

@@ -0,0 +1,5 @@
+import type { LoadBalancingPolicy, ProviderHealthConfig, VirtualRouterClassifierConfig, VirtualRouterContextRoutingConfig } from '../types.js';
+export declare const DEFAULT_CLASSIFIER: Required<VirtualRouterClassifierConfig>;
+export declare const DEFAULT_LOAD_BALANCING: LoadBalancingPolicy;
+export declare const DEFAULT_HEALTH: ProviderHealthConfig;
+export declare const DEFAULT_CONTEXT_ROUTING: VirtualRouterContextRoutingConfig;

package/dist/router/virtual-router/bootstrap/config-defaults.js

@@ -0,0 +1,13 @@
+export const DEFAULT_CLASSIFIER = {
+    longContextThresholdTokens: 180000,
+    thinkingKeywords: ['think step', 'analysis', 'reasoning', '仔细分析', '深度思考'],
+    codingKeywords: ['apply_patch', 'write_file', 'create_file', 'shell', '修改文件', '写入文件'],
+    backgroundKeywords: ['background', 'context dump', '上下文'],
+    visionKeywords: ['vision', 'image', 'picture', 'photo']
+};
+export const DEFAULT_LOAD_BALANCING = { strategy: 'round-robin' };
+export const DEFAULT_HEALTH = { failureThreshold: 3, cooldownMs: 30_000, fatalCooldownMs: 300_000 };
+export const DEFAULT_CONTEXT_ROUTING = {
+    warnRatio: 0.9,
+    hardLimit: false
+};

package/dist/router/virtual-router/bootstrap/config-normalizers.d.ts

@@ -0,0 +1,4 @@
+import type { VirtualRouterClockConfig, VirtualRouterConfig, VirtualRouterContextRoutingConfig } from '../types.js';
+export declare function normalizeExecCommandGuard(input: unknown): VirtualRouterConfig['execCommandGuard'] | undefined;
+export declare function normalizeClock(raw: unknown): VirtualRouterClockConfig | undefined;
+export declare function normalizeContextRouting(input: unknown): VirtualRouterContextRoutingConfig;

package/dist/router/virtual-router/bootstrap/config-normalizers.js

@@ -0,0 +1,106 @@
+import { DEFAULT_CONTEXT_ROUTING } from './config-defaults.js';
+export function normalizeExecCommandGuard(input) {
+    if (!input || typeof input !== 'object' || Array.isArray(input)) {
+        return undefined;
+    }
+    const record = input;
+    const enabledRaw = record.enabled;
+    const enabled = enabledRaw === true ||
+        (typeof enabledRaw === 'string' && enabledRaw.trim().toLowerCase() === 'true') ||
+        (typeof enabledRaw === 'number' && enabledRaw === 1);
+    if (!enabled) {
+        return undefined;
+    }
+    const policyFileRaw = record.policyFile ?? record.policy_file;
+    const policyFile = typeof policyFileRaw === 'string' && policyFileRaw.trim().length ? policyFileRaw.trim() : undefined;
+    return {
+        enabled: true,
+        ...(policyFile ? { policyFile } : {})
+    };
+}
+export function normalizeClock(raw) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+        return undefined;
+    }
+    const record = raw;
+    const enabled = record.enabled === true ||
+        (typeof record.enabled === 'string' && record.enabled.trim().toLowerCase() === 'true') ||
+        (typeof record.enabled === 'number' && record.enabled === 1);
+    if (!enabled) {
+        return undefined;
+    }
+    const out = { enabled: true };
+    if (typeof record.retentionMs === 'number' && Number.isFinite(record.retentionMs) && record.retentionMs >= 0) {
+        out.retentionMs = Math.floor(record.retentionMs);
+    }
+    if (typeof record.dueWindowMs === 'number' && Number.isFinite(record.dueWindowMs) && record.dueWindowMs >= 0) {
+        out.dueWindowMs = Math.floor(record.dueWindowMs);
+    }
+    if (typeof record.tickMs === 'number' && Number.isFinite(record.tickMs) && record.tickMs >= 0) {
+        out.tickMs = Math.floor(record.tickMs);
+    }
+    if (record.holdNonStreaming === true ||
+        (typeof record.holdNonStreaming === 'string' && record.holdNonStreaming.trim().toLowerCase() === 'true') ||
+        (typeof record.holdNonStreaming === 'number' && record.holdNonStreaming === 1)) {
+        out.holdNonStreaming = true;
+    }
+    if (typeof record.holdMaxMs === 'number' && Number.isFinite(record.holdMaxMs) && record.holdMaxMs >= 0) {
+        out.holdMaxMs = Math.floor(record.holdMaxMs);
+    }
+    return out;
+}
+export function normalizeContextRouting(input) {
+    if (!input || typeof input !== 'object') {
+        return { ...DEFAULT_CONTEXT_ROUTING };
+    }
+    const record = input;
+    const warnCandidate = coerceRatio(record.warnRatio) ?? coerceRatio(record.warn_ratio);
+    const hardLimitCandidate = coerceBoolean(record.hardLimit) ?? coerceBoolean(record.hard_limit);
+    const warnRatio = clampWarnRatio(warnCandidate ?? DEFAULT_CONTEXT_ROUTING.warnRatio);
+    const hardLimit = typeof hardLimitCandidate === 'boolean' ? hardLimitCandidate : DEFAULT_CONTEXT_ROUTING.hardLimit;
+    return {
+        warnRatio,
+        hardLimit
+    };
+}
+function coerceRatio(value) {
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        return value;
+    }
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        if (!trimmed) {
+            return undefined;
+        }
+        const parsed = Number(trimmed);
+        if (Number.isFinite(parsed)) {
+            return parsed;
+        }
+    }
+    return undefined;
+}
+function clampWarnRatio(value) {
+    if (!Number.isFinite(value)) {
+        return DEFAULT_CONTEXT_ROUTING.warnRatio;
+    }
+    const clamped = Math.max(0.1, Math.min(value, 0.99));
+    return Number.isFinite(clamped) ? clamped : DEFAULT_CONTEXT_ROUTING.warnRatio;
+}
+function coerceBoolean(value) {
+    if (typeof value === 'boolean') {
+        return value;
+    }
+    if (typeof value === 'string') {
+        const normalized = value.trim().toLowerCase();
+        if (!normalized) {
+            return undefined;
+        }
+        if (['true', '1', 'yes', 'y'].includes(normalized)) {
+            return true;
+        }
+        if (['false', '0', 'no', 'n'].includes(normalized)) {
+            return false;
+        }
+    }
+    return undefined;
+}

package/dist/router/virtual-router/bootstrap/profile-builder.d.ts

@@ -0,0 +1,7 @@
+import { type ProviderHealthConfig, type ProviderProfile, type ProviderRuntimeProfile } from '../types.js';
+export declare function buildProviderProfiles(targetKeys: Set<string>, runtimeEntries: Record<string, ProviderRuntimeProfile>): {
+    profiles: Record<string, ProviderProfile>;
+    targetRuntime: Record<string, ProviderRuntimeProfile>;
+};
+export declare function resolveContextTokens(runtime: ProviderRuntimeProfile, modelId: string): number;
+export declare function normalizeHealth(input: unknown): ProviderHealthConfig | undefined;