@jsonstudio/llms 0.4.4 → 0.4.5

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

@@ -1,3 +1,8 @@
+import { createBridgeActionState, runBridgeActionPipeline } from '../shared/bridge-actions.js';
+import { resolveBridgePolicy, resolvePolicyActions } from '../shared/bridge-policies.js';
+import { normalizeChatMessageContent } from '../shared/chat-output-normalizer.js';
+import { mapBridgeToolsToChat } from '../shared/tool-mapping.js';
+import { prepareGeminiToolsForBridge } from '../shared/gemini-tool-utils.js';
 function isObject(v) {
     return !!v && typeof v === 'object' && !Array.isArray(v);
 }
@@ -48,49 +53,6 @@ function mapChatRoleToGemini(role) {
         return 'tool';
     return 'user';
 }
-function mapGeminiToolsToOpenAI(tools) {
-    const out = [];
-    if (!tools)
-        return out;
-    const arr = Array.isArray(tools) ? tools : [tools];
-    for (const t of arr) {
-        if (!t || typeof t !== 'object')
-            continue;
-        const tObj = t;
-        const fds = Array.isArray(tObj.functionDeclarations) ? tObj.functionDeclarations : [];
-        if (fds.length) {
-            for (const fd of fds) {
-                if (!fd || typeof fd !== 'object')
-                    continue;
-                const name = typeof fd.name === 'string' ? String(fd.name) : undefined;
-                if (!name)
-                    continue;
-                const description = typeof fd.description === 'string' ? String(fd.description) : undefined;
-                const parameters = isObject(fd.parameters)
-                    ? JSON.parse(JSON.stringify(fd.parameters))
-                    : { type: 'object', properties: {} };
-                const fn = { name, parameters };
-                if (description)
-                    fn.description = description;
-                out.push({ type: 'function', function: fn });
-            }
-            continue;
-        }
-        // 单个函数声明形状：直接把对象视为 FunctionDeclaration
-        const name = typeof tObj.name === 'string' ? String(tObj.name) : undefined;
-        if (name) {
-            const description = typeof tObj.description === 'string' ? String(tObj.description) : undefined;
-            const parameters = isObject(tObj.parameters)
-                ? JSON.parse(JSON.stringify(tObj.parameters))
-                : { type: 'object', properties: {} };
-            const fn = { name, parameters };
-            if (description)
-                fn.description = description;
-            out.push({ type: 'function', function: fn });
-        }
-    }
-    return out;
-}
 export function buildOpenAIChatFromGeminiRequest(payload) {
     const messages = [];
     // systemInstruction → Chat system 消息
@@ -160,8 +122,21 @@ export function buildOpenAIChatFromGeminiRequest(payload) {
                 continue;
             }
         }
