@jsonstudio/llms 0.6.2172 → 0.6.3214

package/dist/router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.d.ts

@@ -0,0 +1,46 @@
+export type { NativeContextToolOutput, NativeResumeToolOutput } from './native-hub-pipeline-inbound-outbound-semantics.js';
+export interface NativeReqInboundSemanticLiftApplyInput {
+    chatEnvelope: Record<string, unknown>;
+    payload?: Record<string, unknown>;
+    protocol?: string;
+    entryEndpoint?: string;
+    responsesResume?: Record<string, unknown>;
+}
+export type NativeProviderProtocolToken = NonNullable<NativeReqInboundSemanticLiftApplyInput['protocol']>;
+export interface NativeReqInboundChatToStandardizedInput {
+    chatEnvelope: Record<string, unknown>;
+    adapterContext: Record<string, unknown>;
+    endpoint: string;
+    requestId?: string;
+}
+export declare function sanitizeReqInboundFormatEnvelopeWithNative<T>(candidate: unknown): T;
+export declare function mapReqInboundResumeToolOutputsDetailedWithNative(responsesResume: unknown): Array<{
+    tool_call_id: string;
+    content: string;
+}>;
+export declare function resolveClientInjectReadyWithNative(metadata: Record<string, unknown>): boolean;
+export declare function normalizeContextCaptureLabelWithNative(label: string | undefined): string;
+export declare function shouldRunHubChatProcessWithNative(requestId: string, entryEndpoint: string): boolean;
+export declare function normalizeProviderProtocolTokenWithNative(value: string | undefined): string | undefined;
+export declare function isShellLikeToolNameTokenWithNative(name: string | undefined): boolean;
+export declare function applyReqInboundSemanticLiftWithNative(input: NativeReqInboundSemanticLiftApplyInput): Record<string, unknown>;
+export declare function chatEnvelopeToStandardizedWithNative(input: NativeReqInboundChatToStandardizedInput): Record<string, unknown>;
+export declare function resolveReqInboundServerToolFollowupSnapshotWithNative(adapterContext: unknown): Record<string, unknown> | undefined;
+export declare function augmentReqInboundContextSnapshotWithNative(context: Record<string, unknown>, fallbackSnapshot: Record<string, unknown>): Record<string, unknown>;
+export declare function normalizeReqInboundToolCallIdStyleWithNative(value: unknown): 'fc' | 'preserve' | undefined;
+export declare function mapReqInboundBridgeToolsToChatWithNative(rawTools: unknown): Array<Record<string, unknown>>;
+export declare function captureReqInboundResponsesContextSnapshotWithNative(input: {
+    rawRequest: Record<string, unknown>;
+    requestId?: string;
+    toolCallIdStyle?: unknown;
+}): Record<string, unknown>;
+export declare function collectReqInboundToolOutputsWithNative(payload: unknown): Array<{
+    tool_call_id: string;
+    call_id: string;
+    output?: string;
+    name?: string;
+}>;
+export declare function buildReqInboundToolOutputSnapshotWithNative(payload: Record<string, unknown>, providerProtocol: string | undefined): Record<string, unknown>;
+export declare function appendReqInboundToolParseDiagnosticTextWithNative(outputText: string, toolName: string | undefined): string | undefined;
+export declare function injectReqInboundToolParseDiagnosticsWithNative(payload: Record<string, unknown>): void;
+export declare function normalizeReqInboundShellLikeToolCallsWithNative(payload: Record<string, unknown>): void;

package/dist/router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js

