@jsonstudio/llms 0.6.3409 → 0.6.3541

package/dist/conversion/compat/actions/universal-shape-filter.js

@@ -1,393 +1,14 @@
-const DEFAULT_TOOL_OUTPUT = 'Command succeeded (no output).';
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-function toRecord(value) {
-    return isRecord(value) ? value : {};
-}
-function toArray(value) {
-    return Array.isArray(value) ? value : [];
-}
-function hasArrayItems(value) {
-    return Array.isArray(value) && value.length > 0;
-}
+import { buildNativeReqOutboundCompatAdapterContext } from "../../hub/pipeline/compat/native-adapter-context.js";
+import { applyUniversalShapeRequestFilterWithNative, applyUniversalShapeResponseFilterWithNative, } from "../../../router/virtual-router/engine-selection/native-compat-action-semantics.js";
 export class UniversalShapeFilter {
     cfg;
     constructor(config) {
         this.cfg = config;
     }
     applyRequestFilter(payload) {
-        const cfg = this.cfg;
-        const allow = new Set(cfg.request.allowTopLevel);
-        const src = toRecord(payload);
-        const out = {};
-        for (const key of Object.keys(src)) {
-            if (allow.has(key)) {
-                out[key] = src[key];
-            }
-        }
-        const normalizedMessages = this.normalizeRequestMessages(out.messages, cfg.request);
-        out.messages = normalizedMessages;
-        this.normalizeTools(out, cfg.request);
-        this.cleanupToolChoice(out);
-        return out;
+        return applyUniversalShapeRequestFilterWithNative(payload, this.cfg);
     }
     applyResponseFilter(payload, ctx) {
-        const envFlag = String(process.env.RCC_COMPAT_FILTER_OFF_RESPONSES || '1').toLowerCase();
-        const envBypass = !(envFlag === '0' || envFlag === 'false' || envFlag === 'off');
-        const entryEndpoint = ctx?.entryEndpoint ?? ctx?.endpoint;
-        const entry = typeof entryEndpoint === 'string' ? entryEndpoint.toLowerCase() : '';
-        if (entry === '/v1/responses' || envBypass) {
-            return payload;
-        }
-        const cfg = this.cfg;
-        const src = toRecord(payload);
-        const out = this.shallowPick(src, cfg.response.allowTopLevel);
-        const choices = Array.isArray(src.choices) ? src.choices : [];
-        out.choices = choices.map((choice, idx) => this.normalizeResponseChoice(choice, idx, cfg.response));
-        if (src.usage && typeof src.usage === 'object') {
-            out.usage = this.shallowPick(src.usage, cfg.response.usage?.allow || []);
-        }
-        return out;
-    }
-    shallowPick(obj, allow) {
-        if (!isRecord(obj)) {
-            return {};
-        }
-        const out = {};
-        for (const key of allow) {
-            if (Object.prototype.hasOwnProperty.call(obj, key)) {
-                out[key] = obj[key];
-            }
-        }
-        return out;
-    }
-    toObjectArgs(value) {
-        if (value === null || value === undefined) {
-            return {};
-        }
-        if (isRecord(value)) {
-            return value;
-        }
-        if (typeof value === 'string') {
-            try {
-                return JSON.parse(value);
-            }
-            catch {
-                return { raw: value };
-            }
-        }
-        return {};
-    }
-    toStringArgs(value) {
-        if (typeof value === 'string') {
-            return value;
-        }
-        try {
-            return JSON.stringify(value ?? {});
-        }
-        catch {
-            return '{}';
-        }
-    }
-    normalizeToolContent(value) {
-        if (typeof value === 'string') {
-            return value.trim().length ? value : DEFAULT_TOOL_OUTPUT;
-        }
-        if (value === null || value === undefined) {
-            return DEFAULT_TOOL_OUTPUT;
-        }
-        try {
-            const text = JSON.stringify(value);
-            return text && text.length ? text : DEFAULT_TOOL_OUTPUT;
-        }
-        catch {
-            return DEFAULT_TOOL_OUTPUT;
-        }
-    }
-    normalizeRequestMessages(messages, requestCfg) {
-        const entries = toArray(messages);
-        const normalized = entries.map(entry => this.normalizeSingleMessage(entry, requestCfg));
-        const withRules = this.applyMessageRules(normalized, requestCfg);
-        this.pairToolResults(withRules);
-        return withRules;
-    }
-    normalizeSingleMessage(message, requestCfg) {
-        const msg = toRecord(message);
-        const allowedRoles = requestCfg.messages.allowedRoles;
-        const requestedRole = typeof msg.role === 'string' ? msg.role : undefined;
-        const role = (requestedRole && allowedRoles.includes(requestedRole)) ? requestedRole : 'user';
-        const normalized = { role };
-        if (role === 'tool') {
-            normalized.content = this.normalizeToolContent(msg.content);
-            if (typeof msg.name === 'string') {
-                normalized.name = msg.name;
-            }
-            if (typeof msg.tool_call_id === 'string') {
-                normalized.tool_call_id = msg.tool_call_id;
-            }
-        }
-        else if (Array.isArray(msg.content)) {
-            normalized.content = msg.content.map((part) => {
-                if (typeof part === 'string') {
-                    return part;
-                }
-                if (isRecord(part)) {
-                    return { ...part };
-                }
-                return part;
-            });
-        }
-        else {
-            normalized.content = (msg.content !== null && msg.content !== undefined) ? String(msg.content) : '';
-        }
-        if (role === 'assistant' && hasArrayItems(msg.tool_calls)) {
-            normalized.tool_calls = this.normalizeAssistantToolCalls(msg.tool_calls, requestCfg);
-            if (requestCfg.messages.assistantWithToolCallsContentNull) {
-                normalized.content = null;
-            }
-        }
-        return normalized;
-    }
-    normalizeAssistantToolCalls(toolCalls, requestCfg) {
-        const entries = toArray(toolCalls);
-        return entries.map(call => {
-            const tc = toRecord(call);
-            const fn = toRecord(tc.function);
-            const name = typeof fn.name === 'string' ? fn.name : undefined;
-            const argsValue = requestCfg.assistantToolCalls?.functionArgumentsType === 'string'
-                ? this.toStringArgs(fn.arguments)
-                : this.toObjectArgs(fn.arguments);
-            const normalized = {
-                type: typeof tc.type === 'string' ? tc.type : 'function',
-                function: { ...(name ? { name } : {}), arguments: argsValue }
-            };
-            if (typeof tc.id === 'string') {
-                normalized.id = tc.id;
-            }
-            return normalized;
-        });
-    }
-    applyMessageRules(messages, requestCfg) {
-        const rules = Array.isArray(requestCfg.messagesRules) ? requestCfg.messagesRules : [];
-        if (!rules.length) {
-            if (requestCfg.messages.suppressAssistantToolCalls) {
-                return messages.filter(msg => !(msg.role === 'assistant' && hasArrayItems(msg.tool_calls)));
-            }
-            return messages;
-        }
-        const result = [];
-        for (const message of messages) {
-            let dropped = false;
-            for (const rule of rules) {
-                const when = rule.when || {};
-                const matchRole = when.role ? message.role === when.role : true;
-                const hasTools = hasArrayItems(message.tool_calls);
-                const matchTools = typeof when.hasToolCalls === 'boolean' ? hasTools === when.hasToolCalls : true;
-                if (matchRole && matchTools) {
-                    if (rule.action === 'drop') {
-                        dropped = true;
-                        break;
-                    }
-                    if (rule.action === 'set' && rule.set && typeof rule.set === 'object') {
-                        Object.assign(message, rule.set);
-                    }
-                }
-            }
-            if (!dropped) {
-                result.push(message);
-            }
-        }
-        return result;
-    }
-    pairToolResults(messages) {
-        const nameById = new Map();
-        for (const message of messages) {
-            if (message.role === 'assistant' && hasArrayItems(message.tool_calls)) {
-                for (const call of message.tool_calls) {
-                    const toolCall = toRecord(call);
-                    if (typeof toolCall.id !== 'string') {
-                        continue;
-                    }
-                    const fn = toRecord(toolCall.function);
-                    if (typeof fn.name === 'string') {
-                        nameById.set(toolCall.id, fn.name);
-                    }
-                }
-            }
-        }
-        for (const message of messages) {
-            if (message.role !== 'tool') {
-                continue;
-            }
-            const name = typeof message.name === 'string' ? message.name.trim() : '';
-            if (name) {
-                continue;
-            }
-            const toolCallId = typeof message.tool_call_id === 'string' ? message.tool_call_id : undefined;
-            if (toolCallId && nameById.has(toolCallId)) {
-                message.name = nameById.get(toolCallId);
-            }
-        }
-    }
-    normalizeTools(container, requestCfg) {
-        if (!Array.isArray(container.tools)) {
-            return;
-        }
-        if (!requestCfg.tools?.normalize) {
-            if (requestCfg.tools?.forceToolChoiceAuto) {
-                container.tool_choice = 'auto';
-            }
-            return;
-        }
-        const normalized = [];
-        for (const toolEntry of container.tools) {
-            const normalizedTool = this.normalizeSingleTool(toolEntry);
-            normalized.push(normalizedTool);
-        }
-        container.tools = normalized;
-        if (requestCfg.tools?.forceToolChoiceAuto) {
-            container.tool_choice = 'auto';
-        }
-    }
-    normalizeSingleTool(toolEntry) {
-        const tool = toRecord(toolEntry);
-        const fnTop = {
-            name: typeof tool.name === 'string' ? tool.name : undefined,
-            description: typeof tool.description === 'string' ? tool.description : undefined,
-            parameters: tool.parameters
-        };
-        const fn = toRecord(tool.function);
-        const name = typeof fn.name === 'string' ? fn.name : fnTop.name;
-        const description = typeof fn.description === 'string' ? fn.description : fnTop.description;
-        let parameters = fn.parameters !== undefined ? fn.parameters : fnTop.parameters;
-        parameters = this.normalizeToolParameters(parameters, name);
-        const normalizedFn = {
-            ...(name ? { name } : {}),
-            ...(description ? { description } : {})
-        };
-        if (parameters !== undefined) {
-            normalizedFn.parameters = parameters;
-        }
-        return {
-            type: 'function',
-            function: normalizedFn
-        };
-    }
-    normalizeToolParameters(input, name) {
-        if (input === null || input === undefined) {
-            return undefined;
-        }
-        let params;
-        if (typeof input === 'string') {
-            try {
-                params = JSON.parse(input);
-            }
-            catch {
-                params = undefined;
-            }
-        }
-        else if (isRecord(input)) {
-            params = input;
-        }
-        if (!params) {
-            return undefined;
-        }
-        if (name && name.trim().toLowerCase() === 'shell') {
-            return this.enforceShellSchema(params);
-        }
-        return params;
-    }
-    enforceShellSchema(schema) {
-        const next = { ...schema };
-        if (typeof next.type !== 'string') {
-            next.type = 'object';
-        }
-        if (!isRecord(next.properties)) {
-            next.properties = {};
-        }
-        const props = next.properties;
-        const command = toRecord(props.command);
-        const hasOneOf = Array.isArray(command.oneOf);
-        if (!hasOneOf) {
-            const descText = typeof command.description === 'string'
-                ? command.description
-                : 'Shell command. Prefer a single string; an array of argv tokens is also accepted.';
-            props.command = {
-                description: descText,
-                oneOf: [
-                    { type: 'string' },
-                    { type: 'array', items: { type: 'string' } }
-                ]
-            };
-            const requiredList = Array.isArray(next.required)
-                ? next.required.filter((item) => typeof item === 'string')
-                : [];
-            if (!requiredList.includes('command')) {
-                requiredList.push('command');
-            }
-            next.required = requiredList;
-            if (typeof next.additionalProperties !== 'boolean') {
-                next.additionalProperties = false;
-            }
-        }
-        return next;
-    }
-    cleanupToolChoice(container) {
-        const toolsArray = Array.isArray(container.tools) ? container.tools : [];
-        if (!toolsArray.length && Object.prototype.hasOwnProperty.call(container, 'tool_choice')) {
-            delete container.tool_choice;
-        }
-    }
-    normalizeResponseChoice(choice, idx, responseCfg) {
-        const choiceRecord = toRecord(choice);
-        const normalized = {
-            index: typeof choiceRecord.index === 'number' ? choiceRecord.index : idx
-        };
-        const message = toRecord(choiceRecord.message);
-        normalized.message = this.normalizeResponseMessage(message, responseCfg);
-        const hasToolCalls = hasArrayItems(normalized.message.tool_calls);
-        normalized.finish_reason = choiceRecord.finish_reason ?? (hasToolCalls ? 'tool_calls' : null);
-        return normalized;
-    }
-    normalizeResponseMessage(message, responseCfg) {
-        const normalized = {};
-        normalized.role = typeof message.role === 'string'
-            ? message.role
-            : (responseCfg.choices.message.roleDefault || 'assistant');
-        if (hasArrayItems(message.tool_calls)) {
-            normalized.tool_calls = this.normalizeResponseToolCalls(message.tool_calls, responseCfg);
-            normalized.content = responseCfg.choices.message.contentNullWhenToolCalls ? null : message.content ?? '';
-        }
-        else {
-            normalized.content = message.content ?? '';
-        }
-        if (typeof message.reasoning_content === 'string') {
-            normalized.reasoning_content = message.reasoning_content;
-        }
-        if (message.audio) {
-            normalized.audio = message.audio;
-        }
-        return normalized;
-    }
-    normalizeResponseToolCalls(toolCalls, responseCfg) {
-        const entries = toArray(toolCalls);
-        return entries.map(call => {
-            const tc = toRecord(call);
-            const fn = toRecord(tc.function);
-            const name = typeof fn.name === 'string' ? fn.name : undefined;
-            const argsObject = this.toObjectArgs(fn.arguments);
-            const argsValue = responseCfg.choices.message.tool_calls?.function?.argumentsType === 'string'
-                ? this.toStringArgs(argsObject)
-                : argsObject;
-            const normalized = {
-                type: typeof tc.type === 'string' ? tc.type : 'function',
-                function: { ...(name ? { name } : {}), arguments: argsValue }
-            };
-            if (typeof tc.id === 'string') {
-                normalized.id = tc.id;
-            }
-            return normalized;
-        });
+        return applyUniversalShapeResponseFilterWithNative(payload, this.cfg, buildNativeReqOutboundCompatAdapterContext(ctx));
     }
 }

