@jsonstudio/rcc 0.90.323 → 0.90.364

package/vendor/@jsonstudio/llms/dist/conversion/bridge-id-utils.d.ts

@@ -0,0 +1,9 @@
+type NormalizeOptions = {
+    callId?: string;
+    fallback?: string;
+};
+export declare function normalizeFunctionCallId(options: NormalizeOptions): string;
+export declare function normalizeFunctionCallOutputId(options: NormalizeOptions): string;
+export declare function normalizeResponsesCallId(options: NormalizeOptions): string;
+export declare function clampResponsesInputItemId(raw: unknown): string | undefined;
+export {};

package/vendor/@jsonstudio/llms/dist/conversion/bridge-id-utils.js

@@ -0,0 +1,13 @@
+import { clampResponsesInputItemIdWithNative, normalizeFunctionCallIdWithNative, normalizeFunctionCallOutputIdWithNative, normalizeResponsesCallIdWithNative } from '../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+export function normalizeFunctionCallId(options) {
+    return normalizeFunctionCallIdWithNative(options);
+}
+export function normalizeFunctionCallOutputId(options) {
+    return normalizeFunctionCallOutputIdWithNative(options);
+}
+export function normalizeResponsesCallId(options) {
+    return normalizeResponsesCallIdWithNative(options);
+}
+export function clampResponsesInputItemId(raw) {
+    return clampResponsesInputItemIdWithNative(raw);
+}

package/vendor/@jsonstudio/llms/dist/conversion/bridge-instructions.d.ts

@@ -0,0 +1 @@
+export declare function ensureBridgeInstructions(payload: Record<string, unknown>): string | undefined;

package/vendor/@jsonstudio/llms/dist/conversion/bridge-instructions.js

@@ -0,0 +1,17 @@
+import { ensureBridgeInstructionsWithNative } from '../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+export function ensureBridgeInstructions(payload) {
+    const normalized = ensureBridgeInstructionsWithNative(payload);
+    if (normalized && typeof normalized === 'object') {
+        if (Object.prototype.hasOwnProperty.call(normalized, 'input')) {
+            payload.input = normalized.input;
+        }
+        if (Object.prototype.hasOwnProperty.call(normalized, 'instructions')) {
+            payload.instructions = normalized.instructions;
+        }
+        else if (Object.prototype.hasOwnProperty.call(payload, 'instructions')) {
+            delete payload.instructions;
+        }
+    }
+    const instructions = payload.instructions;
+    return typeof instructions === 'string' && instructions.length ? instructions : undefined;
+}

package/vendor/@jsonstudio/llms/dist/conversion/bridge-message-utils.d.ts

@@ -0,0 +1,23 @@
+import type { BridgeInputItem } from './types/bridge-message-types.js';
+export interface BridgeInputBuildOptions {
+    messages: Array<Record<string, unknown>>;
+    tools?: Array<Record<string, unknown>> | undefined;
+}
+export interface BridgeInputBuildResult {
+    input: BridgeInputItem[];
+    combinedSystemInstruction?: string;
+    latestUserInstruction?: string;
+    originalSystemMessages: string[];
+}
+export declare function coerceBridgeRole(role: unknown): string;
+export declare function serializeToolArguments(argsStringOrObj: unknown, _functionName: string | undefined, _tools: unknown): string;
+export declare function serializeToolOutput(entry: BridgeInputItem): string | null;
+export declare function convertMessagesToBridgeInput(options: BridgeInputBuildOptions): BridgeInputBuildResult;
+export interface BridgeInputToChatOptions {
+    input?: BridgeInputItem[];
+    tools?: Array<Record<string, unknown>>;
+    normalizeFunctionName?: ((raw: unknown) => string | undefined) | 'default' | 'responses';
+    toolResultFallbackText?: string;
+}
+export declare function convertBridgeInputToChatMessages(options: BridgeInputToChatOptions): Array<Record<string, unknown>>;
+export declare function ensureMessagesArray(state: any): Array<Record<string, unknown>>;

package/vendor/@jsonstudio/llms/dist/conversion/bridge-message-utils.js

