@jsonstudio/rcc 0.90.876 → 0.90.1270

package/node_modules/@jsonstudio/llms/dist/router/virtual-router/engine-selection/native-shared-conversion-semantics-responses.js

@@ -18,6 +18,28 @@ function parseResponsesConversationResumeResult(raw) {
         meta: meta
     };
 }
+function parseNullableResponsesConversationResumeResult(raw) {
+    const parsed = parseJson(raw);
+    if (parsed === null) {
+        return null;
+    }
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        return null;
+    }
+    const row = parsed;
+    const payload = row.payload;
+    const meta = row.meta;
+    if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+        return null;
+    }
+    if (!meta || typeof meta !== 'object' || Array.isArray(meta)) {
+        return null;
+    }
+    return {
+        payload: payload,
+        meta: meta
+    };
+}
 export function pickResponsesPersistedFieldsWithNative(payload) {
     const capability = 'pickResponsesPersistedFieldsJson';
     const fail = (reason) => failNativeRequired(capability, reason);
@@ -146,6 +168,60 @@ export function resumeResponsesConversationPayloadWithNative(entry, responseId,
         return fail(reason);
     }
 }
+export function restoreResponsesContinuationPayloadWithNative(entry, incomingPayload, requestId, scopeKey) {
+    const capability = 'restoreResponsesContinuationPayloadJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const entryJson = safeStringify(entry ?? null);
+    const incomingPayloadJson = safeStringify(incomingPayload ?? null);
+    if (!entryJson || !incomingPayloadJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(entryJson, incomingPayloadJson, requestId, scopeKey);
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        return parseNullableResponsesConversationResumeResult(raw);
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
+export function materializeResponsesContinuationPayloadWithNative(entry, incomingPayload, requestId, scopeKey) {
+    const capability = 'materializeResponsesContinuationPayloadJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const entryJson = safeStringify(entry ?? null);
+    const incomingPayloadJson = safeStringify(incomingPayload ?? null);
+    if (!entryJson || !incomingPayloadJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(entryJson, incomingPayloadJson, requestId, scopeKey);
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        return parseNullableResponsesConversationResumeResult(raw);
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
 export function enforceChatBudgetWithNative(chat, allowedBytes, systemTextLimit) {
     const capability = 'enforceChatBudgetJson';
     const fail = (reason) => failNativeRequired(capability, reason);

package/node_modules/@jsonstudio/llms/dist/router/virtual-router/engine-selection/native-shared-conversion-semantics.d.ts

@@ -1,6 +1,6 @@
 export { clampResponsesInputItemIdWithNative, normalizeFunctionCallIdWithNative, normalizeFunctionCallOutputIdWithNative, normalizeResponsesCallIdWithNative } from './native-shared-conversion-semantics-call-id.js';
 export { cloneRuntimeMetadataWithNative, encodeMetadataPassthroughWithNative, ensureProtocolStateWithNative, ensureRuntimeMetadataCarrierWithNative, extractMetadataPassthroughWithNative, getProtocolStateWithNative, readRuntimeMetadataWithNative } from './native-shared-conversion-semantics-metadata.js';
-export { convertResponsesOutputToInputItemsWithNative, enforceChatBudgetWithNative, pickResponsesPersistedFieldsWithNative, prepareResponsesConversationEntryWithNative, resolveBudgetForModelWithNative, resumeResponsesConversationPayloadWithNative } from './native-shared-conversion-semantics-responses.js';
+export { convertResponsesOutputToInputItemsWithNative, enforceChatBudgetWithNative, materializeResponsesContinuationPayloadWithNative, pickResponsesPersistedFieldsWithNative, prepareResponsesConversationEntryWithNative, resolveBudgetForModelWithNative, restoreResponsesContinuationPayloadWithNative, resumeResponsesConversationPayloadWithNative } from './native-shared-conversion-semantics-responses.js';
 export { buildGeminiToolsFromBridgeWithNative, injectMcpToolsForChatWithNative, injectMcpToolsForResponsesWithNative, normalizeArgsBySchemaWithNative, normalizeOpenaiChatMessagesWithNative, normalizeOpenaiToolCallWithNative, prepareGeminiToolsForBridgeWithNative } from './native-shared-conversion-semantics-tools.js';
 export { extractApplyPatchCallsFromTextWithNative, extractBareExecCommandFromTextWithNative, extractExecuteBlocksFromTextWithNative, extractExploredListDirectoryCallsFromTextWithNative, extractInvokeToolsFromTextWithNative, extractJsonToolCallsFromTextWithNative, extractParameterXmlToolsFromTextWithNative, extractQwenToolCallTokensFromTextWithNative, extractSimpleXmlToolsFromTextWithNative, extractToolNamespaceXmlBlocksFromTextWithNative, extractXMLToolCallsFromTextWithNative, mapReasoningContentToResponsesOutputWithNative, mergeToolCallsWithNative, repairToolCallsWithNative, validateToolArgumentsWithNative } from './native-shared-conversion-semantics-toolcalls.js';
 export { normalizeChatMessageContentWithNative, normalizeContentPartWithNative, normalizeMessageContentPartsWithNative, normalizeOpenaiMessageWithNative, normalizeOpenaiToolWithNative } from './native-shared-conversion-semantics-openai.js';

package/node_modules/@jsonstudio/llms/dist/router/virtual-router/engine-selection/native-shared-conversion-semantics.js

@@ -2,7 +2,7 @@ import { failNativeRequired, isNativeDisabledByEnv } from './native-router-hotpa
 import { parseArray, parseJson, parseRecord, parseString, readNativeFunction, safeStringify } from './native-shared-conversion-semantics-core.js';
 export { clampResponsesInputItemIdWithNative, normalizeFunctionCallIdWithNative, normalizeFunctionCallOutputIdWithNative, normalizeResponsesCallIdWithNative } from './native-shared-conversion-semantics-call-id.js';
 export { cloneRuntimeMetadataWithNative, encodeMetadataPassthroughWithNative, ensureProtocolStateWithNative, ensureRuntimeMetadataCarrierWithNative, extractMetadataPassthroughWithNative, getProtocolStateWithNative, readRuntimeMetadataWithNative } from './native-shared-conversion-semantics-metadata.js';
-export { convertResponsesOutputToInputItemsWithNative, enforceChatBudgetWithNative, pickResponsesPersistedFieldsWithNative, prepareResponsesConversationEntryWithNative, resolveBudgetForModelWithNative, resumeResponsesConversationPayloadWithNative } from './native-shared-conversion-semantics-responses.js';
+export { convertResponsesOutputToInputItemsWithNative, enforceChatBudgetWithNative, materializeResponsesContinuationPayloadWithNative, pickResponsesPersistedFieldsWithNative, prepareResponsesConversationEntryWithNative, resolveBudgetForModelWithNative, restoreResponsesContinuationPayloadWithNative, resumeResponsesConversationPayloadWithNative } from './native-shared-conversion-semantics-responses.js';
 export { buildGeminiToolsFromBridgeWithNative, injectMcpToolsForChatWithNative, injectMcpToolsForResponsesWithNative, normalizeArgsBySchemaWithNative, normalizeOpenaiChatMessagesWithNative, normalizeOpenaiToolCallWithNative, prepareGeminiToolsForBridgeWithNative } from './native-shared-conversion-semantics-tools.js';
 export { extractApplyPatchCallsFromTextWithNative, extractBareExecCommandFromTextWithNative, extractExecuteBlocksFromTextWithNative, extractExploredListDirectoryCallsFromTextWithNative, extractInvokeToolsFromTextWithNative, extractJsonToolCallsFromTextWithNative, extractParameterXmlToolsFromTextWithNative, extractQwenToolCallTokensFromTextWithNative, extractSimpleXmlToolsFromTextWithNative, extractToolNamespaceXmlBlocksFromTextWithNative, extractXMLToolCallsFromTextWithNative, mapReasoningContentToResponsesOutputWithNative, mergeToolCallsWithNative, repairToolCallsWithNative, validateToolArgumentsWithNative } from './native-shared-conversion-semantics-toolcalls.js';
 export { normalizeChatMessageContentWithNative, normalizeContentPartWithNative, normalizeMessageContentPartsWithNative, normalizeOpenaiMessageWithNative, normalizeOpenaiToolWithNative } from './native-shared-conversion-semantics-openai.js';

package/node_modules/@jsonstudio/llms/dist/router/virtual-router/engine-selection/native-virtual-router-bootstrap-providers.d.ts

@@ -0,0 +1,24 @@
+import { type ProviderProfile, type ProviderRuntimeProfile } from '../types.js';
+type ModelIndexEntry = {
+    declared: boolean;
+    models: string[];
+};
+export declare function bootstrapProvidersWithNative(input: {
+    providersSource: Record<string, unknown>;
+}): {
+    runtimeEntries: Record<string, ProviderRuntimeProfile>;
+    aliasIndex: Map<string, string[]>;
+    modelIndex: Map<string, ModelIndexEntry>;
+    source: 'native';
+};
+export declare function bootstrapProviderProfilesWithNative(input: {
+    routedTargetKeys: Iterable<string>;
+    aliasIndex: Map<string, string[]>;
+    modelIndex: Map<string, ModelIndexEntry>;
+    runtimeEntries: Record<string, ProviderRuntimeProfile>;
+}): {
+    profiles: Record<string, ProviderProfile>;
+    targetRuntime: Record<string, ProviderRuntimeProfile>;
+    source: 'native';
+};
+export {};

package/node_modules/@jsonstudio/llms/dist/router/virtual-router/engine-selection/native-virtual-router-bootstrap-providers.js

@@ -0,0 +1,78 @@
+import { VirtualRouterError, VirtualRouterErrorCode } from '../types.js';
+import { parseVirtualRouterNativeError } from '../native-error.js';
+import { isNativeDisabledByEnv, makeNativeRequiredError } from './native-router-hotpath-policy.js';
+import { loadNativeRouterHotpathBinding } from './native-router-hotpath-loader.js';
+function requireNativeFunction(exportName) {
+    if (isNativeDisabledByEnv()) {
+        throw makeNativeRequiredError(exportName, 'native disabled');
+    }
+    const binding = loadNativeRouterHotpathBinding();
+    const fn = binding?.[exportName];
+    if (typeof fn !== 'function') {
+        throw makeNativeRequiredError(exportName);
+    }
+    return fn;
+}
+function parseJsonPayload(raw) {
+    const returnedVirtualRouterError = parseVirtualRouterNativeError(raw);
+    if (returnedVirtualRouterError) {
+        throw returnedVirtualRouterError;
+    }
+    if (typeof raw !== 'string' || !raw) {
+        throw new VirtualRouterError('Virtual router native bootstrap returned empty payload', VirtualRouterErrorCode.CONFIG_ERROR);
+    }
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        throw new VirtualRouterError('Virtual router native bootstrap returned invalid payload', VirtualRouterErrorCode.CONFIG_ERROR);
+    }
+}
+export function bootstrapProvidersWithNative(input) {
+    const fn = requireNativeFunction('bootstrapVirtualRouterProvidersJson');
+    let raw;
+    try {
+        raw = fn(JSON.stringify(input.providersSource ?? {}));
+    }
+    catch (error) {
+        const virtualRouterError = parseVirtualRouterNativeError(error);
+        if (virtualRouterError)
+            throw virtualRouterError;
+        throw error;
+    }
+    const parsed = parseJsonPayload(raw);
+    if (!parsed || typeof parsed !== 'object' || !parsed.runtimeEntries || !parsed.aliasIndex || !parsed.modelIndex) {
+        throw new VirtualRouterError('Virtual router native providers bootstrap returned invalid payload', VirtualRouterErrorCode.CONFIG_ERROR);
+    }
+    return {
+        runtimeEntries: parsed.runtimeEntries,
+        aliasIndex: new Map(Object.entries(parsed.aliasIndex)),
+        modelIndex: new Map(Object.entries(parsed.modelIndex)),
+        source: 'native'
+    };
+}
+export function bootstrapProviderProfilesWithNative(input) {
+    const fn = requireNativeFunction('bootstrapVirtualRouterProviderProfilesJson');
+    const routedTargetKeys = Array.from(input.routedTargetKeys ?? []);
+    const aliasIndex = Object.fromEntries(input.aliasIndex.entries());
+    const modelIndex = Object.fromEntries(input.modelIndex.entries());
+    let raw;
+    try {
+        raw = fn(JSON.stringify(routedTargetKeys), JSON.stringify(aliasIndex), JSON.stringify(modelIndex), JSON.stringify(input.runtimeEntries ?? {}));
+    }
+    catch (error) {
+        const virtualRouterError = parseVirtualRouterNativeError(error);
+        if (virtualRouterError)
+            throw virtualRouterError;
+        throw error;
+    }
+    const parsed = parseJsonPayload(raw);
+    if (!parsed || typeof parsed !== 'object' || !parsed.profiles || !parsed.targetRuntime) {
+        throw new VirtualRouterError('Virtual router native provider profiles bootstrap returned invalid payload', VirtualRouterErrorCode.CONFIG_ERROR);
+    }
+    return {
+        profiles: parsed.profiles,
+        targetRuntime: parsed.targetRuntime,
+        source: 'native'
+    };
+}

package/node_modules/@jsonstudio/llms/dist/router/virtual-router/engine-selection/native-virtual-router-bootstrap-routing.d.ts

@@ -0,0 +1,17 @@
+import { type RoutePoolTier } from '../types.js';
+import type { NormalizedRoutePoolConfig } from '../bootstrap/routing-config.js';
+type ModelIndexEntry = {
+    declared: boolean;
+    models: string[];
+};
+export declare function bootstrapRoutingWithNative(input: {
+    routingSource: Record<string, unknown>;
+    aliasIndex: Map<string, string[]>;
+    modelIndex: Map<string, ModelIndexEntry>;
+}): {
+    routingSource: Record<string, NormalizedRoutePoolConfig[]>;
+    routing: Record<string, RoutePoolTier[]>;
+    targetKeys: Set<string>;
+    source: 'native';
+};
+export {};

package/node_modules/@jsonstudio/llms/dist/router/virtual-router/engine-selection/native-virtual-router-bootstrap-routing.js

@@ -0,0 +1,72 @@
+import { VirtualRouterError, VirtualRouterErrorCode } from '../types.js';
+import { parseVirtualRouterNativeError } from '../native-error.js';
+import { isNativeDisabledByEnv, makeNativeRequiredError } from './native-router-hotpath-policy.js';
+import { loadNativeRouterHotpathBinding } from './native-router-hotpath-loader.js';
+function requireNativeFunction(exportName) {
+    if (isNativeDisabledByEnv()) {
+        throw makeNativeRequiredError(exportName, 'native disabled');
+    }
+    const binding = loadNativeRouterHotpathBinding();
+    const fn = binding?.[exportName];
+    if (typeof fn !== 'function') {
+        throw makeNativeRequiredError(exportName);
+    }
+    return fn;
+}
+function isStringArray(value) {
+    return Array.isArray(value) && value.every((item) => typeof item === 'string');
+}
+function parseNativePayload(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== 'object') {
+            return null;
+        }
+        if (!parsed.routingSource || typeof parsed.routingSource !== 'object') {
+            return null;
+        }
+        if (!parsed.routing || typeof parsed.routing !== 'object') {
+            return null;
+        }
+        if (!isStringArray(parsed.targetKeys)) {
+            return null;
+        }
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+export function bootstrapRoutingWithNative(input) {
+    const fn = requireNativeFunction('bootstrapVirtualRouterRoutingJson');
+    const aliasIndex = Object.fromEntries(input.aliasIndex.entries());
+    const modelIndex = Object.fromEntries(input.modelIndex.entries());
+    let raw;
+    try {
+        raw = fn(JSON.stringify(input.routingSource ?? {}), JSON.stringify(aliasIndex), JSON.stringify(modelIndex));
+    }
+    catch (error) {
+        const virtualRouterError = parseVirtualRouterNativeError(error);
+        if (virtualRouterError) {
+            throw virtualRouterError;
+        }
+        throw error;
+    }
+    const returnedVirtualRouterError = parseVirtualRouterNativeError(raw);
+    if (returnedVirtualRouterError) {
+        throw returnedVirtualRouterError;
+    }
+    if (typeof raw !== 'string' || !raw) {
+        throw new VirtualRouterError('Virtual router native bootstrap returned empty payload', VirtualRouterErrorCode.CONFIG_ERROR);
+    }
+    const parsed = parseNativePayload(raw);
+    if (!parsed) {
+        throw new VirtualRouterError('Virtual router native bootstrap returned invalid payload', VirtualRouterErrorCode.CONFIG_ERROR);
+    }
+    return {
+        routingSource: parsed.routingSource,
+        routing: parsed.routing,
+        targetKeys: new Set(parsed.targetKeys),
+        source: 'native'
+    };
+}

package/node_modules/@jsonstudio/llms/dist/router/virtual-router/engine-selection/route-utils.js

@@ -78,6 +78,7 @@ export function sortRoutePools(pools) {
 }
 export function buildRouteCandidates(requestedRoute, classificationCandidates, features, routing, providerRegistry) {
     const hasMultimodalTargets = routeHasTargets(routing.multimodal);
+    const hasVisionTargets = routeHasTargets(routing.vision);
     const hasVideoTargets = routeHasTargets(routing.video);
     const hasRemoteVideoAttachment = features.hasVideoAttachment === true && features.hasRemoteVideoAttachment === true;
     const normalized = normalizeRouteAlias(requestedRoute || DEFAULT_ROUTE);
@@ -101,6 +102,11 @@ export function buildRouteCandidates(requestedRoute, classificationCandidates, f
                 baseList.unshift('multimodal');
             }
         }
+        else if (hasVisionTargets) {
+            if (!baseList.includes('vision')) {
+                baseList.unshift('vision');
+            }
+        }
         if (hasMultimodalTargets) {
             const multimodalAwareRoutes = [DEFAULT_ROUTE, 'thinking'];
             for (const routeName of multimodalAwareRoutes) {
@@ -123,6 +129,9 @@ export function buildRouteCandidates(requestedRoute, classificationCandidates, f
     if (features.hasImageAttachment && hasMultimodalTargets) {
         ordered = reorderForPreferredModel(ordered, 'kimi-k2.5', routing, providerRegistry);
     }
+    if (features.hasImageAttachment && !hasMultimodalTargets && hasVisionTargets) {
+        ordered = ['vision', ...ordered.filter((routeName) => routeName !== 'vision')];
+    }
     const deduped = [];
     for (const routeName of ordered) {
         if (routeName && !deduped.includes(routeName)) {

package/node_modules/@jsonstudio/llms/dist/router/virtual-router/engine-selection/tier-selection-select.js

@@ -158,6 +158,12 @@ function preferAntigravityAliasesOnRetry(opts) {
 }
 export function selectProviderKeyFromCandidatePool(opts) {
     const { routeName, tier, stickyKey, candidates, isSafePool, deps, options, contextResult, warnRatio, excludedKeys, isRecoveryAttempt, now, nowForWeights, healthWeightedCfg, contextWeightedCfg } = opts;
+    const selectableCandidates = excludedKeys.size > 0
+        ? candidates.filter((key) => !excludedKeys.has(key))
+        : candidates;
+    if (selectableCandidates.length === 0) {
+        return null;
+    }
     const quotaView = deps.quotaView;
     const tierLoadBalancing = resolveTierLoadBalancing(tier, deps.loadBalancer.getPolicy());
     const isAvailable = (key) => {
@@ -196,12 +202,12 @@ export function selectProviderKeyFromCandidatePool(opts) {
         // Single-provider pool should never be "emptied" by health/cooldown.
         // If there's only one possible target, we must return it even if it's currently unhealthy,
         // otherwise context routing can incorrectly fall back to a smaller-context route.
-        if (candidates.length === 1) {
-            return candidates[0] ?? null;
+        if (selectableCandidates.length === 1) {
+            return selectableCandidates[0] ?? null;
         }
         const retryPreferredCandidates = isRecoveryAttempt
-            ? preferAntigravityAliasesOnRetry({ candidates, excludedKeys, deps })
-            : candidates;
+            ? preferAntigravityAliasesOnRetry({ candidates: selectableCandidates, excludedKeys, deps })
+            : selectableCandidates;
         // Alias-level selection strategy (config-driven).
         // Apply sticky-queue pinning per provider/model group (candidates can be mixed providers).
         const pinnedCandidates = applyAliasStickyQueuePinning({
@@ -321,7 +327,7 @@ export function selectProviderKeyFromCandidatePool(opts) {
         routeName,
         tier,
         stickyKey,
-        candidates,
+        candidates: selectableCandidates,
         isSafePool,
         deps,
         options,

package/node_modules/@jsonstudio/llms/dist/router/virtual-router/engine.js

@@ -4,6 +4,7 @@ import { ProviderRegistry } from './provider-registry.js';
 import { loadRoutingInstructionStateSync } from './sticky-session-store.js';
 import { mergeStopMessageFromPersisted } from './stop-message-state-sync.js';
 import { resolveStopMessageScope } from './engine/routing-state/store.js';
+import { extractVirtualRouterNativeErrorMessage, parseVirtualRouterNativeError, VIRTUAL_ROUTER_ERROR_PREFIX } from './native-error.js';
 import { resolveRouteColor, resolveSessionColor } from './engine-logging.js';
 import { resolveRccUserDir } from '../../runtime/user-data-paths.js';
 import { buildStopMessageMarkerParseLog, cleanStopMessageMarkersInPlace, emitStopMessageMarkerParseLog, formatStopMessageStatusLabel } from './stop-message-markers.js';
@@ -103,16 +104,15 @@ export class VirtualRouterEngine {
         return JSON.parse(this.nativeProxy.getStatus());
     }
 }
-const VIRTUAL_ROUTER_ERROR_PREFIX = 'VIRTUAL_ROUTER_ERROR:';
 function normalizeNativeVirtualRouterError(error) {
     if (error instanceof VirtualRouterError) {
         return error;
     }
-    const message = extractNativeErrorMessage(error);
-    const parsed = parseVirtualRouterErrorMessage(message);
+    const parsed = parseVirtualRouterNativeError(error);
     if (parsed) {
-        return new VirtualRouterError(parsed.message, parsed.code);
+        return parsed;
     }
+    const message = extractVirtualRouterNativeErrorMessage(error);
     if (isVirtualRouterErrorLike(error)) {
         return new VirtualRouterError(typeof error.message === 'string' && error.message.trim() ? error.message : 'Virtual router error', error.code);
     }
@@ -171,41 +171,6 @@ function mergeStopMessageSnapshotWithPersisted(snapshot, scope) {
         stopMessageAiHistory: merged.stopMessageAiHistory
     };
 }
-function extractNativeErrorMessage(error) {
-    if (typeof error === 'string') {
-        return error;
-    }
-    if (error instanceof Error) {
-        return error.message;
-    }
-    if (error && typeof error === 'object') {
-        const message = error.message;
-        if (typeof message === 'string') {
-            return message;
-        }
-    }
-    return '';
-}
-function parseVirtualRouterErrorMessage(message) {
-    if (!message) {
-        return null;
-    }
-    const normalized = message.startsWith('Error:') ? message.replace(/^Error:\s*/, '') : message;
-    if (!normalized.startsWith(VIRTUAL_ROUTER_ERROR_PREFIX)) {
-        return null;
-    }
-    const remainder = normalized.slice(VIRTUAL_ROUTER_ERROR_PREFIX.length);
-    const idx = remainder.indexOf(':');
-    if (idx <= 0) {
-        return null;
-    }
-    const code = remainder.slice(0, idx);
-    const detail = remainder.slice(idx + 1).trim();
-    if (!isVirtualRouterErrorCode(code)) {
-        return null;
-    }
-    return { code, message: detail || 'Virtual router error' };
-}
 function isVirtualRouterErrorCode(value) {
     return Object.values(VirtualRouterErrorCode).includes(value);
 }