@jsonstudio/rcc 0.90.352 → 0.90.367

package/vendor/llmswitch-core/dist/conversion/hub/types/chat-schema.d.ts

@@ -0,0 +1,112 @@
+import type { JsonObject, JsonValue } from './json.js';
+export type ChatHubVersion = 'chat-hub@1';
+export interface ConversationReference {
+    readonly id?: string;
+    readonly parentIds?: readonly string[];
+    readonly metadata?: JsonObject;
+}
+export interface InstructionSegment {
+    readonly id?: string;
+    readonly source: string;
+    readonly content: string;
+    readonly metadata?: JsonObject;
+}
+export interface InstructionsEnvelope {
+    readonly segments: readonly InstructionSegment[];
+}
+export type MessageRole = 'system' | 'user' | 'assistant' | 'tool';
+interface BaseContentBlock {
+    readonly type: string;
+    readonly metadata?: JsonObject;
+}
+export interface TextContentBlock extends BaseContentBlock {
+    readonly type: 'text';
+    readonly text: string;
+    readonly annotations?: readonly JsonObject[];
+}
+export interface ImageContentBlock extends BaseContentBlock {
+    readonly type: 'image';
+    readonly mimeType?: string;
+    readonly data?: string;
+    readonly uri?: string;
+}
+export interface AudioContentBlock extends BaseContentBlock {
+    readonly type: 'audio';
+    readonly mimeType?: string;
+    readonly data?: string;
+    readonly uri?: string;
+}
+export interface DataContentBlock extends BaseContentBlock {
+    readonly type: 'data';
+    readonly mimeType?: string;
+    readonly value: JsonValue;
+}
+export interface ToolCallContentBlock extends BaseContentBlock {
+    readonly type: 'tool_call';
+    readonly toolCallId: string;
+    readonly name: string;
+    readonly arguments: JsonObject;
+}
+export interface ToolResultContentBlock extends BaseContentBlock {
+    readonly type: 'tool_result';
+    readonly toolCallId: string;
+    readonly output: readonly TextContentBlock[];
+    readonly isError?: boolean;
+}
+export type ChatContentBlock = TextContentBlock | ImageContentBlock | AudioContentBlock | DataContentBlock | ToolCallContentBlock | ToolResultContentBlock;
+export interface ChatMessage {
+    readonly id?: string;
+    readonly role: MessageRole;
+    readonly name?: string;
+    readonly content: readonly ChatContentBlock[];
+    readonly metadata?: JsonObject;
+}
+export interface ChatToolDefinition {
+    readonly id?: string;
+    readonly type: 'function' | string;
+    readonly name: string;
+    readonly description?: string;
+    readonly parameters?: JsonObject;
+    readonly strict?: boolean;
+    readonly metadata?: JsonObject;
+}
+export interface ChatAttachment {
+    readonly id: string;
+    readonly kind: 'file' | 'image' | 'audio';
+    readonly uri?: string;
+    readonly mimeType?: string;
+    readonly metadata?: JsonObject;
+}
+export interface ChatGenerationConfig {
+    readonly temperature?: number;
+    readonly topP?: number;
+    readonly topK?: number;
+    readonly maxOutputTokens?: number;
+    readonly stopSequences?: readonly string[];
+    readonly stream?: boolean;
+    readonly parallelToolCalls?: boolean;
+    readonly responseFormat?: JsonObject;
+    readonly metadata?: JsonObject;
+}
+export interface DetourEntry {
+    readonly path: string;
+    readonly value?: JsonValue;
+    readonly reason: string;
+    readonly stage: string;
+}
+export interface DetourState {
+    readonly inbound: readonly DetourEntry[];
+    readonly outbound: readonly DetourEntry[];
+}
+export interface ChatHubEnvelope {
+    readonly version: ChatHubVersion;
+    readonly conversation?: ConversationReference;
+    readonly instructions?: InstructionsEnvelope;
+    readonly messages: readonly ChatMessage[];
+    readonly tools?: readonly ChatToolDefinition[];
+    readonly config?: ChatGenerationConfig;
+    readonly attachments?: readonly ChatAttachment[];
+    readonly detours?: DetourState;
+    readonly metadata?: JsonObject;
+}
+export {};