@@ -0,0 +1,45 @@
+import { buildBridgeHistoryWithNative, coerceBridgeRoleWithNative, convertBridgeInputToChatMessagesWithNative, ensureMessagesArrayWithNative, serializeToolArgumentsWithNative, serializeToolOutputWithNative } from '../router/virtual-router/engine-selection/native-hub-bridge-action-semantics.js';
+function assertBridgeMessageUtilsNativeAvailable() {
+    if (typeof buildBridgeHistoryWithNative !== 'function' ||
+        typeof convertBridgeInputToChatMessagesWithNative !== 'function' ||
+        typeof coerceBridgeRoleWithNative !== 'function' ||
+        typeof serializeToolArgumentsWithNative !== 'function' ||
+        typeof serializeToolOutputWithNative !== 'function' ||
+        typeof ensureMessagesArrayWithNative !== 'function') {
+        throw new Error('[bridge-message-utils] native bindings unavailable');
+    }
+}
+export function coerceBridgeRole(role) {
+    assertBridgeMessageUtilsNativeAvailable();
+    return coerceBridgeRoleWithNative(role);
+}
+export function serializeToolArguments(argsStringOrObj, _functionName, _tools) {
+    assertBridgeMessageUtilsNativeAvailable();
+    return serializeToolArgumentsWithNative({ args: argsStringOrObj });
+}
+export function serializeToolOutput(entry) {
+    assertBridgeMessageUtilsNativeAvailable();
+    return serializeToolOutputWithNative({ output: entry?.output });
+}
+export function convertMessagesToBridgeInput(options) {
+    assertBridgeMessageUtilsNativeAvailable();
+    const { messages, tools } = options;
+    const native = buildBridgeHistoryWithNative({ messages, tools });
+    return native;
+}
+export function convertBridgeInputToChatMessages(options) {
+    assertBridgeMessageUtilsNativeAvailable();
+    const { input, tools, normalizeFunctionName, toolResultFallbackText } = options;
+    const output = convertBridgeInputToChatMessagesWithNative({
+        input: Array.isArray(input) ? input : [],
+        tools,
+        toolResultFallbackText,
+        normalizeFunctionName: typeof normalizeFunctionName === 'string' ? normalizeFunctionName : undefined
+    });
+    return output.messages;
+}
+export function ensureMessagesArray(state) {
+    assertBridgeMessageUtilsNativeAvailable();
+    const output = ensureMessagesArrayWithNative({ state });
+    return output.messages;
+}

package/vendor/@jsonstudio/llms/dist/conversion/bridge-metadata.d.ts

@@ -0,0 +1,2 @@
+export declare const BRIDGE_RAW_SYSTEM_METADATA_KEY = "__rcc_raw_system";
+export declare function resolveBridgeMetadataNativeProtocol(): string;

package/vendor/@jsonstudio/llms/dist/conversion/bridge-metadata.js

@@ -0,0 +1,5 @@
+export const BRIDGE_RAW_SYSTEM_METADATA_KEY = '__rcc_raw_system';
+import { normalizeProviderProtocolTokenWithNative } from '../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';
+export function resolveBridgeMetadataNativeProtocol() {
+    return normalizeProviderProtocolTokenWithNative('openai-responses') ?? 'openai-responses';
+}

package/vendor/@jsonstudio/llms/dist/conversion/bridge-policies.d.ts

@@ -0,0 +1,18 @@
+import type { BridgeActionDescriptor, BridgeActionStage } from './bridge-actions.js';
+type PhaseConfig = {
+    inbound?: BridgeActionDescriptor[];
+    outbound?: BridgeActionDescriptor[];
+};
+export interface BridgePolicy {
+    id: string;
+    protocol?: string;
+    moduleType?: string;
+    request?: PhaseConfig;
+    response?: PhaseConfig;
+}
+export declare function resolveBridgePolicy(options: {
+    protocol?: string;
+    moduleType?: string;
+} | undefined): BridgePolicy | undefined;
+export declare function resolvePolicyActions(policy: BridgePolicy | undefined, stage: BridgeActionStage): BridgeActionDescriptor[] | undefined;
+export {};

