@jsonstudio/llms 0.6.3685 → 0.6.3686

package/dist/conversion/hub/process/chat-process-media.js

@@ -1,9 +1,9 @@
-import { analyzeChatProcessMedia, stripChatProcessHistoricalImages } from '../../../router/virtual-router/engine-selection/native-router-hotpath.js';
+import { analyzeChatProcessMedia, stripChatProcessHistoricalImages, } from "../../../router/virtual-router/engine-selection/native-router-hotpath.js";
 export function stripHistoricalImageAttachments(messages) {
     if (!Array.isArray(messages) || !messages.length) {
         return messages;
     }
-    const placeholderText = '[Image omitted]';
+    const placeholderText = "[Image omitted]";
     const stripped = stripChatProcessHistoricalImages(messages, placeholderText);
     if (stripped.changed !== true || !Array.isArray(stripped.messages)) {
         return messages;
@@ -12,17 +12,17 @@ export function stripHistoricalImageAttachments(messages) {
 }
 const INLINE_MEDIA_DATA_RE = /data:(image|video)\/[a-z0-9.+-]+;base64,[a-z0-9+/=\s]+/i;
 function isVisualToolMessage(message) {
-    if (!message || typeof message !== 'object') {
+    if (!message || typeof message !== "object") {
         return false;
     }
-    if (message.role !== 'tool') {
+    if (message.role !== "tool") {
         return false;
     }
-    const name = typeof message.name === 'string' ? message.name.trim().toLowerCase() : '';
-    if (name === 'view_image') {
+    const name = typeof message.name === "string" ? message.name.trim().toLowerCase() : "";
+    if (name === "view_image") {
         return true;
     }
-    const content = typeof message.content === 'string' ? message.content : '';
+    const content = typeof message.content === "string" ? message.content : "";
     return INLINE_MEDIA_DATA_RE.test(content);
 }
 export function stripHistoricalVisualToolOutputs(messages) {
@@ -34,14 +34,14 @@ export function stripHistoricalVisualToolOutputs(messages) {
         if (!isVisualToolMessage(message)) {
             return message;
         }
-        const content = typeof message.content === 'string' ? message.content : '';
+        const content = typeof message.content === "string" ? message.content : "";
         if (!INLINE_MEDIA_DATA_RE.test(content)) {
             return message;
         }
         changed = true;
         return {
             ...message,
-            content: '[Image omitted]'
+            content: "[Image omitted]",
         };
     });
     return changed ? next : messages;
@@ -52,3 +52,57 @@ export function containsImageAttachment(messages) {
     }
     return analyzeChatProcessMedia(messages).containsCurrentTurnImage === true;
 }
+export function repairIncompleteToolCalls(messages) {
+    if (!Array.isArray(messages) || messages.length === 0) {
+        return messages;
+    }
+    const toolCallIdsWithResponse = new Set();
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const msg = messages[i];
+        if (msg?.role === "tool" && typeof msg.tool_call_id === "string") {
+            toolCallIdsWithResponse.add(msg.tool_call_id);
+        }
+    }
+    const result = [];
+    let changed = false;
+    for (const msg of messages) {
+        if (msg?.role === "assistant" && Array.isArray(msg.tool_calls)) {
+            const completeToolCalls = [];
+            const missingToolCallIds = [];
+            for (const tc of msg.tool_calls) {
+                const tcId = typeof tc?.id === "string" ? tc.id : "";
+                if (tcId && toolCallIdsWithResponse.has(tcId)) {
+                    completeToolCalls.push(tc);
+                }
+                else if (tcId) {
+                    missingToolCallIds.push(tcId);
+                }
+            }
+            if (missingToolCallIds.length > 0) {
+                changed = true;
+                const repaired = {
+                    ...msg,
+                    tool_calls: completeToolCalls.length > 0 ? completeToolCalls : undefined,
+                };
+                if (!repaired.tool_calls) {
+                    delete repaired.tool_calls;
+                }
+                result.push(repaired);
+                for (const missingId of missingToolCallIds) {
+                    result.push({
+                        role: "tool",
+                        tool_call_id: missingId,
+                        content: '{"status":"tool_call_repaired_orphaned_tool_call"}',
+                    });
+                }
+            }
+            else {
+                result.push(msg);
+            }
+        }
+        else {
+            result.push(msg);
+        }
+    }
+    return changed ? result : messages;
+}

package/dist/conversion/hub/process/chat-process-session-usage.d.ts

@@ -1,25 +1,7 @@
+import type { AdapterContext } from '../types/chat-envelope.js';
 import type { ProcessedRequest, StandardizedRequest } from '../types/standardized.js';
-type SessionScopeMetadata = {
-    sessionId?: string;
-    conversationId?: string;
-};
-type ChatProcessSessionRequestSnapshot = Pick<StandardizedRequest | ProcessedRequest, 'messages' | 'tools' | 'parameters'>;
-export interface ChatProcessSessionInputEstimateResult {
-    tokens?: number;
-    scope?: string;
-    mode: 'session_reuse' | 'session_delta' | 'unavailable';
-    reason?: 'missing_scope' | 'missing_state' | 'missing_previous_usage' | 'tools_signature_changed' | 'parameters_signature_changed' | 'message_count_regressed' | 'boundary_mismatch';
-    previousMessageCount?: number;
-    appendedMessageCount?: number;
-    hasPreviousTokens?: boolean;
-    hasPreviousMessageCount?: boolean;
-    hasToolsSignature?: boolean;
-    hasParametersSignature?: boolean;
-    previousParametersSignatureDigest?: string;
-    currentParametersSignatureDigest?: string;
-}
-export declare function estimateChatProcessSessionInputTokens(metadata: SessionScopeMetadata, request: StandardizedRequest | ProcessedRequest): number | undefined;
-export declare function estimateChatProcessSessionInputTokensDetailed(metadata: SessionScopeMetadata, request: StandardizedRequest | ProcessedRequest): ChatProcessSessionInputEstimateResult;
-export declare function saveChatProcessSessionInputEstimate(metadata: SessionScopeMetadata, request: StandardizedRequest | ProcessedRequest, estimatedInputTokens: number): void;
-export declare function saveChatProcessSessionActualUsage(metadata: SessionScopeMetadata, usageRaw: unknown, requestSnapshot?: ChatProcessSessionRequestSnapshot): void;
-export {};
+export declare function estimateSessionBoundTokens(request: StandardizedRequest | ProcessedRequest, metadata: Record<string, unknown> | undefined): number | undefined;
+export declare function saveChatProcessSessionActualUsage(options: {
+    context: AdapterContext;
+    usage: Record<string, unknown> | undefined;
+}): void;

package/dist/conversion/hub/process/chat-process-session-usage.js

@@ -1,246 +1,147 @@
 import { loadRoutingInstructionStateSync, saveRoutingInstructionStateSync } from '../../../router/virtual-router/sticky-session-store.js';
 import { countRequestTokens } from '../../../router/virtual-router/token-counter.js';
-function buildEmptyRoutingInstructionState() {
+function createEmptyRoutingInstructionState() {
     return {
-        forcedTarget: undefined,
-        stickyTarget: undefined,
-        preferTarget: undefined,
         allowedProviders: new Set(),
         disabledProviders: new Set(),
         disabledKeys: new Map(),
-        disabledModels: new Map(),
-        stopMessageSource: undefined,
-        stopMessageText: undefined,
-        stopMessageMaxRepeats: undefined,
-        stopMessageUsed: undefined,
-        stopMessageUpdatedAt: undefined,
-        stopMessageLastUsedAt: undefined,
-        stopMessageStageMode: undefined,
-        stopMessageAiMode: undefined,
-        stopMessageAiSeedPrompt: undefined,
-        stopMessageAiHistory: undefined,
-        preCommandSource: undefined,
-        preCommandScriptPath: undefined,
-        preCommandUpdatedAt: undefined,
-        chatProcessInputTokens: undefined,
-        chatProcessMessageCount: undefined,
-        chatProcessToolsSignature: undefined,
-        chatProcessParametersSignature: undefined,
-        chatProcessBoundarySignature: undefined,
-        chatProcessUpdatedAt: undefined
+        disabledModels: new Map()
     };
 }
-function readScope(metadata) {
-    const sessionId = typeof metadata.sessionId === 'string' ? metadata.sessionId.trim() : '';
+function resolveSessionUsageScope(record) {
+    const sessionId = typeof record?.sessionId === 'string' ? record.sessionId.trim() : '';
     if (sessionId) {
         return `session:${sessionId}`;
     }
-    const conversationId = typeof metadata.conversationId === 'string' ? metadata.conversationId.trim() : '';
+    const conversationId = typeof record?.conversationId === 'string' ? record.conversationId.trim() : '';
     if (conversationId) {
         return `conversation:${conversationId}`;
     }
     return undefined;
 }
-function stableSignature(value) {
+function loadState(scope) {
     try {
-        return JSON.stringify(value ?? null) || 'null';
+        return loadRoutingInstructionStateSync(scope);
     }
     catch {
-        return 'unserializable';
+        return null;
     }
 }
-function messageBoundarySignature(message) {
-    if (!message) {
+function readRoundedToken(value) {
+    if (typeof value !== 'number' || !Number.isFinite(value)) {
         return undefined;
     }
-    return stableSignature({
-        role: message.role,
-        content: message.content ?? null,
-        tool_calls: Array.isArray(message.tool_calls) ? message.tool_calls : [],
-        tool_call_id: message.tool_call_id ?? null,
-        name: message.name ?? null
-    });
-}
-function coercePositiveInteger(value) {
-    return typeof value === 'number' && Number.isFinite(value) && value > 0
-        ? Math.max(1, Math.round(value))
-        : undefined;
+    const rounded = Math.round(value);
+    return rounded > 0 ? rounded : undefined;
 }
-function digestSignature(value) {
-    if (!value) {
-        return undefined;
+function buildSnapshot(scope, state) {
+    if (!state) {
+        return null;
     }
-    let hash = 2166136261;
-    for (let i = 0; i < value.length; i += 1) {
-        hash ^= value.charCodeAt(i);
-        hash = Math.imul(hash, 16777619);
+    const totalTokens = readRoundedToken(state.chatProcessLastTotalTokens);
+    const inputTokens = readRoundedToken(state.chatProcessLastInputTokens);
+    const messageCount = readRoundedToken(state.chatProcessLastMessageCount);
+    const updatedAtMs = readRoundedToken(state.chatProcessLastUpdatedAt);
+    if (totalTokens === undefined && inputTokens === undefined) {
+        return null;
     }
-    return `${value.length}:${(hash >>> 0).toString(16)}`;
-}
-function hasReusableSessionUsageShape(state) {
-    if (!state) {
-        return false;
-    }
-    const previousTokens = coercePositiveInteger(state.chatProcessInputTokens);
-    const previousMessageCount = typeof state.chatProcessMessageCount === 'number' &&
-        Number.isFinite(state.chatProcessMessageCount) &&
-        state.chatProcessMessageCount >= 0;
-    const toolsSignature = typeof state.chatProcessToolsSignature === 'string' && state.chatProcessToolsSignature.trim().length > 0;
-    const parametersSignature = typeof state.chatProcessParametersSignature === 'string' &&
-        state.chatProcessParametersSignature.trim().length > 0;
-    return previousTokens !== undefined && previousMessageCount && toolsSignature && parametersSignature;
-}
-function applyRequestSnapshotToState(state, request) {
-    if (!request || typeof request !== 'object') {
-        return false;
-    }
-    const messages = Array.isArray(request.messages) ? request.messages : null;
-    if (!messages) {
-        return false;
-    }
-    state.chatProcessMessageCount = messages.length;
-    state.chatProcessToolsSignature = stableSignature(request.tools ?? null);
-    state.chatProcessParametersSignature = stableSignature(request.parameters ?? null);
-    state.chatProcessBoundarySignature = messageBoundarySignature(messages[messages.length - 1]);
-    return true;
-}
-export function estimateChatProcessSessionInputTokens(metadata, request) {
-    return estimateChatProcessSessionInputTokensDetailed(metadata, request).tokens;
+    return {
+        scope,
+        ...(totalTokens !== undefined ? { totalTokens } : {}),
+        ...(inputTokens !== undefined ? { inputTokens } : {}),
+        ...(messageCount !== undefined ? { messageCount } : {}),
+        ...(updatedAtMs !== undefined ? { updatedAtMs } : {})
+    };
 }
-export function estimateChatProcessSessionInputTokensDetailed(metadata, request) {
-    const scope = readScope(metadata);
-    if (!scope) {
-        return {
-            scope,
-            mode: 'unavailable',
-            reason: 'missing_scope'
-        };
-    }
-    const state = loadRoutingInstructionStateSync(scope);
-    if (!state) {
-        return {
-            scope,
-            mode: 'unavailable',
-            reason: 'missing_state'
-        };
-    }
-    const previousTokens = coercePositiveInteger(state.chatProcessInputTokens);
-    const previousMessageCount = typeof state.chatProcessMessageCount === 'number' &&
-        Number.isFinite(state.chatProcessMessageCount) &&
-        state.chatProcessMessageCount >= 0
-        ? Math.max(0, Math.floor(state.chatProcessMessageCount))
-        : undefined;
-    if (previousTokens === undefined || previousMessageCount === undefined) {
-        return {
-            scope,
-            mode: 'unavailable',
-            reason: 'missing_previous_usage',
-            hasPreviousTokens: previousTokens !== undefined,
-            hasPreviousMessageCount: previousMessageCount !== undefined,
-            hasToolsSignature: Boolean(state.chatProcessToolsSignature),
-            hasParametersSignature: Boolean(state.chatProcessParametersSignature)
-        };
-    }
-    const currentToolsSignature = stableSignature(request.tools ?? null);
-    const currentParametersSignature = stableSignature(request.parameters ?? null);
-    if (state.chatProcessToolsSignature !== currentToolsSignature) {
-        return {
-            scope,
-            mode: 'unavailable',
-            reason: 'tools_signature_changed',
-            previousMessageCount,
-            hasPreviousTokens: true,
-            hasPreviousMessageCount: true
-        };
-    }
-    if (state.chatProcessParametersSignature !== currentParametersSignature) {
-        return {
-            scope,
-            mode: 'unavailable',
-            reason: 'parameters_signature_changed',
-            previousMessageCount,
-            hasPreviousTokens: true,
-            hasPreviousMessageCount: true,
-            previousParametersSignatureDigest: digestSignature(state.chatProcessParametersSignature),
-            currentParametersSignatureDigest: digestSignature(currentParametersSignature)
-        };
+function normalizeUsage(usage) {
+    if (!usage || typeof usage !== 'object') {
+        return null;
+    }
+    const inputTokens = readRoundedToken(usage.input_tokens ??
+        usage.prompt_tokens ??
+        usage.inputTokens ??
+        usage.promptTokens ??
+        usage.request_tokens ??
+        usage.requestTokens);
+    const outputTokens = readRoundedToken(usage.output_tokens ??
+        usage.completion_tokens ??
+        usage.outputTokens ??
+        usage.completionTokens ??
+        usage.response_tokens ??
+        usage.responseTokens);
+    const totalTokens = readRoundedToken(usage.total_tokens ??
+        usage.totalTokens ??
+        ((inputTokens ?? 0) + (outputTokens ?? 0) > 0
+            ? (inputTokens ?? 0) + (outputTokens ?? 0)
+            : undefined));
+    if (totalTokens === undefined && inputTokens === undefined) {
+        return null;
     }
+    return {
+        ...(inputTokens !== undefined ? { inputTokens } : {}),
+        ...(outputTokens !== undefined ? { outputTokens } : {}),
+        ...(totalTokens !== undefined ? { totalTokens } : {})
+    };
+}
+function estimateDeltaTokens(request, previousMessageCount) {
     const messages = Array.isArray(request.messages) ? request.messages : [];
-    if (previousMessageCount > messages.length) {
-        return {
-            scope,
-            mode: 'unavailable',
-            reason: 'message_count_regressed',
-            previousMessageCount
-        };
-    }
-    if (previousMessageCount > 0) {
-        const boundary = messageBoundarySignature(messages[previousMessageCount - 1]);
-        if ((state.chatProcessBoundarySignature || undefined) !== boundary) {
-            return {
-                scope,
-                mode: 'unavailable',
-                reason: 'boundary_mismatch',
-                previousMessageCount
-            };
-        }
+    if (previousMessageCount < 0 || previousMessageCount > messages.length) {
+        return undefined;
     }
     const appendedMessages = messages.slice(previousMessageCount);
     if (appendedMessages.length === 0) {
-        return {
-            tokens: previousTokens,
-            scope,
-            mode: 'session_reuse',
-            previousMessageCount,
-            appendedMessageCount: 0
-        };
-    }
-    const delta = countRequestTokens({
+        return 0;
+    }
+    return countRequestTokens({
         model: request.model,
         messages: appendedMessages,
-        tools: undefined,
         parameters: {},
-        metadata: request.metadata ?? { originalEndpoint: '' }
+        metadata: { originalEndpoint: request.metadata?.originalEndpoint ?? '/v1/chat/completions' }
     });
-    return {
-        tokens: previousTokens + delta,
-        scope,
-        mode: 'session_delta',
-        previousMessageCount,
-        appendedMessageCount: appendedMessages.length
-    };
 }
-export function saveChatProcessSessionInputEstimate(metadata, request, estimatedInputTokens) {
-    const scope = readScope(metadata);
-    const normalized = coercePositiveInteger(estimatedInputTokens);
-    if (!scope || normalized === undefined) {
-        return;
+export function estimateSessionBoundTokens(request, metadata) {
+    const scope = resolveSessionUsageScope(metadata);
+    if (!scope) {
+        return undefined;
     }
-    const state = loadRoutingInstructionStateSync(scope) ?? buildEmptyRoutingInstructionState();
-    const messages = Array.isArray(request.messages) ? request.messages : [];
-    state.chatProcessInputTokens = normalized;
-    state.chatProcessMessageCount = messages.length;
-    state.chatProcessToolsSignature = stableSignature(request.tools ?? null);
-    state.chatProcessParametersSignature = stableSignature(request.parameters ?? null);
-    state.chatProcessBoundarySignature = messageBoundarySignature(messages[messages.length - 1]);
-    state.chatProcessUpdatedAt = Date.now();
-    saveRoutingInstructionStateSync(scope, state);
+    const snapshot = buildSnapshot(scope, loadState(scope));
+    if (!snapshot) {
+        return undefined;
+    }
+    const previousTotal = snapshot.totalTokens ?? snapshot.inputTokens;
+    const previousMessageCount = snapshot.messageCount;
+    if (previousTotal === undefined || previousMessageCount === undefined) {
+        return undefined;
+    }
+    const deltaTokens = estimateDeltaTokens(request, previousMessageCount);
+    if (deltaTokens === undefined) {
+        return undefined;
+    }
+    return Math.max(1, Math.round(previousTotal + deltaTokens));
 }
-export function saveChatProcessSessionActualUsage(metadata, usageRaw, requestSnapshot) {
-    const scope = readScope(metadata);
-    if (!scope || !usageRaw || typeof usageRaw !== 'object' || Array.isArray(usageRaw)) {
+export function saveChatProcessSessionActualUsage(options) {
+    const scope = resolveSessionUsageScope(options.context);
+    if (!scope) {
         return;
     }
-    const usage = usageRaw;
-    const actualInputTokens = coercePositiveInteger(usage.prompt_tokens ?? usage.input_tokens ?? usage.total_input_tokens);
-    if (actualInputTokens === undefined) {
+    const normalizedUsage = normalizeUsage(options.usage);
+    if (!normalizedUsage) {
         return;
     }
-    const state = loadRoutingInstructionStateSync(scope) ?? buildEmptyRoutingInstructionState();
-    if (!hasReusableSessionUsageShape(state) && !applyRequestSnapshotToState(state, requestSnapshot)) {
-        return;
+    const capturedChatRequest = options.context.capturedChatRequest;
+    const messageCount = Array.isArray(capturedChatRequest?.messages)
+        ? (capturedChatRequest.messages ?? []).length
+        : undefined;
+    const state = loadState(scope) ?? createEmptyRoutingInstructionState();
+    if (normalizedUsage.totalTokens !== undefined) {
+        state.chatProcessLastTotalTokens = normalizedUsage.totalTokens;
+    }
+    if (normalizedUsage.inputTokens !== undefined) {
+        state.chatProcessLastInputTokens = normalizedUsage.inputTokens;
+    }
+    if (typeof messageCount === 'number' && Number.isFinite(messageCount)) {
+        state.chatProcessLastMessageCount = Math.max(0, Math.round(messageCount));
     }
-    state.chatProcessInputTokens = actualInputTokens;
-    state.chatProcessUpdatedAt = Date.now();
+    state.chatProcessLastUpdatedAt = Date.now();
     saveRoutingInstructionStateSync(scope, state);
 }

package/dist/conversion/hub/response/provider-response.js

@@ -15,11 +15,11 @@ import { runRespProcessStage3ServerToolOrchestration } from '../pipeline/stages/
 import { runRespOutboundStage1ClientRemap } from '../pipeline/stages/resp_outbound/resp_outbound_stage1_client_remap/index.js';
 import { runRespOutboundStage2SseStream } from '../pipeline/stages/resp_outbound/resp_outbound_stage2_sse_stream/index.js';
 import { recordResponsesResponse } from '../../shared/responses-conversation-store.js';
-import { saveChatProcessSessionActualUsage } from '../process/chat-process-session-usage.js';
 import { ProviderProtocolError } from '../../provider-protocol-error.js';
 import { readRuntimeMetadata } from '../../runtime-metadata.js';
 import { commitClockReservation, resolveClockConfig } from '../../../servertool/clock/task-store.js';
 import { detectProviderResponseShapeWithNative } from '../../../router/virtual-router/engine-selection/native-chat-process-servertool-orchestration-semantics.js';
+import { saveChatProcessSessionActualUsage } from '../process/chat-process-session-usage.js';
 const PROVIDER_RESPONSE_REGISTRY = {
     'openai-chat': {
         createFormatAdapter: () => new ChatFormatAdapter(),
@@ -398,18 +398,6 @@ export async function convertProviderResponse(options) {
     });
     applyModelOverride(clientPayload, displayModel);
     stripInternalPolicyDebugFields(clientPayload);
-    try {
-        const usage = clientPayload && typeof clientPayload === 'object' && !Array.isArray(clientPayload)
-            ? clientPayload.usage
-            : undefined;
-        saveChatProcessSessionActualUsage({
-            sessionId: typeof options.context.sessionId === 'string' ? options.context.sessionId : undefined,
-            conversationId: typeof options.context.conversationId === 'string' ? options.context.conversationId : undefined
-        }, usage, isJsonRecord(options.context.capturedChatRequest) ? options.context.capturedChatRequest : undefined);
-    }
-    catch {
-        // best-effort: usage backfill must not break response conversion
-    }
     if (clientProtocol === 'openai-responses') {
         try {
             recordResponsesResponse({
@@ -464,6 +452,18 @@ export async function convertProviderResponse(options) {
     });
     // Commit scheduled-task delivery only after a successful client payload/stream is prepared.
     await maybeCommitClockReservationFromContext(options.context);
+    try {
+        const usage = clientPayload && typeof clientPayload === 'object' && !Array.isArray(clientPayload)
+            ? clientPayload.usage
+            : undefined;
+        saveChatProcessSessionActualUsage({
+            context: options.context,
+            usage
+        });
+    }
+    catch {
+        // best-effort: usage persistence must not break response delivery
+    }
     if (outbound.stream) {
         const usage = clientPayload && typeof clientPayload === 'object' && !Array.isArray(clientPayload)
             ? clientPayload.usage

package/dist/conversion/hub/types/chat-envelope.d.ts

@@ -53,7 +53,6 @@ export interface AdapterContext {
     originalModelId?: string;
     clientModelId?: string;
     toolCallIdStyle?: 'fc' | 'preserve';
-    applyPatchToolMode?: 'schema' | 'freeform';
     responsesResume?: JsonObject;
     [key: string]: JsonValue;
 }

package/dist/conversion/pipeline/codecs/v2/openai-openai-pipeline.js

@@ -142,6 +142,10 @@ export class OpenAIOpenAIPipelineCodec {
         if (!Array.isArray(openaiPayload.tools) && Array.isArray(inboundPayload.tools)) {
             openaiPayload.tools = inboundPayload.tools;
         }
+        if (openaiPayload.tool_choice === undefined &&
+            inboundPayload.tool_choice !== undefined) {
+            openaiPayload.tool_choice = inboundPayload.tool_choice;
+        }
         const filterContext = {
             ...context,
             requestId,

package/dist/conversion/responses/responses-openai-bridge.d.ts

@@ -10,7 +10,6 @@ export declare function buildChatRequestFromResponses(payload: Record<string, un
 export declare function buildResponsesRequestFromChat(payload: Record<string, unknown>, ctx?: ResponsesRequestContext, extras?: {
     bridgeHistory?: BridgeInputBuildResult;
     systemInstruction?: string;
-    routeToolCallIdStyle?: 'fc' | 'preserve';
 }): BuildResponsesRequestResult;
 export { buildResponsesPayloadFromChat, extractRequestIdFromResponse } from './responses-openai-bridge/response-payload.js';
 export { buildChatResponseFromResponses } from '../shared/responses-response-utils.js';