@jsonstudio/rcc 0.90.352 → 0.90.367

package/vendor/llmswitch-core/dist/router/virtual-router/engine-selection/native-hub-pipeline-edge-stage-semantics.js

@@ -0,0 +1,333 @@
+import { failNativeRequired, isNativeDisabledByEnv, } from "./native-router-hotpath-policy.js";
+import { loadNativeRouterHotpathBindingForInternalUse } from "./native-router-hotpath.js";
+function readNativeFunction(name) {
+    const binding = loadNativeRouterHotpathBindingForInternalUse();
+    const fn = binding?.[name];
+    return typeof fn === "function"
+        ? fn
+        : null;
+}
+function safeStringify(value) {
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+function parseRecord(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+            return null;
+        }
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+function parseFormatEnvelopePayload(raw, direction, fallbackProtocol, fallbackPayload) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+            return null;
+        }
+        const row = parsed;
+        const envelope = row.envelope;
+        if (!envelope || typeof envelope !== "object" || Array.isArray(envelope)) {
+            return null;
+        }
+        const env = envelope;
+        const protocol = typeof env.format === "string" && env.format.trim().length
+            ? env.format.trim()
+            : fallbackProtocol;
+        const payload = env.payload &&
+            typeof env.payload === "object" &&
+            !Array.isArray(env.payload)
+            ? env.payload
+            : fallbackPayload;
+        const out = {
+            protocol,
+            direction,
+            payload,
+        };
+        if (env.metadata &&
+            typeof env.metadata === "object" &&
+            !Array.isArray(env.metadata)) {
+            out.meta = env.metadata;
+        }
+        return out;
+    }
+    catch {
+        return null;
+    }
+}
+function parseOptionalString(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (parsed === null) {
+            return undefined;
+        }
+        if (typeof parsed !== "string") {
+            return null;
+        }
+        const trimmed = parsed.trim();
+        return trimmed ? trimmed : undefined;
+    }
+    catch {
+        return null;
+    }
+}
+function parseBoolean(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        return typeof parsed === "boolean" ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function sanitizeFormatEnvelopeWithNative(candidate) {
+    const capability = "sanitizeFormatEnvelopeJson";
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail("native disabled");
+    }
+    const fn = readNativeFunction("sanitizeFormatEnvelopeJson");
+    if (!fn) {
+        return fail();
+    }
+    const candidateJson = safeStringify(candidate);
+    if (!candidateJson) {
+        return fail("json stringify failed");
+    }
+    try {
+        const raw = fn(candidateJson);
+        if (typeof raw !== "string" || !raw) {
+            return fail("empty result");
+        }
+        const parsed = parseRecord(raw);
+        return parsed ?? fail("invalid payload");
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? "unknown");
+        return fail(reason);
+    }
+}
+export function sanitizeChatCompletionLikeWithNative(candidate) {
+    const capability = "sanitizeChatCompletionLikeJson";
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail("native disabled");
+    }
+    const fn = readNativeFunction("sanitizeChatCompletionLikeJson");
+    if (!fn) {
+        return fail();
+    }
+    const candidateJson = safeStringify(candidate);
+    if (!candidateJson) {
+        return fail("json stringify failed");
+    }
+    try {
+        const raw = fn(candidateJson);
+        if (typeof raw !== "string" || !raw) {
+            return fail("empty result");
+        }
+        const parsed = parseRecord(raw);
+        return parsed ?? fail("invalid payload");
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? "unknown");
+        return fail(reason);
+    }
+}
+export function stripPrivateFieldsWithNative(payload) {
+    const capability = "stripPrivateFieldsJson";
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail("native disabled");
+    }
+    const fn = readNativeFunction("stripPrivateFieldsJson");
+    if (!fn) {
+        return fail();
+    }
+    const payloadJson = safeStringify(payload);
+    if (!payloadJson) {
+        return fail("json stringify failed");
+    }
+    try {
+        const raw = fn(payloadJson);
+        if (typeof raw !== "string" || !raw) {
+            return fail("empty result");
+        }
+        const parsed = parseRecord(raw);
+        return parsed ?? fail("invalid payload");
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? "unknown");
+        return fail(reason);
+    }
+}
+export function resolveCompatProfileWithNative(adapterContext, explicitProfile) {
+    const capability = "resolveCompatProfileJson";
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail("native disabled");
+    }
+    const fn = readNativeFunction("resolveCompatProfileJson");
+    if (!fn) {
+        return fail();
+    }
+    const adapterContextJson = safeStringify(adapterContext);
+    const explicitJson = safeStringify(explicitProfile ?? null);
+    if (!adapterContextJson || !explicitJson) {
+        return fail("json stringify failed");
+    }
+    try {
+        const raw = fn(adapterContextJson, explicitJson);
+        if (typeof raw !== "string" || !raw) {
+            return fail("empty result");
+        }
+        const parsed = parseOptionalString(raw);
+        return parsed === null ? fail("invalid payload") : parsed;
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? "unknown");
+        return fail(reason);
+    }
+}
+export function resolveSseStreamModeWithNative(wantsStream, clientProtocol) {
+    const capability = "resolveSseStreamModeJson";
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail("native disabled");
+    }
+    const fn = readNativeFunction("resolveSseStreamModeJson");
+    if (!fn) {
+        return fail();
+    }
+    try {
+        const raw = fn(Boolean(wantsStream), String(clientProtocol || ""));
+        if (typeof raw !== "string" || !raw) {
+            return fail("empty result");
+        }
+        const parsed = parseBoolean(raw);
+        return parsed === null ? fail("invalid payload") : parsed;
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? "unknown");
+        return fail(reason);
+    }
+}
+export function parseReqInboundFormatEnvelopeWithNative(input) {
+    const capability = "parseFormatEnvelopeJson";
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail("native disabled");
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const inputJson = safeStringify(input);
+    if (!inputJson) {
+        return fail("json stringify failed");
+    }
+    try {
+        const raw = fn(inputJson);
+        if (typeof raw !== "string" || !raw) {
+            return fail("empty result");
+        }
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+            return fail("invalid envelope structure");
+        }
+        const result = parsed;
+        if (!result.envelope || typeof result.envelope !== "object") {
+            return fail("missing envelope in result");
+        }
+        return result.envelope;
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? "unknown");
+        return fail(reason);
+    }
+}
+export function parseRespInboundFormatEnvelopeWithNative(input) {
+    const capability = "parseRespFormatEnvelopeJson";
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail("native disabled");
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const inputJson = safeStringify(input);
+    if (!inputJson) {
+        return fail("json stringify failed");
+    }
+    try {
+        const raw = fn(inputJson);
+        if (typeof raw !== "string" || !raw) {
+            return fail("empty result");
+        }
+        const parsed = parseFormatEnvelopePayload(raw, "response", input.protocol, input.payload);
+        return parsed ?? fail("invalid payload");
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? "unknown");
+        return fail(reason);
+    }
+}
+export function validateChatEnvelopeWithNative(chatEnvelope, options) {
+    const capability = "validateChatEnvelopeJson";
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail("native disabled");
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const envelopeJson = safeStringify(chatEnvelope);
+    if (!envelopeJson) {
+        return fail("json stringify failed");
+    }
+    const isChatEnvelopeValidationError = (message) => typeof message === "string" &&
+        message.includes("ChatEnvelopeValidationError(");
+    try {
+        const raw = fn(envelopeJson, String(options.stage || ""), String(options.direction || ""), options.source);
+        const nativeErrorMessage = raw instanceof Error
+            ? raw.message
+            : raw &&
+                typeof raw === "object" &&
+                "message" in raw
+                ? (() => {
+                    const candidate = raw.message;
+                    return typeof candidate === "string" ? candidate : "";
+                })()
+                : "";
+        if (nativeErrorMessage) {
+            if (isChatEnvelopeValidationError(nativeErrorMessage)) {
+                throw new Error(nativeErrorMessage);
+            }
+            return fail(nativeErrorMessage);
+        }
+        if (typeof raw !== "string" || !raw) {
+            return fail("empty result");
+        }
+        const parsed = parseBoolean(raw);
+        if (parsed !== true) {
+            return fail("invalid payload");
+        }
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? "unknown");
+        if (isChatEnvelopeValidationError(reason)) {
+            throw error instanceof Error ? error : new Error(reason);
+        }
+        return fail(reason);
+    }
+}