package/vendor/@jsonstudio/llms/dist/conversion/bridge-policies.js

@@ -0,0 +1,11 @@
+import { resolveBridgePolicyActionsWithNative, resolveBridgePolicyWithNative } from '../router/virtual-router/engine-selection/native-hub-bridge-policy-semantics.js';
+export function resolveBridgePolicy(options) {
+    const resolved = resolveBridgePolicyWithNative(options);
+    if (!resolved) {
+        return undefined;
+    }
+    return resolved;
+}
+export function resolvePolicyActions(policy, stage) {
+    return resolveBridgePolicyActionsWithNative(policy, stage);
+}

package/vendor/@jsonstudio/llms/dist/conversion/codec-registry.d.ts

@@ -0,0 +1,10 @@
+import type { ConversionCodec } from './types.js';
+export type CodecFactory = () => Promise<ConversionCodec> | ConversionCodec;
+export declare class CodecRegistry {
+    private readonly factories;
+    private readonly instances;
+    constructor(_deps?: unknown);
+    register(id: string, factory: CodecFactory): void;
+    resolve(id: string): Promise<ConversionCodec>;
+}
+export declare function getDefaultCodecFactories(): Record<string, CodecFactory>;

package/vendor/@jsonstudio/llms/dist/conversion/codec-registry.js

@@ -0,0 +1,37 @@
+import { OpenAIOpenAIPipelineCodec } from './pipeline/codecs/v2/openai-openai-pipeline.js';
+import { AnthropicOpenAIPipelineCodec } from './pipeline/codecs/v2/anthropic-openai-pipeline.js';
+import { ResponsesOpenAIPipelineCodec } from './pipeline/codecs/v2/responses-openai-pipeline.js';
+export class CodecRegistry {
+    factories = new Map();
+    instances = new Map();
+    constructor(_deps) { }
+    register(id, factory) {
+        this.factories.set(id, factory);
+    }
+    async resolve(id) {
+        if (this.instances.has(id)) {
+            return this.instances.get(id);
+        }
+        const factory = this.factories.get(id);
+        if (!factory) {
+            throw new Error(`Unknown conversion codec: ${id}`);
+        }
+        const instance = await factory();
+        await instance.initialize();
+        this.instances.set(id, instance);
+        return instance;
+    }
+}
+// Default codec factories placeholder. In phase 1 we intentionally do not
+// reimplement codecs here; the router will not be switched yet. This file is
+// prepared so later phases can register actual codecs.
+export function getDefaultCodecFactories() {
+    return {
+        'openai-openai': () => new OpenAIOpenAIPipelineCodec(),
+        'openai-openai-v2': () => new OpenAIOpenAIPipelineCodec(),
+        'anthropic-openai': () => new AnthropicOpenAIPipelineCodec(),
+        'anthropic-openai-v2': () => new AnthropicOpenAIPipelineCodec(),
+        'responses-openai': () => new ResponsesOpenAIPipelineCodec(),
+        'responses-openai-v2': () => new ResponsesOpenAIPipelineCodec()
+    };
+}

package/vendor/@jsonstudio/llms/dist/conversion/codecs/anthropic-openai-codec.d.ts

@@ -0,0 +1,22 @@
+import type { ConversionCodec, ConversionContext, ConversionProfile } from '../types.js';
+import { buildAnthropicRequestFromOpenAIChat } from '../shared/anthropic-message-utils.js';
+export declare function buildOpenAIChatFromAnthropic(payload: unknown, options?: {
+    includeToolCallIds?: boolean;
+}): {
+    messages: unknown[];
+} & Record<string, unknown>;
+export declare function buildAnthropicFromOpenAIChat(payload: unknown, options?: {
+    toolNameMap?: Record<string, string>;
+    requestId?: string;
+    entryEndpoint?: string;
+}): Record<string, unknown>;
+export { buildAnthropicRequestFromOpenAIChat };
+export declare class AnthropicOpenAIConversionCodec implements ConversionCodec {
+    private readonly _dependencies;
+    readonly id = "anthropic-openai";
+    private initialized;
+    constructor(_dependencies: any);
+    initialize(): Promise<void>;
+    convertRequest(payload: any, _profile: ConversionProfile, context: ConversionContext): Promise<any>;
+    convertResponse(payload: any, _profile: ConversionProfile, context: ConversionContext): Promise<any>;
+}