package/vendor/llmswitch-core/dist/conversion/hub/types/chat-schema.js

@@ -0,0 +1 @@
+export {};

package/vendor/llmswitch-core/dist/conversion/hub/types/errors.d.ts

@@ -0,0 +1,5 @@
+export declare class ConversionError extends Error {
+    readonly nodeId?: string;
+    readonly stage?: string;
+    constructor(message: string, nodeId?: string, stage?: string, cause?: Error);
+}

package/vendor/llmswitch-core/dist/conversion/hub/types/errors.js

@@ -0,0 +1,13 @@
+export class ConversionError extends Error {
+    nodeId;
+    stage;
+    constructor(message, nodeId, stage, cause) {
+        super(message);
+        this.name = 'ConversionError';
+        this.nodeId = nodeId;
+        this.stage = stage;
+        if (cause) {
+            this.cause = cause;
+        }
+    }
+}

package/vendor/llmswitch-core/dist/conversion/hub/types/format-envelope.d.ts

@@ -0,0 +1,7 @@
+import type { JsonObject } from './json.js';
+export interface FormatEnvelope<TPayload extends JsonObject = JsonObject> {
+    protocol: string;
+    direction: 'request' | 'response';
+    payload: TPayload;
+    meta?: JsonObject;
+}

package/vendor/llmswitch-core/dist/conversion/hub/types/format-envelope.js

@@ -0,0 +1 @@
+export {};

package/vendor/llmswitch-core/dist/conversion/hub/types/index.d.ts

@@ -0,0 +1,6 @@
+export * from './chat-envelope.js';
+export * from './format-envelope.js';
+export * from './json.js';
+export * from './standardized.js';
+export * from './errors.js';
+export * from './node.js';

package/vendor/llmswitch-core/dist/conversion/hub/types/index.js

@@ -0,0 +1,6 @@
+export * from './chat-envelope.js';
+export * from './format-envelope.js';
+export * from './json.js';
+export * from './standardized.js';
+export * from './errors.js';
+export * from './node.js';

package/vendor/llmswitch-core/dist/conversion/hub/types/json.d.ts

@@ -0,0 +1,9 @@
+export type JsonPrimitive = string | number | boolean | null;
+export type JsonValue = JsonPrimitive | JsonValue[] | JsonObject;
+export interface JsonObject {
+    [key: string]: JsonValue;
+}
+export type JsonArray = JsonValue[];
+export declare function isJsonObject(value: JsonValue | null | undefined): value is JsonObject;
+export declare function isJsonArray(value: JsonValue | null | undefined): value is JsonArray;
+export declare function jsonClone<T extends JsonValue>(value: T): T;

package/vendor/llmswitch-core/dist/conversion/hub/types/json.js