package/vendor/llmswitch-core/dist/router/virtual-router/engine-selection/native-hub-pipeline-governance-semantics.d.ts

@@ -0,0 +1,30 @@
+export interface NativeToolGovernanceRules {
+    maxNameLength?: number;
+    allowedCharacters?: unknown;
+    forceCase?: 'lower' | 'upper';
+    defaultName?: string;
+    trimWhitespace?: boolean;
+    onViolation?: 'truncate' | 'reject';
+}
+export interface NativeToolGovernanceRuleNode {
+    request?: NativeToolGovernanceRules;
+    response?: NativeToolGovernanceRules;
+}
+export type NativeToolGovernanceRegistry = Record<string, NativeToolGovernanceRuleNode>;
+export declare function resolveDefaultToolGovernanceRulesWithNative(): NativeToolGovernanceRegistry;
+export declare function governRequestWithNative(input: {
+    request: Record<string, unknown>;
+    protocol?: string;
+    registry?: NativeToolGovernanceRegistry;
+}): {
+    request: Record<string, unknown>;
+    summary: Record<string, unknown>;
+};
+export declare function governResponseWithNative(input: {
+    payload: Record<string, unknown>;
+    protocol?: string;
+    registry?: NativeToolGovernanceRegistry;
+}): {
+    payload: Record<string, unknown>;
+    summary: Record<string, unknown>;
+};