package/vendor/@jsonstudio/llms/dist/conversion/codecs/anthropic-openai-codec.js

@@ -0,0 +1,52 @@
+import { buildAnthropicRequestFromOpenAIChat } from '../shared/anthropic-message-utils.js';
+import { buildAnthropicFromOpenAIChatWithNative, buildOpenAIChatFromAnthropicWithNative } from '../../router/virtual-router/engine-selection/native-compat-action-semantics.js';
+export function buildOpenAIChatFromAnthropic(payload, options) {
+    const result = buildOpenAIChatFromAnthropicWithNative((payload ?? {}), options);
+    return (result.request ?? {});
+}
+export function buildAnthropicFromOpenAIChat(payload, options) {
+    return buildAnthropicFromOpenAIChatWithNative((payload ?? {}), options);
+}
+export { buildAnthropicRequestFromOpenAIChat };
+export class AnthropicOpenAIConversionCodec {
+    _dependencies;
+    id = 'anthropic-openai';
+    initialized = false;
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    constructor(_dependencies) {
+        this._dependencies = _dependencies;
+    }
+    async initialize() {
+        this.initialized = true;
+    }
+    async convertRequest(payload, _profile, context) {
+        if (!this.initialized)
+            await this.initialize();
+        const native = buildOpenAIChatFromAnthropicWithNative(payload ?? {}, {
+            includeToolCallIds: true
+        });
+        const request = native.request && typeof native.request === 'object'
+            ? { ...native.request }
+            : {};
+        const aliasMap = native.anthropicToolNameMap && typeof native.anthropicToolNameMap === 'object'
+            ? native.anthropicToolNameMap
+            : undefined;
+        if (aliasMap && Object.keys(aliasMap).length > 0) {
+            context.metadata = context.metadata ?? {};
+            context.metadata.anthropicToolNameMap = aliasMap;
+        }
+        return request;
+    }
+    async convertResponse(payload, _profile, context) {
+        if (!this.initialized)
+            await this.initialize();
+        const aliasMap = context.metadata && typeof context.metadata === 'object'
+            ? context.metadata.anthropicToolNameMap
+            : undefined;
+        return buildAnthropicFromOpenAIChatWithNative((payload ?? {}), {
+            toolNameMap: aliasMap,
+            requestId: context.requestId,
+            entryEndpoint: context.entryEndpoint ?? context.endpoint
+        });
+    }
+}

package/vendor/@jsonstudio/llms/dist/conversion/codecs/gemini-openai-codec.d.ts

@@ -0,0 +1,17 @@
+import type { ConversionCodec, ConversionContext, ConversionProfile } from '../types.js';
+import type { JsonObject, JsonValue } from '../hub/types/json.js';
+export declare function buildOpenAIChatFromGeminiRequest(payload: unknown): {
+    messages: JsonValue[];
+} & JsonObject;
+export declare function buildOpenAIChatFromGeminiResponse(payload: unknown): JsonObject;
+export declare function buildGeminiFromOpenAIChat(chatResp: unknown): JsonObject;
+export declare class GeminiOpenAIConversionCodec implements ConversionCodec {
+    private readonly _dependencies;
+    readonly id = "gemini-openai";
+    private initialized;
+    constructor(_dependencies: any);
+    initialize(): Promise<void>;
+    private ensureInit;
+    convertRequest(payload: any, _profile: ConversionProfile, _context: ConversionContext): Promise<any>;
+    convertResponse(payload: any, _profile: ConversionProfile, _context: ConversionContext): Promise<any>;
+}

package/vendor/@jsonstudio/llms/dist/conversion/codecs/gemini-openai-codec.js

