@jsonstudio/llms 0.6.3238 → 0.6.3275

package/dist/conversion/compat/actions/deepseek-web-request.js

@@ -1,9 +1,9 @@
+import { applyToolTextRequestGuidance } from './tool-text-request-guidance.js';
 const DEFAULT_OPTIONS = {
     strictToolRequired: true,
-    textToolFallback: true
+    toolProtocol: undefined
 };
 const SEARCH_ROUTE_PREFIXES = ['web_search', 'search'];
-const TOOL_TEXT_GUIDANCE_MARKER = 'Tool-call output contract (STRICT)';
 const readString = (value) => {
     if (typeof value !== 'string') {
         return undefined;
@@ -27,6 +27,31 @@ function readBoolean(input, fallback) {
     }
     return fallback;
 }
+function readOptionalBoolean(input) {
+    if (typeof input === 'boolean') {
+        return input;
+    }
+    if (typeof input === 'string') {
+        const normalized = input.trim().toLowerCase();
+        if (['true', '1', 'yes', 'on'].includes(normalized)) {
+            return true;
+        }
+        if (['false', '0', 'no', 'off'].includes(normalized)) {
+            return false;
+        }
+    }
+    return undefined;
+}
+function readToolProtocol(input) {
+    if (typeof input !== 'string') {
+        return undefined;
+    }
+    const normalized = input.trim().toLowerCase();
+    if (normalized === 'text' || normalized === 'native') {
+        return normalized;
+    }
+    return undefined;
+}
 function resolveOptions(adapterContext) {
     const context = (adapterContext ?? {});
     const deepseekNode = isRecord(context.deepseek)
@@ -37,9 +62,12 @@ function resolveOptions(adapterContext) {
     if (!deepseekNode) {
         return { ...DEFAULT_OPTIONS };
     }
+    const legacyFallback = readOptionalBoolean(deepseekNode.textToolFallback);
+    const toolProtocol = readToolProtocol(deepseekNode.toolProtocol) ??
+        (legacyFallback !== undefined ? (legacyFallback ? 'text' : 'native') : undefined);
     return {
         strictToolRequired: readBoolean(deepseekNode.strictToolRequired, DEFAULT_OPTIONS.strictToolRequired),
-        textToolFallback: readBoolean(deepseekNode.textToolFallback, DEFAULT_OPTIONS.textToolFallback)
+        toolProtocol
     };
 }
 function normalizeContentToText(content) {
@@ -127,90 +155,6 @@ function normalizeToolCallsAsText(toolCallsRaw) {
         return '';
     }
 }
-function summarizeToolSchema(tool) {
-    const fn = isRecord(tool.function) ? tool.function : tool;
-    const name = readString(fn.name) ?? readString(tool.name) ?? 'unknown_tool';
-    const description = readString(fn.description) ?? 'No description';
-    const params = isRecord(fn.parameters) ? fn.parameters : undefined;
-    const properties = isRecord(params?.properties) ? params?.properties : undefined;
-    const required = Array.isArray(params?.required)
-        ? params.required.map((item) => readString(item)).filter((item) => Boolean(item))
-        : [];
-    const lines = [`Tool: ${name}`, `Description: ${description}`];
-    if (properties) {
-        const fields = [];
-        for (const [propName, propValue] of Object.entries(properties)) {
-            const type = isRecord(propValue) ? (readString(propValue.type) ?? 'string') : 'string';
-            const marker = required.includes(propName) ? ' (required)' : '';
-            fields.push(`  - ${propName}: ${type}${marker}`);
-        }
-        if (fields.length) {
-            lines.push('Parameters:', ...fields);
-        }
-    }
-    return lines.join('\n');
-}
-function buildToolFallbackInstruction(toolsRaw, requireToolCall) {
-    if (!Array.isArray(toolsRaw) || toolsRaw.length === 0) {
-        return '';
-    }
-    const schemas = toolsRaw
-        .filter((item) => isRecord(item))
-        .map((item) => summarizeToolSchema(item));
-    if (!schemas.length) {
-        return '';
-    }
-    return [
-        'You have access to these tools:',
-        '',
-        schemas.join('\n\n'),
-        '',
-        `${TOOL_TEXT_GUIDANCE_MARKER}:`,
-        '1) If you call a tool, your ENTIRE assistant output must be a single JSON object.',
-        '2) Use this exact top-level shape (and key names):',
-        '{"tool_calls":[{"name":"tool_name","input":{"arg":"value"}}]}',
-        '3) Use only `name` + `input` for each tool call. Do NOT emit `arguments`, `parameters`, or custom wrappers.',
-        '4) Do NOT include markdown fences, prose, progress logs, or shell transcript around the JSON.',
-        '5) Do NOT output pseudo tool results in text (forbidden examples: {"exec_command":...}, <function_results>...</function_results>).',
-        '6) If multiple tools are needed, append multiple entries in `tool_calls`.',
-        requireToolCall
-            ? '7) tool_choice is required for this turn: return at least one tool call.'
-            : '7) If no tool is needed, plain text is allowed.',
-        '',
-        'Valid example:',
-        '{"tool_calls":[{"name":"exec_command","input":{"cmd":"pnpm -v","workdir":"/workspace"}}]}'
-    ].join('\n');
-}
-function hasToolGuidanceMarker(messages) {
-    for (const item of messages) {
-        if (typeof item?.text !== 'string') {
-            continue;
-        }
-        if (item.text.includes(TOOL_TEXT_GUIDANCE_MARKER)) {
-            return true;
-        }
-    }
-    return false;
-}
-function isToolChoiceRequired(root) {
-    const toolChoice = root.tool_choice;
-    if (typeof toolChoice === 'string') {
-        const normalized = toolChoice.trim().toLowerCase();
-        if (normalized === 'required') {
-            return true;
-        }
-        if (normalized === 'none' || normalized === 'auto') {
-            return false;
-        }
-    }
-    if (isRecord(toolChoice)) {
-        const type = readString(toolChoice.type)?.toLowerCase();
-        if (type === 'function') {
-            return true;
-        }
-    }
-    return false;
-}
 function toPromptMessages(root, options) {
     const messagesRaw = Array.isArray(root.messages) ? root.messages : [];
     const messages = [];
@@ -235,20 +179,6 @@ function toPromptMessages(root, options) {
         const text = parts.filter(Boolean).join('\n').trim();
         messages.push({ role, text });
     }
-    if (options.textToolFallback) {
-        const instruction = hasToolGuidanceMarker(messages)
-            ? ''
-            : buildToolFallbackInstruction(root.tools, isToolChoiceRequired(root));
-        if (instruction) {
-            const first = messages[0];
-            if (first && first.role === 'system') {
-                first.text = [first.text, instruction].filter(Boolean).join('\n\n');
-            }
-            else {
-                messages.unshift({ role: 'system', text: instruction });
-            }
-        }
-    }
     return messages;
 }
 function mergeByRole(messages) {
@@ -337,27 +267,30 @@ export function applyDeepSeekWebRequestTransform(payload, adapterContext) {
     }
     const root = structuredClone(payload);
     const options = resolveOptions(adapterContext);
-    const model = resolveModel(root, adapterContext);
+    const guidedRoot = options.toolProtocol === 'text'
+        ? applyToolTextRequestGuidance(root, { enabled: true })
+        : root;
+    const model = resolveModel(guidedRoot, adapterContext);
     const flags = resolveThinkingSearchFlags(model);
-    const forceSearch = shouldForceSearch(root, adapterContext);
-    const prompt = buildPromptFromMessages(toPromptMessages(root, options));
+    const forceSearch = shouldForceSearch(guidedRoot, adapterContext);
+    const prompt = buildPromptFromMessages(toPromptMessages(guidedRoot, options));
     const next = {
-        ...(readString(root.chat_session_id) ? { chat_session_id: readString(root.chat_session_id) } : {}),
-        parent_message_id: readString(root.parent_message_id) ?? null,
+        ...(readString(guidedRoot.chat_session_id) ? { chat_session_id: readString(guidedRoot.chat_session_id) } : {}),
+        parent_message_id: readString(guidedRoot.parent_message_id) ?? null,
         prompt,
-        ref_file_ids: Array.isArray(root.ref_file_ids) ? root.ref_file_ids : [],
+        ref_file_ids: Array.isArray(guidedRoot.ref_file_ids) ? guidedRoot.ref_file_ids : [],
         thinking_enabled: flags.thinking,
         search_enabled: forceSearch ? true : flags.search
     };
-    if (root.stream === true) {
+    if (guidedRoot.stream === true) {
         next.stream = true;
     }
     // Preserve a tiny runtime hint surface for response-side strict/fallback checks.
     next.metadata = {
-        ...(isRecord(root.metadata) ? root.metadata : {}),
+        ...(isRecord(guidedRoot.metadata) ? guidedRoot.metadata : {}),
         deepseek: {
             strictToolRequired: options.strictToolRequired,
-            textToolFallback: options.textToolFallback
+            ...(options.toolProtocol ? { toolProtocol: options.toolProtocol } : {})
         }
     };
     return next;

package/dist/conversion/compat/actions/deepseek-web-response.d.ts

@@ -1,8 +1,11 @@
 import type { AdapterContext } from '../../hub/types/chat-envelope.js';
 import type { JsonObject } from '../../hub/types/json.js';
 import { type TextMarkupNormalizeOptions } from '../../shared/text-markup-normalizer.js';
+type DeepSeekToolProtocol = 'native' | 'text';
 export interface DeepSeekWebResponseConfig {
     strictToolRequired?: boolean;
     textNormalizer?: TextMarkupNormalizeOptions;
+    toolProtocol?: DeepSeekToolProtocol;
 }
 export declare function applyDeepSeekWebResponseTransform(payload: JsonObject, adapterContext?: AdapterContext, config?: DeepSeekWebResponseConfig): JsonObject;
+export {};

package/dist/conversion/compat/actions/deepseek-web-response.js

@@ -1,8 +1,10 @@
 import { validateToolCall } from '../../../tools/tool-registry.js';
 import { encoding_for_model, get_encoding } from 'tiktoken';
+import { normalizeFunctionCallId } from '../../bridge-id-utils.js';
 const DEFAULT_OPTIONS = {
     strictToolRequired: true,
-    textNormalizer: undefined
+    textNormalizer: undefined,
+    toolProtocol: undefined
 };
 const SHELL_LIKE_TOOL_NAMES = new Set(['exec_command', 'shell_command', 'shell', 'bash', 'terminal']);
 const SHELL_TOOL_NAME_ALIASES = new Map([
@@ -29,6 +31,52 @@ const readString = (value) => {
     const trimmed = value.trim();
     return trimmed.length ? trimmed : undefined;
 };
+function flattenMessageContent(content) {
+    if (typeof content === 'string') {
+        return content.trim();
+    }
+    if (Array.isArray(content)) {
+        const parts = [];
+        for (const part of content) {
+            if (!isRecord(part)) {
+                continue;
+            }
+            const text = readString(part.text) ?? readString(part.content) ?? readString(part.value);
+            if (text) {
+                parts.push(text);
+            }
+        }
+        return parts.join('\n').trim();
+    }
+    if (isRecord(content)) {
+        const direct = readString(content.text) ?? readString(content.content);
+        if (direct) {
+            return direct;
+        }
+        if (Array.isArray(content.content)) {
+            return flattenMessageContent(content.content);
+        }
+    }
+    return '';
+}
+function extractResponsesMessageText(item) {
+    const parts = [];
+    const content = Array.isArray(item.content) ? item.content : [];
+    for (const part of content) {
+        if (!isRecord(part)) {
+            continue;
+        }
+        const text = readString(part.text) ?? readString(part.content) ?? readString(part.value);
+        if (text) {
+            parts.push(text);
+        }
+    }
+    const outputText = readString(item.output_text);
+    if (outputText) {
+        parts.push(outputText);
+    }
+    return parts.join('\n').trim();
+}
 function readNumber(value) {
     if (typeof value === 'number' && Number.isFinite(value)) {
         return value;
@@ -75,6 +123,16 @@ function readOptionalBoolean(input) {
     }
     return undefined;
 }
+function readToolProtocol(input) {
+    if (typeof input !== 'string') {
+        return undefined;
+    }
+    const normalized = input.trim().toLowerCase();
+    if (normalized === 'text' || normalized === 'native') {
+        return normalized;
+    }
+    return undefined;
+}
 function getTokenEncoder(modelHint) {
     const normalized = typeof modelHint === 'string' ? modelHint.trim() : '';
     if (normalized) {
@@ -116,19 +174,27 @@ function resolveOptions(adapterContext, config) {
             ? context.__rt.deepseek
             : undefined;
     if (!deepseekNode) {
+        const toolProtocolOverride = readToolProtocol(config?.toolProtocol);
         return {
             ...DEFAULT_OPTIONS,
             strictToolRequired: readOptionalBoolean(config?.strictToolRequired) ?? DEFAULT_OPTIONS.strictToolRequired,
-            textNormalizer: config?.textNormalizer
+            textNormalizer: config?.textNormalizer,
+            toolProtocol: toolProtocolOverride ?? DEFAULT_OPTIONS.toolProtocol
         };
     }
     const strictOverride = readOptionalBoolean(config?.strictToolRequired);
+    const toolProtocolOverride = readToolProtocol(config?.toolProtocol);
+    const legacyFallback = readOptionalBoolean(deepseekNode.textToolFallback);
+    const toolProtocol = toolProtocolOverride ??
+        readToolProtocol(deepseekNode.toolProtocol) ??
+        (legacyFallback !== undefined ? (legacyFallback ? 'text' : 'native') : undefined);
     return {
         strictToolRequired: strictOverride ??
             readBoolean(deepseekNode.strictToolRequired, DEFAULT_OPTIONS.strictToolRequired),
         textNormalizer: config?.textNormalizer && typeof config.textNormalizer === 'object'
             ? config.textNormalizer
-            : undefined
+            : undefined,
+        toolProtocol
     };
 }
 function resolveCapturedRequest(adapterContext) {
@@ -686,7 +752,7 @@ function applyUsageEstimate(root, choices, adapterContext, captured) {
 function normalizeChoice(choice, options, allowedToolNames, callIdPrefix) {
     const message = isRecord(choice.message) ? choice.message : undefined;
     if (!message) {
-        return { hasNative: false, hasFallback: false, harvestedFunctionResults: false };
+        return { hasNative: false, hasText: false, harvestedFunctionResults: false };
     }
     const native = normalizeMessageToolCalls(message, allowedToolNames, callIdPrefix);
     if (native) {
@@ -694,14 +760,83 @@ function normalizeChoice(choice, options, allowedToolNames, callIdPrefix) {
         if (!finish || finish === 'stop') {
             choice.finish_reason = 'tool_calls';
         }
-        return { hasNative: true, hasFallback: false, harvestedFunctionResults: false };
+        return { hasNative: true, hasText: false, harvestedFunctionResults: false };
+    }
+    if (options.toolProtocol === 'text') {
+        const contentText = flattenMessageContent(message.content);
+        if (contentText && (contentText.startsWith('{') || contentText.startsWith('['))) {
+            message.tool_calls = contentText;
+        }
+        const text = normalizeMessageToolCalls(message, allowedToolNames, callIdPrefix);
+        if (text) {
+            const finish = readString(choice.finish_reason)?.toLowerCase();
+            if (!finish || finish === 'stop') {
+                choice.finish_reason = 'tool_calls';
+            }
+            return { hasNative: false, hasText: true, harvestedFunctionResults: false };
+        }
     }
     return {
         hasNative: false,
-        hasFallback: false,
+        hasText: false,
         harvestedFunctionResults: false
     };
 }
+function harvestResponsesTextToolCalls(root, options, allowedToolNames) {
+    if (options.toolProtocol !== 'text') {
+        return { harvested: false };
+    }
+    const output = Array.isArray(root.output) ? root.output : [];
+    if (!output.length) {
+        return { harvested: false };
+    }
+    let harvested = false;
+    const nextOutput = [];
+    let callIndex = 0;
+    for (const item of output) {
+        if (!isRecord(item)) {
+            nextOutput.push(item);
+            continue;
+        }
+        const type = readString(item.type)?.toLowerCase() ?? '';
+        if (type !== 'message') {
+            nextOutput.push(item);
+            continue;
+        }
+        const role = readString(item.role)?.toLowerCase() ?? 'assistant';
+        if (role !== 'assistant') {
+            nextOutput.push(item);
+            continue;
+        }
+        const text = extractResponsesMessageText(item);
+        if (!text || (!text.trim().startsWith('{') && !text.trim().startsWith('['))) {
+            nextOutput.push(item);
+            continue;
+        }
+        const normalizedCalls = normalizeToolCalls(text.trim(), allowedToolNames, 'deepseek_resp_call');
+        if (!normalizedCalls.length) {
+            nextOutput.push(item);
+            continue;
+        }
+        harvested = true;
+        for (const call of normalizedCalls) {
+            callIndex += 1;
+            const callId = readString(call.id) ?? `deepseek_resp_call_${callIndex}`;
+            const itemId = normalizeFunctionCallId({ callId, fallback: `fc_${callId}` });
+            nextOutput.push({
+                type: 'function_call',
+                id: itemId,
+                call_id: callId,
+                name: call.function.name,
+                arguments: call.function.arguments
+            });
+        }
+    }
+    if (harvested) {
+        root.output = nextOutput;
+    }
+    return { harvested };
+}
 function writeCompatState(root, state, source, harvestedFunctionResults) {
     const metadata = isRecord(root.metadata) ? root.metadata : {};
     metadata.deepseek = {
@@ -724,7 +859,7 @@ export function applyDeepSeekWebResponseTransform(payload, adapterContext, confi
     const toolChoiceRequired = isToolChoiceRequired(captured);
     const choices = Array.isArray(root.choices) ? root.choices : [];
     let hasNative = false;
-    let hasFallback = false;
+    let hasText = false;
     let harvestedFunctionResults = false;
     for (const [index, choice] of choices.entries()) {
         if (!isRecord(choice)) {
@@ -732,18 +867,22 @@ export function applyDeepSeekWebResponseTransform(payload, adapterContext, confi
         }
         const result = normalizeChoice(choice, options, allowedToolNames, `deepseek_call_${index + 1}`);
         hasNative = hasNative || result.hasNative;
-        hasFallback = hasFallback || result.hasFallback;
+        hasText = hasText || result.hasText;
         harvestedFunctionResults = harvestedFunctionResults || result.harvestedFunctionResults;
     }
+    if (!choices.length) {
+        const harvested = harvestResponsesTextToolCalls(root, options, allowedToolNames);
+        hasText = hasText || harvested.harvested;
+    }
     const state = hasNative
         ? 'native_tool_calls'
-        : hasFallback
+        : hasText
             ? 'text_tool_calls'
             : 'no_tool_calls';
-    const source = hasNative ? 'native' : hasFallback ? 'fallback' : 'none';
+    const source = hasNative ? 'native' : hasText ? 'text' : 'none';
     writeCompatState(root, state, source, harvestedFunctionResults);
     applyUsageEstimate(root, choices, adapterContext, captured);
-    if (toolChoiceRequired && options.strictToolRequired && !hasNative && !hasFallback) {
+    if (toolChoiceRequired && options.strictToolRequired && !hasNative && !hasText) {
         const error = new Error('DeepSeek tool_choice=required but no valid tool call was produced');
         error.code = 'DEEPSEEK_TOOL_REQUIRED_MISSING';
         error.details = {

package/dist/conversion/hub/response/response-runtime.d.ts

@@ -2,6 +2,7 @@ import type { JsonObject } from '../types/json.js';
 type ToolAliasMap = Record<string, string>;
 interface AnthropicResponseOptions {
     aliasMap?: ToolAliasMap;
+    includeToolCallIds?: boolean;
 }
 export declare function buildOpenAIChatFromAnthropicMessage(payload: JsonObject, options?: AnthropicResponseOptions): JsonObject;
 export declare function buildAnthropicResponseFromChat(chatResponse: JsonObject, options?: AnthropicResponseOptions): JsonObject;

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

@@ -221,8 +221,10 @@ export function buildOpenAIChatFromAnthropicMessage(payload, options) {
             default: return 'stop';
         }
     };
+    const includeToolCallIds = options?.includeToolCallIds === true;
     const canonicalToolCalls = toolCalls.map((tc) => ({
         id: tc.id,
+        ...(includeToolCallIds ? { call_id: tc.id, tool_call_id: tc.id } : {}),
         type: 'function',
         function: { name: tc.name, arguments: tc.args }
     }));
@@ -237,11 +239,35 @@ export function buildOpenAIChatFromAnthropicMessage(payload, options) {
             const key = deriveToolCallKey(inferred);
             if (key && seen.has(key))
                 continue;
+            if (includeToolCallIds && typeof inferred.id === 'string') {
+                const inferredId = String(inferred.id);
+                if (!("call_id" in inferred))
+                    inferred.call_id = inferredId;
+                if (!("tool_call_id" in inferred))
+                    inferred.tool_call_id = inferredId;
+            }
             canonicalToolCalls.push(inferred);
             if (key)
                 seen.add(key);
         }
     }
+    for (const call of canonicalToolCalls) {
+        const cid = typeof call.id === 'string' ? String(call.id) : '';
+        if (includeToolCallIds) {
+            if (cid) {
+                if (!("call_id" in call))
+                    call.call_id = cid;
+                if (!("tool_call_id" in call))
+                    call.tool_call_id = cid;
+            }
+        }
+        else {
+            if ("call_id" in call)
+                delete call.call_id;
+            if ("tool_call_id" in call)
+                delete call.tool_call_id;
+        }
+    }
     const message = {
         role: typeof payload.role === 'string' ? payload.role : 'assistant',
         content: textParts.join('\n')

package/dist/conversion/shared/anthropic-message-utils.d.ts

@@ -7,7 +7,9 @@ interface OpenAIChatPayload extends Unknown {
 }
 export declare function normalizeAnthropicToolName(value: unknown): string | undefined;
 export declare function denormalizeAnthropicToolName(value: unknown): string | undefined;
-export declare function buildOpenAIChatFromAnthropic(payload: unknown): OpenAIChatPayload;
+export declare function buildOpenAIChatFromAnthropic(payload: unknown, options?: {
+    includeToolCallIds?: boolean;
+}): OpenAIChatPayload;
 export interface BuildAnthropicFromOpenAIOptions {
     toolNameMap?: Record<string, string>;
     requestId?: string;

package/dist/conversion/shared/anthropic-message-utils.js

@@ -17,23 +17,24 @@ function safeJson(v) {
     }
 }
 function stripOpenAIChatToolAliasFields(messages) {
+    // No-op: preserve tool_call_id/call_id for downstream consumers and regression parity.
+    void messages;
+}
+function stripToolCallIdFieldsFromAssistant(messages) {
     for (const message of messages) {
-        if (!message || typeof message !== 'object') {
+        if (!message || typeof message !== 'object')
             continue;
-        }
         const role = String(message.role || '').toLowerCase();
-        if (role === 'assistant' && Array.isArray(message.tool_calls)) {
-            for (const call of message.tool_calls) {
-                if (!call || typeof call !== 'object') {
-                    continue;
-                }
-                delete call.tool_call_id;
-                delete call.call_id;
-            }
+        if (role !== 'assistant')
             continue;
-        }
-        if (role === 'tool') {
-            delete message.call_id;
+        const calls = message.tool_calls;
+        if (!Array.isArray(calls))
+            continue;
+        for (const call of calls) {
+            if (!call || typeof call !== 'object')
+                continue;
+            delete call.call_id;
+            delete call.tool_call_id;
         }
     }
 }
@@ -352,7 +353,7 @@ function invertAnthropicAliasMap(source) {
     }
     return Object.keys(inverted).length ? inverted : undefined;
 }
-export function buildOpenAIChatFromAnthropic(payload) {
+export function buildOpenAIChatFromAnthropic(payload, options) {
     const newMessages = [];
     const body = isObject(payload) ? payload : {};
     const canonicalAliasMap = coerceAliasRecord(buildAnthropicToolAliasMap(body.tools));
@@ -458,7 +459,13 @@ export function buildOpenAIChatFromAnthropic(payload) {
                 const input = block.input ?? {};
                 const args = safeJson(input);
                 const canonicalName = resolveToolName(name) || name;
-                toolCalls.push({ id, type: 'function', function: { name: canonicalName, arguments: args } });
+                const includeIds = options?.includeToolCallIds === true;
+                toolCalls.push({
+                    id,
+                    ...(includeIds ? { call_id: id, tool_call_id: id } : {}),
+                    type: 'function',
+                    function: { name: canonicalName, arguments: args }
+                });
             }
             else if (t === 'tool_result') {
                 const callId = requireTrimmedString(block.tool_call_id ??
@@ -549,6 +556,7 @@ export function buildOpenAIChatFromAnthropic(payload) {
     catch {
         // ignore policy failures
     }
+    stripToolCallIdFieldsFromAssistant(newMessages);
     stripOpenAIChatToolAliasFields(newMessages);
     return request;
 }

package/dist/conversion/shared/openai-finalizer.d.ts

@@ -1,11 +1,8 @@
-type ProcessingMode = 'streaming' | 'non-streaming' | 'auto';
 export type ChatReasoningMode = 'keep' | 'drop' | 'append_to_content';
 export interface FinalizeOptions {
     requestId?: string;
     endpoint?: string;
-    processingMode?: ProcessingMode;
     stream?: boolean;
     reasoningMode?: ChatReasoningMode;
 }
 export declare function finalizeOpenAIChatResponse(chatLike: unknown, opts?: FinalizeOptions): Promise<unknown>;
-export {};