@jsonstudio/llms 0.6.1643 → 0.6.1739

package/dist/conversion/hub/pipeline/compat/compat-pipeline-executor.js

@@ -14,6 +14,10 @@ import { applyGlmWebSearchRequestTransform } from '../../../compat/actions/glm-w
 import { applyGeminiWebSearchCompat } from '../../../compat/actions/gemini-web-search.js';
 import { applyIflowWebSearchRequestTransform } from '../../../compat/actions/iflow-web-search.js';
 import { applyIflowToolTextFallback } from '../../../compat/actions/iflow-tool-text-fallback.js';
+import { unwrapIflowResponseBodyEnvelope } from '../../../compat/actions/iflow-response-body-unwrap.js';
+import { applyIflowKimiHistoryMediaPlaceholder } from '../../../compat/actions/iflow-kimi-history-media-placeholder.js';
+import { applyIflowKimiCliDefaults } from '../../../compat/actions/iflow-kimi-cli-defaults.js';
+import { fillIflowKimiThinkingReasoningContent } from '../../../compat/actions/iflow-kimi-thinking-reasoning-fill.js';
 import { applyGlmImageContentTransform } from '../../../compat/actions/glm-image-content.js';
 import { applyGlmVisionPromptTransform } from '../../../compat/actions/glm-vision-prompt.js';
 import { applyClaudeThinkingToolSchemaCompat } from '../../../compat/actions/claude-thinking-tools.js';
@@ -21,6 +25,11 @@ import { wrapGeminiCliRequest } from '../../../compat/actions/gemini-cli-request
 import { prepareAntigravityThoughtSignatureForGeminiRequest } from '../../../compat/actions/antigravity-thought-signature-prepare.js';
 import { cacheAntigravityThoughtSignatureFromGeminiResponse } from '../../../compat/actions/antigravity-thought-signature-cache.js';
 import { applyAnthropicClaudeCodeSystemPromptCompat } from '../../../compat/actions/anthropic-claude-code-system-prompt.js';