@@ -0,0 +1,9 @@
+export function isJsonObject(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+export function isJsonArray(value) {
+    return Array.isArray(value);
+}
+export function jsonClone(value) {
+    return JSON.parse(JSON.stringify(value));
+}

package/vendor/llmswitch-core/dist/conversion/hub/types/node.d.ts

@@ -0,0 +1,31 @@
+import type { JsonObject } from './json.js';
+export interface HubNodeRequestContext {
+    id: string;
+    endpoint: string;
+    context?: Record<string, unknown>;
+}
+export interface HubNodeContext {
+    request: HubNodeRequestContext;
+}
+export interface HubNodeResult {
+    success: boolean;
+    data?: Record<string, unknown>;
+    error?: {
+        code: string;
+        message: string;
+        details?: JsonObject;
+        cause?: Error;
+    };
+    metadata: {
+        node: string;
+        executionTime: number;
+        startTime: number;
+        endTime: number;
+        dataProcessed?: {
+            messages?: number;
+            tools?: number;
+            tokens?: number;
+            responseSize?: number;
+        };
+    };
+}

package/vendor/llmswitch-core/dist/conversion/hub/types/node.js

@@ -0,0 +1 @@
+export {};

package/vendor/llmswitch-core/dist/conversion/hub/types/standardized.d.ts

@@ -0,0 +1,99 @@
+import type { ChatMessageContentPart, ChatSemantics } from './chat-envelope.js';
+import type { JsonObject } from './json.js';
+export type ToolChoice = 'none' | 'auto' | 'required' | {
+    type: 'function';
+    function: {
+        name: string;
+    };
+} | Record<string, unknown>;
+export interface StandardizedTool {
+    type: 'function';
+    function: {
+        name: string;
+        description?: string;
+        parameters: {
+            type?: string | string[];
+            properties?: Record<string, unknown>;
+            required?: string[];
+            additionalProperties?: boolean;
+            [key: string]: unknown;
+        };
+        strict?: boolean;
+    };
+}
+export interface ToolCall {
+    id: string;
+    type: 'function';
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+export interface ToolCallResult {
+    tool_call_id: string;
+    status: 'success' | 'error' | 'timeout' | 'pending';
+    result?: JsonObject | JsonObject[] | string | number | boolean | null;
+    error?: string;
+    executionTime?: number;
+}
+export type StandardizedMessageContent = string | ChatMessageContentPart[] | null;
+export interface StandardizedMessage {
+    role: 'system' | 'user' | 'assistant' | 'tool';
+    content: StandardizedMessageContent;
+    tool_calls?: ToolCall[];
+    tool_call_id?: string;
+    name?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface StandardizedParameters {
+    temperature?: number;
+    max_tokens?: number;
+    top_p?: number;
+    frequency_penalty?: number;
+    presence_penalty?: number;
+    stop?: string | string[];
+    stream?: boolean;
+    [key: string]: unknown;
+}
+export interface StandardizedMetadata {
+    originalEndpoint: string;
+    capturedContext?: Record<string, unknown>;
+    requestId?: string;
+    stream?: boolean;
+    toolChoice?: ToolChoice;
+    providerKey?: string;
+    providerType?: string;
+    processMode?: 'chat' | 'passthrough';
+    routeHint?: string;
+    webSearchEnabled?: boolean;
+    [key: string]: unknown;
+}
+export interface StandardizedRequest {
+    model: string;
+    messages: StandardizedMessage[];
+    tools?: StandardizedTool[];
+    parameters: StandardizedParameters;
+    metadata: StandardizedMetadata;
+    semantics?: ChatSemantics;
+}
+export interface ProcessedRequest extends StandardizedRequest {
+    processed: {
+        timestamp: number;
+        appliedRules: string[];
+        status: 'success' | 'partial' | 'failed';
+    };
+    processingMetadata: {
+        toolCalls?: ToolCallResult[];
+        streaming?: {
+            enabled: boolean;
+            chunkCount?: number;
+            totalTokens?: number;
+        };
+        context?: {
+            systemPrompt?: string;
+            conversationHistory?: string[];
+            relevantContext?: Record<string, unknown>;
+        };
+        passthrough?: boolean;
+    };
+}

package/vendor/llmswitch-core/dist/conversion/hub/types/standardized.js

@@ -0,0 +1 @@
+export {};

package/vendor/llmswitch-core/dist/conversion/index.d.ts

@@ -0,0 +1,33 @@
+export * from './types.js';
+export * from './schema-validator.js';
+export * from './codec-registry.js';
+export * from './hub/node-support.js';
+export * from './hub/standardized-bridge.js';
+export * from './hub/registry.js';
+export * from './hub/pipelines/inbound.js';
+export * from './hub/pipelines/outbound.js';
+export * from './hub/response/provider-response.js';
+export * from './hub/response/response-runtime.js';
+export * from './hub/pipeline/hub-pipeline.js';
+export * from './hub/format-adapters/index.js';
+export * from './hub/semantic-mappers/index.js';
+export * from './hub/types/index.js';
+export * from './hub/hub-feature.js';
+export { normalizeChatRequest } from './shared/openai-message-normalize.js';
+export { runStandardChatRequestFilters } from './shared/chat-request-filters.js';
+export * from './shared/tooling.js';
+export * from '../guidance/index.js';
+export * from './shared/tool-mapping.js';
+export * from './shared/reasoning-mapping.js';
+export * from './args-mapping.js';
+export * from './shared/text-markup-normalizer.js';
+export * from './shared/tool-governor.js';
+export { governTools } from './shared/tool-governor.js';
+export * from './shared/streaming-text-extractor.js';
+export * from './shared/tool-harvester.js';
+export * from './responses/responses-openai-bridge.js';
+export { ProtocolConversionPipeline, PipelineValidationError, type ProtocolInboundPipelineOptions, type ProtocolInboundPipelineResult, type ProtocolOutboundPipelineOptions, type ProtocolOutboundPipelineResult } from './pipeline/index.js';
+export * from './pipeline/schema/index.js';
+export * from './pipeline/hooks/protocol-hooks.js';
+export * from './pipeline/hooks/adapter-context.js';
+export * from './pipeline/meta/meta-bag.js';

package/vendor/llmswitch-core/dist/conversion/index.js

@@ -0,0 +1,33 @@
+export * from './types.js';
+export * from './schema-validator.js';
+export * from './codec-registry.js';
+export * from './hub/node-support.js';
+export * from './hub/standardized-bridge.js';
+export * from './hub/registry.js';
+export * from './hub/pipelines/inbound.js';
+export * from './hub/pipelines/outbound.js';
+export * from './hub/response/provider-response.js';
+export * from './hub/response/response-runtime.js';
+export * from './hub/pipeline/hub-pipeline.js';
+export * from './hub/format-adapters/index.js';
+export * from './hub/semantic-mappers/index.js';
+export * from './hub/types/index.js';
+export * from './hub/hub-feature.js';
+export { normalizeChatRequest } from './shared/openai-message-normalize.js';
+export { runStandardChatRequestFilters } from './shared/chat-request-filters.js';
+export * from './shared/tooling.js';
+export * from '../guidance/index.js';
+export * from './shared/tool-mapping.js';
+export * from './shared/reasoning-mapping.js';
+export * from './args-mapping.js';
+export * from './shared/text-markup-normalizer.js';
+export * from './shared/tool-governor.js';
+export { governTools } from './shared/tool-governor.js';
+export * from './shared/streaming-text-extractor.js';
+export * from './shared/tool-harvester.js';
+export * from './responses/responses-openai-bridge.js';
+export { ProtocolConversionPipeline, PipelineValidationError } from './pipeline/index.js';
+export * from './pipeline/schema/index.js';
+export * from './pipeline/hooks/protocol-hooks.js';
+export * from './pipeline/hooks/adapter-context.js';
+export * from './pipeline/meta/meta-bag.js';

package/vendor/llmswitch-core/dist/conversion/jsonish.d.ts

@@ -0,0 +1,3 @@
+export declare function tryParseJson<T = unknown>(s: unknown): T | unknown;
+export declare function parseLenient(value: unknown): unknown;
+export declare function repairArgumentsToString(value: unknown): string;

package/vendor/llmswitch-core/dist/conversion/jsonish.js

@@ -0,0 +1,20 @@
+// Shared JSON-ish parsing helpers
+import { parseLenientJsonishWithNative, repairArgumentsToStringWithNative } from '../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+export function tryParseJson(s) {
+    if (typeof s !== 'string')
+        return s;
+    try {
+        return JSON.parse(s);
+    }
+    catch {
+        return s;
+    }
+}
+// Lenient parsing for function.arguments often produced by models
+export function parseLenient(value) {
+    return parseLenientJsonishWithNative(value);
+}
+// CCR-style repair: JSON -> JSON5-like cleanup -> safe fallback
+export function repairArgumentsToString(value) {
+    return repairArgumentsToStringWithNative(value);
+}

package/vendor/llmswitch-core/dist/conversion/mcp-injection.d.ts

@@ -0,0 +1,2 @@
+export declare function injectMcpToolsForChat(tools: any[] | undefined, discoveredServers: string[]): any[];
+export declare function injectMcpToolsForResponses(tools: any[] | undefined, discoveredServers: string[]): any[];

package/vendor/llmswitch-core/dist/conversion/mcp-injection.js

@@ -0,0 +1,7 @@
+import { injectMcpToolsForChatWithNative, injectMcpToolsForResponsesWithNative } from '../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+export function injectMcpToolsForChat(tools, discoveredServers) {
+    return injectMcpToolsForChatWithNative(tools, discoveredServers);
+}
+export function injectMcpToolsForResponses(tools, discoveredServers) {
+    return injectMcpToolsForResponsesWithNative(tools, discoveredServers);
+}

package/vendor/llmswitch-core/dist/conversion/media.d.ts

@@ -0,0 +1 @@
+export declare function isImagePath(p: unknown): boolean;

package/vendor/llmswitch-core/dist/conversion/media.js

@@ -0,0 +1,4 @@
+import { isImagePathWithNative } from '../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+export function isImagePath(p) {
+    return isImagePathWithNative(p);
+}