package/vendor/llmswitch-core/dist/router/virtual-router/engine-selection/native-hub-pipeline-governance-semantics.js

@@ -0,0 +1,202 @@
+import { failNativeRequired, isNativeDisabledByEnv } from './native-router-hotpath-policy.js';
+import { loadNativeRouterHotpathBindingForInternalUse } from './native-router-hotpath.js';
+function readNativeFunction(name) {
+    const binding = loadNativeRouterHotpathBindingForInternalUse();
+    const fn = binding?.[name];
+    return typeof fn === 'function' ? fn : null;
+}
+function safeStringify(value) {
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+function normalizeAllowedCharactersToken(value) {
+    if (typeof value === 'string') {
+        const token = value.trim();
+        return token || undefined;
+    }
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return undefined;
+    }
+    const row = value;
+    if (typeof row.source === 'string' && row.source.trim()) {
+        return row.source.trim();
+    }
+    return undefined;
+}
+function normalizeRulesForNative(rules) {
+    if (!rules || typeof rules !== 'object') {
+        return undefined;
+    }
+    const normalizedAllowed = normalizeAllowedCharactersToken(rules.allowedCharacters);
+    return {
+        ...rules,
+        ...(normalizedAllowed ? { allowedCharacters: normalizedAllowed } : {})
+    };
+}
+function normalizeRegistryForNative(registry) {
+    if (!registry || typeof registry !== 'object') {
+        return undefined;
+    }
+    const out = {};
+    for (const [protocol, node] of Object.entries(registry)) {
+        out[protocol] = {
+            request: normalizeRulesForNative(node?.request),
+            response: normalizeRulesForNative(node?.response)
+        };
+    }
+    return out;
+}
+function parseRegistry(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            return null;
+        }
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+function readNativeErrorReason(value) {
+    if (value instanceof Error) {
+        const text = value.message.trim();
+        return text || String(value);
+    }
+    if (!value || typeof value !== 'object') {
+        return undefined;
+    }
+    const row = value;
+    const message = typeof row.message === 'string' ? row.message.trim() : '';
+    if (message) {
+        return message;
+    }
+    return undefined;
+}
+export function resolveDefaultToolGovernanceRulesWithNative() {
+    const capability = 'resolveDefaultToolGovernanceRulesJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    try {
+        const raw = fn();
+        const errorReason = readNativeErrorReason(raw);
+        if (errorReason) {
+            return fail(errorReason);
+        }
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        const parsed = parseRegistry(raw);
+        return parsed ?? fail('invalid payload');
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
+export function governRequestWithNative(input) {
+    const capability = 'governRequestJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const normalizedInput = {
+        ...input,
+        registry: normalizeRegistryForNative(input.registry)
+    };
+    const inputJson = safeStringify(normalizedInput);
+    if (!inputJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(inputJson);
+        const errorReason = readNativeErrorReason(raw);
+        if (errorReason) {
+            return fail(errorReason);
+        }
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            return fail('invalid payload');
+        }
+        const row = parsed;
+        if (!row.request || typeof row.request !== 'object' || Array.isArray(row.request)) {
+            return fail('invalid request payload');
+        }
+        if (!row.summary || typeof row.summary !== 'object' || Array.isArray(row.summary)) {
+            return fail('invalid summary payload');
+        }
+        return {
+            request: row.request,
+            summary: row.summary
+        };
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
+export function governResponseWithNative(input) {
+    const capability = 'governToolNameResponseJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const normalizedInput = {
+        ...input,
+        registry: normalizeRegistryForNative(input.registry)
+    };
+    const inputJson = safeStringify(normalizedInput);
+    if (!inputJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(inputJson);
+        const errorReason = readNativeErrorReason(raw);
+        if (errorReason) {
+            return fail(errorReason);
+        }
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            return fail('invalid payload');
+        }
+        const row = parsed;
+        if (!row.payload || typeof row.payload !== 'object' || Array.isArray(row.payload)) {
+            return fail('invalid response payload');
+        }
+        if (!row.summary || typeof row.summary !== 'object' || Array.isArray(row.summary)) {
+            return fail('invalid summary payload');
+        }
+        return {
+            payload: row.payload,
+            summary: row.summary
+        };
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}

