@jsonstudio/rcc 0.90.323 → 0.90.364

package/vendor/@jsonstudio/llms/dist/router/virtual-router/engine-selection/native-router-hotpath-policy.js

@@ -0,0 +1,18 @@
+export function isNativeDisabledByEnv() {
+    return false;
+}
+export function isNativeRequiredByEnv() {
+    return true;
+}
+export function hasCompleteNativeBinding(binding, requiredExports) {
+    if (!binding || typeof binding !== 'object')
+        return false;
+    const row = binding;
+    return requiredExports.every((key) => typeof row[key] === 'function');
+}
+export function makeNativeRequiredError(capability, reason) {
+    return new Error(`[virtual-router-native-hotpath] native ${capability} is required but unavailable${reason ? `: ${reason}` : ''}`);
+}
+export function failNativeRequired(capability, reason) {
+    throw makeNativeRequiredError(capability, reason);
+}

package/vendor/@jsonstudio/llms/dist/router/virtual-router/engine-selection/native-router-hotpath-quota-buckets.d.ts

@@ -0,0 +1,25 @@
+export type QuotaBucketInputEntry = {
+    key: string;
+    order: number;
+    hasQuota: boolean;
+    inPool: boolean;
+    cooldownUntil?: number;
+    blacklistUntil?: number;
+    priorityTier?: number;
+    selectionPenalty?: number;
+};
+type QuotaBucketOutputEntry = {
+    key: string;
+    penalty: number;
+    order: number;
+};
+export type QuotaBucketResult = {
+    priorities: number[];
+    buckets: Map<number, QuotaBucketOutputEntry[]>;
+};
+type HotpathMode = 'auto' | 'native-only';
+export declare function buildQuotaBuckets(entries: QuotaBucketInputEntry[], nowMs: number): QuotaBucketResult;
+export declare function buildQuotaBucketsWithMode(entries: QuotaBucketInputEntry[], nowMs: number, mode: HotpathMode | string): QuotaBucketResult;
+export declare function getNativeRouterHotpathSource(): 'native' | 'unavailable';
+export declare function resolveNativeModuleUrlFromEnv(): string | undefined;
+export {};

package/vendor/@jsonstudio/llms/dist/router/virtual-router/engine-selection/native-router-hotpath-quota-buckets.js

@@ -0,0 +1,85 @@
+import { loadNativeRouterHotpathBinding, resolveNativeModuleUrlFromEnv as resolveNativeModuleUrlFromEnvInLoader } from './native-router-hotpath-loader.js';
+function coerceNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+function parseNativePayload(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (!parsed || !Array.isArray(parsed.priorities) || !Array.isArray(parsed.buckets)) {
+            return null;
+        }
+        const buckets = new Map();
+        for (const tier of parsed.buckets) {
+            const priority = coerceNumber(tier.priority);
+            if (priority === undefined) {
+                continue;
+            }
+            const entriesRaw = Array.isArray(tier.entries)
+                ? tier.entries
+                : [];
+            const entries = [];
+            for (const item of entriesRaw) {
+                if (!item || typeof item !== 'object' || Array.isArray(item)) {
+                    continue;
+                }
+                const row = item;
+                const key = typeof row.key === 'string' ? row.key : '';
+                const penalty = coerceNumber(row.penalty) ?? 0;
+                const order = coerceNumber(row.order) ?? 0;
+                if (!key) {
+                    continue;
+                }
+                entries.push({ key, penalty, order });
+            }
+            buckets.set(priority, entries);
+        }
+        const priorities = parsed.priorities
+            .map((value) => coerceNumber(value))
+            .filter((value) => value !== undefined)
+            .sort((a, b) => a - b);
+        return { priorities, buckets };
+    }
+    catch {
+        return null;
+    }
+}
+function computeQuotaBucketsNative(entries, nowMs) {
+    const binding = loadNativeRouterHotpathBinding();
+    const fn = binding?.computeQuotaBucketsJson;
+    if (typeof fn !== 'function') {
+        return null;
+    }
+    try {
+        const resultJson = fn(JSON.stringify(entries), nowMs);
+        if (typeof resultJson !== 'string' || !resultJson) {
+            return null;
+        }
+        return parseNativePayload(resultJson);
+    }
+    catch {
+        return null;
+    }
+}
+export function buildQuotaBuckets(entries, nowMs) {
+    return buildQuotaBucketsWithMode(entries, nowMs, 'auto');
+}
+export function buildQuotaBucketsWithMode(entries, nowMs, mode) {
+    if (mode !== 'auto' && mode !== 'native-only') {
+        throw new Error(`[virtual-router-native-hotpath] unsupported hotpath mode: ${String(mode)}`);
+    }
+    const nativeResult = computeQuotaBucketsNative(entries, nowMs);
+    if (nativeResult) {
+        return nativeResult;
+    }
+    throw new Error('[virtual-router-native-hotpath] native router hotpath is required but unavailable');
+}
+export function getNativeRouterHotpathSource() {
+    const binding = loadNativeRouterHotpathBinding();
+    if (typeof binding?.computeQuotaBucketsJson === 'function') {
+        return 'native';
+    }
+    return 'unavailable';
+}
+export function resolveNativeModuleUrlFromEnv() {
+    return resolveNativeModuleUrlFromEnvInLoader();
+}

