@jsonstudio/llms 0.6.795 → 0.6.802

package/dist/conversion/hub/pipeline/context-limit.d.ts

@@ -0,0 +1,13 @@
+import type { ProcessedRequest, StandardizedRequest } from '../types/standardized.js';
+import type { TargetMetadata } from '../../../router/virtual-router/types.js';
+export declare function enforceTargetContextLimitOrThrow(options: {
+    requestId: string;
+    routeName?: string;
+    target: TargetMetadata;
+    request: StandardizedRequest | ProcessedRequest;
+}): {
+    estimatedInputTokens?: number;
+    maxContextTokens?: number;
+    allowedTokens?: number;
+    safetyRatio?: number;
+};

package/dist/conversion/hub/pipeline/context-limit.js

@@ -0,0 +1,55 @@
+import { computeRequestTokens } from '../../../router/virtual-router/token-estimator.js';
+function readSafetyRatioFromEnv() {
+    const raw = process?.env?.RCC_CONTEXT_TOKEN_SAFETY_RATIO ??
+        process?.env?.ROUTECODEX_CONTEXT_TOKEN_SAFETY_RATIO ??
+        '';
+    const value = Number(raw);
+    if (!Number.isFinite(value)) {
+        return 0;
+    }
+    // Keep within sane bounds; default is 0 (exact limit).
+    return Math.max(0, Math.min(0.5, value));
+}
+export function enforceTargetContextLimitOrThrow(options) {
+    const maxContextTokensRaw = options.target?.maxContextTokens;
+    const maxContextTokens = typeof maxContextTokensRaw === 'number' && Number.isFinite(maxContextTokensRaw) && maxContextTokensRaw > 0
+        ? Math.floor(maxContextTokensRaw)
+        : undefined;
+    if (!maxContextTokens) {
+        return {};
+    }
+    const estimatedInputTokens = computeRequestTokens(options.request, '');
+    if (!(typeof estimatedInputTokens === 'number' && Number.isFinite(estimatedInputTokens) && estimatedInputTokens > 0)) {
+        return { maxContextTokens };
+    }
+    const safetyRatio = readSafetyRatioFromEnv();
+    const allowedTokens = Math.max(1, Math.floor(maxContextTokens * (1 - safetyRatio)));
+    if (estimatedInputTokens >= allowedTokens) {
+        const providerKey = options.target?.providerKey || 'unknown';
+        const modelId = options.target?.modelId || options.request?.model || 'unknown';
+        const routeName = options.routeName || 'unknown';
+        const message = `Context too long for ${providerKey}.${modelId}: ` +
+            `estimatedInputTokens=${estimatedInputTokens} exceeds allowed=${allowedTokens} ` +
+            `(maxContextTokens=${maxContextTokens}, safetyRatio=${safetyRatio}, route=${routeName})`;
+        const err = Object.assign(new Error(message), {
+            name: 'ContextLimitError',
+            code: 'CONTEXT_TOO_LONG',
+            status: 400,
+            requestId: options.requestId,
+            providerKey: options.target?.providerKey,
+            providerType: options.target?.providerType,
+            routeName: options.routeName,
+            details: {
+                estimatedInputTokens,
+                allowedTokens,
+                maxContextTokens,
+                safetyRatio,
+                providerKey: options.target?.providerKey,
+                modelId,
+                routeName
+            }
+        });
+        throw err;
+    }
+    return { estimatedInputTokens, maxContextTokens, allowedTokens, safetyRatio };
+}

package/dist/conversion/shared/snapshot-hooks.js

@@ -110,6 +110,59 @@ function extractNestedGroupRequestId(value) {
     }
     return undefined;
 }