package/vendor/llmswitch-core/dist/conversion/metadata-passthrough.d.ts

@@ -0,0 +1,11 @@
+import { type JsonObject, type JsonValue } from './hub/types/json.js';
+interface PassthroughOptions {
+    prefix: string;
+    keys: readonly string[];
+}
+export declare function encodeMetadataPassthrough(parameters: JsonObject | undefined, options: PassthroughOptions): Record<string, string> | undefined;
+export declare function extractMetadataPassthrough(metadataField: JsonValue | undefined, options: PassthroughOptions): {
+    metadata?: JsonObject;
+    passthrough?: JsonObject;
+};
+export {};

package/vendor/llmswitch-core/dist/conversion/metadata-passthrough.js

@@ -0,0 +1,20 @@
+import { isJsonObject, jsonClone } from './hub/types/json.js';
+import { encodeMetadataPassthroughWithNative, extractMetadataPassthroughWithNative } from '../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+export function encodeMetadataPassthrough(parameters, options) {
+    return encodeMetadataPassthroughWithNative(parameters, options.prefix, options.keys);
+}
+export function extractMetadataPassthrough(metadataField, options) {
+    if (!metadataField || !isJsonObject(metadataField)) {
+        return {};
+    }
+    const cloned = jsonClone(metadataField);
+    const native = extractMetadataPassthroughWithNative(cloned, options.prefix, options.keys);
+    const metadata = native.metadata && isJsonObject(native.metadata) ? native.metadata : undefined;
+    const passthrough = native.passthrough && isJsonObject(native.passthrough)
+        ? native.passthrough
+        : undefined;
+    return {
+        metadata,
+        passthrough
+    };
+}