@@ -0,0 +1,85 @@
+import { ProviderProtocolError } from '../provider-protocol-error.js';
+import { runGeminiFromOpenAIChatCodecWithNative, runGeminiOpenAIRequestCodecWithNative, runGeminiOpenAIResponseCodecWithNative } from '../../router/virtual-router/engine-selection/native-compat-action-semantics.js';
+function isJsonValue(value) {
+    if (value === null ||
+        typeof value === 'string' ||
+        typeof value === 'number' ||
+        typeof value === 'boolean') {
+        return true;
+    }
+    if (Array.isArray(value)) {
+        return value.every((entry) => isJsonValue(entry));
+    }
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    return Object.values(value).every((entry) => isJsonValue(entry));
+}
+function narrowJsonObject(value) {
+    const out = {};
+    for (const [key, entry] of Object.entries(value)) {
+        if (isJsonValue(entry)) {
+            out[key] = entry;
+        }
+    }
+    return out;
+}
+function unwrapProviderProtocolError(result) {
+    const raw = result.__providerProtocolError;
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+        return;
+    }
+    const error = raw;
+    throw new ProviderProtocolError(String(error.message ?? 'Gemini provider protocol error'), {
+        code: String(error.code ?? 'MALFORMED_RESPONSE'),
+        protocol: typeof error.protocol === 'string' ? error.protocol : 'gemini-chat',
+        providerType: typeof error.providerType === 'string' ? error.providerType : 'gemini',
+        category: error.category === 'TOOL_ERROR' || error.category === 'INTERNAL_ERROR' || error.category === 'EXTERNAL_ERROR'
+            ? error.category
+            : undefined,
+        details: error.details && typeof error.details === 'object' && !Array.isArray(error.details)
+            ? error.details
+            : undefined
+    });
+}
+export function buildOpenAIChatFromGeminiRequest(payload) {
+    const native = runGeminiOpenAIRequestCodecWithNative((payload ?? {}));
+    const request = narrowJsonObject(native);
+    return {
+        ...request,
+        messages: Array.isArray(native.messages) ? native.messages.filter((entry) => isJsonValue(entry)) : []
+    };
+}
+export function buildOpenAIChatFromGeminiResponse(payload) {
+    const result = runGeminiOpenAIResponseCodecWithNative((payload ?? {}));
+    unwrapProviderProtocolError(result);
+    return narrowJsonObject(result);
+}
+export function buildGeminiFromOpenAIChat(chatResp) {
+    const result = runGeminiFromOpenAIChatCodecWithNative((chatResp ?? {}));
+    return narrowJsonObject(result);
+}
+export class GeminiOpenAIConversionCodec {
+    _dependencies;
+    id = 'gemini-openai';
+    initialized = false;
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    constructor(_dependencies) {
+        this._dependencies = _dependencies;
+    }
+    async initialize() {
+        this.initialized = true;
+    }
+    async ensureInit() {
+        if (!this.initialized)
+            await this.initialize();
+    }
+    async convertRequest(payload, _profile, _context) {
+        await this.ensureInit();
+        return buildOpenAIChatFromGeminiRequest(payload);
+    }
+    async convertResponse(payload, _profile, _context) {
+        await this.ensureInit();
+        return buildGeminiFromOpenAIChat(payload);
+    }
+}

package/vendor/@jsonstudio/llms/dist/conversion/codecs/openai-openai-codec.d.ts

@@ -0,0 +1,12 @@
+import type { ConversionCodec, ConversionContext, ConversionProfile } from '../types.js';
+export declare class OpenAIOpenAIConversionCodec implements ConversionCodec {
+    private readonly dependencies;
+    readonly id = "openai-openai";
+    private initialized;
+    private ctxMap;
+    constructor(dependencies: any);
+    initialize(): Promise<void>;
+    convertRequest(payload: any, _profile: ConversionProfile, context: ConversionContext): Promise<any>;
+    convertResponse(payload: any, _profile: ConversionProfile, context: ConversionContext): Promise<any>;
+    private ensureInit;
+}

package/vendor/@jsonstudio/llms/dist/conversion/codecs/openai-openai-codec.js

