@jsonstudio/llms 0.6.1749 → 0.6.1890

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

@@ -0,0 +1,886 @@
+import { normalizeAssistantTextToToolCalls } from '../../shared/text-markup-normalizer.js';
+import { validateToolCall } from '../../../tools/tool-registry.js';
+import { encoding_for_model, get_encoding } from 'tiktoken';
+const DEFAULT_OPTIONS = {
+    strictToolRequired: true,
+    textToolFallback: true
+};
+const DEFAULT_TOKEN_ENCODING = 'cl100k_base';
+const tokenEncoderCache = new Map();
+let defaultTokenEncoder = null;
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const readString = (value) => {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed.length ? trimmed : undefined;
+};
+function readNumber(value) {
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        return value;
+    }
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        if (!trimmed.length) {
+            return undefined;
+        }
+        const parsed = Number(trimmed);
+        if (Number.isFinite(parsed)) {
+            return parsed;
+        }
+    }
+    return undefined;
+}
+function readBoolean(input, fallback) {
+    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 fallback;
+}
+function getTokenEncoder(modelHint) {
+    const normalized = typeof modelHint === 'string' ? modelHint.trim() : '';
+    if (normalized) {
+        const cached = tokenEncoderCache.get(normalized);
+        if (cached) {
+            return cached;
+        }
+        try {
+            const encoder = encoding_for_model(normalized);
+            tokenEncoderCache.set(normalized, encoder);
+            return encoder;
+        }
+        catch {
+            // fall through to default encoder
+        }
+    }
+    if (!defaultTokenEncoder) {
+        defaultTokenEncoder = get_encoding(DEFAULT_TOKEN_ENCODING);
+    }
+    return defaultTokenEncoder;
+}
+function countTextTokens(text, modelHint) {
+    const trimmed = text.trim();
+    if (!trimmed.length) {
+        return 0;
+    }
+    try {
+        return getTokenEncoder(modelHint).encode(trimmed).length;
+    }
+    catch {
+        return 0;
+    }
+}
+function resolveOptions(adapterContext) {
+    const context = (adapterContext ?? {});
+    const deepseekNode = isRecord(context.deepseek)
+        ? context.deepseek
+        : isRecord(context.__rt) && isRecord(context.__rt.deepseek)
+            ? context.__rt.deepseek
+            : undefined;
+    if (!deepseekNode) {
+        return { ...DEFAULT_OPTIONS };
+    }
+    return {
+        strictToolRequired: readBoolean(deepseekNode.strictToolRequired, DEFAULT_OPTIONS.strictToolRequired),
+        textToolFallback: readBoolean(deepseekNode.textToolFallback, DEFAULT_OPTIONS.textToolFallback)
+    };
+}
+function resolveCapturedRequest(adapterContext) {
+    const context = (adapterContext ?? {});
+    if (isRecord(context.capturedChatRequest)) {
+        return context.capturedChatRequest;
+    }
+    return undefined;
+}
+function resolveEstimatedInputTokens(adapterContext) {
+    const context = (adapterContext ?? {});
+    const candidates = [
+        context.estimatedInputTokens,
+        context.estimated_tokens,
+        context.estimatedTokens
+    ];
+    for (const candidate of candidates) {
+        const value = readNumber(candidate);
+        if (typeof value === 'number' && Number.isFinite(value) && value > 0) {
+            return Math.max(1, Math.round(value));
+        }
+    }
+    return undefined;
+}
+function resolveModelHint(root, captured, adapterContext) {
+    return (readString(root.model) ??
+        readString(captured?.model) ??
+        readString(adapterContext?.modelId) ??
+        readString(adapterContext?.clientModelId) ??
+        readString(adapterContext?.originalModelId));
+}
+function looksLikeKnownProviderResponseShape(value) {
+    if (!isRecord(value))
+        return false;
+    if (Array.isArray(value.choices))
+        return true;
+    if (Array.isArray(value.output) || value.object === 'response')
+        return true;
+    if (typeof value.type === 'string' && String(value.type).toLowerCase() === 'message' && Array.isArray(value.content)) {
+        return true;
+    }
+    if (Array.isArray(value.candidates))
+        return true;
+    return false;
+}
+function tryUnwrapKnownShape(value, depth) {
+    if (depth < 0) {
+        return null;
+    }
+    if (looksLikeKnownProviderResponseShape(value)) {
+        return value;
+    }
+    if (!isRecord(value)) {
+        return null;
+    }
+    for (const key of ['data', 'body', 'response', 'payload', 'result', 'biz_data']) {
+        const nested = value[key];
+        const unwrapped = tryUnwrapKnownShape(nested, depth - 1);
+        if (unwrapped) {
+            return unwrapped;
+        }
+    }
+    return null;
+}
+function isLikelyRateLimitMessage(message) {
+    return /(rate.?limit|quota|too many|exceed|exceeded|limit reached|message count)/i.test(message);
+}
+function throwDeepSeekBusinessEnvelopeError(root, adapterContext) {
+    const dataNode = isRecord(root.data) ? root.data : undefined;
+    const upstreamCode = readNumber(root.code);
+    const bizCode = readNumber(dataNode?.biz_code);
+    const bizMsg = readString(dataNode?.biz_msg);
+    const topMsg = readString(root.msg);
+    const message = bizMsg ?? topMsg ?? 'DeepSeek returned a non-chat business envelope';
+    const error = new Error(`[deepseek-web] upstream business error: ${message}`);
+    error.code = 'DEEPSEEK_BIZ_ERROR';
+    if ((typeof bizCode === 'number' && bizCode === 3) || isLikelyRateLimitMessage(message)) {
+        error.statusCode = 429;
+    }
+    error.details = {
+        requestId: readString(root.request_id) ??
+            readString(adapterContext?.requestId),
+        upstreamCode,
+        bizCode,
+        bizMsg,
+        upstreamMsg: topMsg,
+        payloadKeys: Object.keys(root).slice(0, 20),
+        phase: 'chat_process.resp.stage3.compat'
+    };
+    throw error;
+}
+function normalizeDeepSeekBusinessEnvelope(root, adapterContext) {
+    if (looksLikeKnownProviderResponseShape(root)) {
+        return root;
+    }
+    const hasEnvelopeKeys = Object.prototype.hasOwnProperty.call(root, 'code')
+        && Object.prototype.hasOwnProperty.call(root, 'data');
+    if (!hasEnvelopeKeys) {
+        return root;
+    }
+    const unwrapped = tryUnwrapKnownShape(root.data, 6);
+    if (unwrapped) {
+        return unwrapped;
+    }
+    const dataNode = isRecord(root.data) ? root.data : undefined;
+    const upstreamCode = readNumber(root.code);
+    const bizCode = readNumber(dataNode?.biz_code);
+    const bizMsg = readString(dataNode?.biz_msg);
+    const topMsg = readString(root.msg);
+    if ((typeof upstreamCode === 'number' && upstreamCode !== 0) ||
+        (typeof bizCode === 'number' && bizCode !== 0) ||
+        Boolean(bizMsg) ||
+        Boolean(topMsg)) {
+        throwDeepSeekBusinessEnvelopeError(root, adapterContext);
+    }
+    return root;
+}
+function resolveRequestedToolNames(captured) {
+    const names = new Set();
+    if (!captured) {
+        return names;
+    }
+    const toolsRaw = Array.isArray(captured.tools) ? captured.tools : [];
+    for (const tool of toolsRaw) {
+        if (!isRecord(tool)) {
+            continue;
+        }
+        const fnNode = isRecord(tool.function) ? tool.function : undefined;
+        const name = readString(fnNode?.name) ?? readString(tool.name);
+        if (name) {
+            names.add(name);
+        }
+    }
+    return names;
+}
+function isToolChoiceRequired(captured) {
+    if (!captured) {
+        return false;
+    }
+    const toolChoice = captured.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 tryParseJsonText(value) {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        // Best-effort repair: some upstream payloads place raw newlines/tabs inside JSON strings.
+        let out = '';
+        let changed = false;
+        let inString = false;
+        let escaped = false;
+        for (let i = 0; i < value.length; i += 1) {
+            const ch = value[i] ?? '';
+            if (inString) {
+                if (escaped) {
+                    out += ch;
+                    escaped = false;
+                    continue;
+                }
+                if (ch === '\\') {
+                    out += ch;
+                    escaped = true;
+                    continue;
+                }
+                if (ch === '"') {
+                    out += ch;
+                    inString = false;
+                    continue;
+                }
+                if (ch === '\n') {
+                    out += '\\n';
+                    changed = true;
+                    continue;
+                }
+                if (ch === '\r') {
+                    out += '\\n';
+                    changed = true;
+                    continue;
+                }
+                if (ch === '\t') {
+                    out += '\\t';
+                    changed = true;
+                    continue;
+                }
+                const code = ch.charCodeAt(0);
+                if (code >= 0 && code < 0x20) {
+                    out += `\\u${code.toString(16).padStart(4, '0')}`;
+                    changed = true;
+                    continue;
+                }
+                out += ch;
+                continue;
+            }
+            if (ch === '"') {
+                inString = true;
+            }
+            out += ch;
+        }
+        if (!changed) {
+            return null;
+        }
+        try {
+            return JSON.parse(out);
+        }
+        catch {
+            return null;
+        }
+    }
+}
+function normalizeToolArguments(value, toolName) {
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        if (!trimmed.length) {
+            return JSON.stringify({});
+        }
+        const parsed = tryParseJsonText(trimmed);
+        if (parsed !== null) {
+            return JSON.stringify(parsed);
+        }
+        if (toolName) {
+            const validation = validateToolCall(toolName, trimmed);
+            if (validation.ok && typeof validation.normalizedArgs === 'string' && validation.normalizedArgs.trim().length > 0) {
+                return validation.normalizedArgs;
+            }
+        }
+        return null;
+    }
+    if (value === undefined || value === null) {
+        const empty = JSON.stringify({});
+        if (!toolName) {
+            return empty;
+        }
+        const validation = validateToolCall(toolName, empty);
+        if (validation.ok && typeof validation.normalizedArgs === 'string' && validation.normalizedArgs.trim().length > 0) {
+            return validation.normalizedArgs;
+        }
+        return empty;
+    }
+    try {
+        const serialized = JSON.stringify(value);
+        if (!toolName) {
+            return serialized;
+        }
+        const validation = validateToolCall(toolName, serialized);
+        if (validation.ok && typeof validation.normalizedArgs === 'string' && validation.normalizedArgs.trim().length > 0) {
+            return validation.normalizedArgs;
+        }
+        return serialized;
+    }
+    catch {
+        return null;
+    }
+}
+function coerceToolCallsValue(toolCallsRaw) {
+    if (Array.isArray(toolCallsRaw)) {
+        return toolCallsRaw;
+    }
+    if (typeof toolCallsRaw !== 'string') {
+        return [];
+    }
+    const parsed = tryParseJsonText(toolCallsRaw.trim());
+    if (Array.isArray(parsed)) {
+        return parsed;
+    }
+    if (isRecord(parsed) && Array.isArray(parsed.tool_calls)) {
+        return parsed.tool_calls;
+    }
+    return [];
+}
+function normalizeToolCallEntry(entry, allowedToolNames, callIdPrefix, index) {
+    const fn = isRecord(entry.function) ? entry.function : undefined;
+    const name = readString(entry.name) ?? readString(fn?.name);
+    if (!name) {
+        return null;
+    }
+    if (allowedToolNames.size > 0 && !allowedToolNames.has(name)) {
+        return null;
+    }
+    const argsSource = entry.input !== undefined
+        ? entry.input
+        : entry.arguments !== undefined
+            ? entry.arguments
+            : fn?.arguments;
+    const normalizedArgs = normalizeToolArguments(argsSource, name);
+    if (!normalizedArgs) {
+        return null;
+    }
+    const id = readString(entry.id) ??
+        readString(entry.call_id) ??
+        `${callIdPrefix}_${index + 1}`;
+    return {
+        id,
+        type: 'function',
+        function: {
+            name,
+            arguments: normalizedArgs
+        }
+    };
+}
+function normalizeToolCalls(toolCallsRaw, allowedToolNames, callIdPrefix) {
+    const toolCalls = coerceToolCallsValue(toolCallsRaw);
+    const normalized = [];
+    for (const [index, entry] of toolCalls.entries()) {
+        if (!isRecord(entry)) {
+            continue;
+        }
+        const call = normalizeToolCallEntry(entry, allowedToolNames, callIdPrefix, index);
+        if (call) {
+            normalized.push(call);
+        }
+    }
+    return normalized;
+}
+function normalizeMessageToolCalls(message, allowedToolNames, callIdPrefix) {
+    const nextCalls = normalizeToolCalls(message.tool_calls, allowedToolNames, callIdPrefix);
+    if (!nextCalls.length) {
+        delete message.tool_calls;
+        return false;
+    }
+    message.tool_calls = nextCalls;
+    message.content = null;
+    return true;
+}
+function collectMessageTextCandidates(message) {
+    const candidates = [];
+    const content = message.content;
+    if (typeof content === 'string' && content.trim().length) {
+        candidates.push(content);
+    }
+    else if (Array.isArray(content)) {
+        for (const part of content) {
+            if (!isRecord(part)) {
+                continue;
+            }
+            const text = readString(part.text) ?? readString(part.content);
+            if (text) {
+                candidates.push(text);
+            }
+        }
+    }
+    const reasoning = readString(message.reasoning) ?? readString(message.reasoning_content);
+    if (reasoning) {
+        candidates.push(reasoning);
+    }
+    return candidates;
+}
+function normalizeFunctionResultsMarkupText(value) {
+    let changed = false;
+    const replaced = value.replace(/<function_results>\s*([\s\S]*?)\s*<\/function_results>/gi, (_match, inner) => {
+        changed = true;
+        const payload = typeof inner === 'string' ? inner.trim() : '';
+        if (!payload.length) {
+            return '';
+        }
+        return `\n\`\`\`json\n${payload}\n\`\`\`\n`;
+    });
+    if (!changed) {
+        return { text: value, changed: false };
+    }
+    return {
+        text: replaced.replace(/\n{3,}/g, '\n\n').trim(),
+        changed: true
+    };
+}
+function harvestFunctionResultsMarkup(message) {
+    let harvested = false;
+    const apply = (input) => {
+        if (typeof input !== 'string') {
+            return undefined;
+        }
+        const normalized = normalizeFunctionResultsMarkupText(input);
+        if (normalized.changed) {
+            harvested = true;
+        }
+        return normalized.text;
+    };
+    if (typeof message.content === 'string') {
+        const next = apply(message.content);
+        if (typeof next === 'string') {
+            message.content = next;
+        }
+    }
+    else if (Array.isArray(message.content)) {
+        for (const part of message.content) {
+            if (!isRecord(part)) {
+                continue;
+            }
+            if (typeof part.text === 'string') {
+                const next = apply(part.text);
+                if (typeof next === 'string') {
+                    part.text = next;
+                }
+            }
+            if (typeof part.content === 'string') {
+                const next = apply(part.content);
+                if (typeof next === 'string') {
+                    part.content = next;
+                }
+            }
+        }
+    }
+    if (typeof message.reasoning === 'string') {
+        const next = apply(message.reasoning);
+        if (typeof next === 'string') {
+            message.reasoning = next;
+        }
+    }
+    if (typeof message.reasoning_content === 'string') {
+        const next = apply(message.reasoning_content);
+        if (typeof next === 'string') {
+            message.reasoning_content = next;
+        }
+    }
+    return harvested;
+}
+function extractToolCallsFromDeepSeekJsonText(text, allowedToolNames, callIdPrefix) {
+    const normalized = [];
+    const trimmed = text.trim();
+    if (!trimmed.length) {
+        return normalized;
+    }
+    const parseCandidate = (candidate) => {
+        if (!isRecord(candidate)) {
+            return;
+        }
+        const calls = coerceToolCallsValue(candidate.tool_calls);
+        for (const entry of calls) {
+            if (!isRecord(entry)) {
+                continue;
+            }
+            const call = normalizeToolCallEntry(entry, allowedToolNames, callIdPrefix, normalized.length);
+            if (call) {
+                normalized.push(call);
+            }
+        }
+    };
+    const parsedRoot = tryParseJsonText(trimmed);
+    if (parsedRoot !== null) {
+        parseCandidate(parsedRoot);
+    }
+    if (normalized.length > 0) {
+        return normalized;
+    }
+    const toolCallPattern = /\{\s*["']tool_calls["']\s*:\s*\[(.*?)\]\s*\}/gs;
+    let match;
+    while ((match = toolCallPattern.exec(trimmed)) !== null) {
+        const segment = match[1];
+        const parsed = tryParseJsonText(`{"tool_calls":[${segment}]}`);
+        if (parsed !== null) {
+            parseCandidate(parsed);
+        }
+    }
+    if (normalized.length === 0) {
+        const hasToolCallsMarker = /tool_calls/i.test(trimmed);
+        const hasApplyPatchMarker = /apply_patch/i.test(trimmed);
+        if (hasToolCallsMarker && hasApplyPatchMarker) {
+            const patchMatch = trimmed.match(/\*\*\*\s*Begin Patch[\s\S]*?\*\*\*\s*End Patch/);
+            const patchText = readString(patchMatch?.[0]);
+            if (patchText && (allowedToolNames.size === 0 || allowedToolNames.has('apply_patch'))) {
+                const validation = validateToolCall('apply_patch', patchText);
+                if (validation.ok && typeof validation.normalizedArgs === 'string' && validation.normalizedArgs.trim().length > 0) {
+                    normalized.push({
+                        id: `${callIdPrefix}_repair_1`,
+                        type: 'function',
+                        function: {
+                            name: 'apply_patch',
+                            arguments: validation.normalizedArgs
+                        }
+                    });
+                }
+            }
+        }
+    }
+    return normalized;
+}
+function normalizeMessageTextToolCalls(message, allowedToolNames, callIdPrefix) {
+    const candidates = collectMessageTextCandidates(message);
+    if (!candidates.length) {
+        return false;
+    }
+    for (const text of candidates) {
+        const calls = extractToolCallsFromDeepSeekJsonText(text, allowedToolNames, callIdPrefix);
+        if (!calls.length) {
+            continue;
+        }
+        message.tool_calls = calls;
+        message.content = null;
+        return true;
+    }
+    return false;
+}
+function looksLikeShellCommand(value) {
+    return /^(?:pnpm|npm|yarn|node|git|rg|ls|cat|find|sed|head|tail|rm|cp|mv|mkdir|bash|sh|zsh)\b/i.test(value.trim());
+}
+function parseJsonArrayCommand(value) {
+    const trimmed = value.trim();
+    if (!trimmed.startsWith('[') || !trimmed.endsWith(']')) {
+        return undefined;
+    }
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (!Array.isArray(parsed)) {
+            return undefined;
+        }
+        const tokens = parsed
+            .map((item) => (item == null ? '' : String(item)))
+            .filter((item) => item.length > 0);
+        if (!tokens.length) {
+            return undefined;
+        }
+        return tokens.join(' ');
+    }
+    catch {
+        return undefined;
+    }
+}
+function normalizeCommandLine(raw) {
+    return raw.trim().replace(/^\$\s*/, '').trim();
+}
+function extractCommandCandidates(text) {
+    const commands = [];
+    const seen = new Set();
+    const push = (value) => {
+        const normalized = value.trim();
+        if (!normalized || seen.has(normalized)) {
+            return;
+        }
+        seen.add(normalized);
+        commands.push(normalized);
+    };
+    const blockPattern = /```(?:bash|sh|zsh)?\s*\n([\s\S]*?)```/gi;
+    let blockMatch;
+    while ((blockMatch = blockPattern.exec(text)) !== null) {
+        const block = (blockMatch[1] ?? '').toString();
+        const lines = block
+            .split(/\r?\n/)
+            .map((line) => normalizeCommandLine(line))
+            .filter((line) => line.length > 0 && !line.startsWith('#'));
+        if (!lines.length) {
+            continue;
+        }
+        const first = lines[0];
+        if (!looksLikeShellCommand(first)) {
+            continue;
+        }
+        push(lines.join('\n'));
+    }
+    const linePattern = text.split(/\r?\n/);
+    for (const raw of linePattern) {
+        const line = raw.trim();
+        if (!line.length || line.startsWith('```')) {
+            continue;
+        }
+        const ran = line.match(/^(?:[•*+-]\s*)?Ran\s+(.+)$/i);
+        if (ran?.[1]) {
+            const payload = ran[1].trim();
+            const parsedArray = parseJsonArrayCommand(payload);
+            if (parsedArray && looksLikeShellCommand(parsedArray)) {
+                push(parsedArray);
+                continue;
+            }
+            if (looksLikeShellCommand(payload)) {
+                push(payload);
+                continue;
+            }
+        }
+        const normalized = normalizeCommandLine(line);
+        if (looksLikeShellCommand(normalized)) {
+            push(normalized);
+        }
+    }
+    return commands;
+}
+function normalizeMessageCommandToolCall(message, allowedToolNames, callIdPrefix) {
+    if (allowedToolNames.size > 0 && !allowedToolNames.has('exec_command')) {
+        return false;
+    }
+    const candidates = collectMessageTextCandidates(message);
+    if (!candidates.length) {
+        return false;
+    }
+    for (const text of candidates) {
+        const commands = extractCommandCandidates(text);
+        if (!commands.length) {
+            continue;
+        }
+        const cmd = commands[commands.length - 1];
+        message.tool_calls = [
+            {
+                id: `${callIdPrefix}_cmd_1`,
+                type: 'function',
+                function: {
+                    name: 'exec_command',
+                    arguments: JSON.stringify({ cmd })
+                }
+            }
+        ];
+        message.content = null;
+        return true;
+    }
+    return false;
+}
+function normalizeUsageSnapshot(raw) {
+    if (!isRecord(raw)) {
+        return {};
+    }
+    const prompt = readNumber(raw.prompt_tokens) ?? readNumber(raw.input_tokens);
+    const completion = readNumber(raw.completion_tokens) ?? readNumber(raw.output_tokens);
+    const total = readNumber(raw.total_tokens);
+    return {
+        ...(typeof prompt === 'number' ? { prompt: Math.max(0, Math.round(prompt)) } : {}),
+        ...(typeof completion === 'number' ? { completion: Math.max(0, Math.round(completion)) } : {}),
+        ...(typeof total === 'number' ? { total: Math.max(0, Math.round(total)) } : {})
+    };
+}
+function estimateCompletionTokensFromChoices(choices, modelHint) {
+    const segments = [];
+    for (const choice of choices) {
+        if (!isRecord(choice)) {
+            continue;
+        }
+        const message = isRecord(choice.message) ? choice.message : undefined;
+        if (!message) {
+            continue;
+        }
+        const candidates = collectMessageTextCandidates(message);
+        if (candidates.length) {
+            segments.push(...candidates);
+        }
+        if (Array.isArray(message.tool_calls) && message.tool_calls.length) {
+            try {
+                segments.push(JSON.stringify(message.tool_calls));
+            }
+            catch {
+                // ignore serialization failure
+            }
+        }
+    }
+    if (!segments.length) {
+        return 0;
+    }
+    const joined = segments.join('\n');
+    return countTextTokens(joined, modelHint);
+}
+function applyUsageEstimate(root, choices, adapterContext, captured) {
+    const current = normalizeUsageSnapshot(root.usage);
+    const prompt = current.prompt ?? resolveEstimatedInputTokens(adapterContext);
+    const completion = current.completion ??
+        estimateCompletionTokensFromChoices(choices, resolveModelHint(root, captured, adapterContext));
+    const total = current.total ??
+        (typeof prompt === 'number' && typeof completion === 'number' ? prompt + completion : undefined);
+    if (typeof prompt !== 'number' &&
+        typeof completion !== 'number' &&
+        typeof total !== 'number') {
+        return;
+    }
+    const usage = isRecord(root.usage) ? { ...root.usage } : {};
+    if (typeof prompt === 'number') {
+        usage.prompt_tokens = prompt;
+        usage.input_tokens = prompt;
+    }
+    if (typeof completion === 'number') {
+        usage.completion_tokens = completion;
+        usage.output_tokens = completion;
+    }
+    if (typeof total === 'number') {
+        usage.total_tokens = total;
+    }
+    root.usage = usage;
+}
+function normalizeChoice(choice, options, allowedToolNames, callIdPrefix) {
+    const message = isRecord(choice.message) ? choice.message : undefined;
+    if (!message) {
+        return { hasNative: false, hasFallback: false, harvestedFunctionResults: false };
+    }
+    const native = normalizeMessageToolCalls(message, allowedToolNames, callIdPrefix);
+    if (native) {
+        const finish = readString(choice.finish_reason)?.toLowerCase();
+        if (!finish || finish === 'stop') {
+            choice.finish_reason = 'tool_calls';
+        }
+        return { hasNative: true, hasFallback: false, harvestedFunctionResults: false };
+    }
+    if (!options.textToolFallback) {
+        return {
+            hasNative: false,
+            hasFallback: false,
+            harvestedFunctionResults: harvestFunctionResultsMarkup(message)
+        };
+    }
+    const transformed = normalizeAssistantTextToToolCalls(message);
+    if (transformed !== message) {
+        choice.message = transformed;
+    }
+    const fallbackMessage = isRecord(choice.message) ? choice.message : message;
+    let fallback = normalizeMessageToolCalls(fallbackMessage, allowedToolNames, callIdPrefix);
+    if (!fallback) {
+        fallback = normalizeMessageTextToolCalls(fallbackMessage, allowedToolNames, callIdPrefix);
+    }
+    if (fallback) {
+        const finish = readString(choice.finish_reason)?.toLowerCase();
+        if (!finish || finish === 'stop') {
+            choice.finish_reason = 'tool_calls';
+        }
+        return { hasNative: false, hasFallback: true, harvestedFunctionResults: false };
+    }
+    const commandFallback = normalizeMessageCommandToolCall(fallbackMessage, allowedToolNames, callIdPrefix);
+    if (commandFallback) {
+        const finish = readString(choice.finish_reason)?.toLowerCase();
+        if (!finish || finish === 'stop') {
+            choice.finish_reason = 'tool_calls';
+        }
+        return { hasNative: false, hasFallback: true, harvestedFunctionResults: false };
+    }
+    return {
+        hasNative: false,
+        hasFallback: false,
+        harvestedFunctionResults: harvestFunctionResultsMarkup(fallbackMessage)
+    };
+}
+function writeCompatState(root, state, source, harvestedFunctionResults) {
+    const metadata = isRecord(root.metadata) ? root.metadata : {};
+    metadata.deepseek = {
+        ...(isRecord(metadata.deepseek) ? metadata.deepseek : {}),
+        toolCallState: state,
+        toolCallSource: source,
+        ...(harvestedFunctionResults ? { functionResultsTextHarvested: true } : {})
+    };
+    root.metadata = metadata;
+}
+export function applyDeepSeekWebResponseTransform(payload, adapterContext) {
+    if (!payload || typeof payload !== 'object') {
+        return payload;
+    }
+    const cloned = structuredClone(payload);
+    const root = normalizeDeepSeekBusinessEnvelope(cloned, adapterContext);
+    const options = resolveOptions(adapterContext);
+    const captured = resolveCapturedRequest(adapterContext);
+    const allowedToolNames = resolveRequestedToolNames(captured);
+    const toolChoiceRequired = isToolChoiceRequired(captured);
+    const choices = Array.isArray(root.choices) ? root.choices : [];
+    let hasNative = false;
+    let hasFallback = false;
+    let harvestedFunctionResults = false;
+    for (const [index, choice] of choices.entries()) {
+        if (!isRecord(choice)) {
+            continue;
+        }
+        const result = normalizeChoice(choice, options, allowedToolNames, `deepseek_call_${index + 1}`);
+        hasNative = hasNative || result.hasNative;
+        hasFallback = hasFallback || result.hasFallback;
+        harvestedFunctionResults = harvestedFunctionResults || result.harvestedFunctionResults;
+    }
+    const state = hasNative
+        ? 'native_tool_calls'
+        : hasFallback
+            ? 'text_tool_calls'
+            : 'no_tool_calls';
+    const source = hasNative ? 'native' : hasFallback ? 'fallback' : 'none';
+    writeCompatState(root, state, source, harvestedFunctionResults);
+    applyUsageEstimate(root, choices, adapterContext, captured);
+    if (toolChoiceRequired && options.strictToolRequired && !hasNative && !hasFallback) {
+        const error = new Error('DeepSeek tool_choice=required but no valid tool call was produced');
+        error.code = 'DEEPSEEK_TOOL_REQUIRED_MISSING';
+        error.details = {
+            requestId: readString(adapterContext?.requestId),
+            phase: 'chat_process.resp.stage3.compat',
+            state,
+            fallbackEnabled: options.textToolFallback,
+            strictToolRequired: options.strictToolRequired
+        };
+        throw error;
+    }
+    return root;
+}