@jsonstudio/llms 0.6.1172 → 0.6.1354

package/dist/conversion/codecs/gemini-openai-codec.d.ts

@@ -2,7 +2,9 @@ import type { ConversionCodec, ConversionContext, ConversionProfile } from '../t
 export declare function buildOpenAIChatFromGeminiRequest(payload: any): {
     messages: any[];
 };
-export declare function buildOpenAIChatFromGeminiResponse(payload: any): any;
+export declare function buildOpenAIChatFromGeminiResponse(payload: any, options?: {
+    aliasMap?: Record<string, string>;
+}): any;
 export declare function buildGeminiFromOpenAIChat(chatResp: any): any;
 export declare class GeminiOpenAIConversionCodec implements ConversionCodec {
     private readonly _dependencies;

package/dist/conversion/codecs/gemini-openai-codec.js

@@ -175,7 +175,7 @@ export function buildOpenAIChatFromGeminiRequest(payload) {
     }
     return { messages };
 }
-export function buildOpenAIChatFromGeminiResponse(payload) {
+export function buildOpenAIChatFromGeminiResponse(payload, options) {
     const candidates = Array.isArray(payload?.candidates) ? payload.candidates : [];
     const primary = candidates[0] && typeof candidates[0] === 'object' ? candidates[0] : {};
     const content = primary?.content || {};
@@ -229,9 +229,12 @@ export function buildOpenAIChatFromGeminiResponse(payload) {
         // 5. Function call (tool call)
         if (pObj.functionCall && typeof pObj.functionCall === 'object') {
             const fc = pObj.functionCall;
-            const name = typeof fc.name === 'string' ? String(fc.name) : undefined;
-            if (!name)
+            const nameRaw = typeof fc.name === 'string' ? String(fc.name) : undefined;
+            if (!nameRaw)
                 continue;
+            const name = options?.aliasMap && typeof options.aliasMap[nameRaw] === 'string'
+                ? String(options.aliasMap[nameRaw])
+                : nameRaw;
             let id = typeof fc.id === 'string' && fc.id.trim().length ? String(fc.id).trim() : undefined;
             const argsRaw = (fc.args ?? fc.arguments);
             let argsStr;
@@ -268,7 +271,10 @@ export function buildOpenAIChatFromGeminiResponse(payload) {
         if (pObj.functionResponse && typeof pObj.functionResponse === 'object') {
             const fr = pObj.functionResponse;
             const callId = typeof fr.id === 'string' && fr.id.trim().length ? String(fr.id) : undefined;
-            const name = typeof fr.name === 'string' && fr.name.trim().length ? String(fr.name) : undefined;
+            const nameRaw = typeof fr.name === 'string' && fr.name.trim().length ? String(fr.name) : undefined;
+            const name = nameRaw && options?.aliasMap && typeof options.aliasMap[nameRaw] === 'string'
+                ? String(options.aliasMap[nameRaw])
+                : nameRaw;
             const resp = fr.response;
             let contentStr = '';
             if (typeof resp === 'string') {

package/dist/conversion/compat/actions/gemini-web-search.d.ts

@@ -3,7 +3,7 @@ import type { AdapterContext } from '../../hub/types/chat-envelope.js';
 /**
  * Gemini web_search 请求适配（作用于 Gemini 请求 payload，而不是 ChatEnvelope）：
  *
- * - 仅在 routeId 以 `web_search` 开头时生效（来自 AdapterContext.routeId）；
+ * - 仅在 routeId 以 `web_search` 或 `search` 开头时生效（来自 AdapterContext.routeId）；
  * - 针对 Gemini 请求中的 `tools` 字段进行清洗：
  *   - 保留 name === 'web_search' 的 functionDeclarations（如果存在）；
  *   - 丢弃其它 Codex 自身工具（exec_command / MCP 等），避免 Cloud Code 报

package/dist/conversion/compat/actions/gemini-web-search.js

@@ -2,7 +2,7 @@ const isRecord = (value) => typeof value === 'object' && value !== null && !Arra
 /**
  * Gemini web_search 请求适配（作用于 Gemini 请求 payload，而不是 ChatEnvelope）：
  *
- * - 仅在 routeId 以 `web_search` 开头时生效（来自 AdapterContext.routeId）；
+ * - 仅在 routeId 以 `web_search` 或 `search` 开头时生效（来自 AdapterContext.routeId）；
  * - 针对 Gemini 请求中的 `tools` 字段进行清洗：
  *   - 保留 name === 'web_search' 的 functionDeclarations（如果存在）；
  *   - 丢弃其它 Codex 自身工具（exec_command / MCP 等），避免 Cloud Code 报
@@ -15,7 +15,10 @@ const isRecord = (value) => typeof value === 'object' && value !== null && !Arra
  */
 export function applyGeminiWebSearchCompat(payload, adapterContext) {
     const routeId = typeof adapterContext?.routeId === 'string' ? adapterContext.routeId : '';
-    if (!routeId || !routeId.toLowerCase().startsWith('web_search')) {
+    const normalizedRoute = routeId.trim().toLowerCase();
+    // Some hosts/configs use "search" as the route name for web search engines.
+    // Treat both "web_search*" and "search*" as web-search routes.
+    if (!normalizedRoute || (!normalizedRoute.startsWith('web_search') && !normalizedRoute.startsWith('search'))) {
         return payload;
     }
     const cloned = { ...payload };

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

@@ -0,0 +1,12 @@
+import type { JsonObject } from '../../hub/types/json.js';
+/**
+ * Some iFlow models reject OpenAI `tools`/`tool_choice` fields with a non-standard 200 error envelope.
+ *
+ * For such models, we fall back to "text tool calls":
+ * - remove top-level `tools` / `tool_choice` so upstream accepts the request
+ * - inject a system instruction telling the model to emit `<tool:...>` blocks
+ * - response pipeline will harvest those blocks into canonical `tool_calls`
+ */
+export declare function applyIflowToolTextFallback(payload: JsonObject, options?: {
+    models?: string[];
+}): JsonObject;

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

@@ -0,0 +1,199 @@
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+function normalizeModel(value) {
+    return typeof value === 'string' ? value.trim().toLowerCase() : '';
+}
+function hasNonEmptyArray(value) {
+    return Array.isArray(value) && value.length > 0;
+}
+function ensureSystemMessage(messages) {
+    const first = messages[0];
+    if (isRecord(first) && typeof first.role === 'string' && first.role.toLowerCase() === 'system') {
+        return first;
+    }
+    const sys = { role: 'system', content: '' };
+    messages.unshift(sys);
+    return sys;
+}
+function appendSystemText(sys, extra) {
+    const prev = typeof sys.content === 'string' ? sys.content : '';
+    if (prev.includes('## Tool Calls (Text Markup Mode)')) {
+        return;
+    }
+    const combined = prev ? `${prev}\n\n${extra}` : extra;
+    sys.content = combined;
+}
+function buildToolMarkupInstruction() {
+    // Keep this concise. The response-side canonicalizer will harvest these blocks into tool_calls.
+    return [
+        '## Tool Calls (Text Markup Mode)',
+        '',
+        'You MAY call tools by emitting one or more XML blocks with this exact format, and nothing else inside the block:',
+        '',
+        '<tool:exec_command>',
+        '<command>...</command>',
+        '<timeout_ms>10000</timeout_ms>',
+        '</tool:exec_command>',
+        '',
+        '<tool:write_stdin>',
+        '<session_id>...</session_id>',
+        '<input>...</input>',
+        '</tool:write_stdin>',
+        '',
+        'Rules:',
+        '- Use `<tool:exec_command>` to run shell commands.',
+        '- Use `<tool:write_stdin>` to send input to an existing session.',
+        '- Do NOT wrap these blocks in code fences.',
+        '- Do NOT invent tools; only use exec_command and write_stdin.',
+        ''
+    ].join('\n');
+}
+function stringifyToolOutput(value) {
+    if (typeof value === 'string')
+        return value;
+    if (value === null || value === undefined)
+        return '';
+    try {
+        return JSON.stringify(value, null, 2);
+    }
+    catch {
+        return String(value);
+    }
+}
+function coerceToolCallToXmlBlock(toolCall) {
+    if (!isRecord(toolCall))
+        return null;
+    const type = typeof toolCall.type === 'string' ? toolCall.type.trim().toLowerCase() : '';
+    if (type && type !== 'function')
+        return null;
+    const fn = isRecord(toolCall.function) ? toolCall.function : null;
+    const name = typeof fn?.name === 'string' ? fn.name.trim() : '';
+    if (!name)
+        return null;
+    const argsRaw = fn?.arguments;
+    let args = null;
+    if (typeof argsRaw === 'string' && argsRaw.trim().length) {
+        try {
+            const parsed = JSON.parse(argsRaw);
+            args = isRecord(parsed) ? parsed : null;
+        }
+        catch {
+            args = { raw: argsRaw };
+        }
+    }
+    else if (isRecord(argsRaw)) {
+        args = argsRaw;
+    }
+    if (name === 'exec_command') {
+        const command = typeof args?.cmd === 'string'
+            ? args.cmd
+            : typeof args?.command === 'string'
+                ? args.command
+                : '';
+        if (!command)
+            return null;
+        const timeoutMs = typeof args?.timeout_ms === 'number' && Number.isFinite(args.timeout_ms)
+            ? Math.floor(args.timeout_ms)
+            : undefined;
+        return [
+            '<tool:exec_command>',
+            `<command>${command}</command>`,
+            ...(timeoutMs !== undefined ? [`<timeout_ms>${timeoutMs}</timeout_ms>`] : []),
+            '</tool:exec_command>'
+        ].join('\n');
+    }
+    if (name === 'write_stdin') {
+        const sessionId = typeof args?.session_id === 'string'
+            ? args.session_id
+            : typeof args?.sessionId === 'string'
+                ? args.sessionId
+                : '';
+        const input = typeof args?.chars === 'string'
+            ? args.chars
+            : typeof args?.input === 'string'
+                ? args.input
+                : '';
+        if (!sessionId || !input)
+            return null;
+        return [
+            '<tool:write_stdin>',
+            `<session_id>${sessionId}</session_id>`,
+            `<input>${input}</input>`,
+            '</tool:write_stdin>'
+        ].join('\n');
+    }
+    return null;
+}
+function rewriteMessageToolSurfaceInPlace(message) {
+    const role = typeof message.role === 'string' ? message.role.trim().toLowerCase() : '';
+    // Tool result messages are not supported by some iFlow models; convert them into plain text.
+    if (role === 'tool') {
+        const toolName = typeof message.name === 'string' ? message.name.trim() : '';
+        const toolCallId = typeof message.tool_call_id === 'string' ? String(message.tool_call_id).trim() : '';
+        const content = stringifyToolOutput(message.content);
+        message.role = 'user';
+        message.content = [
+            'Tool result:',
+            ...(toolName ? [`name: ${toolName}`] : []),
+            ...(toolCallId ? [`tool_call_id: ${toolCallId}`] : []),
+            'output:',
+            content
+        ].join('\n');
+        delete message.name;
+        delete message.tool_call_id;
+        return;
+    }
+    // Assistant tool_calls are not supported by some iFlow models; convert them to XML tool markup.
+    const toolCallsRaw = message.tool_calls;
+    if (hasNonEmptyArray(toolCallsRaw)) {
+        const blocks = toolCallsRaw
+            .map(coerceToolCallToXmlBlock)
+            .filter((b) => typeof b === 'string' && b.length > 0);
+        if (blocks.length) {
+            const prev = typeof message.content === 'string' ? message.content : '';
+            const joined = blocks.join('\n\n');
+            message.content = prev && prev.trim().length ? `${prev}\n\n${joined}` : joined;
+        }
+        delete message.tool_calls;
+    }
+}
+/**
+ * Some iFlow models reject OpenAI `tools`/`tool_choice` fields with a non-standard 200 error envelope.
+ *
+ * For such models, we fall back to "text tool calls":
+ * - remove top-level `tools` / `tool_choice` so upstream accepts the request
+ * - inject a system instruction telling the model to emit `<tool:...>` blocks
+ * - response pipeline will harvest those blocks into canonical `tool_calls`
+ */
+export function applyIflowToolTextFallback(payload, options) {
+    if (!payload || typeof payload !== 'object') {
+        return payload;
+    }
+    const root = structuredClone(payload);
+    const model = normalizeModel(root.model);
+    const models = Array.isArray(options?.models) ? options.models.map((m) => normalizeModel(m)).filter(Boolean) : [];
+    if (!model || !models.includes(model)) {
+        return root;
+    }
+    // Only apply when we have a message array to carry the injected instruction.
+    const messages = root.messages;
+    if (!hasNonEmptyArray(messages)) {
+        return root;
+    }
+    // Always strip tool schemas for fallback models (including followups),
+    // otherwise the first turn might succeed but the tool loop breaks.
+    if ('tools' in root) {
+        delete root.tools;
+    }
+    if ('tool_choice' in root) {
+        delete root.tool_choice;
+    }
+    // Rewrite message-level tool protocol to plain text so upstream accepts it.
+    for (const msg of messages) {
+        if (!isRecord(msg))
+            continue;
+        rewriteMessageToolSurfaceInPlace(msg);
+    }
+    const sys = ensureSystemMessage(messages);
+    appendSystemText(sys, buildToolMarkupInstruction());
+    return root;
+}

package/dist/conversion/compat/actions/iflow-web-search.d.ts

@@ -3,7 +3,7 @@ import type { AdapterContext } from '../../hub/types/chat-envelope.js';
 /**
  * IFlow web_search 请求适配（作用于 openai-chat 兼容 payload）：
  *
- * - 仅在 routeId 以 `web_search` 开头时生效（来自 AdapterContext.routeId）；
+ * - 仅在 routeId 以 `web_search` 或 `search` 开头时生效（来自 AdapterContext.routeId）；
  * - 读取顶层的 `web_search` helper 对象 `{ query, recency, count, engine }`；
  * - 当 query 为空或无效时：删除 helper，原样透传；
  * - 当 query 有效时：构造一个标准的 OpenAI function tool：

package/dist/conversion/compat/actions/iflow-web-search.js

@@ -3,7 +3,7 @@ const DEBUG_IFLOW_WEB_SEARCH = (process.env.ROUTECODEX_DEBUG_IFLOW_WEB_SEARCH ||
 /**
  * IFlow web_search 请求适配（作用于 openai-chat 兼容 payload）：
  *
- * - 仅在 routeId 以 `web_search` 开头时生效（来自 AdapterContext.routeId）；
+ * - 仅在 routeId 以 `web_search` 或 `search` 开头时生效（来自 AdapterContext.routeId）；
  * - 读取顶层的 `web_search` helper 对象 `{ query, recency, count, engine }`；
  * - 当 query 为空或无效时：删除 helper，原样透传；
  * - 当 query 有效时：构造一个标准的 OpenAI function tool：
@@ -17,7 +17,10 @@ const DEBUG_IFLOW_WEB_SEARCH = (process.env.ROUTECODEX_DEBUG_IFLOW_WEB_SEARCH ||
  */
 export function applyIflowWebSearchRequestTransform(payload, adapterContext) {
     const routeId = typeof adapterContext?.routeId === 'string' ? adapterContext.routeId : '';
-    if (!routeId || !routeId.toLowerCase().startsWith('web_search')) {
+    const normalizedRoute = routeId.trim().toLowerCase();
+    // Some hosts/configs use "search" as the route name for web search engines.
+    // Treat both "web_search*" and "search*" as web-search routes.
+    if (!normalizedRoute || (!normalizedRoute.startsWith('web_search') && !normalizedRoute.startsWith('search'))) {
         return payload;
     }
     const root = structuredClone(payload);

package/dist/conversion/hub/operation-table/semantic-mappers/anthropic-mapper.js

@@ -3,7 +3,6 @@ import { buildOpenAIChatFromAnthropic, buildAnthropicRequestFromOpenAIChat } fro
 import { encodeMetadataPassthrough, extractMetadataPassthrough } from '../../../shared/metadata-passthrough.js';
 import { buildAnthropicToolAliasMap } from '../../../shared/anthropic-message-utils.js';
 import { ChatSemanticMapper } from './chat-mapper.js';
-import { ensureProtocolState, getProtocolState } from '../../../shared/protocol-state.js';
 const ANTHROPIC_PARAMETER_KEYS = [
     'model',
     'temperature',
@@ -38,12 +37,12 @@ function ensureSemantics(chat) {
     }
     return chat.semantics;
 }
-function ensureAnthropicSemanticsNode(chat) {
+function ensureToolsSemanticsNode(chat) {
     const semantics = ensureSemantics(chat);
-    if (!semantics.anthropic || !isJsonObject(semantics.anthropic)) {
-        semantics.anthropic = {};
+    if (!semantics.tools || !isJsonObject(semantics.tools)) {
+        semantics.tools = {};
     }
-    return semantics.anthropic;
+    return semantics.tools;
 }
 function markExplicitEmptyTools(chat) {
     const semantics = ensureSemantics(chat);
@@ -52,11 +51,11 @@ function markExplicitEmptyTools(chat) {
     }
     semantics.tools.explicitEmpty = true;
 }
-function readAnthropicSemantics(chat) {
+function readToolsSemantics(chat) {
     if (!chat.semantics || typeof chat.semantics !== 'object') {
         return undefined;
     }
-    const node = chat.semantics.anthropic;
+    const node = chat.semantics.tools;
     return node && isJsonObject(node) ? node : undefined;
 }
 function hasExplicitEmptyToolsSemantics(chat) {
@@ -126,34 +125,24 @@ export class AnthropicSemanticMapper {
         const metadata = chatEnvelope.metadata ?? { context: canonicalContext };
         chatEnvelope.metadata = metadata;
         metadata.context = canonicalContext;
-        let semanticsNode;
-        const resolveExtraFields = () => {
-            if (!isJsonObject(metadata.extraFields)) {
-                metadata.extraFields = {};
-            }
-            return metadata.extraFields;
-        };
-        const protocolState = ensureProtocolState(metadata, 'anthropic');
+        const semantics = ensureSemantics(chatEnvelope);
+        if (!semantics.system || !isJsonObject(semantics.system)) {
+            semantics.system = {};
+        }
+        if (!semantics.providerExtras || !isJsonObject(semantics.providerExtras)) {
+            semantics.providerExtras = {};
+        }
         const systemBlocks = cloneAnthropicSystemBlocks(payload.system);
         if (systemBlocks) {
-            protocolState.systemBlocks = systemBlocks;
-            semanticsNode = semanticsNode ?? ensureAnthropicSemanticsNode(chatEnvelope);
-            semanticsNode.systemBlocks = jsonClone(systemBlocks);
+            semantics.system.blocks = jsonClone(systemBlocks);
         }
         if (payload.tools && Array.isArray(payload.tools) && payload.tools.length === 0) {
-            metadata.toolsFieldPresent = true;
-            resolveExtraFields().toolsFieldPresent = true;
             markExplicitEmptyTools(chatEnvelope);
         }
         const aliasMap = buildAnthropicToolAliasMap(payload.tools);
         if (aliasMap) {
-            const extraFields = resolveExtraFields();
-            ctx.anthropicToolNameMap = aliasMap;
-            canonicalContext.anthropicToolNameMap = aliasMap;
-            metadata.anthropicToolNameMap = aliasMap;
-            extraFields.anthropicToolNameMap = aliasMap;
-            semanticsNode = semanticsNode ?? ensureAnthropicSemanticsNode(chatEnvelope);
-            semanticsNode.toolAliasMap = jsonClone(aliasMap);
+            const toolsNode = ensureToolsSemanticsNode(chatEnvelope);
+            toolsNode.toolNameAliasMap = jsonClone(aliasMap);
         }
         if (Array.isArray(payload.messages) && payload.messages.length) {
             const shapes = payload.messages.map((entry) => {
@@ -172,14 +161,8 @@ export class AnthropicSemanticMapper {
                 }
                 return typeof rawContent;
             });
-            const extraFields = resolveExtraFields();
-            const mirrorNode = extraFields.anthropicMirror && typeof extraFields.anthropicMirror === 'object'
-                ? extraFields.anthropicMirror
-                : {};
-            mirrorNode.messageContentShape = shapes;
-            extraFields.anthropicMirror = mirrorNode;
-            semanticsNode = semanticsNode ?? ensureAnthropicSemanticsNode(chatEnvelope);
-            semanticsNode.mirror = jsonClone(mirrorNode);
+            const mirrorNode = { messageContentShape: shapes };
+            semantics.providerExtras.anthropicMirror = jsonClone(mirrorNode);
         }
         if (missing.length) {
             metadata.missingFields = Array.isArray(metadata.missingFields)
@@ -189,9 +172,7 @@ export class AnthropicSemanticMapper {
         const providerMetadata = passthrough.metadata ??
             (payload.metadata && isJsonObject(payload.metadata) ? jsonClone(payload.metadata) : undefined);
         if (providerMetadata) {
-            metadata.providerMetadata = providerMetadata;
-            semanticsNode = semanticsNode ?? ensureAnthropicSemanticsNode(chatEnvelope);
-            semanticsNode.providerMetadata = jsonClone(providerMetadata);
+            semantics.providerExtras.providerMetadata = jsonClone(providerMetadata);
         }
         const mergedParameters = { ...(chatEnvelope.parameters ?? {}) };
         const mergeParameters = (source) => {
@@ -232,8 +213,7 @@ export class AnthropicSemanticMapper {
             messages: chat.messages,
             tools: chat.tools
         };
-        const semanticsNode = readAnthropicSemantics(chat);
-        const explicitEmptyTools = (chat.metadata?.toolsFieldPresent === true) || hasExplicitEmptyToolsSemantics(chat);
+        const explicitEmptyTools = hasExplicitEmptyToolsSemantics(chat);
         const trimmedParameters = chat.parameters && typeof chat.parameters === 'object' ? chat.parameters : undefined;
         if (trimmedParameters) {
             for (const [key, value] of Object.entries(trimmedParameters)) {
@@ -268,28 +248,39 @@ export class AnthropicSemanticMapper {
         if (explicitEmptyTools && (!Array.isArray(chat.tools) || chat.tools.length === 0)) {
             baseRequest.tools = [];
         }
-        const protocolState = getProtocolState(chat.metadata, 'anthropic');
-        if (protocolState?.systemBlocks !== undefined) {
-            baseRequest.system = jsonClone(protocolState.systemBlocks);
+        try {
+            const sysNode = chat.semantics && typeof chat.semantics === 'object' ? chat.semantics.system : undefined;
+            if (sysNode && typeof sysNode === 'object' && !Array.isArray(sysNode) && sysNode.blocks !== undefined) {
+                baseRequest.system = jsonClone(sysNode.blocks);
+            }
         }
-        else if (semanticsNode?.systemBlocks !== undefined) {
-            baseRequest.system = jsonClone(semanticsNode.systemBlocks);
+        catch {
+            // ignore
         }
-        if (chat.metadata &&
-            typeof chat.metadata === 'object' &&
-            chat.metadata.extraFields &&
-            typeof chat.metadata.extraFields === 'object' &&
-            chat.metadata.extraFields.anthropicMirror) {
-            baseRequest.__anthropicMirror = jsonClone(chat.metadata.extraFields.anthropicMirror ?? {});
+        try {
+            const extras = chat.semantics && typeof chat.semantics === 'object' ? chat.semantics.providerExtras : undefined;
+            const mirror = extras && typeof extras === 'object' && !Array.isArray(extras) ? extras.anthropicMirror : undefined;
+            if (mirror && typeof mirror === 'object' && !Array.isArray(mirror)) {
+                baseRequest.__anthropicMirror = jsonClone(mirror);
+            }
+            const providerMetadata = extras && typeof extras === 'object' && !Array.isArray(extras) ? extras.providerMetadata : undefined;
+            if (providerMetadata && typeof providerMetadata === 'object' && !Array.isArray(providerMetadata)) {
+                // Only for anthropic-native endpoint: allow restoring anthropic metadata back into outbound.
+                const existing = baseRequest.metadata && isJsonObject(baseRequest.metadata)
+                    ? jsonClone(baseRequest.metadata)
+                    : {};
+                const merged = {
+                    ...existing,
+                    ...jsonClone(providerMetadata)
+                };
+                baseRequest.metadata = merged;
+            }
         }
-        else if (semanticsNode?.mirror && isJsonObject(semanticsNode.mirror)) {
-            baseRequest.__anthropicMirror = jsonClone(semanticsNode.mirror);
+        catch {
+            // ignore
         }
         const payloadSource = buildAnthropicRequestFromOpenAIChat(baseRequest);
         const payload = sanitizeAnthropicPayload(JSON.parse(JSON.stringify(payloadSource)));
-        if (chat.metadata?.toolsFieldPresent && (!Array.isArray(chat.tools) || chat.tools.length === 0)) {
-            payload.tools = [];
-        }
         sanitizeAnthropicPayload(payload);
         return {
             protocol: 'anthropic-messages',

package/dist/conversion/hub/operation-table/semantic-mappers/chat-mapper.js

@@ -323,9 +323,6 @@ function applyExtraFields(body, metadata, semantics) {
     if (semanticsExtras) {
         sources.push(semanticsExtras);
     }
-    if (metadata?.extraFields && isJsonObject(metadata.extraFields)) {
-        sources.push(metadata.extraFields);
-    }
     if (!sources.length) {
         return;
     }
@@ -350,9 +347,6 @@ export class ChatSemanticMapper {
             }
         }
         const metadata = { context: ctx };
-        if (normalized.systemSegments.length) {
-            metadata.systemInstructions = normalized.systemSegments;
-        }
         const rawSystemBlocks = collectSystemRawBlocks(payload.messages);
         if (rawSystemBlocks) {
             const protocolState = ensureProtocolState(metadata, 'openai');
@@ -362,13 +356,7 @@ export class ChatSemanticMapper {
             metadata.missingFields = normalized.missingFields;
         }
         const extraFields = collectExtraFields(payload);
-        if (extraFields) {
-            metadata.extraFields = extraFields;
-        }
         const explicitEmptyTools = Array.isArray(payload.tools) && payload.tools.length === 0;
-        if (explicitEmptyTools) {
-            metadata.toolsFieldPresent = true;
-        }
         const semantics = buildOpenAISemantics({
             systemSegments: normalized.systemSegments,
             extraFields,
@@ -384,7 +372,7 @@ export class ChatSemanticMapper {
         };
     }
     async fromChat(chat, ctx) {
-        const shouldEmitEmptyTools = hasExplicitEmptyToolsSemantics(chat.semantics) || chat.metadata?.toolsFieldPresent === true;
+        const shouldEmitEmptyTools = hasExplicitEmptyToolsSemantics(chat.semantics);
         const payload = {
             messages: chat.messages,
             tools: chat.tools ?? (shouldEmitEmptyTools ? [] : undefined),