@@ -0,0 +1,54 @@
+import { runOpenAIRequestCodecWithNative, runOpenAIResponseCodecWithNative } from '../../router/virtual-router/engine-selection/native-compat-action-semantics.js';
+export class OpenAIOpenAIConversionCodec {
+    dependencies;
+    id = 'openai-openai';
+    initialized = false;
+    ctxMap = new Map();
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    constructor(dependencies) {
+        this.dependencies = dependencies;
+    }
+    async initialize() {
+        this.initialized = true;
+    }
+    async convertRequest(payload, _profile, context) {
+        await this.ensureInit();
+        const requestId = context.requestId ?? `req_${Date.now()}`;
+        try {
+            const wantsStream = !!((payload && typeof payload === 'object' && payload.stream === true) ||
+                context?.stream === true ||
+                (context?.metadata && context.metadata.stream === true));
+            const entryEndpoint = String(context.entryEndpoint || context.endpoint || '');
+            this.ctxMap.set(requestId, { stream: wantsStream, entryEndpoint });
+        }
+        catch {
+            // ignore context capture failures
+        }
+        return runOpenAIRequestCodecWithNative((payload ?? {}), {
+            preserveStreamField: true,
+            requestId,
+            entryEndpoint: context.entryEndpoint ?? context.endpoint,
+            endpoint: context.endpoint,
+            stream: context.stream,
+            metadata: context.metadata ?? {}
+        });
+    }
+    async convertResponse(payload, _profile, context) {
+        await this.ensureInit();
+        const ctx = context.requestId ? this.ctxMap.get(context.requestId) : undefined;
+        if (context.requestId) {
+            this.ctxMap.delete(context.requestId);
+        }
+        return runOpenAIResponseCodecWithNative((payload ?? {}), {
+            stream: ctx?.stream === true,
+            endpoint: context.entryEndpoint || context.endpoint || ctx?.entryEndpoint,
+            requestId: context.requestId,
+            reasoningMode: context.metadata?.reasoningMode,
+            idPrefixBase: 'reasoning_choice'
+        });
+    }
+    async ensureInit() {
+        if (!this.initialized)
+            await this.initialize();
+    }
+}

package/vendor/@jsonstudio/llms/dist/conversion/codecs/responses-openai-codec.d.ts

@@ -0,0 +1,12 @@
+import type { ConversionCodec, ConversionContext, ConversionProfile } from '../types.js';
+export declare class ResponsesOpenAIConversionCodec implements ConversionCodec {
+    private readonly dependencies;
+    readonly id = "responses-openai";
+    private initialized;
+    private ctxMap;
+    constructor(dependencies: any);
+    initialize(): Promise<void>;
+    convertRequest(payload: any, _profile: ConversionProfile, context: ConversionContext): Promise<any>;
+    convertResponse(payload: any, _profile: ConversionProfile, context: ConversionContext): Promise<any>;
+    private ensureInit;
+}

package/vendor/@jsonstudio/llms/dist/conversion/codecs/responses-openai-codec.js

