@jsonstudio/rcc 0.90.872 → 0.90.1270

package/node_modules/@jsonstudio/llms/dist/conversion/hub/types/chat-envelope.d.ts

@@ -56,13 +56,93 @@ export interface AdapterContext {
     responsesResume?: JsonObject;
     [key: string]: JsonValue;
 }
+export type ChatContinuationStickyScope = 'request_chain' | 'session' | 'conversation' | 'request';
+export type ChatContinuationStateOrigin = 'openai-responses' | 'openai-chat' | 'anthropic-messages' | 'gemini-chat' | 'servertool-followup' | 'tool-loop' | 'unknown';
+export interface ChatContinuationPointer extends JsonObject {
+    protocol?: string;
+    requestId?: string;
+    responseId?: string;
+    previousResponseId?: string;
+    turnId?: string;
+}
+export interface ChatToolContinuation extends JsonObject {
+    mode?: 'required_action' | 'submit_tool_outputs' | 'tool_calls' | 'tool_outputs' | 'servertool_followup';
+    pendingToolCallIds?: string[];
+    submittedToolCallIds?: string[];
+    resumeOutputs?: JsonValue[];
+}
+export interface ChatContinuationSemantics extends JsonObject {
+    chainId?: string;
+    previousTurnId?: string;
+    resumeFrom?: ChatContinuationPointer;
+    stickyScope?: ChatContinuationStickyScope;
+    stateOrigin?: ChatContinuationStateOrigin | string;
+    restored?: boolean;
+    toolContinuation?: ChatToolContinuation;
+    protocolHints?: JsonObject;
+}
+export type ChatProtocolMappingDisposition = 'preserved' | 'lossy' | 'dropped' | 'unsupported';
+export interface ChatProtocolMappingAuditEntry extends JsonObject {
+    field: string;
+    disposition: ChatProtocolMappingDisposition;
+    reason: string;
+    sourceProtocol?: string;
+    targetProtocol?: string;
+    source?: string;
+}
+export interface ChatSemanticAudit extends JsonObject {
+    protocolMapping?: {
+        preserved?: ChatProtocolMappingAuditEntry[];
+        lossy?: ChatProtocolMappingAuditEntry[];
+        dropped?: ChatProtocolMappingAuditEntry[];
+        unsupported?: ChatProtocolMappingAuditEntry[];
+    };
+}
+export interface ChatToolSemantics extends JsonObject {
+    explicitEmpty?: boolean;
+    clientToolsRaw?: JsonValue[];
+    toolNameAliasMap?: JsonObject;
+    toolAliasMap?: JsonObject;
+}
+export interface ChatResponsesSemantics extends JsonObject {
+    context?: JsonObject;
+    resume?: JsonObject;
+    requestParameters?: JsonObject;
+    responseFormat?: JsonValue;
+    include?: JsonValue[];
+    store?: boolean;
+    promptCacheKey?: string;
+    toolChoice?: JsonValue;
+    parallelToolCalls?: boolean;
+    reasoning?: JsonValue;
+    text?: JsonValue;
+    serviceTier?: JsonValue;
+    truncation?: JsonValue;
+    modalities?: JsonValue;
+}
+export interface ChatAnthropicSemantics extends JsonObject {
+    systemBlocks?: JsonValue[];
+    toolNameAliasMap?: JsonObject;
+    clientToolsRaw?: JsonValue[];
+    messageContentShape?: JsonValue;
+    providerMetadata?: JsonObject;
+}
+export interface ChatGeminiSemantics extends JsonObject {
+    systemInstruction?: JsonValue;
+    safetySettings?: JsonValue;
+    generationConfig?: JsonObject;
+    toolConfig?: JsonObject;
+    providerMetadata?: JsonObject;
+}
 export interface ChatSemantics extends JsonObject {
+    continuation?: ChatContinuationSemantics;
     session?: JsonObject;
     system?: JsonObject;
-    tools?: JsonObject;
-    responses?: JsonObject;
-    anthropic?: JsonObject;
-    gemini?: JsonObject;
+    tools?: ChatToolSemantics;
+    responses?: ChatResponsesSemantics;
+    anthropic?: ChatAnthropicSemantics;
+    gemini?: ChatGeminiSemantics;
+    audit?: ChatSemanticAudit;
     providerExtras?: JsonObject;
 }
 export interface ChatEnvelope {

package/node_modules/@jsonstudio/llms/dist/conversion/pipeline/codecs/v2/responses-openai-pipeline.js

@@ -7,6 +7,26 @@ import { chatEnvelopeToStandardizedWithNative } from '../../../../router/virtual
 import { standardizedToChatEnvelopeWithNative } from '../../../../router/virtual-router/engine-selection/native-hub-pipeline-req-outbound-semantics.js';
 const DEFAULT_RESPONSES_ENDPOINT = '/v1/responses';
 const RESPONSES_PROTOCOL = 'openai-responses';
+function formatUnknownError(error) {
+    if (error instanceof Error) {
+        return error.stack || `${error.name}: ${error.message}`;
+    }
+    try {
+        return JSON.stringify(error);
+    }
+    catch {
+        return String(error);
+    }
+}
+function logResponsesOpenAiPipelineNonBlocking(stage, error, details = {}) {
+    try {
+        const detailSuffix = Object.keys(details).length ? ` details=${JSON.stringify(details)}` : '';
+        console.warn(`[responses-openai-pipeline] ${stage} failed (non-blocking): ${formatUnknownError(error)}${detailSuffix}`);
+    }
+    catch {
+        // Never throw from non-blocking logging.
+    }
+}
 function assertJsonObject(value, stage) {
     if (!value || typeof value !== 'object' || Array.isArray(value)) {
         throw new Error(`Responses pipeline codec requires JSON payload at ${stage}`);
@@ -109,7 +129,12 @@ function captureToolResults(payload) {
                 try {
                     output = JSON.stringify(rawOut);
                 }
-                catch { /* ignore */ }
+                catch (error) {
+                    logResponsesOpenAiPipelineNonBlocking('capture_tool_results.stringify_output', error, {
+                        itemType: t,
+                        toolCallId: typeof tool_call_id === 'string' ? tool_call_id : undefined
+                    });
+                }
             }
             results.push({ tool_call_id, output });
         }

package/node_modules/@jsonstudio/llms/dist/conversion/responses/responses-openai-bridge/response-payload.js

@@ -2,7 +2,7 @@ import { evaluateResponsesHostPolicy } from '../responses-host-policy.js';
 import { normalizeMessageReasoningTools } from '../../shared/reasoning-tool-normalizer.js';
 import { createBridgeActionState, runBridgeActionPipeline } from '../../bridge-actions.js';
 import { resolveBridgePolicy, resolvePolicyActions } from '../../bridge-policies.js';
-import { consumeResponsesPayloadSnapshot, consumeResponsesPassthrough } from '../../shared/responses-reasoning-registry.js';
+import { consumeResponsesPayloadSnapshotByAliases, consumeResponsesPassthroughByAliases } from '../../shared/responses-reasoning-registry.js';
 import { stripInternalToolingMetadata } from '../../shared/responses-tool-utils.js';
 import { ProviderProtocolError } from '../../provider-protocol-error.js';
 import { buildResponsesPayloadFromChatWithNative, normalizeResponsesToolCallArgumentsForClientWithNative } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-resp-semantics.js';
@@ -35,17 +35,18 @@ function unwrapData(value) {
     }
     return current;
 }
-function resolveSnapshotLookupKey(response, context) {
+function resolveSnapshotLookupKeys(response, context) {
+    const keys = [];
     if (typeof response?.request_id === 'string') {
-        return response.request_id;
+        keys.push(response.request_id);
     }
     if (typeof context?.requestId === 'string') {
-        return context.requestId;
+        keys.push(context.requestId);
     }
     if (typeof response?.id === 'string') {
-        return response.id;
+        keys.push(response.id);
     }
-    return undefined;
+    return Array.from(new Set(keys.map((value) => value.trim()).filter((value) => value.length > 0)));
 }
 function shouldStripHostManagedFields(context) {
     const result = evaluateResponsesHostPolicy(context, typeof context?.targetProtocol === 'string' ? context?.targetProtocol : undefined);
@@ -73,9 +74,9 @@ export function buildResponsesPayloadFromChat(payload, context) {
     if (response.object === 'response' && Array.isArray(response.output)) {
         return response;
     }
-    const snapshotLookupKey = resolveSnapshotLookupKey(response, context);
-    const snapshotPayload = snapshotLookupKey ? consumeResponsesPayloadSnapshot(snapshotLookupKey) : undefined;
-    const passthroughPayload = snapshotLookupKey ? consumeResponsesPassthrough(snapshotLookupKey) : undefined;
+    const snapshotLookupKeys = resolveSnapshotLookupKeys(response, context);
+    const snapshotPayload = snapshotLookupKeys.length ? consumeResponsesPayloadSnapshotByAliases(snapshotLookupKeys) : undefined;
+    const passthroughPayload = snapshotLookupKeys.length ? consumeResponsesPassthroughByAliases(snapshotLookupKeys) : undefined;
     const sourceForRetention = (passthroughPayload && typeof passthroughPayload === 'object' ? passthroughPayload : undefined) ??
         readInlineRetentionPayload(response, '__responses_passthrough') ??
         (snapshotPayload && typeof snapshotPayload === 'object' ? snapshotPayload : undefined) ??

package/node_modules/@jsonstudio/llms/dist/conversion/responses/responses-openai-bridge/utils.js

@@ -91,6 +91,25 @@ export function sanitizeCapturedResponsesInput(input) {
         return input;
     }
     const acceptedCallIds = new Set();
+    let sawFunctionCalls = false;
+    for (const entry of input) {
+        if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
+            continue;
+        }
+        const type = typeof entry.type === 'string' ? String(entry.type).trim().toLowerCase() : '';
+        if (type !== 'function_call') {
+            continue;
+        }
+        sawFunctionCalls = true;
+        const sanitizedName = sanitizeResponsesFunctionName(entry.name);
+        if (!sanitizedName) {
+            continue;
+        }
+        const callId = typeof entry.call_id === 'string' ? String(entry.call_id).trim() : '';
+        if (callId) {
+            acceptedCallIds.add(callId);
+        }
+    }
     const out = [];
     for (const entry of input) {
         if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
@@ -106,16 +125,12 @@ export function sanitizeCapturedResponsesInput(input) {
             const next = rawName === sanitizedName
                 ? entry
                 : { ...entry, name: sanitizedName };
-            const callId = typeof next.call_id === 'string' ? String(next.call_id).trim() : '';
-            if (callId) {
-                acceptedCallIds.add(callId);
-            }
             out.push(next);
             continue;
         }
         if (type === 'function_call_output') {
             const callId = typeof entry.call_id === 'string' ? String(entry.call_id).trim() : '';
-            if (!callId || !acceptedCallIds.has(callId)) {
+            if (!callId || (sawFunctionCalls && !acceptedCallIds.has(callId))) {
                 continue;
             }
         }

package/node_modules/@jsonstudio/llms/dist/conversion/responses/responses-openai-bridge.js

@@ -10,7 +10,7 @@ import { appendLocalImageBlockOnLatestUserInputWithNative, buildBridgeHistoryWit
 // --- Utilities (ported strictly) ---
 import { resolveBridgePolicy, resolvePolicyActions } from '../bridge-policies.js';
 import { logHubStageTiming } from '../hub/pipeline/hub-stage-timing.js';
-import { RESPONSES_TOOL_PASSTHROUGH_KEYS, buildSlimBridgeDecisionMetadata, buildSlimResponsesBridgeContext, collectResponsesRequestParameters, extractMetadataExtraFields, pickObjectFields, sanitizeCapturedResponsesInput, stripToolControlFieldsFromContextMetadata, stripToolControlFieldsFromParameterObject, unwrapData } from './responses-openai-bridge/utils.js';
+import { RESPONSES_TOOL_PASSTHROUGH_KEYS, RESPONSES_REQUEST_PARAMETER_KEYS, buildSlimBridgeDecisionMetadata, buildSlimResponsesBridgeContext, collectResponsesRequestParameters, extractMetadataExtraFields, pickObjectFields, sanitizeCapturedResponsesInput, stripToolControlFieldsFromContextMetadata, stripToolControlFieldsFromParameterObject, unwrapData } from './responses-openai-bridge/utils.js';
 function readCapturedToolResults(context) {
     const raw = context.__captured_tool_results;
     return Array.isArray(raw)
@@ -80,6 +80,52 @@ function filterResponsesInboundActionsByPayloadHints(actions, messages) {
         return !toolOnlyActions.has(name);
     });
 }
+function readPreviousResponseIdFromChatSemantics(chat) {
+    const semantics = chat?.semantics && typeof chat.semantics === 'object' && !Array.isArray(chat.semantics)
+        ? chat.semantics
+        : undefined;
+    if (!semantics) {
+        return '';
+    }
+    const continuation = semantics.continuation && typeof semantics.continuation === 'object' && !Array.isArray(semantics.continuation)
+        ? semantics.continuation
+        : undefined;
+    const resumeFrom = continuation?.resumeFrom && typeof continuation.resumeFrom === 'object' && !Array.isArray(continuation.resumeFrom)
+        ? continuation.resumeFrom
+        : undefined;
+    const responses = semantics.responses && typeof semantics.responses === 'object' && !Array.isArray(semantics.responses)
+        ? semantics.responses
+        : undefined;
+    const responsesResume = responses?.resume && typeof responses.resume === 'object' && !Array.isArray(responses.resume)
+        ? responses.resume
+        : undefined;
+    const candidates = [
+        resumeFrom?.previousResponseId,
+        responsesResume?.restoredFromResponseId,
+        resumeFrom?.responseId
+    ];
+    for (const candidate of candidates) {
+        if (typeof candidate === 'string' && candidate.trim().length > 0) {
+            return candidate.trim();
+        }
+    }
+    return '';
+}
+function readResumeDeltaInputFromChatSemantics(chat) {
+    const semantics = chat?.semantics && typeof chat.semantics === 'object' && !Array.isArray(chat.semantics)
+        ? chat.semantics
+        : undefined;
+    const responses = semantics?.responses && typeof semantics.responses === 'object' && !Array.isArray(semantics.responses)
+        ? semantics.responses
+        : undefined;
+    const responsesResume = responses?.resume && typeof responses.resume === 'object' && !Array.isArray(responses.resume)
+        ? responses.resume
+        : undefined;
+    const deltaInput = responsesResume?.deltaInput;
+    return Array.isArray(deltaInput)
+        ? jsonClone(deltaInput)
+        : undefined;
+}
 export function captureResponsesContext(payload, dto) {
     const preservedInput = Array.isArray(payload.input)
         ? payload.input
@@ -249,11 +295,20 @@ export function buildResponsesRequestFromChat(payload, ctx, extras) {
         requestMetadata: buildSlimBridgeDecisionMetadata(requestMetadata),
         envelopeMetadata: buildSlimBridgeDecisionMetadata(envelopeMetadata),
         bridgeMetadata: buildSlimBridgeDecisionMetadata(bridgeMetadata),
-        extraBridgeHistory: extras?.bridgeHistory
+        extraBridgeHistory: extras?.bridgeHistory,
+        requestSemantics: chat?.semantics && typeof chat.semantics === 'object' && !Array.isArray(chat.semantics)
+            ? chat.semantics
+            : undefined
     });
     const forceWebSearch = bridgeDecisions.forceWebSearch === true;
     const toolCallIdStyle = bridgeDecisions.toolCallIdStyle;
     const historySeed = bridgeDecisions.historySeed;
+    const previousResponseId = typeof bridgeDecisions.previousResponseId === 'string' && bridgeDecisions.previousResponseId.trim().length > 0
+        ? bridgeDecisions.previousResponseId.trim()
+        : readPreviousResponseIdFromChatSemantics(chat);
+    const resumedDeltaInput = previousResponseId.length > 0
+        ? readResumeDeltaInputFromChatSemantics(chat)
+        : undefined;
     // tools: 反向映射为 ResponsesToolDefinition 形状
     const chatTools = Array.isArray(chat.tools) ? chat.tools : [];
     const responsesToolsFromChat = mapChatToolsToBridge(chatTools, {
@@ -278,7 +333,7 @@ export function buildResponsesRequestFromChat(payload, ctx, extras) {
             }
         }
     }
-    const history = historySeed ??
+    const history = (previousResponseId ? undefined : historySeed) ??
         buildBridgeHistoryWithNative({
             messages,
             tools: Array.isArray(out.tools) ? out.tools : undefined
@@ -289,13 +344,22 @@ export function buildResponsesRequestFromChat(payload, ctx, extras) {
     }
     const { input, combinedSystemInstruction, originalSystemMessages } = history;
     // 不追加 metadata，以便 roundtrip 与原始 payload 对齐；系统提示直接写入 instructions。
+    const inputForUpstream = previousResponseId.length > 0 && Array.isArray(resumedDeltaInput)
+        ? resumedDeltaInput
+        : input;
+    if (callIdTransformer) {
+        enforceToolCallIdStyle(inputForUpstream, callIdTransformer);
+    }
     const upstreamInput = filterBridgeInputForUpstreamWithNative({
-        input,
+        input: inputForUpstream,
         allowToolCallId: toolCallIdStyle === 'preserve'
     }).input;
     if (upstreamInput.length) {
         out.input = upstreamInput;
     }
+    if (previousResponseId.length > 0) {
+        out.previous_response_id = previousResponseId;
+    }
     const streamFromChat = typeof chat.stream === 'boolean' ? chat.stream : undefined;
     const streamFromParameters = chat?.parameters && typeof chat.parameters?.stream === 'boolean'
         ? chat.parameters.stream
@@ -348,6 +412,26 @@ export function buildResponsesRequestFromChat(payload, ctx, extras) {
     });
     Object.assign(out, preparedEnvelope.request);
     delete out.parameters;
+    const retainedParameters = {
+        ...(contextParameters ?? {}),
+        ...(chat.parameters && typeof chat.parameters === 'object' && !Array.isArray(chat.parameters)
+            ? chat.parameters
+            : {})
+    };
+    for (const key of RESPONSES_REQUEST_PARAMETER_KEYS) {
+        if (out[key] !== undefined || retainedParameters[key] === undefined) {
+            continue;
+        }
+        out[key] = jsonClone(retainedParameters[key]);
+    }
+    if (out.stream === undefined) {
+        const retainedStream = streamFromChat ??
+            streamFromParameters ??
+            (typeof ctx?.stream === 'boolean' ? ctx.stream : undefined);
+        if (retainedStream !== undefined) {
+            out.stream = retainedStream;
+        }
+    }
     ensureBridgeInstructions(out);
     return { request: out, originalSystemMessages };
 }

package/node_modules/@jsonstudio/llms/dist/conversion/shared/anthropic-message-utils-core.js

@@ -1,5 +1,9 @@
 import { ProviderProtocolError } from '../provider-protocol-error.js';
-const ANTHROPIC_TOOL_NAME_ALIASES = new Map();
+const ANTHROPIC_TOOL_NAME_ALIASES = new Map([
+    ['bash', 'shell_command'],
+    ['shell', 'shell_command'],
+    ['terminal', 'shell_command'],
+]);
 const CANONICAL_TO_ANTHROPIC_TOOL_NAMES = new Map([['shell_command', 'Bash']]);
 export function isObject(v) {
     return !!v && typeof v === 'object' && !Array.isArray(v);

package/node_modules/@jsonstudio/llms/dist/conversion/shared/anthropic-message-utils-openai-request.js

@@ -3,7 +3,7 @@ import { ProviderProtocolError } from '../provider-protocol-error.js';
 import { jsonClone } from '../hub/types/json.js';
 import { logHubStageTiming } from '../hub/pipeline/hub-stage-timing.js';
 import { parseLenientJsonishWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
-import { isObject, normalizeShellLikeToolInput, requireSystemText, requireTrimmedString, sanitizeToolUseId } from './anthropic-message-utils-core.js';
+import { flattenAnthropicText, isObject, normalizeShellLikeToolInput, requireTrimmedString, sanitizeToolUseId } from './anthropic-message-utils-core.js';
 import { normalizeAnthropicToolChoice } from './anthropic-message-utils-openai-response.js';
 const ANTHROPIC_TOP_LEVEL_FIELDS = new Set([
     'model',
@@ -21,6 +21,30 @@ const ANTHROPIC_TOP_LEVEL_FIELDS = new Set([
     'tool_choice',
     'thinking'
 ]);
+const EMPTY_TOOL_RESULT_FALLBACK = '[RouteCodex] Tool output was empty; execution status unknown.';
+const UNIFIED_EXEC_CAP_WARNING_RE = /^warning:\s*the maximum number of unified exec processes you can keep open is \d+\s+and you currently have \d+\s+processes open\.[\s\S]*automatic pruning of old processes\s*$/i;
+function hasVisibleText(value) {
+    return typeof value === 'string' && value.trim().length > 0;
+}
+function isInternalUnifiedExecCapacityWarning(value) {
+    return typeof value === 'string' && UNIFIED_EXEC_CAP_WARNING_RE.test(value.trim());
+}
+function sanitizeUserVisibleText(value) {
+    if (!hasVisibleText(value)) {
+        return '';
+    }
+    if (isInternalUnifiedExecCapacityWarning(value)) {
+        return '';
+    }
+    return String(value);
+}
+function normalizeToolResultText(value) {
+    const sanitized = sanitizeUserVisibleText(value);
+    if (!hasVisibleText(sanitized)) {
+        return EMPTY_TOOL_RESULT_FALLBACK;
+    }
+    return sanitized;
+}
 export function buildAnthropicRequestFromOpenAIChat(chatReq, options) {
     const requestBody = isObject(chatReq) ? chatReq : {};
     const requestId = typeof options?.requestId === 'string' && options.requestId.trim().length
@@ -75,9 +99,8 @@ export function buildAnthropicRequestFromOpenAIChat(chatReq, options) {
     });
     const systemBlocks = [];
     const pushSystemBlock = (text) => {
-        const trimmed = text.trim();
-        if (trimmed)
-            systemBlocks.push({ type: 'text', text: trimmed });
+        if (hasVisibleText(text))
+            systemBlocks.push({ type: 'text', text });
     };
     try {
         const sys = requestBody.system;
@@ -85,7 +108,15 @@ export function buildAnthropicRequestFromOpenAIChat(chatReq, options) {
             if (!val)
                 return;
             if (typeof val === 'string') {
-                pushSystemBlock(requireSystemText(val, 'top-level system'));
+                if (!hasVisibleText(val)) {
+                    throw new ProviderProtocolError('Anthropic bridge constraint violated: top-level system must contain text', {
+                        code: 'MALFORMED_REQUEST',
+                        protocol: 'anthropic-messages',
+                        providerType: 'anthropic',
+                        details: { context: 'top-level system' }
+                    });
+                }
+                pushSystemBlock(val);
                 return;
             }
             if (Array.isArray(val)) {
@@ -94,7 +125,16 @@ export function buildAnthropicRequestFromOpenAIChat(chatReq, options) {
                 return;
             }
             if (typeof val === 'object') {
-                pushSystemBlock(requireSystemText(val, 'top-level system'));
+                const text = flattenAnthropicText(val);
+                if (!hasVisibleText(text)) {
+                    throw new ProviderProtocolError('Anthropic bridge constraint violated: top-level system must contain text', {
+                        code: 'MALFORMED_REQUEST',
+                        protocol: 'anthropic-messages',
+                        providerType: 'anthropic',
+                        details: { context: 'top-level system' }
+                    });
+                }
+                pushSystemBlock(text);
                 return;
             }
             throw new ProviderProtocolError('Anthropic bridge constraint violated: unsupported system payload type', {
@@ -121,9 +161,10 @@ export function buildAnthropicRequestFromOpenAIChat(chatReq, options) {
             mirrorIndex += 1;
         }
         const contentNode = m.content;
-        const text = collectText(contentNode).trim();
+        const text = sanitizeUserVisibleText(collectText(contentNode));
+        const hasText = hasVisibleText(text);
         if (role === 'system') {
-            if (!text) {
+            if (!hasText) {
                 throw new ProviderProtocolError('Anthropic bridge constraint violated: Chat system message must contain text', {
                     code: 'MALFORMED_REQUEST',
                     protocol: 'anthropic-messages',
@@ -146,7 +187,7 @@ export function buildAnthropicRequestFromOpenAIChat(chatReq, options) {
             }
             const block = {
                 type: 'tool_result',
-                content: text
+                content: normalizeToolResultText(text)
             };
             block.tool_use_id = toolCallId;
             messages.push({
@@ -169,7 +210,7 @@ export function buildAnthropicRequestFromOpenAIChat(chatReq, options) {
                     });
                     continue;
                 }
-                if (t === 'image_url') {
+                if (t === 'image_url' || t === 'input_image') {
                     let url = '';
                     const imageUrl = node.image_url;
                     if (typeof imageUrl === 'string') {
@@ -206,16 +247,16 @@ export function buildAnthropicRequestFromOpenAIChat(chatReq, options) {
                 }
             }
         }
-        if (text) {
+        if (hasText) {
             blocks.push({ type: 'text', text });
         }
         if (role === 'assistant') {
             const reasoningText = typeof m.reasoning_content === 'string'
-                ? String(m.reasoning_content).trim()
+                ? String(m.reasoning_content)
                 : typeof m.reasoning === 'string'
-                    ? String(m.reasoning).trim()
+                    ? String(m.reasoning)
                     : '';
-            if (reasoningText.length > 0) {
+            if (hasVisibleText(reasoningText)) {
                 blocks.push({ type: 'thinking', text: reasoningText });
             }
         }

package/node_modules/@jsonstudio/llms/dist/conversion/shared/anthropic-message-utils-tool-schema.js

@@ -10,8 +10,7 @@ const ANTHROPIC_STABLE_TOOL_SCHEMA_NAMES = new Set([
     'view_image',
     'web_search',
     'clock',
-    'continue_execution',
-    'review'
+    'continue_execution'
 ]);
 const ANTHROPIC_STABLE_TOOL_SCHEMA_KEYS = new Map([
     ['exec_command', new Set(['cmd', 'command', 'workdir', 'justification', 'login', 'max_output_tokens', 'sandbox_permissions', 'shell', 'yield_time_ms', 'tty', 'prefix_rule'])],

package/node_modules/@jsonstudio/llms/dist/conversion/shared/anthropic-message-utils.js

@@ -1,10 +1,11 @@
 import { createBridgeActionState, runBridgeActionPipeline } from '../bridge-actions.js';
 import { resolveBridgePolicy, resolvePolicyActions } from '../bridge-policies.js';
+import { ProviderProtocolError } from '../provider-protocol-error.js';
 import { normalizeChatMessageContent } from './chat-output-normalizer.js';
 import { jsonClone } from '../hub/types/json.js';
 import { mapAnthropicToolsToChat } from './anthropic-message-utils-tool-schema.js';
 import { coerceAnthropicAliasRecord } from './anthropic-message-utils-openai-response.js';
-import { flattenAnthropicText, isObject, normalizeAnthropicToolName, normalizeToolResultContent, requireSystemText, requireTrimmedString, safeJson } from './anthropic-message-utils-core.js';
+import { flattenAnthropicText, isObject, normalizeAnthropicToolName, normalizeToolResultContent, requireTrimmedString, safeJson } from './anthropic-message-utils-core.js';
 export { denormalizeAnthropicToolName, normalizeAnthropicToolName } from './anthropic-message-utils-core.js';
 export { mapAnthropicToolsToChat, mapChatToolsToAnthropicTools } from './anthropic-message-utils-tool-schema.js';
 export { buildAnthropicFromOpenAIChat } from './anthropic-message-utils-openai-response.js';
@@ -54,6 +55,21 @@ function invertAnthropicAliasMap(source) {
     }
     return Object.keys(inverted).length ? inverted : undefined;
 }
+function hasVisibleText(value) {
+    return typeof value === 'string' && value.trim().length > 0;
+}
+function requireAnthropicTextPreserveWhitespace(block, context) {
+    const text = flattenAnthropicText(block);
+    if (!hasVisibleText(text)) {
+        throw new ProviderProtocolError(`Anthropic bridge constraint violated: ${context} must contain text`, {
+            code: 'MALFORMED_REQUEST',
+            protocol: 'anthropic-messages',
+            providerType: 'anthropic',
+            details: { context }
+        });
+    }
+    return text;
+}
 export function buildOpenAIChatFromAnthropic(payload, options) {
     const newMessages = [];
     const body = isObject(payload) ? payload : {};
@@ -87,7 +103,7 @@ export function buildOpenAIChatFromAnthropic(payload, options) {
             ? [rawSystem]
             : [];
     for (const block of systemBlocks) {
-        const text = requireSystemText(block, 'system entry');
+        const text = requireAnthropicTextPreserveWhitespace(block, 'system entry');
         newMessages.push({ role: 'system', content: text });
     }
     const msgs = Array.isArray(body.messages) ? body.messages : [];
@@ -98,14 +114,17 @@ export function buildOpenAIChatFromAnthropic(payload, options) {
         const content = m.content;
         if (!Array.isArray(content)) {
             const text = flattenAnthropicText(content);
-            if (text) {
+            if (hasVisibleText(text)) {
                 const normalized = normalizeChatMessageContent(text);
+                const reasoningText = typeof normalized.reasoningText === 'string' && normalized.reasoningText.trim().length
+                    ? normalized.reasoningText
+                    : undefined;
                 const message = {
                     role,
-                    content: normalized.contentText ?? text
+                    content: reasoningText ? (normalized.contentText ?? text) : text
                 };
-                if (typeof normalized.reasoningText === 'string' && normalized.reasoningText.trim().length) {
-                    message.reasoning_content = normalized.reasoningText.trim();
+                if (reasoningText) {
+                    message.reasoning_content = reasoningText;
                 }
                 newMessages.push(message);
             }
@@ -121,13 +140,13 @@ export function buildOpenAIChatFromAnthropic(payload, options) {
                 continue;
             const t = String(block.type || '').toLowerCase();
             if (t === 'text' && typeof block.text === 'string') {
-                const s = block.text.trim();
-                if (s)
+                const s = String(block.text);
+                if (hasVisibleText(s))
                     textParts.push(s);
             }
             else if (t === 'thinking' || t === 'reasoning') {
-                const thinkingText = flattenAnthropicText(block).trim();
-                if (thinkingText) {
+                const thinkingText = flattenAnthropicText(block);
+                if (hasVisibleText(thinkingText)) {
                     reasoningParts.push(thinkingText);
                 }
             }
@@ -177,22 +196,26 @@ export function buildOpenAIChatFromAnthropic(payload, options) {
                 toolResults.push({ role: 'tool', tool_call_id: callId, content: contentStr });
             }
         }
-        const combinedText = textParts.join('\n');
+        const combinedText = textParts.join('');
         const normalized = normalizeChatMessageContent(combinedText);
         const hasRawText = typeof combinedText === 'string' && combinedText.trim().length > 0;
         const mergedReasoning = [...reasoningParts];
         if (typeof normalized.reasoningText === 'string' && normalized.reasoningText.trim().length) {
-            mergedReasoning.push(normalized.reasoningText.trim());
+            mergedReasoning.push(normalized.reasoningText);
         }
         const hasText = typeof normalized.contentText === 'string' && normalized.contentText.length > 0;
         const hasReasoning = mergedReasoning.length > 0;
         if (hasText || hasRawText || toolCalls.length > 0 || hasReasoning || imageBlocks.length > 0) {
-            let contentNode = (hasText ? normalized.contentText : undefined) ?? combinedText ?? '';
+            let contentNode = hasReasoning
+                ? ((hasText ? normalized.contentText : undefined) ?? combinedText ?? '')
+                : (combinedText ?? '');
             if (imageBlocks.length > 0) {
                 const blocks = [];
-                const textPayload = (hasText ? normalized.contentText : undefined) ?? combinedText ?? '';
+                const textPayload = hasReasoning
+                    ? ((hasText ? normalized.contentText : undefined) ?? combinedText ?? '')
+                    : (combinedText ?? '');
                 if (typeof textPayload === 'string' && textPayload.trim().length) {
-                    blocks.push({ type: 'text', text: textPayload.trim() });
+                    blocks.push({ type: 'text', text: textPayload });
                 }
                 for (const img of imageBlocks) {
                     blocks.push(jsonClone(img));