@jsonstudio/llms 0.6.1892 → 0.6.2172

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

@@ -3,6 +3,7 @@ const DEFAULT_OPTIONS = {
     textToolFallback: true
 };
 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;
@@ -164,7 +165,7 @@ function buildToolFallbackInstruction(toolsRaw, requireToolCall) {
         '',
         schemas.join('\n\n'),
         '',
-        'Tool-call output contract (STRICT):',
+        `${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"}}]}',
@@ -180,6 +181,17 @@ function buildToolFallbackInstruction(toolsRaw, requireToolCall) {
         '{"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') {
@@ -224,7 +236,9 @@ function toPromptMessages(root, options) {
         messages.push({ role, text });
     }
     if (options.textToolFallback) {
-        const instruction = buildToolFallbackInstruction(root.tools, isToolChoiceRequired(root));
+        const instruction = hasToolGuidanceMarker(messages)
+            ? ''
+            : buildToolFallbackInstruction(root.tools, isToolChoiceRequired(root));
         if (instruction) {
             const first = messages[0];
             if (first && first.role === 'system') {

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

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

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

@@ -3,8 +3,23 @@ import { validateToolCall } from '../../../tools/tool-registry.js';
 import { encoding_for_model, get_encoding } from 'tiktoken';
 const DEFAULT_OPTIONS = {
     strictToolRequired: true,
-    textToolFallback: true
+    textToolFallback: true,
+    textNormalizer: undefined
 };
+const SHELL_LIKE_TOOL_NAMES = new Set(['exec_command', 'shell_command', 'shell', 'bash', 'terminal']);
+const SHELL_TOOL_NAME_ALIASES = new Map([
+    ['shell_command', 'exec_command'],
+    ['shell', 'exec_command'],
+    ['bash', 'exec_command'],
+    ['terminal', 'exec_command']
+]);
+const SHELL_ALLOWED_TOOL_CANDIDATES = [
+    'exec_command',
+    'shell_command',
+    'bash',
+    'shell',
+    'terminal'
+];
 const DEFAULT_TOKEN_ENCODING = 'cl100k_base';
 const tokenEncoderCache = new Map();
 let defaultTokenEncoder = null;
@@ -47,6 +62,21 @@ 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 getTokenEncoder(modelHint) {
     const normalized = typeof modelHint === 'string' ? modelHint.trim() : '';
     if (normalized) {
@@ -80,7 +110,7 @@ function countTextTokens(text, modelHint) {
         return 0;
     }
 }
-function resolveOptions(adapterContext) {
+function resolveOptions(adapterContext, config) {
     const context = (adapterContext ?? {});
     const deepseekNode = isRecord(context.deepseek)
         ? context.deepseek
@@ -88,11 +118,23 @@ function resolveOptions(adapterContext) {
             ? context.__rt.deepseek
             : undefined;
     if (!deepseekNode) {
-        return { ...DEFAULT_OPTIONS };
+        return {
+            ...DEFAULT_OPTIONS,
+            strictToolRequired: readOptionalBoolean(config?.strictToolRequired) ?? DEFAULT_OPTIONS.strictToolRequired,
+            textToolFallback: readOptionalBoolean(config?.textToolFallback) ?? DEFAULT_OPTIONS.textToolFallback,
+            textNormalizer: config?.textNormalizer
+        };
     }
+    const strictOverride = readOptionalBoolean(config?.strictToolRequired);
+    const fallbackOverride = readOptionalBoolean(config?.textToolFallback);
     return {
-        strictToolRequired: readBoolean(deepseekNode.strictToolRequired, DEFAULT_OPTIONS.strictToolRequired),
-        textToolFallback: readBoolean(deepseekNode.textToolFallback, DEFAULT_OPTIONS.textToolFallback)
+        strictToolRequired: strictOverride ??
+            readBoolean(deepseekNode.strictToolRequired, DEFAULT_OPTIONS.strictToolRequired),
+        textToolFallback: fallbackOverride ??
+            readBoolean(deepseekNode.textToolFallback, DEFAULT_OPTIONS.textToolFallback),
+        textNormalizer: config?.textNormalizer && typeof config.textNormalizer === 'object'
+            ? config.textNormalizer
+            : undefined
     };
 }
 function resolveCapturedRequest(adapterContext) {
@@ -226,6 +268,19 @@ function resolveRequestedToolNames(captured) {
             names.add(name);
         }
     }
+    const toolChoice = captured.tool_choice;
+    if (isRecord(toolChoice)) {
+        const type = readString(toolChoice.type)?.toLowerCase();
+        if (type === 'function') {
+            const fnNode = isRecord(toolChoice.function)
+                ? toolChoice.function
+                : undefined;
+            const forcedName = readString(fnNode?.name) ?? readString(toolChoice.name);
+            if (forcedName) {
+                names.add(forcedName);
+            }
+        }
+    }
     return names;
 }
 function isToolChoiceRequired(captured) {
@@ -362,6 +417,128 @@ function normalizeToolArguments(value, toolName) {
         return null;
     }
 }
+function hasAllowedToolName(allowed, candidate) {
+    if (allowed.has(candidate)) {
+        return true;
+    }
+    const lowered = candidate.toLowerCase();
+    for (const name of allowed) {
+        if (name.toLowerCase() === lowered) {
+            return true;
+        }
+    }
+    return false;
+}
+function findAllowedToolNameCaseInsensitive(allowed, candidate) {
+    if (allowed.has(candidate)) {
+        return candidate;
+    }
+    const lowered = candidate.toLowerCase();
+    for (const name of allowed) {
+        if (name.toLowerCase() === lowered) {
+            return name;
+        }
+    }
+    return undefined;
+}
+function resolveAllowedShellToolName(allowedToolNames) {
+    for (const candidate of SHELL_ALLOWED_TOOL_CANDIDATES) {
+        const resolved = findAllowedToolNameCaseInsensitive(allowedToolNames, candidate);
+        if (resolved) {
+            return resolved;
+        }
+    }
+    return undefined;
+}
+function resolveToolNameForCompat(rawName, allowedToolNames) {
+    const normalizedRawName = rawName.toLowerCase();
+    const alias = SHELL_TOOL_NAME_ALIASES.get(normalizedRawName);
+    const shellLike = SHELL_LIKE_TOOL_NAMES.has(normalizedRawName) || alias === 'exec_command';
+    if (allowedToolNames.size > 0 && shellLike) {
+        const allowedShell = resolveAllowedShellToolName(allowedToolNames);
+        if (allowedShell) {
+            return allowedShell;
+        }
+    }
+    if (!alias) {
+        return findAllowedToolNameCaseInsensitive(allowedToolNames, rawName) ?? rawName;
+    }
+    if (allowedToolNames.size === 0) {
+        return alias;
+    }
+    const allowedAlias = findAllowedToolNameCaseInsensitive(allowedToolNames, alias);
+    if (allowedAlias) {
+        return allowedAlias;
+    }
+    const allowedRaw = findAllowedToolNameCaseInsensitive(allowedToolNames, rawName);
+    if (allowedRaw) {
+        return allowedRaw;
+    }
+    return alias;
+}
+function readCommandFromShellArgs(args) {
+    const input = isRecord(args.input) ? args.input : undefined;
+    const direct = readString(args.cmd) ??
+        readString(args.command) ??
+        readString(args.script) ??
+        (() => {
+            const arr = Array.isArray(args.command) ? args.command : Array.isArray(args.cmd) ? args.cmd : undefined;
+            if (!arr)
+                return undefined;
+            const tokens = arr.map((item) => (item == null ? '' : String(item).trim())).filter((item) => item.length > 0);
+            return tokens.length ? tokens.join(' ') : undefined;
+        })();
+    if (direct) {
+        return direct;
+    }
+    if (!input) {
+        return undefined;
+    }
+    return (readString(input.cmd) ??
+        readString(input.command) ??
+        readString(input.script) ??
+        (() => {
+            const arr = Array.isArray(input.command) ? input.command : Array.isArray(input.cmd) ? input.cmd : undefined;
+            if (!arr)
+                return undefined;
+            const tokens = arr.map((item) => (item == null ? '' : String(item).trim())).filter((item) => item.length > 0);
+            return tokens.length ? tokens.join(' ') : undefined;
+        })());
+}
+function readWorkdirFromShellArgs(args) {
+    const input = isRecord(args.input) ? args.input : undefined;
+    return (readString(args.workdir) ??
+        readString(args.cwd) ??
+        readString(args.workDir) ??
+        readString(input?.workdir) ??
+        readString(input?.cwd));
+}
+function normalizeShellLikeArguments(argsString, argsSource) {
+    const parsed = tryParseJsonText(argsString);
+    const args = isRecord(parsed) ? { ...parsed } : isRecord(argsSource) ? { ...argsSource } : {};
+    const cmd = readCommandFromShellArgs(args);
+    if (!cmd) {
+        return argsString;
+    }
+    const workdir = readWorkdirFromShellArgs(args);
+    const next = {
+        ...args,
+        cmd,
+        command: cmd
+    };
+    if (workdir) {
+        next.workdir = workdir;
+    }
+    if (Object.prototype.hasOwnProperty.call(next, 'toon')) {
+        delete next.toon;
+    }
+    try {
+        return JSON.stringify(next);
+    }
+    catch {
+        return JSON.stringify({ cmd, command: cmd, ...(workdir ? { workdir } : {}) });
+    }
+}
 function coerceToolCallsValue(toolCallsRaw) {
     if (Array.isArray(toolCallsRaw)) {
         return toolCallsRaw;
@@ -380,13 +557,11 @@ function coerceToolCallsValue(toolCallsRaw) {
 }
 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)) {
+    const rawName = readString(entry.name) ?? readString(fn?.name);
+    if (!rawName) {
         return null;
     }
+    const name = resolveToolNameForCompat(rawName, allowedToolNames);
     const argsSource = entry.input !== undefined
         ? entry.input
         : entry.arguments !== undefined
@@ -396,6 +571,9 @@ function normalizeToolCallEntry(entry, allowedToolNames, callIdPrefix, index) {
     if (!normalizedArgs) {
         return null;
     }
+    const finalArgs = SHELL_LIKE_TOOL_NAMES.has(name.toLowerCase())
+        ? normalizeShellLikeArguments(normalizedArgs, argsSource)
+        : normalizedArgs;
     const id = readString(entry.id) ??
         readString(entry.call_id) ??
         `${callIdPrefix}_${index + 1}`;
@@ -404,7 +582,7 @@ function normalizeToolCallEntry(entry, allowedToolNames, callIdPrefix, index) {
         type: 'function',
         function: {
             name,
-            arguments: normalizedArgs
+            arguments: finalArgs
         }
     };
 }
@@ -473,17 +651,41 @@ function normalizeFunctionResultsMarkupText(value) {
         changed: true
     };
 }
+function normalizeCommentaryMarkupText(value) {
+    const capturedCommentary = [];
+    let changed = false;
+    const stripped = value.replace(/<\s*commentary\s*>([\s\S]*?)<\s*\/\s*commentary\s*>/gi, (_match, inner) => {
+        changed = true;
+        const text = typeof inner === 'string' ? inner.trim() : '';
+        if (text.length) {
+            capturedCommentary.push(text);
+        }
+        return '';
+    });
+    if (!changed) {
+        return { text: value, changed: false };
+    }
+    const collapsed = stripped.replace(/\n{3,}/g, '\n\n').trim();
+    if (collapsed.length) {
+        return { text: collapsed, changed: true };
+    }
+    return {
+        text: capturedCommentary.join('\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) {
+        const functionResultsNormalized = normalizeFunctionResultsMarkupText(input);
+        if (functionResultsNormalized.changed) {
             harvested = true;
         }
-        return normalized.text;
+        const commentaryNormalized = normalizeCommentaryMarkupText(functionResultsNormalized.text);
+        return commentaryNormalized.text;
     };
     if (typeof message.content === 'string') {
         const next = apply(message.content);
@@ -545,29 +747,87 @@ function extractToolCallsFromDeepSeekJsonText(text, allowedToolNames, callIdPref
             }
         }
     };
-    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);
+    const standalonePayload = (() => {
+        const trimDeepSeekTailArtifacts = (value) => {
+            let out = value.trim();
+            // Remove DeepSeek sentinel tails (e.g. <|end|>, <| User |>).
+            out = out
+                .replace(/(?:<[\u007C\uFF5C]\s*end[^>\n]*[\u007C\uFF5C]>\s*)+$/i, '')
+                .replace(/(?:<[\u007C\uFF5C]\s*(?:user|assistant|system|tool|observation)[^>\n]*[\u007C\uFF5C]>\s*)+$/i, '')
+                .trim();
+            return out;
+        };
+        const extractLeadingJsonObject = (value) => {
+            const trimmedValue = value.trimStart();
+            if (!trimmedValue.startsWith('{')) {
+                return undefined;
+            }
+            let depth = 0;
+            let inString = false;
+            let escaped = false;
+            for (let i = 0; i < trimmedValue.length; i += 1) {
+                const ch = trimmedValue[i] ?? '';
+                if (inString) {
+                    if (escaped) {
+                        escaped = false;
+                        continue;
+                    }
+                    if (ch === '\\') {
+                        escaped = true;
+                        continue;
+                    }
+                    if (ch === '"') {
+                        inString = false;
+                    }
+                    continue;
+                }
+                if (ch === '"') {
+                    inString = true;
+                    continue;
+                }
+                if (ch === '{') {
+                    depth += 1;
+                    continue;
+                }
+                if (ch === '}') {
+                    depth -= 1;
+                    if (depth === 0) {
+                        return trimmedValue.slice(0, i + 1).trim();
+                    }
+                    continue;
+                }
+            }
+            return undefined;
+        };
+        let candidate = trimDeepSeekTailArtifacts(trimmed);
+        const fenced = candidate.match(/^```(?:json|tool_call|tool_calls)?\s*([\s\S]*?)\s*```/i);
+        if (fenced?.[1]) {
+            candidate = trimDeepSeekTailArtifacts(fenced[1]);
+        }
+        const leadingObject = extractLeadingJsonObject(candidate);
+        if (!leadingObject) {
+            return undefined;
+        }
+        if (!/["']tool_calls["']\s*:/.test(leadingObject)) {
+            return undefined;
+        }
+        return leadingObject;
+    })();
+    if (standalonePayload) {
+        const parsedRoot = tryParseJsonText(standalonePayload);
+        if (parsedRoot !== null) {
+            parseCandidate(parsedRoot);
         }
     }
     if (normalized.length === 0) {
-        const hasToolCallsMarker = /tool_calls/i.test(trimmed);
-        const hasApplyPatchMarker = /apply_patch/i.test(trimmed);
+        const sourceForRepair = standalonePayload ?? trimmed;
+        const hasToolCallsMarker = /tool_calls/i.test(sourceForRepair);
+        const hasApplyPatchMarker = /apply_patch/i.test(sourceForRepair);
         if (hasToolCallsMarker && hasApplyPatchMarker) {
-            const patchMatch = trimmed.match(/\*\*\*\s*Begin Patch[\s\S]*?\*\*\*\s*End Patch/);
+            const patchMatch = sourceForRepair.match(/\*\*\*\s*Begin Patch[\s\S]*?\*\*\*\s*End Patch/);
             const patchText = readString(patchMatch?.[0]);
-            if (patchText && (allowedToolNames.size === 0 || allowedToolNames.has('apply_patch'))) {
+            const applyPatchAllowed = allowedToolNames.size === 0 || hasAllowedToolName(allowedToolNames, 'apply_patch');
+            if (patchText && applyPatchAllowed) {
                 const validation = validateToolCall('apply_patch', patchText);
                 if (validation.ok && typeof validation.normalizedArgs === 'string' && validation.normalizedArgs.trim().length > 0) {
                     normalized.push({
@@ -683,9 +943,11 @@ function extractCommandCandidates(text) {
     return commands;
 }
 function normalizeMessageCommandToolCall(message, allowedToolNames, callIdPrefix) {
-    if (allowedToolNames.size > 0 && !allowedToolNames.has('exec_command')) {
-        return false;
-    }
+    const commandToolName = hasAllowedToolName(allowedToolNames, 'exec_command')
+        ? 'exec_command'
+        : hasAllowedToolName(allowedToolNames, 'shell_command')
+            ? 'shell_command'
+            : 'exec_command';
     const candidates = collectMessageTextCandidates(message);
     if (!candidates.length) {
         return false;
@@ -701,8 +963,8 @@ function normalizeMessageCommandToolCall(message, allowedToolNames, callIdPrefix
                 id: `${callIdPrefix}_cmd_1`,
                 type: 'function',
                 function: {
-                    name: 'exec_command',
-                    arguments: JSON.stringify({ cmd })
+                    name: commandToolName,
+                    arguments: JSON.stringify({ cmd, command: cmd })
                 }
             }
         ];
@@ -799,7 +1061,7 @@ function normalizeChoice(choice, options, allowedToolNames, callIdPrefix) {
             harvestedFunctionResults: harvestFunctionResultsMarkup(message)
         };
     }
-    const transformed = normalizeAssistantTextToToolCalls(message);
+    const transformed = normalizeAssistantTextToToolCalls(message, options.textNormalizer);
     if (transformed !== message) {
         choice.message = transformed;
     }
@@ -839,13 +1101,13 @@ function writeCompatState(root, state, source, harvestedFunctionResults) {
     };
     root.metadata = metadata;
 }
-export function applyDeepSeekWebResponseTransform(payload, adapterContext) {
+export function applyDeepSeekWebResponseTransform(payload, adapterContext, config) {
     if (!payload || typeof payload !== 'object') {
         return payload;
     }
     const cloned = structuredClone(payload);
     const root = normalizeDeepSeekBusinessEnvelope(cloned, adapterContext);
-    const options = resolveOptions(adapterContext);
+    const options = resolveOptions(adapterContext, config);
     const captured = resolveCapturedRequest(adapterContext);
     const allowedToolNames = resolveRequestedToolNames(captured);
     const toolChoiceRequired = isToolChoiceRequired(captured);

package/dist/conversion/compat/actions/harvest-tool-calls-from-text.d.ts

@@ -1,4 +1,8 @@
 import type { JsonObject } from '../../hub/types/json.js';
+import { type TextMarkupNormalizeOptions } from '../../shared/text-markup-normalizer.js';
+export interface HarvestToolCallsFromTextConfig {
+    normalizer?: TextMarkupNormalizeOptions;
+}
 /**
  * Harvest tool calls from assistant textual markup into OpenAI `tool_calls`.
  *
@@ -8,3 +12,4 @@ import type { JsonObject } from '../../hub/types/json.js';
  * This action is response-only and provider-scoped via compatibility profiles.
  */
 export declare function harvestToolCallsFromText(payload: JsonObject): JsonObject;
+export declare function harvestToolCallsFromTextWithConfig(payload: JsonObject, config?: HarvestToolCallsFromTextConfig): JsonObject;

package/dist/conversion/compat/actions/harvest-tool-calls-from-text.js

@@ -23,7 +23,7 @@ function extractResponsesMessageText(item) {
     }
     return parts.join('\n').trim();
 }
-function harvestToolCallsFromResponsesPayloadInPlace(root) {
+function harvestToolCallsFromResponsesPayloadInPlace(root, config) {
     const output = Array.isArray(root.output) ? root.output : [];
     if (!output.length)
         return false;
@@ -49,7 +49,7 @@ function harvestToolCallsFromResponsesPayloadInPlace(root) {
             nextOutput.push(item);
             continue;
         }
-        const normalized = normalizeAssistantTextToToolCalls({ role: 'assistant', content: text });
+        const normalized = normalizeAssistantTextToToolCalls({ role: 'assistant', content: text }, config?.normalizer);
         const toolCalls = Array.isArray(normalized.tool_calls) ? normalized.tool_calls : [];
         if (!toolCalls.length) {
             nextOutput.push(item);
@@ -91,12 +91,15 @@ function harvestToolCallsFromResponsesPayloadInPlace(root) {
  * This action is response-only and provider-scoped via compatibility profiles.
  */
 export function harvestToolCallsFromText(payload) {
+    return harvestToolCallsFromTextWithConfig(payload);
+}
+export function harvestToolCallsFromTextWithConfig(payload, config) {
     const root = structuredClone(payload);
     const choices = Array.isArray(root.choices) ? root.choices : [];
     // Responses provider payload: harvest into canonical Responses output items first.
     // This allows the normal semantic mapper (Responses → Chat) to surface tool_calls for servertool orchestration.
     if (!choices.length) {
-        harvestToolCallsFromResponsesPayloadInPlace(root);
+        harvestToolCallsFromResponsesPayloadInPlace(root, config);
         return root;
     }
     for (const choice of choices) {
@@ -105,7 +108,7 @@ export function harvestToolCallsFromText(payload) {
         const message = choice.message;
         if (!isRecord(message))
             continue;
-        const normalized = normalizeAssistantTextToToolCalls(message);
+        const normalized = normalizeAssistantTextToToolCalls(message, config?.normalizer);
         if (normalized !== message) {
             choice.message = normalized;
             const hasToolCalls = Array.isArray(normalized.tool_calls) && normalized.tool_calls.length > 0;

package/dist/conversion/compat/actions/iflow-tool-text-fallback.d.ts

@@ -9,4 +9,5 @@ import type { JsonObject } from '../../hub/types/json.js';
  */
 export declare function applyIflowToolTextFallback(payload: JsonObject, options?: {
     models?: string[];
+    routeId?: string;
 }): JsonObject;

package/dist/conversion/compat/actions/iflow-tool-text-fallback.js

@@ -2,6 +2,13 @@ const isRecord = (value) => typeof value === 'object' && value !== null && !Arra
 function normalizeModel(value) {
     return typeof value === 'string' ? value.trim().toLowerCase() : '';
 }
+function isWebSearchRoute(routeId) {
+    if (typeof routeId !== 'string') {
+        return false;
+    }
+    const normalized = routeId.trim().toLowerCase();
+    return normalized.startsWith('web_search') || normalized.startsWith('search');
+}
 function hasNonEmptyArray(value) {
     return Array.isArray(value) && value.length > 0;
 }
@@ -169,6 +176,11 @@ export function applyIflowToolTextFallback(payload, options) {
         return payload;
     }
     const root = structuredClone(payload);
+    if (isWebSearchRoute(options?.routeId)) {
+        // web_search/search routes are independent transport paths and must not be coupled
+        // to model-gated fallback heuristics.
+        return root;
+    }
     const model = normalizeModel(root.model);
     const models = Array.isArray(options?.models) ? options.models.map((m) => normalizeModel(m)).filter(Boolean) : [];
     if (!model || !models.includes(model)) {

package/dist/conversion/compat/actions/strip-orphan-function-calls-tag.js

@@ -1,7 +1,7 @@
 function isRecord(value) {
     return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
 }
-const ORPHAN_TAG_RE = /^\s*(?:[•*+-]\s*)?<\/?\s*function_calls\s*\/?\s*>\s*$/i;
+const ORPHAN_TAG_RE = /^\s*(?:[•*+-]\s*)?(?:<\/?\s*function_calls\s*\/?\s*>|<\/\s*(?:parameter|function|tool_call)\s*>)\s*$/i;
 function stripOrphanTagLines(text) {
     const raw = String(text ?? '');
     if (!raw)

package/dist/conversion/compat/actions/tool-text-request-guidance.d.ts

@@ -0,0 +1,9 @@
+import type { JsonObject } from '../../hub/types/json.js';
+export interface ToolTextRequestGuidanceConfig {
+    enabled?: boolean;
+    marker?: string;
+    instruction?: string;
+    requireTools?: boolean;
+    includeToolNames?: boolean;
+}
+export declare function applyToolTextRequestGuidance(payload: JsonObject, config?: ToolTextRequestGuidanceConfig): JsonObject;