@@ -0,0 +1,503 @@
+import { failNativeRequired, isNativeDisabledByEnv } from './native-router-hotpath-policy.js';
+import { loadNativeRouterHotpathBindingForInternalUse } from './native-router-hotpath.js';
+import { sanitizeFormatEnvelopeWithNative } from './native-hub-pipeline-edge-stage-semantics.js';
+import { augmentContextSnapshotWithNative, collectToolOutputsWithNative, mapResumeToolOutputsDetailedWithNative, normalizeToolCallIdStyleCandidateWithNative, resolveServerToolFollowupSnapshotWithNative } from './native-hub-pipeline-inbound-outbound-semantics.js';
+function readNativeFunction(name) {
+    const binding = loadNativeRouterHotpathBindingForInternalUse();
+    const fn = binding?.[name];
+    return typeof fn === 'function' ? fn : null;
+}
+function parseOptionalString(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (parsed === null) {
+            return undefined;
+        }
+        if (typeof parsed !== 'string') {
+            return null;
+        }
+        const normalized = parsed.trim();
+        return normalized ? normalized : undefined;
+    }
+    catch {
+        return null;
+    }
+}
+function parseBoolean(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        return typeof parsed === 'boolean' ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+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 parseArray(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        return Array.isArray(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function parseToolOutputSnapshotBuildResult(raw) {
+    const parsed = parseRecord(raw);
+    if (!parsed) {
+        return null;
+    }
+    const snapshot = parsed.snapshot;
+    const payload = parsed.payload;
+    if (!snapshot || typeof snapshot !== 'object' || Array.isArray(snapshot)) {
+        return null;
+    }
+    if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+        return null;
+    }
+    return {
+        snapshot: snapshot,
+        payload: payload
+    };
+}
+function safeStringify(value) {
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+function replaceRecord(target, source) {
+    for (const key of Object.keys(target)) {
+        if (!Object.prototype.hasOwnProperty.call(source, key)) {
+            delete target[key];
+        }
+    }
+    Object.assign(target, source);
+}
+export function sanitizeReqInboundFormatEnvelopeWithNative(candidate) {
+    return sanitizeFormatEnvelopeWithNative(candidate);
+}
+export function mapReqInboundResumeToolOutputsDetailedWithNative(responsesResume) {
+    return mapResumeToolOutputsDetailedWithNative(responsesResume);
+}
+export function resolveClientInjectReadyWithNative(metadata) {
+    const capability = 'resolveClientInjectReadyJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction('resolveClientInjectReadyJson');
+    if (!fn) {
+        return fail();
+    }
+    const metadataJson = safeStringify(metadata);
+    if (!metadataJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(metadataJson);
+        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 normalizeContextCaptureLabelWithNative(label) {
+    const capability = 'normalizeContextCaptureLabelJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction('normalizeContextCaptureLabelJson');
+    if (!fn) {
+        return fail();
+    }
+    const labelJson = safeStringify(label ?? null);
+    if (!labelJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(labelJson);
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        const parsed = parseOptionalString(raw);
+        if (parsed === null) {
+            return fail('invalid payload');
+        }
+        return parsed ?? 'context_capture';
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
+export function shouldRunHubChatProcessWithNative(requestId, entryEndpoint) {
+    const capability = 'shouldRunHubChatProcessJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction('shouldRunHubChatProcessJson');
+    if (!fn) {
+        return fail();
+    }
+    try {
+        const raw = fn(requestId, entryEndpoint);
+        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 normalizeProviderProtocolTokenWithNative(value) {
+    const capability = 'normalizeProviderProtocolTokenJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction('normalizeProviderProtocolTokenJson');
+    if (!fn) {
+        return fail();
+    }
+    const valueJson = safeStringify(value ?? null);
+    if (!valueJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(valueJson);
+        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 isShellLikeToolNameTokenWithNative(name) {
+    const capability = 'isShellLikeToolNameTokenJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction('isShellLikeToolNameTokenJson');
+    if (!fn) {
+        return fail();
+    }
+    const nameJson = safeStringify(name ?? null);
+    if (!nameJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(nameJson);
+        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 applyReqInboundSemanticLiftWithNative(input) {
+    const capability = 'applyReqInboundSemanticLiftJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction('applyReqInboundSemanticLiftJson');
+    if (!fn) {
+        return fail();
+    }
+    const inputJson = safeStringify(input);
+    if (!inputJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(inputJson);
+        if (raw instanceof Error) {
+            return fail(raw.message || 'native error');
+        }
+        if (raw && typeof raw === 'object' && 'message' in raw) {
+            const message = raw.message;
+            if (typeof message === 'string' && message.trim().length) {
+                return fail(message.trim());
+            }
+        }
+        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 chatEnvelopeToStandardizedWithNative(input) {
+    const capability = 'chatEnvelopeToStandardizedJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const chatJson = safeStringify(input.chatEnvelope);
+    const adapterContextJson = safeStringify(input.adapterContext);
+    if (!chatJson || !adapterContextJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(chatJson, adapterContextJson, String(input.endpoint || ''), input.requestId);
+        if (raw instanceof Error) {
+            return fail(raw.message || 'native error');
+        }
+        if (raw && typeof raw === 'object' && 'message' in raw) {
+            const message = raw.message;
+            if (typeof message === 'string' && message.trim().length) {
+                return fail(message.trim());
+            }
+        }
+        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 resolveReqInboundServerToolFollowupSnapshotWithNative(adapterContext) {
+    return resolveServerToolFollowupSnapshotWithNative(adapterContext);
+}
+export function augmentReqInboundContextSnapshotWithNative(context, fallbackSnapshot) {
+    return augmentContextSnapshotWithNative(context, fallbackSnapshot);
+}
+export function normalizeReqInboundToolCallIdStyleWithNative(value) {
+    return normalizeToolCallIdStyleCandidateWithNative(value);
+}
+export function mapReqInboundBridgeToolsToChatWithNative(rawTools) {
+    const capability = 'mapBridgeToolsToChatJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const payloadJson = safeStringify(Array.isArray(rawTools) ? rawTools : []);
+    if (!payloadJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(payloadJson);
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        const parsed = parseArray(raw);
+        if (!parsed) {
+            return fail('invalid payload');
+        }
+        return parsed.filter((entry) => Boolean(entry) && typeof entry === 'object' && !Array.isArray(entry));
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
+export function captureReqInboundResponsesContextSnapshotWithNative(input) {
+    const capability = 'captureReqInboundResponsesContextSnapshotJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const inputJson = safeStringify({
+        rawRequest: input.rawRequest,
+        requestId: input.requestId,
+        toolCallIdStyle: input.toolCallIdStyle
+    });
+    if (!inputJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(inputJson);
+        if (raw instanceof Error) {
+            return fail(raw.message || 'native error');
+        }
+        if (raw && typeof raw === 'object' && 'message' in raw) {
+            const message = raw.message;
+            if (typeof message === 'string' && message.trim().length) {
+                return fail(message.trim());
+            }
+        }
+        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 collectReqInboundToolOutputsWithNative(payload) {
+    return collectToolOutputsWithNative(payload);
+}
+export function buildReqInboundToolOutputSnapshotWithNative(payload, providerProtocol) {
+    const capability = 'buildReqInboundToolOutputSnapshotJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const payloadJson = safeStringify(payload);
+    const providerProtocolJson = safeStringify(providerProtocol ?? null);
+    if (!payloadJson || !providerProtocolJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(payloadJson, providerProtocolJson);
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        const parsed = parseToolOutputSnapshotBuildResult(raw);
+        if (!parsed) {
+            return fail('invalid payload');
+        }
+        replaceRecord(payload, parsed.payload);
+        return parsed.snapshot;
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
+export function appendReqInboundToolParseDiagnosticTextWithNative(outputText, toolName) {
+    const capability = 'appendToolParseDiagnosticTextJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction('appendToolParseDiagnosticTextJson');
+    if (!fn) {
+        return fail();
+    }
+    const toolNameJson = safeStringify(toolName ?? null);
+    if (!toolNameJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(outputText, toolNameJson);
+        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 injectReqInboundToolParseDiagnosticsWithNative(payload) {
+    const capability = 'injectToolParseDiagnosticsJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction('injectToolParseDiagnosticsJson');
+    if (!fn) {
+        return fail();
+    }
+    try {
+        const payloadJson = JSON.stringify(payload);
+        if (typeof payloadJson !== 'string') {
+            return fail('json stringify failed');
+        }
+        const raw = fn(payloadJson);
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        const parsed = parseRecord(raw);
+        if (!parsed) {
+            return fail('invalid payload');
+        }
+        replaceRecord(payload, parsed);
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
+export function normalizeReqInboundShellLikeToolCallsWithNative(payload) {
+    const capability = 'normalizeShellLikeToolCallsBeforeGovernanceJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction('normalizeShellLikeToolCallsBeforeGovernanceJson');
+    if (!fn) {
+        return fail();
+    }
+    try {
+        const payloadJson = JSON.stringify(payload);
+        if (typeof payloadJson !== 'string') {
+            return fail('json stringify failed');
+        }
+        const raw = fn(payloadJson);
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        const parsed = parseRecord(raw);
+        if (!parsed) {
+            return fail('invalid payload');
+        }
+        replaceRecord(payload, parsed);
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}

package/dist/router/virtual-router/engine-selection/native-hub-pipeline-req-outbound-semantics.d.ts

@@ -0,0 +1,146 @@
+import type { JsonObject } from '../../../conversion/hub/types/json.js';
+export interface NativeReqOutboundContextMergePlanInput {
+    snapshot?: Record<string, unknown>;
+    existingToolOutputs?: unknown[];
+    hasExistingTools: boolean;
+}
+export interface NativeReqOutboundFormatBuildInput {
+    formatEnvelope: Record<string, unknown>;
+    protocol: string;
+}
+export interface NativeReqOutboundContextMergePlan {
+    mergedToolOutputs?: Array<{
+        tool_call_id: string;
+        content: string;
+        name?: string;
+    }>;
+    normalizedTools?: unknown[];
+}
+export interface NativeReqOutboundContextSnapshotPatchInput {
+    chatEnvelope: Record<string, unknown>;
+    snapshot: Record<string, unknown>;
+}
+export interface NativeReqOutboundContextSnapshotPatch {
+    toolOutputs?: Array<{
+        tool_call_id: string;
+        content: string;
+        name?: string;
+    }>;
+    tools?: Array<{
+        type: 'function';
+        function: {
+            name: string;
+            description?: string;
+            parameters: unknown;
+            strict?: boolean;
+        };
+    }>;
+}
+export interface NativeReqOutboundCompatAdapterContextInput {
+    __rt?: Record<string, unknown>;
+    compatibilityProfile?: string;
+    providerProtocol?: string;
+    providerId?: string;
+    providerKey?: string;
+    runtimeKey?: string;
+    requestId?: string;
+    clientRequestId?: string;
+    groupRequestId?: string;
+    sessionId?: string;
+    conversationId?: string;
+    entryEndpoint?: string;
+    routeId?: string;
+    capturedChatRequest?: JsonObject;
+    deepseek?: Record<string, unknown>;
+    estimatedInputTokens?: number;
+    modelId?: string;
+    clientModelId?: string;
+    originalModelId?: string;
+}
+export interface NativeReqOutboundStandardizedToChatInput {
+    request: JsonObject;
+    adapterContext: NativeReqOutboundCompatAdapterContextInput;
+}
+export interface NativeReqOutboundStage3CompatInput {
+    payload: JsonObject;
+    adapterContext: NativeReqOutboundCompatAdapterContextInput;
+    explicitProfile?: string;
+}
+export interface NativeReqOutboundStage3CompatOutput {
+    payload: JsonObject;
+    appliedProfile?: string;
+    nativeApplied: boolean;
+    rateLimitDetected?: boolean;
+}
+export interface NativeRespInboundStage3CompatInput {
+    payload: JsonObject;
+    adapterContext: NativeReqOutboundCompatAdapterContextInput;
+    explicitProfile?: string;
+}
+export type NativeRespInboundStage3CompatOutput = NativeReqOutboundStage3CompatOutput;
+export interface NativeToolSessionCompatInput {
+    messages: unknown[];
+    toolOutputs?: unknown[];
+}
+export interface NativeToolSessionCompatOutput {
+    messages: unknown[];
+    toolOutputs?: unknown[];
+}
+export interface NativeToolSessionHistoryUpdateInput {
+    messages: unknown[];
+    existingHistory?: {
+        lastMessages: Array<{
+            role: string;
+            toolUse?: {
+                id: string;
+                name?: string;
+            };
+            toolResult?: {
+                id: string;
+                name?: string;
+                status: string;
+            };
+            ts: string;
+        }>;
+        pendingToolUses: Record<string, {
+            name?: string;
+            ts: string;
+        }>;
+        updatedAt: string;
+    };
+    maxMessages?: number;
+    nowIso?: string;
+}
+export interface NativeToolSessionHistoryUpdateOutput {
+    history?: {
+        lastMessages: Array<{
+            role: string;
+            toolUse?: {
+                id: string;
+                name?: string;
+            };
+            toolResult?: {
+                id: string;
+                name?: string;
+                status: string;
+            };
+            ts: string;
+        }>;
+        pendingToolUses: Record<string, {
+            name?: string;
+            ts: string;
+        }>;
+        updatedAt: string;
+    };
+    recordsCount: number;
+}
+export declare function resolveReqOutboundContextMergePlanWithNative(input: NativeReqOutboundContextMergePlanInput): NativeReqOutboundContextMergePlan;
+export declare function buildReqOutboundFormatPayloadWithNative(input: NativeReqOutboundFormatBuildInput): JsonObject;
+export declare function applyReqOutboundContextSnapshotWithNative(input: NativeReqOutboundContextSnapshotPatchInput): NativeReqOutboundContextSnapshotPatch;
+export declare function runReqOutboundStage3CompatWithNative(input: NativeReqOutboundStage3CompatInput): NativeReqOutboundStage3CompatOutput;
+export declare function runRespInboundStage3CompatWithNative(input: NativeRespInboundStage3CompatInput): NativeRespInboundStage3CompatOutput;
+export declare function normalizeToolSessionMessagesWithNative(input: NativeToolSessionCompatInput): NativeToolSessionCompatOutput;
+export declare function updateToolSessionHistoryWithNative(input: NativeToolSessionHistoryUpdateInput): NativeToolSessionHistoryUpdateOutput;
+export declare function applyClaudeThinkingToolSchemaCompatWithNative(payload: JsonObject): JsonObject;
+export declare function standardizedToChatEnvelopeWithNative(input: NativeReqOutboundStandardizedToChatInput): JsonObject;
+export declare function shouldAttachReqOutboundContextSnapshotWithNative(hasSnapshot: boolean, contextMetadataKey: string | undefined): boolean;