+import { normalizeToolCallIdsInPlace } from '../../../compat/actions/normalize-tool-call-ids.js';
+import { harvestToolCallsFromText } from '../../../compat/actions/harvest-tool-calls-from-text.js';
+import { stripOrphanFunctionCallsTag } from '../../../compat/actions/strip-orphan-function-calls-tag.js';
+import { stringifyLmstudioResponsesInput } from '../../../compat/actions/lmstudio-responses-input-stringify.js';
+import { enforceLmstudioResponsesFcToolCallIds } from '../../../compat/actions/lmstudio-responses-fc-ids.js';
 const RATE_LIMIT_ERROR = 'ERR_COMPAT_RATE_LIMIT_DETECTED';
 const INTERNAL_STATE = Symbol('compat.internal_state');
 export function runRequestCompatPipeline(profileId, payload, options) {
@@ -145,6 +154,19 @@ function applyMapping(root, mapping, state) {
         case 'normalize_tool_choice':
             normalizeToolChoice(root, mapping);
             break;
+        case 'normalize_tool_call_ids':
+            normalizeToolCallIdsInPlace(root);
+            break;
+        case 'lmstudio_responses_fc_ids':
+            if (state.direction === 'request') {
+                replaceRoot(root, enforceLmstudioResponsesFcToolCallIds(root));
+            }
+            break;
+        case 'lmstudio_responses_input_stringify':
+            if (state.direction === 'request') {
+                replaceRoot(root, stringifyLmstudioResponsesInput(root, state.adapterContext));
+            }
+            break;
         case 'inject_instruction':
             injectInstruction(root, mapping);
             break;
@@ -154,6 +176,31 @@ function applyMapping(root, mapping, state) {
         case 'extract_glm_tool_markup':
             extractGlmToolMarkup(root);
             break;
+        case 'harvest_tool_calls_from_text':
+            if (state.direction === 'response') {
+                replaceRoot(root, harvestToolCallsFromText(root));
+            }
+            break;
+        case 'strip_orphan_function_calls_tag':
+            if (state.direction === 'response') {
+                replaceRoot(root, stripOrphanFunctionCallsTag(root));
+            }
+            break;
+        case 'iflow_kimi_thinking_reasoning_fill':
+            if (state.direction === 'request') {
+                replaceRoot(root, fillIflowKimiThinkingReasoningContent(root));
+            }
+            break;
+        case 'iflow_kimi_history_media_placeholder':
+            if (state.direction === 'request') {
+                replaceRoot(root, applyIflowKimiHistoryMediaPlaceholder(root));
+            }
+            break;
+        case 'iflow_kimi_cli_defaults':
+            if (state.direction === 'request') {
+                replaceRoot(root, applyIflowKimiCliDefaults(root));
+            }
+            break;
         case 'dto_unwrap':
             dtoUnwrap(root, state);
             break;
@@ -215,6 +262,11 @@ function applyMapping(root, mapping, state) {
                 replaceRoot(root, applyIflowToolTextFallback(root, { models: mapping.models }));
             }
             break;
+        case 'iflow_response_body_unwrap':
+            if (state.direction === 'response') {
+                replaceRoot(root, unwrapIflowResponseBodyEnvelope(root));
+            }
+            break;
         case 'claude_thinking_tool_schema':
             if (state.direction === 'request') {
                 replaceRoot(root, applyClaudeThinkingToolSchemaCompat(root, state.adapterContext));
@@ -290,13 +342,24 @@ function replaceRoot(target, source) {
 }
 function dtoUnwrap(root, state) {
     const original = structuredClone(root);
-    if (isRecord(original.data)) {
+    const data = original.data;
+    if (isRecord(data)) {
         state.dtoEnvelope = { original, isDto: true };
-        replaceRoot(root, original.data);
+        replaceRoot(root, data);
+        return;
     }
-    else {
-        state.dtoEnvelope = { original, isDto: false };
+    // Transport compatibility: some upstreams return JSON bodies but mislabel the content-type,
+    // causing HTTP clients to surface `data` as a string. When a compat profile opts into dto_unwrap,
+    // best-effort parse JSON strings so downstream semantic mapping sees canonical objects.
+    if (typeof data === 'string') {
+        const parsed = tryParseJsonRecord(data);
+        if (parsed) {
+            state.dtoEnvelope = { original, isDto: true };
+            replaceRoot(root, parsed);
+            return;
+        }
     }
+    state.dtoEnvelope = { original, isDto: false };
 }
 function dtoRewrap(root, state) {
     const envelope = state.dtoEnvelope;
@@ -312,6 +375,35 @@ function dtoRewrap(root, state) {
     replaceRoot(root, rebuilt);
     state.dtoEnvelope = undefined;
 }
+function tryParseJsonRecord(raw) {
+    try {
+        let text = typeof raw === 'string' ? raw.trim() : '';
+        if (!text)
+            return null;
+        // anti-XSSI prefix: ")]}',\n{...}"
+        text = text.replace(/^\)\]\}',?\s*/u, '');
+        // single-line SSE-like wrapper sometimes returned as plain text
+        text = text.replace(/^data:\s*/iu, '');
+        // Quick structural guards to avoid parsing random prose.
+        const first = text.charAt(0);
+        const last = text.charAt(text.length - 1);
+        if (first !== '{' || last !== '}') {
+            return null;
+        }
+        // Guard: avoid unbounded parsing for pathological payloads.
+        if (text.length > 10 * 1024 * 1024) {
+            return null;
+        }
+        const parsed = JSON.parse(text);
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            return null;
+        }
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
 function applyShapeFilterMapping(root, mapping, state) {
     const target = mapping.target ?? state.direction;
     const filter = new UniversalShapeFilter(mapping.config);
@@ -765,9 +857,13 @@ function convertOutputEntryToChoice(entry, index, root) {
         (typeof entry.status === 'string' && entry.status) ||
         (typeof root.status === 'string' && root.status) ||
         'stop';
+    const hasToolCalls = message &&
+        typeof message === 'object' &&
+        Array.isArray(message.tool_calls) &&
+        message.tool_calls.length > 0;
     return {
         index,
-        finish_reason: normalizeFinishReason(finishReasonCandidate),
+        finish_reason: hasToolCalls ? 'tool_calls' : normalizeFinishReason(finishReasonCandidate),
         message
     };
 }

package/dist/conversion/hub/pipeline/compat/compat-profile-resolver.d.ts

@@ -0,0 +1,2 @@
+import type { AdapterContext } from '../../types/chat-envelope.js';
+export declare function resolveCompatProfileForContext(adapterContext: AdapterContext): string | undefined;

package/dist/conversion/hub/pipeline/compat/compat-profile-resolver.js

@@ -0,0 +1,63 @@
+const PROFILE_BY_PROVIDER_FAMILY = {
+    iflow: 'chat:iflow',
+    lmstudio: 'chat:lmstudio',
+    antigravity: 'chat:gemini-cli',
+    'gemini-cli': 'chat:gemini-cli'
+};
+function readNonEmptyString(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed.length ? trimmed : undefined;
+}
+function normalizeProviderFamily(value) {
+    const normalized = readNonEmptyString(value)?.toLowerCase();
+    if (!normalized) {
+        return undefined;
+    }
+    if (normalized in PROFILE_BY_PROVIDER_FAMILY) {
+        return normalized;
+    }
+    if (normalized.includes('.')) {
+        const firstToken = normalized.split('.')[0]?.trim();
+        if (firstToken && firstToken in PROFILE_BY_PROVIDER_FAMILY) {
+            return firstToken;
+        }
+    }
+    if (normalized.includes(':')) {
+        const firstToken = normalized.split(':')[0]?.trim();
+        if (firstToken && firstToken in PROFILE_BY_PROVIDER_FAMILY) {
+            return firstToken;
+        }
+    }
+    if (normalized.includes('/')) {
+        const firstToken = normalized.split('/')[0]?.trim();
+        if (firstToken && firstToken in PROFILE_BY_PROVIDER_FAMILY) {
+            return firstToken;
+        }
+    }
+    return undefined;
+}
+function resolveDefaultProfileFromFamily(adapterContext) {
+    const context = adapterContext;
+    const providerFamily = normalizeProviderFamily(context.providerFamily);
+    if (providerFamily) {
+        return PROFILE_BY_PROVIDER_FAMILY[providerFamily];
+    }
+    for (const key of ['providerId', 'providerKey', 'runtimeKey', 'profileId', 'providerType']) {
+        const family = normalizeProviderFamily(context[key]);
+        if (family) {
+            return PROFILE_BY_PROVIDER_FAMILY[family];
+        }
+    }
+    return undefined;
+}
+export function resolveCompatProfileForContext(adapterContext) {
+    const context = adapterContext;
+    const explicit = readNonEmptyString(context.compatibilityProfile);
+    if (explicit) {
+        return explicit;
+    }
+    return resolveDefaultProfileFromFamily(adapterContext);
+}

package/dist/conversion/hub/pipeline/compat/compat-types.d.ts

@@ -47,6 +47,18 @@ export type MappingInstruction = {
     action: 'normalize_tool_choice';
     path?: string;
     objectReplacement?: string;
+} | {
+    action: 'normalize_tool_call_ids';
+} | {
+    action: 'lmstudio_responses_fc_ids';
+} | {
+    action: 'lmstudio_responses_input_stringify';
+} | {
+    action: 'iflow_kimi_history_media_placeholder';
+} | {
+    action: 'iflow_kimi_cli_defaults';
+} | {
+    action: 'iflow_kimi_thinking_reasoning_fill';
 } | {
     action: 'inject_instruction';
     sourcePath: string;
@@ -63,6 +75,10 @@ export type MappingInstruction = {
     action: 'convert_responses_output_to_choices';
 } | {
     action: 'extract_glm_tool_markup';
+} | {
+    action: 'harvest_tool_calls_from_text';
+} | {
+    action: 'strip_orphan_function_calls_tag';
 } | {
     action: 'dto_unwrap';
 } | {
@@ -114,6 +130,8 @@ export type MappingInstruction = {
 } | {
     action: 'iflow_tool_text_fallback';
     models?: string[];
+} | {
+    action: 'iflow_response_body_unwrap';
 } | {
     action: 'claude_thinking_tool_schema';
 } | {

package/dist/conversion/hub/pipeline/hub-pipeline.js

@@ -543,7 +543,7 @@ export class HubPipeline {
         //
         // 注意：这里不再根据 processMode(passthrough/chat) 做分支判断——即使某些
         // route 将 processMode 标记为 passthrough，我们仍然需要保留一次规范化后的
-        // Chat 请求快照，供 stopMessage / gemini_empty_reply_continue 等被动触发型
+        // Chat 请求快照，供 stopMessage / empty_reply_continue 等被动触发型
         // servertool 在响应阶段使用。
         //
         // 之前这里通过 JSON.stringify/parse 做深拷贝，但在部分 Responses/Gemini

package/dist/conversion/hub/pipeline/stages/req_outbound/req_outbound_stage1_semantic_map/index.js

@@ -131,13 +131,16 @@ function normalizeToolOutput(entry) {
 }
 function applyToolCallIdStyleMetadata(chatEnvelope, adapterContext, snapshot) {
     const metadata = chatEnvelope.metadata || (chatEnvelope.metadata = { context: adapterContext });
-    const hasStyle = typeof metadata.toolCallIdStyle === 'string'
-        && String(metadata.toolCallIdStyle).trim().length > 0;
-    if (hasStyle) {
+    const current = typeof metadata.toolCallIdStyle === 'string'
+        ? String(metadata.toolCallIdStyle).trim()
+        : '';
+    const resolved = selectToolCallIdStyle(adapterContext, snapshot);
+    if (!resolved) {
         return;
     }
-    const resolved = selectToolCallIdStyle(adapterContext, snapshot);
-    if (resolved) {
+    // Always honor the route-selected AdapterContext toolCallIdStyle when present.
+    // This prevents cross-provider leakage (e.g. LM Studio "preserve" contaminating OpenAI "fc").
+    if (!current || current !== resolved) {
         metadata.toolCallIdStyle = resolved;
     }
 }

package/dist/conversion/hub/pipeline/stages/req_outbound/req_outbound_stage3_compat/index.js

@@ -1,7 +1,11 @@
 import { applyRequestCompat, applyResponseCompat } from '../../../compat/compat-engine.js';
+import { resolveCompatProfileForContext } from '../../../compat/compat-profile-resolver.js';
 function pickCompatProfile(adapterContext) {
     const candidate = adapterContext.compatibilityProfile;
-    return typeof candidate === 'string' && candidate.trim() ? candidate.trim() : undefined;
+    if (typeof candidate === 'string' && candidate.trim()) {
+        return candidate.trim();
+    }
+    return resolveCompatProfileForContext(adapterContext);
 }
 export async function runReqOutboundStage3Compat(options) {
     const profile = pickCompatProfile(options.adapterContext);

package/dist/conversion/hub/pipeline/stages/resp_inbound/resp_inbound_stage1_sse_decode/index.js

@@ -38,6 +38,19 @@ function resolveProviderType(protocol) {
     return undefined;
 }
 export async function runRespInboundStage1SseDecode(options) {
+    // Transport compatibility: some HTTP clients return JSON bodies as plain strings when the upstream
+    // mislabels `Content-Type`. Best-effort parse JSON text early so downstream format adapters and
+    // semantic mappers always see canonical objects.
+    const maybeJsonText = tryDecodeJsonBodyFromText(options.payload);
+    if (maybeJsonText) {
+        recordStage(options.stageRecorder, 'chat_process.resp.stage1.sse_decode', {
+            streamDetected: false,
+            decoded: false,
+            protocol: options.providerProtocol,
+            reason: 'text_body_is_json'
+        });
+        return { payload: maybeJsonText, decodedFromSse: false };
+    }
     const wrapperError = extractSseWrapperError(options.payload);
     const stream = extractSseStream(options.payload);
     // 某些 mock-provider / 捕获样本在 SSE 连接被异常终止时会携带 error 标记，
@@ -67,6 +80,19 @@ export async function runRespInboundStage1SseDecode(options) {
         });
         return { payload: options.payload, decodedFromSse: false };
     }
+    // Compatibility: when an upstream is asked for streaming but responds with a single JSON body
+    // (common for mock servers and some OpenAI-compatible implementations), the provider wrapper may
+    // still surface a Readable via `__sse_stream`. In that case we should treat it as JSON, not SSE.
+    const maybeJson = await tryDecodeJsonBodyFromStream(stream);
+    if (maybeJson) {
+        recordStage(options.stageRecorder, 'chat_process.resp.stage1.sse_decode', {
+            streamDetected: true,
+            decoded: false,
+            protocol: options.providerProtocol,
+            reason: 'stream_body_is_json'
+        });
+        return { payload: maybeJson, decodedFromSse: false };
+    }
     if (!supportsSseProtocol(options.providerProtocol)) {
         recordStage(options.stageRecorder, 'chat_process.resp.stage1.sse_decode', {
             streamDetected: true,
@@ -120,6 +146,93 @@ export async function runRespInboundStage1SseDecode(options) {
 function supportsSseProtocol(protocol) {
     return protocol === 'openai-chat' || protocol === 'openai-responses' || protocol === 'anthropic-messages' || protocol === 'gemini-chat';
 }
+function tryDecodeJsonBodyFromText(payload) {
+    try {
+        if (typeof payload !== 'string') {
+            return null;
+        }
+        // Normalize common prefixes / wrappers from OpenAI-compatible upstreams.
+        let text = payload.trimStart();
+        // anti-XSSI prefix: ")]}',\n{...}"
+        text = text.replace(/^\)\]\}',?\s*/u, '');
+        // single-line SSE-like wrapper sometimes returned as plain text
+        text = text.replace(/^data:\s*/iu, '');
+        const looksLikeJson = text.startsWith('{') || text.startsWith('[');
+        if (!looksLikeJson) {
+            return null;
+        }
+        // Guard: avoid unbounded parsing for pathological payloads.
+        if (text.length > 10 * 1024 * 1024) {
+            return null;
+        }
+        const parsed = JSON.parse(text);
+        return (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+async function tryDecodeJsonBodyFromStream(stream) {
+    // Peek the first chunk; if it looks like JSON (starts with `{` or `[`), consume full body and parse.
+    const iterator = stream[Symbol.asyncIterator]();
+    const first = await iterator.next();
+    if (first.done || first.value == null) {
+        return null;
+    }
+    const firstChunk = first.value;
+    let prefix = (typeof firstChunk === 'string' ? firstChunk : firstChunk.toString('utf8')).trimStart();
+    prefix = prefix.replace(/^\)\]\}',?\s*/u, '');
+    prefix = prefix.replace(/^data:\s*/iu, '');
+    const looksLikeJson = prefix.startsWith('{') || prefix.startsWith('[');
+    if (!looksLikeJson) {
+        // Rewind by re-wrapping the iterator so downstream SSE decoder still sees the first chunk.
+        // eslint-disable-next-line no-param-reassign
+        stream[Symbol.asyncIterator] = () => replayIterator(firstChunk, iterator);
+        return null;
+    }
+    let body = typeof firstChunk === 'string' ? firstChunk : firstChunk.toString('utf8');
+    while (true) {
+        const next = await iterator.next();
+        if (next.done)
+            break;
+        body += typeof next.value === 'string' ? next.value : Buffer.from(next.value).toString('utf8');
+        // Guard: avoid unbounded buffering if the upstream is actually SSE but starts with whitespace.
+        if (body.length > 1024 * 1024) {
+            return null;
+        }
+    }
+    try {
+        const parsed = JSON.parse(body);
+        return (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function replayIterator(firstChunk, iterator) {
+    let yieldedFirst = false;
+    return {
+        async next() {
+            if (!yieldedFirst) {
+                yieldedFirst = true;
+                return { done: false, value: firstChunk };
+            }
+            return iterator.next();
+        },
+        async return(value) {
+            if (typeof iterator.return === 'function') {
+                return iterator.return(value);
+            }
+            return { done: true, value };
+        },
+        async throw(err) {
+            if (typeof iterator.throw === 'function') {
+                return iterator.throw(err);
+            }
+            throw err;
+        }
+    };
+}
 function extractSseStream(payload) {
     if (!payload || typeof payload !== 'object') {
         return undefined;

package/dist/conversion/hub/pipeline/target-utils.js

@@ -64,6 +64,9 @@ export function applyTargetToSubject(subject, target, originalModel) {
     metadata.processMode = target.processMode || 'chat';
     subject.metadata = metadata;
     const subjectMeta = metadata;
+    if (target.responsesConfig?.toolCallIdStyle) {
+        subjectMeta.toolCallIdStyle = target.responsesConfig.toolCallIdStyle;
+    }
     if (originalModel && typeof originalModel === 'string' && originalModel.trim()) {
         const trimmed = originalModel.trim();
         if (typeof subjectMeta.originalModelId !== 'string' || !subjectMeta.originalModelId) {

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

@@ -118,6 +118,20 @@ function detectProviderResponseShape(payload) {
         return 'gemini-chat';
     return 'unknown';
 }
+function inferProviderTypeFromProtocol(protocol) {
+    const p = typeof protocol === 'string' ? protocol.trim().toLowerCase() : '';
+    if (!p)
+        return undefined;
+    if (p === 'openai-chat')
+        return 'openai';
+    if (p === 'openai-responses')
+        return 'responses';
+    if (p === 'anthropic-messages')
+        return 'anthropic';
+    if (p === 'gemini-chat')
+        return 'gemini';
+    return undefined;
+}
 function isCanonicalChatCompletion(payload) {
     if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
         return false;
@@ -138,9 +152,18 @@ async function coerceClientPayloadToCanonicalChatCompletionOrThrow(options) {
     }
     const detected = detectProviderResponseShape(options.payload);
     if (detected === 'unknown') {
+        const protocol = options.adapterContext?.providerProtocol;
         throw new ProviderProtocolError(`[hub_response] Non-canonical response payload at ${options.scope}`, {
             code: 'MALFORMED_RESPONSE',
-            details: { detected }
+            protocol,
+            providerType: inferProviderTypeFromProtocol(protocol),
+            details: {
+                detected,
+                payloadType: typeof options.payload,
+                payloadKeys: options.payload && typeof options.payload === 'object' && !Array.isArray(options.payload)
+                    ? Object.keys(options.payload).slice(0, 20)
+                    : undefined
+            }
         });
     }
     const plan = PROVIDER_RESPONSE_REGISTRY[detected];
@@ -149,8 +172,11 @@ async function coerceClientPayloadToCanonicalChatCompletionOrThrow(options) {
     if (isCanonicalChatCompletion(coerced)) {
         return coerced;
     }
+    const protocol = options.adapterContext?.providerProtocol;
     throw new ProviderProtocolError(`[hub_response] Failed to canonicalize response payload at ${options.scope}`, {
         code: 'MALFORMED_RESPONSE',
+        protocol,
+        providerType: inferProviderTypeFromProtocol(protocol),
         details: { detected }
     });
 }

package/dist/conversion/responses/responses-openai-bridge.js

@@ -5,6 +5,7 @@ import { createToolCallIdTransformer, enforceToolCallIdStyle, resolveToolCallIdS
 import { mapBridgeToolsToChat, mapChatToolsToBridge } from '../shared/tool-mapping.js';
 import { ProviderProtocolError } from '../shared/errors.js';
 import { readRuntimeMetadata } from '../shared/runtime-metadata.js';
+import { clampResponsesInputItemId } from '../shared/bridge-id-utils.js';
 // --- Utilities (ported strictly) ---
 import { canonicalizeChatResponseTools } from '../shared/tool-canonicalizer.js';
 import { normalizeMessageReasoningTools } from '../shared/reasoning-tool-normalizer.js';
@@ -14,15 +15,31 @@ import { buildResponsesOutputFromChat } from '../shared/responses-output-builder
 function isObject(v) {
     return !!v && typeof v === 'object' && !Array.isArray(v);
 }
-function filterBridgeInputForUpstream(input) {
+function filterBridgeInputForUpstream(input, options) {
     // Upstream `/v1/responses` create only accepts a subset of input item types.
     // In particular, `type:"reasoning"` entries are output-only artifacts (often
     // captured from previous responses) and OpenAI rejects them with schema errors
     // like `input[N].content: array too long (max 0)`.
-    return (Array.isArray(input) ? input : []).filter((item) => {
+    return (Array.isArray(input) ? input : []).flatMap((item) => {
         if (!item || typeof item !== 'object')
-            return false;
-        return item.type !== 'reasoning';
+            return [];
+        if (item.type === 'reasoning') {
+            return [];
+        }
+        // OpenAI `/v1/responses` request schema uses `call_id` for tool outputs.
+        // Some internal carriers may set `tool_call_id`; strip it before sending upstream
+        // to avoid strict schema errors (e.g. "Unknown parameter: input[N].tool_call_id").
+        const clone = { ...item };
+        if (options?.allowToolCallId !== true && clone.tool_call_id !== undefined) {
+            delete clone.tool_call_id;
+        }
+        // OpenAI /v1/responses enforces max length (64) on input item id fields.
+        // Keep this as the single outbound guardrail for all bridged input item types.
+        const normalizedId = clampResponsesInputItemId(clone.id);
+        if (normalizedId) {
+            clone.id = normalizedId;
+        }
+        return [clone];
     });
 }
 // normalizeTools unified in ../shared/args-mapping.ts
@@ -356,7 +373,16 @@ export function buildResponsesRequestFromChat(payload, ctx, extras) {
     const envelopeMetadata = ctx?.metadata && typeof ctx.metadata === 'object' ? ctx.metadata : undefined;
     const metadataExtraFields = extractMetadataExtraFields(envelopeMetadata);
     const contextToolCallIdStyle = readToolCallIdStyleFromContext(ctx);
-    const toolCallIdStyle = contextToolCallIdStyle ?? resolveToolCallIdStyle(envelopeMetadata);
+    const envelopeToolCallIdStyle = resolveToolCallIdStyle(envelopeMetadata);
+    const requestMetadata = chat && typeof chat === 'object' && chat.metadata && typeof chat.metadata === 'object'
+        ? chat.metadata
+        : undefined;
+    const routeToolCallIdStyle = requestMetadata
+        ? normalizeToolCallIdStyleCandidate(requestMetadata.toolCallIdStyle)
+        : undefined;
+    // Route-selected toolCallIdStyle must win over captured context to prevent cross-provider leakage
+    // (e.g. LM Studio "preserve" contaminating OpenAI "fc").
+    const toolCallIdStyle = routeToolCallIdStyle ?? envelopeToolCallIdStyle ?? contextToolCallIdStyle;
     const fallbackHistory = ctx?.input && Array.isArray(ctx.input)
         ? {
             input: ctx.input,
@@ -392,7 +418,7 @@ export function buildResponsesRequestFromChat(payload, ctx, extras) {
         }
     }
     // 不追加 metadata，以便 roundtrip 与原始 payload 对齐；系统提示直接写入 instructions。
-    const upstreamInput = filterBridgeInputForUpstream(input);
+    const upstreamInput = filterBridgeInputForUpstream(input, { allowToolCallId: toolCallIdStyle === 'preserve' });
     if (upstreamInput.length) {
         out.input = upstreamInput;
     }

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

@@ -15,6 +15,21 @@ function safeJson(v) {
         return '{}';
     }
 }
+function sanitizeToolUseId(raw) {
+    const trimmed = typeof raw === 'string' ? raw.trim() : '';
+    if (!trimmed) {
+        return `call_${Math.random().toString(36).slice(2, 10)}`;
+    }
+    if (/^[A-Za-z0-9_-]+$/.test(trimmed)) {
+        return trimmed;
+    }
+    const sanitized = trimmed
+        .replace(/[^A-Za-z0-9_-]/g, '_')
+        .replace(/_{2,}/g, '_')
+        .replace(/^_+/, '')
+        .replace(/_+$/, '');
+    return sanitized || `call_${Math.random().toString(36).slice(2, 10)}`;
+}
 function flattenAnthropicText(content) {
     if (content == null)
         return '';
@@ -477,7 +492,7 @@ export function buildAnthropicFromOpenAIChat(oa, options) {
     const toolNameResolver = createAnthropicToolNameResolver(options?.toolNameMap ?? extractToolNameMapFromPayload(oa));
     for (const tc of toolCalls) {
         try {
-            const id = requireTrimmedString(tc?.id, 'chat.tool_call.id');
+            const id = sanitizeToolUseId(requireTrimmedString(tc?.id, 'chat.tool_call.id'));
             const fn = isObject(tc?.function) ? tc.function : {};
             const canonicalName = requireTrimmedString(fn.name, 'chat.tool_call.function.name');
             const name = toolNameResolver ? toolNameResolver(canonicalName) : canonicalName;
@@ -752,7 +767,7 @@ export function buildAnthropicRequestFromOpenAIChat(chatReq) {
         for (const tc of toolCalls) {
             if (!tc || typeof tc !== 'object')
                 continue;
-            const id = requireTrimmedString(tc.id, 'chat.tool_call.id');
+            const id = sanitizeToolUseId(requireTrimmedString(tc.id, 'chat.tool_call.id'));
             knownToolCallIds.add(id);
         }
     }
@@ -816,7 +831,7 @@ export function buildAnthropicRequestFromOpenAIChat(chatReq) {
             continue;
         }
         if (role === 'tool') {
-            const toolCallId = requireTrimmedString(m.tool_call_id ?? m.call_id ?? m.tool_use_id ?? m.id, 'tool_result.tool_call_id');
+            const toolCallId = sanitizeToolUseId(requireTrimmedString(m.tool_call_id ?? m.call_id ?? m.tool_use_id ?? m.id, 'tool_result.tool_call_id'));
             if (!knownToolCallIds.has(toolCallId)) {
                 throw new ProviderProtocolError(`Anthropic bridge constraint violated: tool result ${toolCallId} has no matching tool call`, {
                     code: 'TOOL_PROTOCOL_ERROR',
@@ -896,7 +911,7 @@ export function buildAnthropicRequestFromOpenAIChat(chatReq) {
         for (const tc of toolCalls) {
             if (!tc || typeof tc !== 'object')
                 continue;
-            const id = requireTrimmedString(tc.id, 'chat.tool_call.id');
+            const id = sanitizeToolUseId(requireTrimmedString(tc.id, 'chat.tool_call.id'));
             const fn = tc.function || {};
             const name = requireTrimmedString(fn.name, 'chat.tool_call.function.name');
             const argsRaw = fn.arguments;
@@ -917,7 +932,7 @@ export function buildAnthropicRequestFromOpenAIChat(chatReq) {
         if (blocks.length > 0) {
             const hasStructuredBlocks = blocks.some((block) => block && typeof block === 'object' && block.type !== 'text');
             let contentNode = blocks;
-            if (targetShape === 'string' || (!targetShape && !hasStructuredBlocks)) {
+            if (!hasStructuredBlocks && (targetShape === 'string' || !targetShape)) {
                 contentNode = text;
             }
             messages.push({ role, content: contentNode });

package/dist/conversion/shared/bridge-id-utils.d.ts

@@ -4,4 +4,6 @@ type NormalizeOptions = {
 };
 export declare function normalizeFunctionCallId(options: NormalizeOptions): string;
 export declare function normalizeFunctionCallOutputId(options: NormalizeOptions): string;
+export declare function normalizeResponsesCallId(options: NormalizeOptions): string;
+export declare function clampResponsesInputItemId(raw: unknown): string | undefined;
 export {};