package/vendor/@jsonstudio/llms/dist/router/virtual-router/engine-selection/native-router-hotpath.d.ts

@@ -0,0 +1,59 @@
+export { buildQuotaBuckets, buildQuotaBucketsWithMode, getNativeRouterHotpathSource, resolveNativeModuleUrlFromEnv, type QuotaBucketInputEntry, type QuotaBucketResult } from './native-router-hotpath-quota-buckets.js';
+export declare function splitAntigravityTargets(targets: string[]): {
+    nonAntigravity: string[];
+    hasAntigravity: boolean;
+    source: 'native';
+};
+export declare function analyzePendingToolSync(messages: unknown[], afterToolCallIds: string[]): {
+    ready: boolean;
+    insertAt: number;
+    source: 'native';
+};
+export declare function analyzeContinueExecutionInjection(messages: unknown[], marker: string, targetText: string): {
+    hasDirective: boolean;
+    source: 'native';
+};
+export declare function stripClockClearDirectiveText(text: string): {
+    hadClear: boolean;
+    next: string;
+    source: 'native';
+};
+export declare function analyzeChatProcessMedia(messages: unknown[]): {
+    stripIndices: number[];
+    containsCurrentTurnImage: boolean;
+    source: 'native';
+};
+export declare function stripChatProcessHistoricalImages(messages: unknown[], placeholderText: string): {
+    changed: boolean;
+    messages: unknown[];
+    source: 'native';
+};
+export declare function analyzeChatWebSearchIntent(messages: unknown[]): {
+    hasIntent: boolean;
+    googlePreferred: boolean;
+    source: 'native';
+};
+export declare function analyzeProviderKey(providerKey: string): {
+    providerId: string | null;
+    alias: string | null;
+    keyIndex?: number;
+    source: 'native';
+};
+export declare function extractAntigravityGeminiSessionIdWithNative(payload: unknown): string;
+export declare function lookupAntigravityPinnedAliasForSessionIdWithNative(sessionId: string, options?: {
+    hydrate?: boolean;
+}): string | undefined;
+export declare function unpinAntigravitySessionAliasForSessionIdWithNative(sessionId: string): boolean;
+export declare function cacheAntigravitySessionSignatureWithNative(input: {
+    aliasKey: string;
+    sessionId: string;
+    signature: string;
+    messageCount?: number;
+}): boolean;
+export declare function getAntigravityRequestSessionMetaWithNative(requestId: string): {
+    aliasKey?: string;
+    sessionId?: string;
+    messageCount?: number;
+};
+export declare function resetAntigravitySignatureCachesWithNative(): boolean;
+export declare function loadNativeRouterHotpathBindingForInternalUse(): unknown;

package/vendor/@jsonstudio/llms/dist/router/virtual-router/engine-selection/native-router-hotpath.js