@@ -0,0 +1,66 @@
+import { runResponsesOpenAIRequestCodecWithNative, runResponsesOpenAIResponseCodecWithNative } from '../../router/virtual-router/engine-selection/native-compat-action-semantics.js';
+export class ResponsesOpenAIConversionCodec {
+    dependencies;
+    id = 'responses-openai';
+    initialized = false;
+    ctxMap = new Map();
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    constructor(dependencies) {
+        this.dependencies = dependencies;
+    }
+    async initialize() {
+        this.initialized = true;
+    }
+    async convertRequest(payload, _profile, context) {
+        await this.ensureInit();
+        const requestId = context.requestId ?? `req_${Date.now()}`;
+        const native = runResponsesOpenAIRequestCodecWithNative((payload ?? {}), { requestId });
+        const request = native.request && typeof native.request === 'object' && !Array.isArray(native.request)
+            ? native.request
+            : {};
+        const capturedContext = native.context && typeof native.context === 'object' && !Array.isArray(native.context)
+            ? {
+                ...native.context,
+                requestId,
+                endpoint: context.endpoint ?? context.entryEndpoint,
+                entryEndpoint: context.entryEndpoint,
+                targetProtocol: _profile.outgoingProtocol,
+                metadata: native.context &&
+                    typeof native.context.metadata === 'object' &&
+                    !Array.isArray(native.context.metadata)
+                    ? native.context.metadata
+                    : (context.metadata ?? {})
+            }
+            : {
+                requestId,
+                endpoint: context.endpoint ?? context.entryEndpoint,
+                entryEndpoint: context.entryEndpoint,
+                targetProtocol: _profile.outgoingProtocol,
+                metadata: context.metadata ?? {}
+            };
+        this.ctxMap.set(requestId, capturedContext);
+        return request;
+    }
+    async convertResponse(payload, _profile, context) {
+        await this.ensureInit();
+        const requestId = context.requestId;
+        const stored = requestId ? this.ctxMap.get(requestId) : undefined;
+        if (requestId) {
+            this.ctxMap.delete(requestId);
+        }
+        const nativeContext = {
+            ...(stored ?? {}),
+            requestId: requestId ?? stored?.requestId,
+            endpoint: context.endpoint ?? stored?.endpoint,
+            entryEndpoint: context.entryEndpoint ?? context.endpoint ?? stored?.entryEndpoint,
+            metadata: (stored?.metadata && typeof stored.metadata === 'object' && !Array.isArray(stored.metadata)
+                ? stored.metadata
+                : context.metadata) ?? {}
+        };
+        return runResponsesOpenAIResponseCodecWithNative((payload ?? {}), nativeContext);
+    }
+    async ensureInit() {
+        if (!this.initialized)
+            await this.initialize();
+    }
+}

package/vendor/@jsonstudio/llms/dist/conversion/compaction-detect.d.ts

@@ -0,0 +1,2 @@
+import type { JsonObject } from './hub/types/json.js';
+export declare function isCompactionRequest(payload: JsonObject): boolean;

package/vendor/@jsonstudio/llms/dist/conversion/compaction-detect.js

@@ -0,0 +1,4 @@
+import { isCompactionRequestWithNative } from '../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+export function isCompactionRequest(payload) {
+    return isCompactionRequestWithNative(payload);
+}

package/vendor/@jsonstudio/llms/dist/conversion/compat/actions/anthropic-claude-code-system-prompt.d.ts

@@ -0,0 +1,4 @@
+import type { AdapterContext } from '../../hub/types/chat-envelope.js';
+import type { JsonObject } from '../../hub/types/json.js';
+import type { AnthropicClaudeCodeSystemPromptConfig } from '../../hub/pipeline/compat/compat-types.js';
+export declare function applyAnthropicClaudeCodeSystemPromptCompat(payload: JsonObject, config?: AnthropicClaudeCodeSystemPromptConfig, adapterContext?: AdapterContext): JsonObject;

package/vendor/@jsonstudio/llms/dist/conversion/compat/actions/anthropic-claude-code-system-prompt.js

@@ -0,0 +1,42 @@
+import { buildNativeReqOutboundCompatAdapterContext } from '../../hub/pipeline/compat/native-adapter-context.js';
+import { runReqOutboundStage3CompatWithNative } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-req-outbound-semantics.js';
+const PROFILE = 'chat:claude-code';
+const DEFAULT_PROVIDER_PROTOCOL = 'anthropic-messages';
+const DEFAULT_ENTRY_ENDPOINT = '/v1/messages';
+function buildClaudeCodeConfigNode(config) {
+    if (!config) {
+        return undefined;
+    }
+    const node = {};
+    if (typeof config.systemText === 'string' && config.systemText.trim()) {
+        node.systemText = config.systemText.trim();
+    }
+    if (typeof config.preserveExistingSystemAsUserMessage === 'boolean') {
+        node.preserveExistingSystemAsUserMessage = config.preserveExistingSystemAsUserMessage;
+    }
+    return Object.keys(node).length ? node : undefined;
+}
+function buildClaudeCodeCompatContext(adapterContext, config) {
+    const nativeContext = buildNativeReqOutboundCompatAdapterContext(adapterContext);
+    const claudeCode = buildClaudeCodeConfigNode(config);
+    return {
+        ...nativeContext,
+        compatibilityProfile: PROFILE,
+        providerProtocol: nativeContext.providerProtocol ?? adapterContext?.providerProtocol ?? DEFAULT_PROVIDER_PROTOCOL,
+        entryEndpoint: nativeContext.entryEndpoint ?? adapterContext?.entryEndpoint ?? DEFAULT_ENTRY_ENDPOINT,
+        ...(claudeCode ? { claudeCode } : {})
+    };
+}
+function buildClaudeCodeCompatInput(payload, config, adapterContext) {
+    return {
+        payload,
+        adapterContext: buildClaudeCodeCompatContext(adapterContext, config),
+        explicitProfile: PROFILE
+    };
+}
+export function applyAnthropicClaudeCodeSystemPromptCompat(payload, config, adapterContext) {
+    if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+        return payload;
+    }
+    return runReqOutboundStage3CompatWithNative(buildClaudeCodeCompatInput(payload, config, adapterContext)).payload;
+}