package/vendor/llmswitch-core/dist/conversion/payload-budget.d.ts

@@ -0,0 +1,13 @@
+export declare function resolveBudgetForModelSync(modelId: string): {
+    maxBytes: number;
+    safetyRatio: number;
+    allowedBytes: number;
+    source: string;
+};
+export declare const resolveBudgetForModel: (modelId: string) => Promise<{
+    maxBytes: number;
+    safetyRatio: number;
+    allowedBytes: number;
+    source: string;
+}>;
+export declare function enforceChatBudget(chat: any, modelId: string): any;

package/vendor/llmswitch-core/dist/conversion/payload-budget.js

@@ -0,0 +1,47 @@
+// Resolve payload budget (bytes) for a given model from host app config, with safety headroom.
+import { UnifiedConfig } from '../config-unified/unified-config.js';
+import { enforceChatBudgetWithNative, resolveBudgetForModelWithNative } from '../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+export function resolveBudgetForModelSync(modelId) {
+    let viaFacade = null;
+    try {
+        const resolved = UnifiedConfig.getContextBudgetForModel(modelId);
+        if (resolved && typeof resolved.allowedBytes === 'number') {
+            viaFacade = resolved;
+        }
+    }
+    catch {
+        // ignore facade errors and fallback
+    }
+    if (viaFacade) {
+        return viaFacade;
+    }
+    return resolveBudgetForModelWithNative(modelId, null);
+}
+export const resolveBudgetForModel = async (modelId) => resolveBudgetForModelSync(modelId);
+// Apply payload budget enforcement to an OpenAI Chat-shaped request object in-place.
+// Strategy (deterministic, minimal):
+// 1) Truncate the first system message to RCC_SYSTEM_TEXT_LIMIT (default 8192 chars).
+// 2) Remove assistant messages that have no tool_calls and empty/whitespace content.
+// 3) Iteratively clamp tool role message content down to fit allowedBytes.
+// 4) If仍超限，轻度收紧 assistant 文本（不移除，仅截断）。
+export function enforceChatBudget(chat, modelId) {
+    try {
+        if (!chat || typeof chat !== 'object')
+            return chat;
+        const messages = Array.isArray(chat.messages) ? chat.messages : [];
+        if (!messages.length)
+            return chat;
+        const budget = resolveBudgetForModelSync(modelId || 'unknown');
+        const allowed = Math.max(1024, Number(budget.allowedBytes || 200000));
+        const sysLimit = (() => {
+            const raw = process?.env?.RCC_SYSTEM_TEXT_LIMIT;
+            const n = Number(raw);
+            return Number.isFinite(n) && n >= 0 ? n : 8192;
+        })();
+        return enforceChatBudgetWithNative(chat, allowed, sysLimit);
+    }
+    catch {
+        // ignore budget errors
+    }
+    return chat;
+}

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

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

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