@@ -0,0 +1,117 @@
+import { parseAntigravityPinnedAliasLookupPayload, parseAntigravityPinnedAliasUnpinPayload, parseAntigravityCacheSignaturePayload, parseAntigravityRequestSessionMetaPayload, parseAntigravitySessionIdPayload, parseClockClearDirectivePayload, parseChatProcessMediaAnalysisPayload, parseChatProcessMediaStripPayload, parseChatWebSearchIntentPayload, parseContinueExecutionInjectionPayload, parsePendingToolSyncPayload, parseProviderKeyPayload } from './native-router-hotpath-analysis.js';
+import { isNativeDisabledByEnv, makeNativeRequiredError } from './native-router-hotpath-policy.js';
+import { loadNativeRouterHotpathBinding } from './native-router-hotpath-loader.js';
+export { buildQuotaBuckets, buildQuotaBucketsWithMode, getNativeRouterHotpathSource, resolveNativeModuleUrlFromEnv } from './native-router-hotpath-quota-buckets.js';
+function parseAntigravitySplitPayload(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (!parsed || !Array.isArray(parsed.nonAntigravity) || typeof parsed.hasAntigravity !== 'boolean') {
+            return null;
+        }
+        const nonAntigravity = parsed.nonAntigravity.filter((value) => typeof value === 'string');
+        return {
+            nonAntigravity,
+            hasAntigravity: parsed.hasAntigravity
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function toErrorReason(error) {
+    return error instanceof Error ? error.message : String(error ?? 'unknown');
+}
+function requireNativeFunction(capability, exportName) {
+    if (isNativeDisabledByEnv()) {
+        throw makeNativeRequiredError(capability, 'native disabled');
+    }
+    const binding = loadNativeRouterHotpathBinding();
+    const fn = binding?.[exportName];
+    if (typeof fn !== 'function') {
+        throw makeNativeRequiredError(capability);
+    }
+    return fn;
+}
+function callNativeJson(capability, exportName, args, parse) {
+    const fn = requireNativeFunction(capability, exportName);
+    let raw;
+    try {
+        raw = fn(...args);
+    }
+    catch (error) {
+        throw makeNativeRequiredError(capability, toErrorReason(error));
+    }
+    if (typeof raw !== 'string' || !raw) {
+        throw makeNativeRequiredError(capability, 'empty result');
+    }
+    const parsed = parse(raw);
+    if (!parsed) {
+        throw makeNativeRequiredError(capability, 'invalid payload');
+    }
+    return parsed;
+}
+export function splitAntigravityTargets(targets) {
+    const parsed = callNativeJson('splitAntigravityTargetsJson', 'splitAntigravityTargetsJson', [JSON.stringify(targets)], parseAntigravitySplitPayload);
+    return { ...parsed, source: 'native' };
+}
+export function analyzePendingToolSync(messages, afterToolCallIds) {
+    const parsed = callNativeJson('analyzePendingToolSyncJson', 'analyzePendingToolSyncJson', [JSON.stringify(messages), JSON.stringify(afterToolCallIds)], parsePendingToolSyncPayload);
+    return { ...parsed, source: 'native' };
+}
+export function analyzeContinueExecutionInjection(messages, marker, targetText) {
+    const normalizedMarker = typeof marker === 'string' ? marker.trim() : '';
+    const normalizedTargetText = typeof targetText === 'string' ? targetText.trim() : '';
+    const parsed = callNativeJson('analyzeContinueExecutionInjectionJson', 'analyzeContinueExecutionInjectionJson', [JSON.stringify(messages), normalizedMarker, normalizedTargetText], parseContinueExecutionInjectionPayload);
+    return { ...parsed, source: 'native' };
+}
+export function stripClockClearDirectiveText(text) {
+    const parsed = callNativeJson('stripClockClearDirectiveTextJson', 'stripClockClearDirectiveTextJson', [String(text || '')], parseClockClearDirectivePayload);
+    return { ...parsed, source: 'native' };
+}
+export function analyzeChatProcessMedia(messages) {
+    const parsed = callNativeJson('analyzeChatProcessMediaJson', 'analyzeChatProcessMediaJson', [JSON.stringify(messages)], parseChatProcessMediaAnalysisPayload);
+    return { ...parsed, source: 'native' };
+}
+export function stripChatProcessHistoricalImages(messages, placeholderText) {
+    const parsed = callNativeJson('stripChatProcessHistoricalImagesJson', 'stripChatProcessHistoricalImagesJson', [JSON.stringify(messages), String(placeholderText || '[Image omitted]')], parseChatProcessMediaStripPayload);
+    return { ...parsed, source: 'native' };
+}
+export function analyzeChatWebSearchIntent(messages) {
+    const parsed = callNativeJson('analyzeChatWebSearchIntentJson', 'analyzeChatWebSearchIntentJson', [JSON.stringify(messages)], parseChatWebSearchIntentPayload);
+    return { ...parsed, source: 'native' };
+}
+export function analyzeProviderKey(providerKey) {
+    const parsed = callNativeJson('parseProviderKeyJson', 'parseProviderKeyJson', [String(providerKey || '')], parseProviderKeyPayload);
+    return { ...parsed, source: 'native' };
+}
+export function extractAntigravityGeminiSessionIdWithNative(payload) {
+    const parsed = callNativeJson('extractAntigravityGeminiSessionIdJson', 'extractAntigravityGeminiSessionIdJson', [JSON.stringify(payload ?? null)], parseAntigravitySessionIdPayload);
+    return parsed.sessionId;
+}
+export function lookupAntigravityPinnedAliasForSessionIdWithNative(sessionId, options) {
+    const parsed = callNativeJson('lookupAntigravityPinnedAliasForSessionIdJson', 'lookupAntigravityPinnedAliasForSessionIdJson', [JSON.stringify({ sessionId: String(sessionId || ''), hydrate: options?.hydrate !== false })], parseAntigravityPinnedAliasLookupPayload);
+    return parsed.alias;
+}
+export function unpinAntigravitySessionAliasForSessionIdWithNative(sessionId) {
+    const parsed = callNativeJson('unpinAntigravitySessionAliasForSessionIdJson', 'unpinAntigravitySessionAliasForSessionIdJson', [JSON.stringify({ sessionId: String(sessionId || '') })], parseAntigravityPinnedAliasUnpinPayload);
+    return parsed.changed;
+}
+export function cacheAntigravitySessionSignatureWithNative(input) {
+    const parsed = callNativeJson('cacheAntigravitySessionSignatureJson', 'cacheAntigravitySessionSignatureJson', [JSON.stringify({
+            aliasKey: String(input.aliasKey || ''),
+            sessionId: String(input.sessionId || ''),
+            signature: String(input.signature || ''),
+            messageCount: typeof input.messageCount === 'number' ? Math.floor(input.messageCount) : undefined
+        })], parseAntigravityCacheSignaturePayload);
+    return parsed.ok;
+}
+export function getAntigravityRequestSessionMetaWithNative(requestId) {
+    return callNativeJson('getAntigravityRequestSessionMetaJson', 'getAntigravityRequestSessionMetaJson', [JSON.stringify({ requestId: String(requestId || '') })], parseAntigravityRequestSessionMetaPayload);
+}
+export function resetAntigravitySignatureCachesWithNative() {
+    const parsed = callNativeJson('resetAntigravitySignatureCachesJson', 'resetAntigravitySignatureCachesJson', ['{}'], parseAntigravityCacheSignaturePayload);
+    return parsed.ok;
+}
+export function loadNativeRouterHotpathBindingForInternalUse() {
+    return loadNativeRouterHotpathBinding();
+}

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

@@ -0,0 +1,243 @@
+export declare function parseLenientJsonishWithNative(value: unknown): unknown;
+export declare function repairArgumentsToStringWithNative(value: unknown): string;
+export declare function extractToolCallsFromReasoningTextWithNative(text: string, idPrefix?: string): {
+    cleanedText: string;
+    toolCalls: Array<Record<string, unknown>>;
+};
+export declare function extractReasoningSegmentsWithNative(source: string): {
+    text: string;
+    segments: string[];
+};
+export declare function normalizeAssistantTextToToolCallsWithNative(message: Record<string, unknown>, options?: Record<string, unknown>): Record<string, unknown>;
+export declare function normalizeReasoningInChatPayloadWithNative(payload: unknown): unknown;
+export declare function normalizeReasoningInResponsesPayloadWithNative(payload: unknown, options?: Record<string, unknown>): unknown;
+export declare function normalizeReasoningInGeminiPayloadWithNative(payload: unknown): unknown;
+export declare function normalizeReasoningInAnthropicPayloadWithNative(payload: unknown): unknown;
+export declare function normalizeReasoningInOpenAIPayloadWithNative(payload: unknown): unknown;
+export declare function bridgeToolToChatDefinitionWithNative(tool: Record<string, unknown>, options?: {
+    sanitizeMode?: string;
+}): Record<string, unknown> | null;
+export declare function chatToolToBridgeDefinitionWithNative(tool: Record<string, unknown>, options?: {
+    sanitizeMode?: string;
+}): Record<string, unknown> | null;
+export declare function mapBridgeToolsToChatWithNative(rawTools: unknown, options?: {
+    sanitizeMode?: string;
+}): Array<Record<string, unknown>>;
+export declare function mapChatToolsToBridgeWithNative(rawTools: unknown, options?: {
+    sanitizeMode?: string;
+}): Array<Record<string, unknown>>;
+export declare function collectToolCallsFromResponsesWithNative(response: Record<string, unknown>): Array<Record<string, unknown>>;
+export declare function resolveFinishReasonWithNative(response: Record<string, unknown>, toolCalls: Array<Record<string, unknown>>): string;
+export declare function buildChatResponseFromResponsesWithNative(payload: unknown): Record<string, unknown> | null;
+export declare function hasValidThoughtSignatureWithNative(block: unknown, options?: Record<string, unknown>): boolean;
+export declare function sanitizeThinkingBlockWithNative(block: unknown): Record<string, unknown>;
+export declare function filterInvalidThinkingBlocksWithNative(messages: unknown, options?: Record<string, unknown>): unknown[];
+export declare function removeTrailingUnsignedThinkingBlocksWithNative(blocks: unknown, options?: Record<string, unknown>): unknown[];
+export declare function sanitizeReasoningTaggedTextWithNative(text: string): string;
+export declare function sanitizeFollowupTextWithNative(rawText: unknown): string;
+export declare function ensureBridgeInstructionsWithNative(payload: Record<string, unknown>): Record<string, unknown>;
+export declare function repairFindMetaWithNative(script: string): string;
+export declare function splitCommandStringWithNative(input: string): string[];
+export declare function packShellArgsWithNative(input: Record<string, unknown>): Record<string, unknown>;
+export declare function flattenByCommaWithNative(items: string[]): string[];
+export declare function chunkStringWithNative(s: string, minParts?: number, maxParts?: number, targetChunk?: number): string[];
+export declare function deriveToolCallKeyWithNative(call: Record<string, unknown> | null | undefined): string | null;
+export declare function normalizeIdValueWithNative(value: unknown, forceGenerate?: boolean): string;
+export declare function extractToolCallIdWithNative(obj: unknown): string | undefined;
+export declare function createToolCallIdTransformerWithNative(style: string): Record<string, unknown>;
+export declare function transformToolCallIdWithNative(state: Record<string, unknown>, id: string): {
+    id: string;
+    state: Record<string, unknown>;
+};
+export declare function enforceToolCallIdStyleWithNative(messages: unknown[], state: Record<string, unknown>): {
+    messages: unknown[];
+    state: Record<string, unknown>;
+};
+export declare function normalizeResponsesToolCallIdsWithNative(payload: unknown): Record<string, unknown> | null;
+export declare function resolveToolCallIdStyleWithNative(metadata: unknown): string;
+export declare function stripInternalToolingMetadataWithNative(metadata: unknown): Record<string, unknown> | null;
+export declare function buildProviderProtocolErrorWithNative(input: {
+    message: string;
+    code: string;
+    protocol?: string;
+    providerType?: string;
+    category?: string;
+    details?: Record<string, unknown>;
+}): Record<string, unknown>;
+export declare function extractJsonToolCallsFromTextWithNative(text: string, options?: Record<string, unknown>): Array<{
+    id?: string;
+    name: string;
+    args: string;
+}> | null;
+export declare function extractXMLToolCallsFromTextWithNative(text: string): Array<{
+    id?: string;
+    name: string;
+    args: string;
+}> | null;
+export declare function extractSimpleXmlToolsFromTextWithNative(text: string): Array<{
+    id?: string;
+    name: string;
+    args: string;
+}> | null;
+export declare function extractParameterXmlToolsFromTextWithNative(text: string): Array<{
+    id?: string;
+    name: string;
+    args: string;
+}> | null;
+export declare function extractInvokeToolsFromTextWithNative(text: string): Array<{
+    id?: string;
+    name: string;
+    args: string;
+}> | null;
+export declare function extractToolNamespaceXmlBlocksFromTextWithNative(text: string): Array<{
+    id?: string;
+    name: string;
+    args: string;
+}> | null;
+export declare function extractApplyPatchCallsFromTextWithNative(text: string): Array<{
+    id?: string;
+    name: string;
+    args: string;
+}> | null;
+export declare function extractBareExecCommandFromTextWithNative(text: string): Array<{
+    id?: string;
+    name: string;
+    args: string;
+}> | null;
+export declare function extractExecuteBlocksFromTextWithNative(text: string): Array<{
+    id?: string;
+    name: string;
+    args: string;
+}> | null;
+export declare function extractExploredListDirectoryCallsFromTextWithNative(text: string): Array<{
+    id?: string;
+    name: string;
+    args: string;
+}> | null;
+export declare function extractQwenToolCallTokensFromTextWithNative(text: string): Array<{
+    id?: string;
+    name: string;
+    args: string;
+}> | null;
+export declare function mergeToolCallsWithNative(existing: Array<Record<string, unknown>> | undefined, additions: Array<Record<string, unknown>> | undefined): Array<Record<string, unknown>>;
+export declare function mapReasoningContentToResponsesOutputWithNative(reasoningContent: unknown): Array<{
+    type: 'reasoning';
+    content: string;
+}>;
+export declare function validateToolArgumentsWithNative(toolName: string | undefined, args: unknown): {
+    repaired: string;
+    success: boolean;
+    error?: string;
+};
+export declare function repairToolCallsWithNative(toolCalls: Array<{
+    name?: string;
+    arguments?: unknown;
+}>): Array<{
+    name?: string;
+    arguments: string;
+}>;
+export declare function isImagePathWithNative(pathValue: unknown): boolean;
+export declare function extractStreamingToolCallsWithNative(input: {
+    buffer: string;
+    text: string;
+    idPrefix: string;
+    idCounter: number;
+    nowMs: number;
+}): {
+    buffer: string;
+    idCounter: number;
+    toolCalls: Array<Record<string, unknown>>;
+};
+export declare function createStreamingToolExtractorStateWithNative(idPrefix?: string): Record<string, unknown>;
+export declare function resetStreamingToolExtractorStateWithNative(state: Record<string, unknown>): Record<string, unknown>;
+export declare function feedStreamingToolExtractorWithNative(input: {
+    state: Record<string, unknown>;
+    text: string;
+    nowMs?: number;
+}): {
+    state: Record<string, unknown>;
+    toolCalls: Array<Record<string, unknown>>;
+};
+export declare function isCompactionRequestWithNative(payload: unknown): boolean;
+export declare function encodeMetadataPassthroughWithNative(parameters: unknown, prefix: string, keys: readonly string[]): Record<string, string> | undefined;
+export declare function extractMetadataPassthroughWithNative(metadataField: unknown, prefix: string, keys: readonly string[]): {
+    metadata?: Record<string, unknown>;
+    passthrough?: Record<string, unknown>;
+};
+export declare function ensureProtocolStateWithNative(metadata: Record<string, unknown>, protocol: string): {
+    metadata: Record<string, unknown>;
+    node: Record<string, unknown>;
+};
+export declare function getProtocolStateWithNative(metadata: Record<string, unknown> | undefined, protocol: string): Record<string, unknown> | undefined;
+export declare function readRuntimeMetadataWithNative(carrier: Record<string, unknown> | null | undefined): Record<string, unknown> | undefined;
+export declare function ensureRuntimeMetadataCarrierWithNative(carrier: Record<string, unknown>): Record<string, unknown>;
+export declare function cloneRuntimeMetadataWithNative(carrier: Record<string, unknown> | null | undefined): Record<string, unknown> | undefined;
+export declare function injectMcpToolsForChatWithNative(tools: unknown[] | undefined, discoveredServers: string[]): unknown[];
+export declare function normalizeArgsBySchemaWithNative(input: unknown, schema: unknown): {
+    ok: boolean;
+    value?: Record<string, unknown>;
+    errors?: string[];
+};
+export declare function normalizeToolsWithNative(tools: unknown): Array<Record<string, unknown>>;
+export declare function extractOutputSegmentsWithNative(source: Record<string, unknown> | undefined, itemsKey?: string): {
+    textParts: string[];
+    reasoningParts: string[];
+};
+export declare function normalizeContentPartWithNative(part: unknown, reasoningCollector: string[]): {
+    normalized: Record<string, unknown> | null;
+    reasoningCollector: string[];
+};
+export declare function normalizeMessageContentPartsWithNative(parts: unknown, reasoningCollector: string[]): {
+    normalizedParts: Array<Record<string, unknown>>;
+    reasoningChunks: string[];
+};
+export declare function normalizeChatMessageContentWithNative(content: unknown): {
+    contentText?: string;
+    reasoningText?: string;
+};
+export declare function normalizeOpenaiMessageWithNative(message: unknown, disableShellCoerce: boolean): unknown;
+export declare function normalizeOpenaiToolWithNative(tool: unknown): unknown;
+export declare function normalizeOpenaiChatMessagesWithNative(messages: unknown): unknown[];
+export declare function normalizeOpenaiToolCallWithNative(toolCall: unknown, disableShellCoerce: boolean): unknown;
+export declare function prepareGeminiToolsForBridgeWithNative(rawTools: unknown, missing: unknown[]): {
+    defs?: Array<Record<string, unknown>>;
+    missing: Array<Record<string, unknown>>;
+};
+export declare function buildGeminiToolsFromBridgeWithNative(defs: unknown, mode?: 'antigravity' | 'default'): Array<Record<string, unknown>> | undefined;
+export declare function pickResponsesPersistedFieldsWithNative(payload: unknown): Record<string, unknown>;
+export declare function convertResponsesOutputToInputItemsWithNative(response: unknown): Array<Record<string, unknown>>;
+export declare function prepareResponsesConversationEntryWithNative(payload: unknown, context: unknown): {
+    basePayload: Record<string, unknown>;
+    input: Array<Record<string, unknown>>;
+    tools?: Array<Record<string, unknown>>;
+};
+export declare function resumeResponsesConversationPayloadWithNative(entry: unknown, responseId: string, submitPayload: unknown, requestId?: string): {
+    payload: Record<string, unknown>;
+    meta: Record<string, unknown>;
+};
+export declare function enforceChatBudgetWithNative(chat: unknown, allowedBytes: number, systemTextLimit: number): unknown;
+export declare function resolveBudgetForModelWithNative(modelId: string, fallback: {
+    maxBytes: number;
+    safetyRatio: number;
+    allowedBytes: number;
+    source: string;
+} | null | undefined): {
+    maxBytes: number;
+    safetyRatio: number;
+    allowedBytes: number;
+    source: string;
+};
+export declare function injectMcpToolsForResponsesWithNative(tools: unknown[] | undefined, discoveredServers: string[]): unknown[];
+export declare function normalizeFunctionCallIdWithNative(input: {
+    callId?: string;
+    fallback?: string;
+}): string;
+export declare function normalizeFunctionCallOutputIdWithNative(input: {
+    callId?: string;
+    fallback?: string;
+}): string;
+export declare function normalizeResponsesCallIdWithNative(input: {
+    callId?: string;
+    fallback?: string;
+}): string;
+export declare function clampResponsesInputItemIdWithNative(rawValue: unknown): string | undefined;