package/vendor/llmswitch-core/dist/router/virtual-router/engine-selection/native-hub-pipeline-inbound-outbound-semantics.d.ts

@@ -0,0 +1,22 @@
+export type NativeResumeToolOutput = {
+    tool_call_id: string;
+    content: string;
+};
+export type NativeContextToolOutput = {
+    tool_call_id: string;
+    call_id: string;
+    output?: string;
+    name?: string;
+};
+export declare function mapResumeToolOutputsDetailedWithNative(responsesResume: unknown): NativeResumeToolOutput[];
+export declare function resolveServerToolFollowupSnapshotWithNative(adapterContext: unknown): Record<string, unknown> | undefined;
+export declare function augmentContextSnapshotWithNative(context: Record<string, unknown>, fallbackSnapshot: Record<string, unknown>): Record<string, unknown>;
+export declare function normalizeToolCallIdStyleCandidateWithNative(value: unknown): 'fc' | 'preserve' | undefined;
+export declare function collectToolOutputsWithNative(payload: unknown): NativeContextToolOutput[];
+export declare function mergeContextToolOutputsWithNative(existing: unknown, snapshot: Record<string, unknown>): Array<{
+    tool_call_id: string;
+    content: string;
+    name?: string;
+}> | undefined;
+export declare function normalizeContextToolsWithNative(snapshot: Record<string, unknown>): unknown[] | undefined;
+export declare function selectToolCallIdStyleWithNative(adapterContext: unknown, snapshot: Record<string, unknown>, current: string | undefined): string | undefined;