@@ -0,0 +1,104 @@
+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';
+function assertJsonObject(value, stage) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error(`Anthropic pipeline codec requires JSON object payload at ${stage}`);
+    }
+    return value;
+}
+function normalizeAliasMap(candidate) {
+    if (!candidate || typeof candidate !== 'object' || Array.isArray(candidate)) {
+        return undefined;
+    }
+    const out = {};
+    for (const [key, value] of Object.entries(candidate)) {
+        if (typeof key !== 'string' || typeof value !== 'string') {
+            continue;
+        }
+        const trimmed = key.trim();
+        if (!trimmed) {
+            continue;
+        }
+        out[trimmed] = value;
+    }
+    return Object.keys(out).length ? out : undefined;
+}
+function buildPipelineContext(profile, context) {
+    return {
+        requestId: context.requestId,
+        entryEndpoint: context.entryEndpoint ?? context.endpoint ?? DEFAULT_ANTHROPIC_ENDPOINT,
+        providerProtocol: context.targetProtocol ?? profile.incomingProtocol ?? ANTHROPIC_PROTOCOL,
+        targetProtocol: profile.outgoingProtocol ?? context.targetProtocol ?? OPENAI_PROTOCOL,
+        profileId: profile.id,
+        stream: context.stream,
+        metadata: context.metadata
+    };
+}
+export class AnthropicOpenAIPipelineCodec {
+    id = 'anthropic-openai-v2';
+    requestMetaStore = new Map();
+    initialized = false;
+    async initialize() {
+        this.initialized = true;
+    }
+    ensureInitialized() {
+        if (!this.initialized) {
+            throw new Error('AnthropicOpenAIPipelineCodec must be initialized before use');
+        }
+    }
+    async convertRequest(payload, profile, context) {
+        this.ensureInitialized();
+        const inboundContext = buildPipelineContext(profile, 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,
+            entryEndpoint: context.entryEndpoint ?? context.endpoint ?? DEFAULT_ANTHROPIC_ENDPOINT,
+            endpoint: context.endpoint ?? context.entryEndpoint ?? DEFAULT_ANTHROPIC_ENDPOINT
+        };
+        return runStandardChatRequestFilters(rebuilt, profile, filterContext);
+    }
+    async convertResponse(payload, profile, context) {
+        this.ensureInitialized();
+        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');
+    }
+}