+function extractNestedEntryEndpoint(value) {
+    if (!value || typeof value !== 'object') {
+        return undefined;
+    }
+    const obj = value;
+    const direct = readStringField(obj.entryEndpoint) ||
+        readStringField(obj.entry_endpoint) ||
+        readStringField(obj.endpoint);
+    if (direct) {
+        return direct;
+    }
+    const meta = obj.meta;
+    if (meta && typeof meta === 'object') {
+        const m = meta;
+        const fromMeta = readStringField(m.entryEndpoint) ||
+            readStringField(m.entry_endpoint) ||
+            readStringField(m.endpoint);
+        if (fromMeta) {
+            return fromMeta;
+        }
+        const ctx = m.context;
+        if (ctx && typeof ctx === 'object') {
+            const c = ctx;
+            const fromCtx = readStringField(c.entryEndpoint) ||
+                readStringField(c.entry_endpoint) ||
+                readStringField(c.endpoint);
+            if (fromCtx) {
+                return fromCtx;
+            }
+        }
+    }
+    const metadata = obj.metadata;
+    if (metadata && typeof metadata === 'object') {
+        const md = metadata;
+        const fromMetadata = readStringField(md.entryEndpoint) ||
+            readStringField(md.entry_endpoint) ||
+            readStringField(md.endpoint);
+        if (fromMetadata) {
+            return fromMetadata;
+        }
+    }
+    const runtime = obj.runtime;
+    if (runtime && typeof runtime === 'object') {
+        const r = runtime;
+        const fromRuntime = readStringField(r.entryEndpoint) ||
+            readStringField(r.entry_endpoint) ||
+            readStringField(r.endpoint);
+        if (fromRuntime) {
+            return fromRuntime;
+        }
+    }
+    return undefined;
+}
 function toErrorCode(error) {
     if (!error || typeof error !== 'object') {
         return undefined;
@@ -205,7 +258,7 @@ async function promotePendingDir(options) {
 }
 async function writeSnapshotFile(options) {
     const root = resolveSnapshotRoot();
-    const folder = resolveSnapshotFolder(options.endpoint);
+    const folder = resolveSnapshotFolder(extractNestedEntryEndpoint(options.data) || options.endpoint);
     const stageToken = sanitizeToken(options.stage, 'snapshot');
     const groupRequestToken = sanitizeToken(options.groupRequestId ||
         extractNestedGroupRequestId(options.data) ||

package/dist/router/virtual-router/engine-selection.js

@@ -220,7 +220,11 @@ function trySelectFromTier(routeName, tier, stickyKey, estimatedTokens, features
         targets = targets.filter((key) => !excludedKeys.has(key));
     }
     if (targets.length > 0) {
-        targets = targets.filter((key) => !deps.isProviderCoolingDown(key));
+        const cooled = targets.filter((key) => !deps.isProviderCoolingDown(key));
+        // 单 provider 兜底：当一个 tier 只有一个候选 key 时，不因 cooldown 造成路由池为空。
+        if (cooled.length > 0 || targets.length !== 1) {
+            targets = cooled;
+        }
     }
     if (allowedProviders && allowedProviders.size > 0) {
         targets = targets.filter((key) => {
@@ -331,14 +335,22 @@ function trySelectFromTier(routeName, tier, stickyKey, estimatedTokens, features
     const selectWithQuota = (candidates) => {
         if (!quotaView) {
             if (tier.mode === 'priority') {
-                return selectFirstAvailable(candidates);
+                const selected = selectFirstAvailable(candidates);
+                if (!selected && candidates.length === 1) {
+                    return candidates[0];
+                }
+                return selected;
             }
-            return deps.loadBalancer.select({
+            const selected = deps.loadBalancer.select({
                 routeName: `${routeName}:${tier.id}`,
                 candidates,
                 stickyKey: options.allowAliasRotation ? undefined : stickyKey,
                 availabilityCheck: (key) => deps.healthManager.isAvailable(key)
             }, tier.mode === 'round-robin' ? 'round-robin' : undefined);
+            if (!selected && candidates.length === 1) {
+                return candidates[0];
+            }
+            return selected;
         }
         const buckets = new Map();
         for (const key of candidates) {
@@ -389,6 +401,33 @@ function trySelectFromTier(routeName, tier, stickyKey, estimatedTokens, features
                 }
             }
         }
+        // default 路由永不因 quota gating 而“空池”：
+        // 当 quotaView 过滤后没有任何可用候选时，默认路由允许忽略 quotaView，
+        // 继续按健康/负载均衡选择一个 providerKey（但不覆盖 forced/required 约束）。
+        const quotaBypassAllowed = routeName === DEFAULT_ROUTE && (!requiredProviderKeys || requiredProviderKeys.size === 0);
+        if (quotaBypassAllowed) {
+            if (tier.mode === 'priority') {
+                const selected = selectFirstAvailable(candidates);
+                if (selected) {
+                    return selected;
+                }
+            }
+            else {
+                const selected = deps.loadBalancer.select({
+                    routeName: `${routeName}:${tier.id}:quota-bypass`,
+                    candidates,
+                    stickyKey: options.allowAliasRotation ? undefined : stickyKey,
+                    availabilityCheck: (key) => deps.healthManager.isAvailable(key)
+                }, tier.mode === 'round-robin' ? 'round-robin' : undefined);
+                if (selected) {
+                    return selected;
+                }
+            }
+        }
+        // 单 provider 兜底：当只剩一个候选 key 时，不因 quota/blacklist/cooldown 或健康状态过滤导致无 provider。
+        if (candidates.length === 1) {
+            return candidates[0];
+        }
         return null;
     };
     for (const candidatePool of prioritizedPools) {
@@ -416,10 +455,13 @@ export function selectFromStickyPool(stickyKeySet, metadata, features, state, de
     ]));
     const disabledModels = new Map(Array.from(state.disabledModels.entries()).map(([provider, models]) => [provider, new Set(models)]));
     let candidates = Array.from(stickyKeySet).filter((key) => !deps.isProviderCoolingDown(key));
+    if (!candidates.length && stickyKeySet.size === 1) {
+        candidates = Array.from(stickyKeySet);
+    }
     const quotaView = deps.quotaView;
     const now = quotaView ? Date.now() : 0;
     if (quotaView) {
-        candidates = candidates.filter((key) => {
+        const filtered = candidates.filter((key) => {
             const entry = quotaView(key);
             if (!entry) {
                 return true;
@@ -435,6 +477,9 @@ export function selectFromStickyPool(stickyKeySet, metadata, features, state, de
             }
             return true;
         });
+        if (filtered.length > 0 || candidates.length !== 1) {
+            candidates = filtered;
+        }
     }
     if (allowedProviders.size > 0) {
         candidates = candidates.filter((key) => {

package/dist/tools/apply-patch/validator.js

@@ -304,6 +304,129 @@ const tryParseJson = (value) => {
         return undefined;
     }
 };
+const escapeUnescapedQuotesInJsonStrings = (input) => {
+    // Best-effort: when JSON is almost valid but contains unescaped `"` inside string values
+    // (e.g. JSX snippets like className="..."), escape quotes that are not followed by a
+    // valid JSON token delimiter. Deterministic; does not attempt to fix structural issues.
+    let out = '';
+    let inString = false;
+    let escaped = false;
+    for (let i = 0; i < input.length; i += 1) {
+        const ch = input[i] ?? '';
+        if (!inString) {
+            if (ch === '"') {
+                inString = true;
+                escaped = false;
+            }
+            out += ch;
+            continue;
+        }
+        if (escaped) {
+            out += ch;
+            escaped = false;
+            continue;
+        }
+        if (ch === '\\') {
+            out += ch;
+            escaped = true;
+            continue;
+        }
+        if (ch === '"') {
+            let j = i + 1;
+            while (j < input.length && /\s/.test(input[j] ?? ''))
+                j += 1;
+            const next = j < input.length ? input[j] : '';
+            if (next === '' || next === ':' || next === ',' || next === '}' || next === ']') {
+                inString = false;
+                out += ch;
+            }
+            else {
+                out += '\\"';
+            }
+            continue;
+        }
+        out += ch;
+    }
+    return out;
+};
+const balanceJsonContainers = (input) => {
+    // Best-effort bracket/brace balancing for JSON-like strings.
+    // Only operates outside string literals. When encountering a closing token that doesn't
+    // match the current stack top, inserts the missing closer(s) to recover.
+    let out = '';
+    let inString = false;
+    let escaped = false;
+    const stack = [];
+    const closeFor = (open) => (open === '{' ? '}' : ']');
+    for (let i = 0; i < input.length; i += 1) {
+        const ch = input[i] ?? '';
+        if (inString) {
+            out += ch;
+            if (escaped) {
+                escaped = false;
+                continue;
+            }
+            if (ch === '\\') {
+                escaped = true;
+                continue;
+            }
+            if (ch === '"') {
+                inString = false;
+            }
+            continue;
+        }
+        if (ch === '"') {
+            inString = true;
+            out += ch;
+            continue;
+        }
+        if (ch === '{' || ch === '[') {
+            stack.push(ch);
+            out += ch;
+            continue;
+        }
+        if (ch === '}' || ch === ']') {
+            const expectedOpen = ch === '}' ? '{' : '[';
+            while (stack.length && stack[stack.length - 1] !== expectedOpen) {
+                const open = stack.pop();
+                out += closeFor(open);
+            }
+            if (stack.length && stack[stack.length - 1] === expectedOpen) {
+                stack.pop();
+            }
+            out += ch;
+            continue;
+        }
+        out += ch;
+    }
+    while (stack.length) {
+        const open = stack.pop();
+        out += closeFor(open);
+    }
+    return out;
+};
+const tryParseJsonLoose = (value) => {
+    const parsed = tryParseJson(value);
+    if (parsed !== undefined)
+        return parsed;
+    if (typeof value !== 'string')
+        return undefined;
+    const trimmed = value.trim();
+    if (!trimmed)
+        return undefined;
+    if (!(trimmed.startsWith('{') || trimmed.startsWith('[')))
+        return undefined;
+    let repaired = escapeUnescapedQuotesInJsonStrings(trimmed);
+    repaired = balanceJsonContainers(repaired);
+    if (!repaired || repaired === trimmed)
+        return undefined;
+    try {
+        return JSON.parse(repaired);
+    }
+    catch {
+        return undefined;
+    }
+};
 const coerceChangesArray = (value) => {
     const parsed = tryParseJson(value);
     if (!parsed)
@@ -402,6 +525,33 @@ export function validateApplyPatchArgs(argsString, rawArgs) {
         if (instructionsField && looksLikePatch(instructionsField)) {
             return { patchText: normalizeApplyPatchText(instructionsField) };
         }
+        // Common wrapper shape (seen in codex samples): { _raw: "{...json...}" }.
+        // `_raw` may contain either patch text or a JSON-encoded structured payload.
+        const rawEnvelope = asString(rec._raw);
+        if (rawEnvelope) {
+            const trimmed = rawEnvelope.trim();
+            if (looksLikePatch(trimmed)) {
+                return { patchText: normalizeApplyPatchText(trimmed) };
+            }
+            const parsed = tryParseJsonLoose(trimmed);
+            if (parsed && isRecord(parsed)) {
+                return extractFromRecord(parsed);
+            }
+            if (Array.isArray(parsed) && parsed.length > 0) {
+                const changesArray = parsed.filter((entry) => isRecord(entry));
+                if (changesArray.length && changesArray.some((c) => typeof c.kind === 'string')) {
+                    const payload = { changes: changesArray };
+                    try {
+                        return { patchText: buildStructuredPatch(payload) };
+                    }
+                    catch (error) {
+                        if (!(error instanceof StructuredApplyPatchError))
+                            throw error;
+                        return { failureReason: error.reason || 'structured_apply_patch_error' };
+                    }
+                }
+            }
+        }
         const payload = coerceStructuredPayload(rec);
         if (payload) {
             try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsonstudio/llms",
-  "version": "0.6.795",
+  "version": "0.6.802",
   "type": "module",
   "main": "dist/index.js",
   "module": "dist/index.js",