package/vendor/@jsonstudio/llms/dist/conversion/compat/actions/anthropic-claude-code-user-id.d.ts

@@ -0,0 +1,3 @@
+import type { AdapterContext } from '../../hub/types/chat-envelope.js';
+import type { JsonObject } from '../../hub/types/json.js';
+export declare function applyAnthropicClaudeCodeUserIdCompat(root: JsonObject, adapterContext?: AdapterContext): void;

package/vendor/@jsonstudio/llms/dist/conversion/compat/actions/anthropic-claude-code-user-id.js

@@ -0,0 +1,30 @@
+import { buildNativeReqOutboundCompatAdapterContext } from '../../hub/pipeline/compat/native-adapter-context.js';
+import { applyAnthropicClaudeCodeUserIdWithNative } from '../../../router/virtual-router/engine-selection/native-compat-action-semantics.js';
+const PROFILE = 'chat:claude-code';
+const DEFAULT_PROVIDER_PROTOCOL = 'anthropic-messages';
+const DEFAULT_ENTRY_ENDPOINT = '/v1/messages';
+function buildClaudeCodeCompatContext(adapterContext) {
+    const nativeContext = buildNativeReqOutboundCompatAdapterContext(adapterContext);
+    return {
+        ...nativeContext,
+        compatibilityProfile: PROFILE,
+        providerProtocol: nativeContext.providerProtocol ??
+            adapterContext?.providerProtocol ??
+            DEFAULT_PROVIDER_PROTOCOL,
+        entryEndpoint: nativeContext.entryEndpoint ??
+            adapterContext?.entryEndpoint ??
+            DEFAULT_ENTRY_ENDPOINT,
+    };
+}
+export function applyAnthropicClaudeCodeUserIdCompat(root, adapterContext) {
+    if (!root || typeof root !== 'object' || Array.isArray(root)) {
+        return;
+    }
+    const normalized = applyAnthropicClaudeCodeUserIdWithNative(root, buildClaudeCodeCompatContext(adapterContext));
+    for (const key of Object.keys(root)) {
+        if (!(key in normalized)) {
+            delete root[key];
+        }
+    }
+    Object.assign(root, normalized);
+}

package/vendor/@jsonstudio/llms/dist/conversion/compat/actions/antigravity-thought-signature-cache.d.ts

@@ -0,0 +1,3 @@
+import type { AdapterContext } from '../../hub/types/chat-envelope.js';
+import type { JsonObject } from '../../hub/types/json.js';
+export declare function cacheAntigravityThoughtSignatureFromGeminiResponse(payload: JsonObject, adapterContext?: AdapterContext): JsonObject;

package/vendor/@jsonstudio/llms/dist/conversion/compat/actions/antigravity-thought-signature-cache.js

@@ -0,0 +1,8 @@
+import { runRespInboundStage3CompatWithNative } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-req-outbound-semantics.js';
+import { buildGeminiCliCompatInput } from './gemini-cli-request.js';
+export function cacheAntigravityThoughtSignatureFromGeminiResponse(payload, adapterContext) {
+    if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+        return payload;
+    }
+    return runRespInboundStage3CompatWithNative(buildGeminiCliCompatInput(payload, adapterContext)).payload;
+}