-        if (textParts.length > 0 || toolCalls.length > 0) {
-            const msg = { role, content: textParts.join('\n') };
+        const combinedText = textParts.join('\n');
+        const normalized = combinedText.length ? normalizeChatMessageContent(combinedText) : { contentText: undefined, reasoningText: undefined };
+        const hasText = typeof normalized.contentText === 'string' && normalized.contentText.length > 0;
+        const reasoningChunks = [];
+        if (typeof normalized.reasoningText === 'string' && normalized.reasoningText.trim().length) {
+            reasoningChunks.push(normalized.reasoningText.trim());
+        }
+        if (hasText || toolCalls.length > 0 || reasoningChunks.length > 0) {
+            const msg = {
+                role,
+                content: normalized.contentText ?? combinedText ?? ''
+            };
+            if (reasoningChunks.length) {
+                msg.reasoning_content = reasoningChunks.join('\n');
+            }
             if (toolCalls.length)
                 msg.tool_calls = toolCalls;
             messages.push(msg);
@@ -178,6 +153,7 @@ export function buildOpenAIChatFromGeminiResponse(payload) {
     const role = mapGeminiRoleToChat(content.role);
     const parts = Array.isArray(content.parts) ? content.parts : [];
     const textParts = [];
+    const reasoningParts = [];
     const toolCalls = [];
     for (const part of parts) {
         if (!part || typeof part !== 'object')
@@ -189,6 +165,21 @@ export function buildOpenAIChatFromGeminiResponse(payload) {
                 textParts.push(t);
             continue;
         }
+        if (Array.isArray(pObj.content)) {
+            for (const inner of pObj.content) {
+                if (typeof inner === 'string') {
+                    textParts.push(inner);
+                }
+                else if (inner && typeof inner === 'object' && typeof inner.text === 'string') {
+                    textParts.push(inner.text);
+                }
+            }
+            continue;
+        }
+        if (typeof pObj.reasoning === 'string') {
+            reasoningParts.push(pObj.reasoning);
+            continue;
+        }
         if (pObj.functionCall && typeof pObj.functionCall === 'object') {
             const fc = pObj.functionCall;
             const name = typeof fc.name === 'string' ? String(fc.name) : undefined;
@@ -234,13 +225,42 @@ export function buildOpenAIChatFromGeminiResponse(payload) {
         usage.completion_tokens = completionTokens;
     if (Number.isFinite(totalTokens))
         usage.total_tokens = totalTokens;
+    const combinedText = textParts.join('\n');
+    const normalized = combinedText.length ? normalizeChatMessageContent(combinedText) : { contentText: undefined, reasoningText: undefined };
     const chatMsg = {
         role,
-        content: textParts.join('\n')
+        content: normalized.contentText ?? combinedText ?? ''
     };
+    if (typeof normalized.reasoningText === 'string' && normalized.reasoningText.trim().length) {
+        reasoningParts.push(normalized.reasoningText.trim());
+    }
+    if (reasoningParts.length) {
+        chatMsg.reasoning_content = reasoningParts.join('\n');
+    }
     if (toolCalls.length) {
         chatMsg.tool_calls = toolCalls;
     }
+    try {
+        const bridgePolicy = resolveBridgePolicy({ protocol: 'gemini-chat' });
+        const actions = resolvePolicyActions(bridgePolicy, 'response_inbound');
+        if (actions?.length) {
+            const actionState = createBridgeActionState({
+                messages: [chatMsg],
+                rawResponse: isObject(payload) ? payload : undefined
+            });
+            runBridgeActionPipeline({
+                stage: 'response_inbound',
+                actions,
+                protocol: bridgePolicy?.protocol ?? 'gemini-chat',
+                moduleType: bridgePolicy?.moduleType ?? 'gemini-chat',
+                requestId: typeof payload?.id === 'string' ? String(payload.id) : undefined,
+                state: actionState
+            });
+        }
+    }
+    catch {
+        // best-effort policy execution
+    }
     const chatResp = {
         id: payload?.id || `chatcmpl_${Date.now()}`,
         object: 'chat.completion',
@@ -276,6 +296,28 @@ export function buildGeminiFromOpenAIChat(chatResp) {
         return 'STOP';
     })();
     const baseRole = mapChatRoleToGemini(msg.role || 'assistant');
+    if (msg) {
+        try {
+            const bridgePolicy = resolveBridgePolicy({ protocol: 'gemini-chat' });
+            const actions = resolvePolicyActions(bridgePolicy, 'response_outbound');
+            if (actions?.length) {
+                const actionState = createBridgeActionState({
+                    messages: [msg]
+                });
+                runBridgeActionPipeline({
+                    stage: 'response_outbound',
+                    actions,
+                    protocol: bridgePolicy?.protocol ?? 'gemini-chat',
+                    moduleType: bridgePolicy?.moduleType ?? 'gemini-chat',
+                    requestId: typeof chatResp?.id === 'string' ? String(chatResp.id) : undefined,
+                    state: actionState
+                });
+            }
+        }
+        catch {
+            // ignore policy failures
+        }
+    }
     const parts = [];
     const contentText = (() => {
         const raw = msg.content;
@@ -377,8 +419,9 @@ export class GeminiOpenAIConversionCodec {
         const { messages } = buildOpenAIChatFromGeminiRequest(payload);
         const out = { model, messages };
         try {
-            const tools = mapGeminiToolsToOpenAI(payload?.tools);
-            if (tools.length > 0)
+            const bridgeTools = prepareGeminiToolsForBridge(payload?.tools);
+            const tools = bridgeTools ? mapBridgeToolsToChat(bridgeTools) : undefined;
+            if (tools && tools.length > 0)
                 out.tools = tools;
         }
         catch {

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

@@ -1,5 +1,5 @@
 import { buildResponsesPayloadFromChat, runStandardChatRequestFilters } from '../index.js';
-import { captureResponsesContext, buildChatRequestFromResponses } from '../shared/responses-request-adapter.js';
+import { captureResponsesContext, buildChatRequestFromResponses } from '../responses/responses-openai-bridge.js';
 import { FilterEngine, ResponseToolTextCanonicalizeFilter, ResponseToolArgumentsStringifyFilter, ResponseFinishInvariantsFilter } from '../../filters/index.js';
 // Ported from root package (no behavior change). Types relaxed.
 export class ResponsesOpenAIConversionCodec {
@@ -82,7 +82,14 @@ export class ResponsesOpenAIConversionCodec {
             entryEndpoint: context.entryEndpoint ?? dto.metadata?.entryEndpoint ?? context.endpoint,
             endpoint: context.endpoint ?? dto.metadata?.endpoint
         };
-        return runStandardChatRequestFilters(chatRequest, profile, ctxForFilters);
+        const filtered = await runStandardChatRequestFilters(chatRequest, profile, ctxForFilters);
+        if (filtered && typeof filtered === 'object') {
+            const maybe = filtered;
+            if (maybe.max_tokens === undefined && typeof maybe.max_output_tokens === 'number') {
+                maybe.max_tokens = maybe.max_output_tokens;
+            }
+        }
+        return filtered;
     }
     async convertResponse(payload, _profile, context) {
         await this.ensureInit();

package/dist/conversion/hub/format-adapters/anthropic-format-adapter.js

@@ -1,6 +1,8 @@
+import { normalizeReasoningInAnthropicPayload } from '../../shared/reasoning-normalizer.js';
 export class AnthropicFormatAdapter {
     protocol = 'anthropic-messages';
     async parseRequest(original, _ctx) {
+        normalizeReasoningInAnthropicPayload(original);
         return {
             protocol: this.protocol,
             direction: 'request',
@@ -11,6 +13,7 @@ export class AnthropicFormatAdapter {
         return format.payload;
     }
     async parseResponse(original, _ctx) {
+        normalizeReasoningInAnthropicPayload(original);
         return {
             protocol: this.protocol,
             direction: 'response',

package/dist/conversion/hub/format-adapters/chat-format-adapter.js

@@ -1,6 +1,8 @@
+import { normalizeReasoningInChatPayload } from '../../shared/reasoning-normalizer.js';
 export class ChatFormatAdapter {
     protocol = 'openai-chat';
     async parseRequest(original, _ctx) {
+        normalizeReasoningInChatPayload(original);
         return {
             protocol: this.protocol,
             direction: 'request',
@@ -11,6 +13,7 @@ export class ChatFormatAdapter {
         return format.payload;
     }
     async parseResponse(original, _ctx) {
+        normalizeReasoningInChatPayload(original);
         return {
             protocol: this.protocol,
             direction: 'response',

package/dist/conversion/hub/format-adapters/gemini-format-adapter.js

@@ -1,6 +1,8 @@
+import { normalizeReasoningInGeminiPayload } from '../../shared/reasoning-normalizer.js';
 export class GeminiFormatAdapter {
     protocol = 'gemini-chat';
     async parseRequest(original, _ctx) {
+        normalizeReasoningInGeminiPayload(original);
         return {
             protocol: this.protocol,
             direction: 'request',
@@ -11,6 +13,7 @@ export class GeminiFormatAdapter {
         return format.payload;
     }
     async parseResponse(original, _ctx) {
+        normalizeReasoningInGeminiPayload(original);
         return {
             protocol: this.protocol,
             direction: 'response',

package/dist/conversion/hub/format-adapters/responses-format-adapter.d.ts

@@ -0,0 +1,19 @@
+import type { FormatAdapter } from './index.js';
+import type { AdapterContext } from '../types/chat-envelope.js';
+import type { FormatEnvelope } from '../types/format-envelope.js';
+import type { JsonObject, JsonValue } from '../types/json.js';
+interface ResponsesFormatPayload extends JsonObject {
+    input?: JsonValue[];
+    tools?: JsonValue[];
+    tool_outputs?: JsonValue[];
+    output?: JsonValue[];
+    id?: string;
+}
+export declare class ResponsesFormatAdapter implements FormatAdapter {
+    readonly protocol = "openai-responses";
+    parseRequest(original: JsonObject, _ctx: AdapterContext): Promise<FormatEnvelope<ResponsesFormatPayload>>;
+    buildRequest(format: FormatEnvelope<ResponsesFormatPayload>, _ctx: AdapterContext): Promise<ResponsesFormatPayload>;
+    parseResponse(original: JsonObject, _ctx: AdapterContext): Promise<FormatEnvelope<ResponsesFormatPayload>>;
+    buildResponse(format: FormatEnvelope<ResponsesFormatPayload>, _ctx: AdapterContext): Promise<ResponsesFormatPayload>;
+}
+export {};

package/dist/conversion/hub/format-adapters/responses-format-adapter.js

@@ -1,6 +1,11 @@
+import { normalizeReasoningInResponsesPayload } from '../../shared/reasoning-normalizer.js';
 export class ResponsesFormatAdapter {
     protocol = 'openai-responses';
     async parseRequest(original, _ctx) {
+        normalizeReasoningInResponsesPayload(original, {
+            includeInput: true,
+            includeInstructions: true
+        });
         return {
             protocol: this.protocol,
             direction: 'request',
@@ -11,6 +16,10 @@ export class ResponsesFormatAdapter {
         return format.payload;
     }
     async parseResponse(original, _ctx) {
+        normalizeReasoningInResponsesPayload(original, {
+            includeOutput: true,
+            includeRequiredAction: true
+        });
         return {
             protocol: this.protocol,
             direction: 'response',

package/dist/conversion/hub/node-support.js

@@ -102,6 +102,7 @@ function deriveAdapterContext(context, fallbackProtocol) {
         (typeof metadata.providerProtocol === 'string' ? metadata.providerProtocol : undefined) ||
         fallbackProtocol;
     const streamingHint = metadata.stream === true ? 'force' : metadata.stream === false ? 'disable' : 'auto';
+    const toolCallIdStyle = typeof metadata.toolCallIdStyle === 'string' ? metadata.toolCallIdStyle : undefined;
     return {
         requestId: context.request.id,
         entryEndpoint: (typeof requestContext.entryEndpoint === 'string' ? requestContext.entryEndpoint : context.request.endpoint) ||
@@ -110,6 +111,7 @@ function deriveAdapterContext(context, fallbackProtocol) {
         providerId: (target?.providerKey || metadata.providerKey),
         routeId: metadata.routeName,
         profileId: metadata.pipelineId,
-        streamingHint
+        streamingHint,
+        toolCallIdStyle
     };
 }

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

@@ -121,6 +121,9 @@ export class HubPipeline {
         metadata.providerType = target.providerType;
         metadata.modelId = target.modelId;
         metadata.processMode = target.processMode || 'chat';
+        if (target.responsesConfig?.toolCallIdStyle) {
+            metadata.toolCallIdStyle = target.responsesConfig.toolCallIdStyle;
+        }
         if (originalModel && typeof originalModel === 'string' && originalModel.trim()) {
             const trimmed = originalModel.trim();
             if (typeof metadata.originalModelId !== 'string' || !metadata.originalModelId) {
@@ -237,9 +240,7 @@ export class HubPipeline {
         const entryEndpoint = typeof metadataRecord.entryEndpoint === 'string'
             ? normalizeEndpoint(metadataRecord.entryEndpoint)
             : endpoint;
-        const providerProtocol = typeof metadataRecord.providerProtocol === 'string'
-            ? metadataRecord.providerProtocol
-            : inferProviderProtocol(entryEndpoint);
+        const providerProtocol = resolveProviderProtocol(metadataRecord.providerProtocol);
         const processMode = metadataRecord.processMode === 'passthrough' ? 'passthrough' : 'chat';
         const direction = metadataRecord.direction === 'response' ? 'response' : 'request';
         const stage = metadataRecord.stage === 'outbound' ? 'outbound' : 'inbound';
@@ -358,15 +359,11 @@ export class HubPipeline {
         }
     }
     resolveSseProtocol(context) {
-        const providerMeta = context.metadata.provider ?? undefined;
-        const profile = typeof providerMeta?.profile === 'string' ? providerMeta.profile : undefined;
-        const providerProtocol = typeof context.metadata.providerProtocol === 'string'
-            ? context.metadata.providerProtocol
-            : context.providerProtocol;
-        const routeHint = typeof context.metadata.routeHint === 'string'
-            ? context.metadata.routeHint
-            : undefined;
-        return inferSseProtocol(routeHint, providerProtocol, context.entryEndpoint);
+        const explicitProtocol = resolveSseProtocolFromMetadata(context.metadata);
+        if (explicitProtocol) {
+            return explicitProtocol;
+        }
+        return context.providerProtocol;
     }
     extractModelHint(metadata) {
         if (typeof metadata.model === 'string' && metadata.model.trim()) {
@@ -395,26 +392,34 @@ function normalizeEndpoint(endpoint) {
     const normalized = trimmed.startsWith('/') ? trimmed : `/${trimmed}`;
     return normalized.replace(/\/{2,}/g, '/');
 }
-function inferProviderProtocol(endpoint) {
-    const lowered = endpoint.toLowerCase();
-    if (lowered.includes('/v1/messages'))
-        return 'anthropic-messages';
-    if (lowered.includes('/v1/responses'))
-        return 'openai-responses';
-    if (lowered.includes('/v1beta'))
-        return 'gemini-chat';
-    return 'openai-chat';
+function resolveProviderProtocol(value) {
+    if (typeof value !== 'string' || !value.trim()) {
+        return 'openai-chat';
+    }
+    const normalized = value.trim().toLowerCase();
+    const mapped = PROVIDER_PROTOCOL_ALIASES[normalized];
+    if (mapped) {
+        return mapped;
+    }
+    throw new Error(`[HubPipeline] Unsupported providerProtocol "${value}". Configure a valid protocol (openai-chat|openai-responses|anthropic-messages|gemini-chat).`);
 }
-function inferSseProtocol(routeHint, providerProtocol, entryEndpoint) {
-    const candidates = [routeHint, providerProtocol, entryEndpoint].filter((value) => typeof value === 'string' && value.length > 0);
-    for (const candidate of candidates) {
-        const lowered = candidate.toLowerCase();
-        if (lowered.includes('responses')) {
-            return 'openai-responses';
-        }
-        if (lowered.includes('messages') || lowered.includes('anthropic')) {
-            return 'anthropic-messages';
-        }
+const PROVIDER_PROTOCOL_ALIASES = {
+    'openai-chat': 'openai-chat',
+    openai: 'openai-chat',
+    chat: 'openai-chat',
+    'responses': 'openai-responses',
+    'openai-responses': 'openai-responses',
+    'anthropic': 'anthropic-messages',
+    'anthropic-messages': 'anthropic-messages',
+    'messages': 'anthropic-messages',
+    'gemini': 'gemini-chat',
+    'google-gemini': 'gemini-chat',
+    'gemini-chat': 'gemini-chat'
+};
+function resolveSseProtocolFromMetadata(metadata) {
+    const candidate = metadata.sseProtocol ?? metadata.clientSseProtocol ?? metadata.routeSseProtocol;
+    if (typeof candidate !== 'string' || !candidate.trim()) {
+        return undefined;
     }
-    return 'openai-chat';
+    return resolveProviderProtocol(candidate);
 }

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

@@ -89,7 +89,7 @@ async function maybeCreateSseStream(protocol, payload, requestId) {
     return codec.convertJsonToSse(payload, { requestId });
 }
 function supportsSseProtocol(protocol) {
-    return protocol === 'openai-chat' || protocol === 'openai-responses' || protocol === 'anthropic-messages';
+    return protocol === 'openai-chat' || protocol === 'openai-responses' || protocol === 'anthropic-messages' || protocol === 'gemini-chat';
 }
 function extractDisplayModel(context) {
     const candidates = [

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

@@ -1,5 +1,5 @@
 import { buildOpenAIChatFromGeminiResponse } from '../../codecs/gemini-openai-codec.js';
-import { buildChatResponseFromResponses } from '../../responses/responses-openai-bridge.js';
+import { buildChatResponseFromResponses } from '../../shared/responses-response-utils.js';
 import { buildOpenAIChatFromAnthropicMessage } from './response-runtime.js';
 export class OpenAIChatResponseMapper {
     toChatCompletion(format, _ctx) {

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

@@ -1,3 +1,7 @@
+import { extractToolCallsFromReasoningText } from '../../shared/reasoning-tool-parser.js';
+import { deriveToolCallKey } from '../../shared/tool-call-utils.js';
+import { createBridgeActionState, runBridgeActionPipeline } from '../../shared/bridge-actions.js';
+import { resolveBridgePolicy, resolvePolicyActions } from '../../shared/bridge-policies.js';
 function flattenAnthropicContent(content) {
     if (typeof content === 'string')
         return content;
@@ -19,6 +23,11 @@ export function buildOpenAIChatFromAnthropicMessage(payload) {
     const content = Array.isArray(payload?.content) ? payload.content : [];
     const textParts = [];
     const toolCalls = [];
+    const inferredToolCalls = [];
+    const reasoningParts = [];
+    if (typeof payload?.reasoning_content === 'string' && payload.reasoning_content.trim().length) {
+        reasoningParts.push(String(payload.reasoning_content).trim());
+    }
     for (const part of content) {
         if (!part || typeof part !== 'object')
             continue;
@@ -50,6 +59,21 @@ export function buildOpenAIChatFromAnthropicMessage(payload) {
                 toolCalls.push({ id, name, args });
             }
         }
+        else if (kind === 'thinking' || kind === 'reasoning') {
+            const text = typeof part.text === 'string'
+                ? part.text
+                : flattenAnthropicContent(part);
+            if (text) {
+                const { cleanedText, toolCalls: inferred } = extractToolCallsFromReasoningText(text, { idPrefix: 'anthropic_reasoning' });
+                const trimmed = cleanedText.trim();
+                if (trimmed.length) {
+                    reasoningParts.push(trimmed);
+                }
+                if (Array.isArray(inferred) && inferred.length) {
+                    inferredToolCalls.push(...inferred);
+                }
+            }
+        }
     }
     const mapFinishReason = (reason) => {
         switch (reason) {
@@ -59,6 +83,60 @@ export function buildOpenAIChatFromAnthropicMessage(payload) {
             default: return 'stop';
         }
     };
+    const canonicalToolCalls = toolCalls.map((tc) => ({
+        id: tc.id,
+        type: 'function',
+        function: { name: tc.name, arguments: tc.args }
+    }));
+    if (inferredToolCalls.length) {
+        const seen = new Set();
+        for (const existing of canonicalToolCalls) {
+            const key = deriveToolCallKey(existing);
+            if (key)
+                seen.add(key);
+        }
+        for (const inferred of inferredToolCalls) {
+            const key = deriveToolCallKey(inferred);
+            if (key && seen.has(key))
+                continue;
+            canonicalToolCalls.push(inferred);
+            if (key)
+                seen.add(key);
+        }
+    }
+    const message = {
+        role: typeof payload.role === 'string' ? payload.role : 'assistant',
+        content: textParts.join('\n')
+    };
+    if (canonicalToolCalls.length) {
+        message.tool_calls = canonicalToolCalls;
+    }
+    if (reasoningParts.length) {
+        message.reasoning_content = reasoningParts.join('\n');
+    }
+    try {
+        const bridgePolicy = resolveBridgePolicy({ protocol: 'anthropic-messages' });
+        const actions = resolvePolicyActions(bridgePolicy, 'response_inbound');
+        if (actions?.length) {
+            const actionState = createBridgeActionState({
+                messages: [message],
+                rawResponse: payload
+            });
+            runBridgeActionPipeline({
+                stage: 'response_inbound',
+                actions,
+                protocol: bridgePolicy?.protocol ?? 'anthropic-messages',
+                moduleType: bridgePolicy?.moduleType ?? 'anthropic-messages',
+                requestId: typeof payload.id === 'string' ? payload.id : undefined,
+                state: actionState
+            });
+        }
+    }
+    catch {
+        // ignore policy failures
+    }
+    const stopReason = typeof payload['stop_reason'] === 'string' ? payload['stop_reason'] : undefined;
+    const finishReason = canonicalToolCalls.length ? 'tool_calls' : mapFinishReason(stopReason);
     return {
         id: typeof payload.id === 'string' ? payload.id : `chatcmpl_${Date.now()}`,
         object: 'chat.completion',
@@ -67,16 +145,8 @@ export function buildOpenAIChatFromAnthropicMessage(payload) {
         choices: [
             {
                 index: 0,
-                finish_reason: mapFinishReason(typeof payload['stop_reason'] === 'string' ? payload['stop_reason'] : undefined),
-                message: {
-                    role: typeof payload.role === 'string' ? payload.role : 'assistant',
-                    content: textParts.join('\n'),
-                    tool_calls: toolCalls.map((tc) => ({
-                        id: tc.id,
-                        type: 'function',
-                        function: { name: tc.name, arguments: tc.args }
-                    }))
-                }
+                finish_reason: finishReason,
+                message
             }
         ],
         usage: payload['usage'] && typeof payload['usage'] === 'object'
@@ -87,9 +157,38 @@ export function buildOpenAIChatFromAnthropicMessage(payload) {
 export function buildAnthropicResponseFromChat(chatResponse) {
     const choice = Array.isArray(chatResponse?.choices) ? chatResponse.choices[0] : undefined;
     const message = choice && typeof choice === 'object' ? choice.message : undefined;
+    if (message) {
+        try {
+            const bridgePolicy = resolveBridgePolicy({ protocol: 'anthropic-messages' });
+            const actions = resolvePolicyActions(bridgePolicy, 'response_outbound');
+            if (actions?.length) {
+                const actionState = createBridgeActionState({
+                    messages: [message]
+                });
+                runBridgeActionPipeline({
+                    stage: 'response_outbound',
+                    actions,
+                    protocol: bridgePolicy?.protocol ?? 'anthropic-messages',
+                    moduleType: bridgePolicy?.moduleType ?? 'anthropic-messages',
+                    requestId: typeof chatResponse.id === 'string' ? chatResponse.id : undefined,
+                    state: actionState
+                });
+            }
+        }
+        catch {
+            // ignore policy failures
+        }
+    }
     const text = flattenAnthropicContent(message?.content);
     const toolCalls = Array.isArray(message?.tool_calls) ? message.tool_calls : [];
     const contentBlocks = [];
+    const reasoningRaw = message?.reasoning_content ?? message?.reasoning;
+    const reasoningText = typeof reasoningRaw === 'string'
+        ? reasoningRaw.trim()
+        : flattenAnthropicContent(reasoningRaw).trim();
+    if (reasoningText) {
+        contentBlocks.push({ type: 'thinking', text: reasoningText });
+    }
     if (text && text.trim().length) {
         contentBlocks.push({ type: 'text', text });
     }