package/dist/conversion/hub/pipeline/compat/native-adapter-context.js

@@ -31,6 +31,7 @@ export function buildNativeReqOutboundCompatAdapterContext(adapterContext) {
         routeId: readString('routeId') ?? adapterContext?.routeId,
         capturedChatRequest: readRecord('capturedChatRequest'),
         deepseek: readRecord('deepseek'),
+        claudeCode: readRecord('claudeCode'),
         estimatedInputTokens: readNumber('estimatedInputTokens'),
         modelId: readString('modelId'),
         clientModelId: readString('clientModelId'),

package/dist/conversion/pipeline/codecs/v2/anthropic-openai-pipeline.d.ts

@@ -2,9 +2,8 @@ import type { ConversionCodec, ConversionContext, ConversionProfile } from '../.
 import type { JsonObject } from '../../../hub/types/json.js';
 export declare class AnthropicOpenAIPipelineCodec implements ConversionCodec {
     readonly id = "anthropic-openai-v2";
-    private readonly pipeline;
+    private readonly requestMetaStore;
     private initialized;
-    constructor();
     initialize(): Promise<void>;
     private ensureInitialized;
     convertRequest(payload: unknown, profile: ConversionProfile, context: ConversionContext): Promise<JsonObject>;

package/dist/conversion/pipeline/codecs/v2/anthropic-openai-pipeline.js

@@ -1,10 +1,10 @@
-import { ProtocolConversionPipeline } from '../../index.js';
-import { chatEnvelopeToStandardized } from '../../../hub/standardized-bridge.js';
-import { AnthropicFormatAdapter } from '../../../hub/format-adapters/anthropic-format-adapter.js';
-import { AnthropicSemanticMapper } from '../../../hub/semantic-mappers/anthropic-mapper.js';
-import { buildAnthropicFromOpenAIChat } from '../../../codecs/anthropic-openai-codec.js';
 import { buildAdapterContextFromPipeline } from '../../hooks/adapter-context.js';
 import { runStandardChatRequestFilters } from '../../../index.js';
+import { buildAnthropicFromOpenAIChat } from '../../../codecs/anthropic-openai-codec.js';
+import { buildOpenAIChatFromAnthropicWithNative } from '../../../../router/virtual-router/engine-selection/native-compat-action-semantics.js';
+import { chatEnvelopeToStandardizedWithNative } from '../../../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';
+import { parseReqInboundFormatEnvelopeWithNative } from '../../../../router/virtual-router/engine-selection/native-hub-pipeline-edge-stage-semantics.js';
+import { mapOpenaiChatToChatWithNative } from '../../../../router/virtual-router/engine-selection/native-hub-pipeline-semantic-mappers.js';
 import { canonicalizeOpenAIChatResponse, convertStandardizedToOpenAIChat as convertCanonicalToOpenAIChat, OPENAI_PROTOCOL } from './shared/openai-chat-helpers.js';
 const DEFAULT_ANTHROPIC_ENDPOINT = '/v1/messages';
 const ANTHROPIC_PROTOCOL = 'anthropic-messages';
@@ -14,93 +14,22 @@ function assertJsonObject(value, stage) {
     }
     return value;
 }
-function coerceAliasMap(candidate) {
+function normalizeAliasMap(candidate) {
     if (!candidate || typeof candidate !== 'object' || Array.isArray(candidate)) {
         return undefined;
     }
-    let populated = false;
-    const result = {};
+    const out = {};
     for (const [key, value] of Object.entries(candidate)) {
-        if (typeof key !== 'string' || typeof value !== 'string')
+        if (typeof key !== 'string' || typeof value !== 'string') {
             continue;
-        const trimmedKey = key.trim();
-        if (!trimmedKey.length)
+        }
+        const trimmed = key.trim();
+        if (!trimmed) {
             continue;
-        result[trimmedKey] = value;
-        populated = true;
-    }
-    return populated ? result : undefined;
-}
-function readAliasMapFromSemantics(semantics) {
-    if (!semantics || typeof semantics !== 'object' || Array.isArray(semantics)) {
-        return undefined;
-    }
-    const toolsNode = semantics.tools;
-    if (!toolsNode || typeof toolsNode !== 'object' || Array.isArray(toolsNode)) {
-        return undefined;
-    }
-    const candidate = toolsNode.toolNameAliasMap ??
-        toolsNode.toolAliasMap;
-    return coerceAliasMap(candidate);
-}
-function ensureAliasMapInSemantics(chatEnvelope, aliasMap) {
-    if (!chatEnvelope || typeof chatEnvelope !== 'object') {
-        return;
-    }
-    const semantics = chatEnvelope.semantics && typeof chatEnvelope.semantics === 'object' && !Array.isArray(chatEnvelope.semantics)
-        ? chatEnvelope.semantics
-        : (() => {
-            chatEnvelope.semantics = {};
-            return chatEnvelope.semantics;
-        })();
-    const toolsNode = semantics.tools && typeof semantics.tools === 'object' && !Array.isArray(semantics.tools)
-        ? semantics.tools
-        : (() => {
-            semantics.tools = {};
-            return semantics.tools;
-        })();
-    if (!toolsNode.toolNameAliasMap && !toolsNode.toolAliasMap) {
-        toolsNode.toolNameAliasMap = { ...aliasMap };
-    }
-}
-function createAnthropicHooks() {
-    const formatAdapter = new AnthropicFormatAdapter();
-    const semanticMapper = new AnthropicSemanticMapper();
-    return {
-        id: 'anthropic-openai-v2',
-        protocol: ANTHROPIC_PROTOCOL,
-        inbound: {
-            parse: async ({ wire, context }) => {
-                const adapterContext = buildAdapterContextFromPipeline(context, {
-                    defaultEntryEndpoint: DEFAULT_ANTHROPIC_ENDPOINT,
-                    overrideProtocol: ANTHROPIC_PROTOCOL
-                });
-                const formatEnvelope = await formatAdapter.parseRequest(wire, adapterContext);
-                const chatEnvelope = await semanticMapper.toChat(formatEnvelope, adapterContext);
-                const aliasMap = readAliasMapFromSemantics(chatEnvelope.semantics);
-                if (aliasMap) {
-                    // A1: tool alias map is mappable semantics; keep it in chat.semantics (never metadata).
-                    ensureAliasMapInSemantics(chatEnvelope, aliasMap);
-                }
-                const canonical = chatEnvelopeToStandardized(chatEnvelope, {
-                    adapterContext,
-                    endpoint: context.entryEndpoint ?? DEFAULT_ANTHROPIC_ENDPOINT,
-                    requestId: context.requestId
-                });
-                return { canonical };
-            }
-        },
-        outbound: {
-            serialize: async ({ canonical, context }) => {
-                const aliasMap = readAliasMapFromSemantics(canonical.semantics);
-                const anthropicPayload = buildAnthropicFromOpenAIChat(canonical, {
-                    toolNameMap: aliasMap,
-                    requestId: context.requestId
-                });
-                return { payload: assertJsonObject(anthropicPayload, 'anthropic_outbound_serialize') };
-            }
         }
-    };
+        out[trimmed] = value;
+    }
+    return Object.keys(out).length ? out : undefined;
 }
 function buildPipelineContext(profile, context) {
     return {
@@ -115,11 +44,8 @@ function buildPipelineContext(profile, context) {
 }
 export class AnthropicOpenAIPipelineCodec {
     id = 'anthropic-openai-v2';
-    pipeline;
+    requestMetaStore = new Map();
     initialized = false;
-    constructor() {
-        this.pipeline = new ProtocolConversionPipeline(createAnthropicHooks());
-    }
     async initialize() {
         this.initialized = true;
     }
@@ -131,28 +57,48 @@ export class AnthropicOpenAIPipelineCodec {
     async convertRequest(payload, profile, context) {
         this.ensureInitialized();
         const inboundContext = buildPipelineContext(profile, context);
-        const inboundOptions = {
-            payload: assertJsonObject(payload, 'anthropic_inbound_request'),
-            context: inboundContext
-        };
-        const inbound = await this.pipeline.convertInbound(inboundOptions);
-        const openaiPayload = await convertCanonicalToOpenAIChat(inbound.canonical, inbound.context);
+        const requestId = context.requestId ?? inboundContext.requestId ?? `req_${Date.now()}`;
+        inboundContext.requestId = requestId;
+        const adapterContext = buildAdapterContextFromPipeline(inboundContext, {
+            defaultEntryEndpoint: DEFAULT_ANTHROPIC_ENDPOINT,
+            overrideProtocol: ANTHROPIC_PROTOCOL
+        });
+        const native = buildOpenAIChatFromAnthropicWithNative(assertJsonObject(payload, 'anthropic_inbound_request'), { includeToolCallIds: true });
+        const openaiRequest = assertJsonObject(native.request, 'anthropic_request_native');
+        const aliasMap = normalizeAliasMap(native.anthropicToolNameMap);
+        this.requestMetaStore.set(requestId, { aliasMap });
+        const formatEnvelope = parseReqInboundFormatEnvelopeWithNative({
+            rawRequest: openaiRequest,
+            protocol: OPENAI_PROTOCOL
+        });
+        const chatEnvelope = mapOpenaiChatToChatWithNative((formatEnvelope.payload ?? {}), adapterContext);
+        const canonical = chatEnvelopeToStandardizedWithNative({
+            chatEnvelope,
+            adapterContext: adapterContext,
+            endpoint: adapterContext.entryEndpoint ?? DEFAULT_ANTHROPIC_ENDPOINT,
+            requestId
+        });
+        const rebuilt = await convertCanonicalToOpenAIChat(canonical, inboundContext, { defaultEndpoint: DEFAULT_ANTHROPIC_ENDPOINT });
         const filterContext = {
             ...context,
-            requestId: context.requestId ?? inbound.context.requestId ?? `req_${Date.now()}`,
+            requestId,
             entryEndpoint: context.entryEndpoint ?? context.endpoint ?? DEFAULT_ANTHROPIC_ENDPOINT,
             endpoint: context.endpoint ?? context.entryEndpoint ?? DEFAULT_ANTHROPIC_ENDPOINT
         };
-        return runStandardChatRequestFilters(openaiPayload, profile, filterContext);
+        return runStandardChatRequestFilters(rebuilt, profile, filterContext);
     }
     async convertResponse(payload, profile, context) {
         this.ensureInitialized();
-        const sanitized = await canonicalizeOpenAIChatResponse(assertJsonObject(payload, 'openai_chat_response'), context);
-        const outboundOptions = {
-            canonical: sanitized,
-            context: buildPipelineContext(profile, context)
-        };
-        const outbound = await this.pipeline.convertOutbound(outboundOptions);
-        return outbound.payload;
+        const pipelineContext = buildPipelineContext(profile, context);
+        const requestId = context.requestId ?? pipelineContext.requestId ?? `req_${Date.now()}`;
+        pipelineContext.requestId = requestId;
+        const stored = this.requestMetaStore.get(requestId);
+        this.requestMetaStore.delete(requestId);
+        const sanitized = await canonicalizeOpenAIChatResponse(assertJsonObject(payload, 'openai_chat_response'), context, { defaultEndpoint: DEFAULT_ANTHROPIC_ENDPOINT, profile: ANTHROPIC_PROTOCOL });
+        return assertJsonObject(buildAnthropicFromOpenAIChat(sanitized, {
+            toolNameMap: stored?.aliasMap,
+            requestId,
+            entryEndpoint: pipelineContext.entryEndpoint ?? DEFAULT_ANTHROPIC_ENDPOINT
+        }), 'anthropic_outbound_serialize');
     }
 }

package/dist/conversion/pipeline/codecs/v2/openai-openai-pipeline.js

@@ -1,9 +1,9 @@
 import { ProtocolConversionPipeline } from '../../index.js';
 import { buildAdapterContextFromPipeline } from '../../hooks/adapter-context.js';
-import { chatEnvelopeToStandardized } from '../../../hub/standardized-bridge.js';
-import { ChatFormatAdapter } from '../../../hub/format-adapters/chat-format-adapter.js';
-import { ChatSemanticMapper } from '../../../hub/semantic-mappers/chat-mapper.js';
 import { runStandardChatRequestFilters } from '../../../index.js';
+import { chatEnvelopeToStandardizedWithNative } from '../../../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';
+import { parseReqInboundFormatEnvelopeWithNative } from '../../../../router/virtual-router/engine-selection/native-hub-pipeline-edge-stage-semantics.js';
+import { mapOpenaiChatToChatWithNative } from '../../../../router/virtual-router/engine-selection/native-hub-pipeline-semantic-mappers.js';
 import { canonicalizeOpenAIChatResponse, convertStandardizedToOpenAIChat as convertCanonicalToOpenAIChat, DEFAULT_OPENAI_ENDPOINT, OPENAI_PROTOCOL } from './shared/openai-chat-helpers.js';
 function assertJsonObject(value, stage) {
     if (!value || typeof value !== 'object' || Array.isArray(value)) {
@@ -58,8 +58,6 @@ function restoreToolCallIndexes(targetMessages, sourceMessages) {
     }
 }
 function createOpenAIHooks() {
-    const formatAdapter = new ChatFormatAdapter();
-    const semanticMapper = new ChatSemanticMapper();
     return {
         id: 'openai-openai-v2',
         protocol: OPENAI_PROTOCOL,
@@ -69,14 +67,18 @@ function createOpenAIHooks() {
                     defaultEntryEndpoint: DEFAULT_OPENAI_ENDPOINT,
                     overrideProtocol: OPENAI_PROTOCOL
                 });
-                const formatEnvelope = await formatAdapter.parseRequest(wire, adapterContext);
-                const chatEnvelope = await semanticMapper.toChat(formatEnvelope, adapterContext);
-                const canonical = chatEnvelopeToStandardized(chatEnvelope, {
-                    adapterContext,
+                const formatEnvelope = parseReqInboundFormatEnvelopeWithNative({
+                    rawRequest: wire,
+                    protocol: OPENAI_PROTOCOL
+                });
+                const chatEnvelope = mapOpenaiChatToChatWithNative((formatEnvelope.payload ?? {}), adapterContext);
+                const canonical = chatEnvelopeToStandardizedWithNative({
+                    chatEnvelope: chatEnvelope,
+                    adapterContext: adapterContext,
                     endpoint: adapterContext.entryEndpoint ?? DEFAULT_OPENAI_ENDPOINT,
                     requestId: adapterContext.requestId
                 });
-                return { canonical };
+                return { canonical: canonical };
             }
         },
         outbound: {

package/dist/conversion/pipeline/codecs/v2/responses-openai-pipeline.d.ts

@@ -2,10 +2,8 @@ import type { ConversionCodec, ConversionContext, ConversionProfile } from '../.
 import type { JsonObject } from '../../../hub/types/json.js';
 export declare class ResponsesOpenAIPipelineCodec implements ConversionCodec {
     readonly id = "responses-openai-v2";
-    private readonly pipeline;
     private readonly requestMetaStore;
     private initialized;
-    constructor();
     initialize(): Promise<void>;
     private ensureInitialized;
     private stashMeta;