@jsonstudio/llms 0.4.2

package/dist/conversion/hub/registry.js

@@ -0,0 +1,98 @@
+import { ChatFormatAdapter } from './format-adapters/chat-format-adapter.js';
+import { AnthropicFormatAdapter } from './format-adapters/anthropic-format-adapter.js';
+import { ResponsesFormatAdapter } from './format-adapters/responses-format-adapter.js';
+import { ChatSemanticMapper } from './semantic-mappers/chat-mapper.js';
+import { AnthropicSemanticMapper } from './semantic-mappers/anthropic-mapper.js';
+import { ResponsesSemanticMapper } from './semantic-mappers/responses-mapper.js';
+import { GeminiSemanticMapper } from './semantic-mappers/gemini-mapper.js';
+import { GeminiFormatAdapter } from './format-adapters/gemini-format-adapter.js';
+export const HUB_PROTOCOL_REGISTRY = {
+    'openai-chat': {
+        protocol: 'openai-chat',
+        inbound: {
+            protocol: 'openai-chat',
+            stages: ['format_parse', 'semantic_map_to_chat'],
+            createFormatAdapter: () => new ChatFormatAdapter(),
+            createSemanticMapper: () => new ChatSemanticMapper()
+        },
+        outbound: {
+            protocol: 'openai-chat',
+            stages: ['semantic_map_from_chat', 'format_build'],
+            createFormatAdapter: () => new ChatFormatAdapter(),
+            createSemanticMapper: () => new ChatSemanticMapper()
+        }
+    },
+    'anthropic-messages': {
+        protocol: 'anthropic-messages',
+        inbound: {
+            protocol: 'anthropic-messages',
+            stages: ['format_parse', 'semantic_map_to_chat'],
+            createFormatAdapter: () => new AnthropicFormatAdapter(),
+            createSemanticMapper: () => new AnthropicSemanticMapper()
+        },
+        outbound: {
+            protocol: 'anthropic-messages',
+            stages: ['semantic_map_from_chat', 'format_build'],
+            createFormatAdapter: () => new AnthropicFormatAdapter(),
+            createSemanticMapper: () => new AnthropicSemanticMapper()
+        }
+    },
+    'openai-responses': {
+        protocol: 'openai-responses',
+        inbound: {
+            protocol: 'openai-responses',
+            stages: ['format_parse', 'semantic_map_to_chat'],
+            createFormatAdapter: () => new ResponsesFormatAdapter(),
+            createSemanticMapper: () => new ResponsesSemanticMapper()
+        },
+        outbound: {
+            protocol: 'openai-responses',
+            stages: ['semantic_map_from_chat', 'format_build'],
+            createFormatAdapter: () => new ResponsesFormatAdapter(),
+            createSemanticMapper: () => new ResponsesSemanticMapper()
+        }
+    },
+    'gemini-chat': {
+        protocol: 'gemini-chat',
+        inbound: {
+            protocol: 'gemini-chat',
+            stages: ['format_parse', 'semantic_map_to_chat'],
+            createFormatAdapter: () => new GeminiFormatAdapter(),
+            createSemanticMapper: () => new GeminiSemanticMapper()
+        },
+        outbound: {
+            protocol: 'gemini-chat',
+            stages: ['semantic_map_from_chat', 'format_build'],
+            createFormatAdapter: () => new GeminiFormatAdapter(),
+            createSemanticMapper: () => new GeminiSemanticMapper()
+        }
+    }
+};
+function instantiateInbound(factory) {
+    return {
+        protocol: factory.protocol,
+        stages: factory.stages,
+        passthrough: factory.passthrough,
+        formatAdapter: factory.createFormatAdapter?.(),
+        semanticMapper: factory.createSemanticMapper?.()
+    };
+}
+function instantiateOutbound(factory) {
+    return {
+        protocol: factory.protocol,
+        stages: factory.stages,
+        passthrough: factory.passthrough,
+        formatAdapter: factory.createFormatAdapter?.(),
+        semanticMapper: factory.createSemanticMapper?.()
+    };
+}
+export function createProtocolPlans(protocol) {
+    const definition = HUB_PROTOCOL_REGISTRY[protocol];
+    if (!definition) {
+        throw new Error(`Unknown hub protocol: ${protocol}`);
+    }
+    return {
+        inbound: instantiateInbound(definition.inbound),
+        outbound: instantiateOutbound(definition.outbound)
+    };
+}

package/dist/conversion/hub/response/chat-response-utils.d.ts

@@ -0,0 +1,6 @@
+import type { ProcessedRequest } from '../types/standardized.js';
+interface BuildProcessedRequestOptions {
+    stream?: boolean;
+}
+export declare function buildProcessedRequestFromChatResponse(chatResponse: any, options?: BuildProcessedRequestOptions): ProcessedRequest;
+export {};

package/dist/conversion/hub/response/chat-response-utils.js

@@ -0,0 +1,89 @@
+function extractMessageContent(message) {
+    const content = (message && typeof message === 'object') ? message.content : undefined;
+    if (Array.isArray(content)) {
+        return content
+            .map((part) => {
+            if (!part)
+                return '';
+            if (typeof part === 'string')
+                return part;
+            if (typeof part.text === 'string')
+                return part.text;
+            if (typeof part.content === 'string')
+                return part.content;
+            return '';
+        })
+            .filter(Boolean)
+            .join('\n');
+    }
+    if (typeof content === 'string')
+        return content;
+    return '';
+}
+function mapToolCalls(toolCalls) {
+    if (!Array.isArray(toolCalls))
+        return undefined;
+    return toolCalls
+        .map((tc) => {
+        if (!tc || typeof tc !== 'object')
+            return null;
+        const fn = tc.function || {};
+        if (typeof fn?.name !== 'string')
+            return null;
+        const args = typeof fn?.arguments === 'string' ? fn.arguments : (() => {
+            try {
+                return JSON.stringify(fn?.arguments ?? {});
+            }
+            catch {
+                return '{}';
+            }
+        })();
+        return {
+            id: typeof tc.id === 'string' ? tc.id : `call_${Math.random().toString(36).slice(2, 10)}`,
+            type: 'function',
+            function: {
+                name: fn.name,
+                arguments: args
+            }
+        };
+    })
+        .filter(Boolean);
+}
+export function buildProcessedRequestFromChatResponse(chatResponse, options) {
+    const streamingEnabled = options?.stream === true;
+    const firstChoice = Array.isArray(chatResponse?.choices) ? chatResponse.choices[0] : null;
+    const msg = firstChoice?.message || {};
+    const content = extractMessageContent(msg);
+    const toolCalls = mapToolCalls(msg?.tool_calls);
+    const assistantMessage = {
+        role: 'assistant',
+        content,
+        tool_calls: toolCalls
+    };
+    const processedRequest = {
+        model: typeof chatResponse?.model === 'string' ? chatResponse.model : 'unknown',
+        messages: [assistantMessage],
+        tools: undefined,
+        parameters: {},
+        metadata: {
+            originalEndpoint: 'openai-chat',
+            ...(streamingEnabled ? { stream: true } : {})
+        },
+        processed: {
+            timestamp: Date.now(),
+            appliedRules: ['response-pipeline'],
+            status: 'success'
+        },
+        processingMetadata: {
+            streaming: {
+                enabled: streamingEnabled,
+                chunkCount: 0,
+                totalTokens: typeof chatResponse?.usage?.completion_tokens === 'number'
+                    ? chatResponse.usage.completion_tokens
+                    : 0
+            },
+            context: {}
+        }
+    };
+    return processedRequest;
+}

package/dist/conversion/hub/response/provider-response.d.ts

@@ -0,0 +1,20 @@
+import { Readable } from 'node:stream';
+import type { AdapterContext } from '../types/chat-envelope.js';
+import type { JsonObject } from '../types/json.js';
+import type { StageRecorder } from '../format-adapters/index.js';
+type ProviderProtocol = 'openai-chat' | 'openai-responses' | 'anthropic-messages' | 'gemini-chat';
+export interface ProviderResponseConversionOptions {
+    providerProtocol: ProviderProtocol;
+    providerResponse: JsonObject;
+    context: AdapterContext;
+    entryEndpoint: string;
+    wantsStream: boolean;
+    stageRecorder?: StageRecorder;
+}
+export interface ProviderResponseConversionResult {
+    body?: JsonObject;
+    __sse_responses?: Readable;
+    format?: string;
+}
+export declare function convertProviderResponse(options: ProviderResponseConversionOptions): Promise<ProviderResponseConversionResult>;
+export {};

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

@@ -0,0 +1,196 @@
+import { Readable } from 'node:stream';
+import { runChatResponseToolFilters } from '../../shared/tool-filter-pipeline.js';
+import { finalizeOpenAIChatResponse } from '../../shared/openai-finalizer.js';
+import { buildProcessedRequestFromChatResponse } from './chat-response-utils.js';
+import { buildAnthropicResponseFromChat } from './response-runtime.js';
+import { buildResponsesPayloadFromChat } from '../../responses/responses-openai-bridge.js';
+import { defaultSseCodecRegistry } from '../../../sse/registry/sse-codec-registry.js';
+import { ChatFormatAdapter } from '../format-adapters/chat-format-adapter.js';
+import { ResponsesFormatAdapter } from '../format-adapters/responses-format-adapter.js';
+import { AnthropicFormatAdapter } from '../format-adapters/anthropic-format-adapter.js';
+import { GeminiFormatAdapter } from '../format-adapters/gemini-format-adapter.js';
+import { OpenAIChatResponseMapper, ResponsesResponseMapper, AnthropicResponseMapper, GeminiResponseMapper } from './response-mappers.js';
+const STAGES = {
+    formatParse: 'resp_format_parse',
+    semanticMap: 'resp_semantic_map_to_chat',
+    governance: 'resp_tool_governance',
+    finalize: 'resp_finalize',
+    processed: 'resp_processed_request',
+    clientMap: 'resp_client_map',
+    sseDecode: 'resp_sse_decode',
+    ssePre: 'resp_sse_output_pre',
+    ssePost: 'resp_sse_output_post'
+};
+const PROVIDER_RESPONSE_REGISTRY = {
+    'openai-chat': {
+        protocol: 'openai-chat',
+        createFormatAdapter: () => new ChatFormatAdapter(),
+        createMapper: () => new OpenAIChatResponseMapper()
+    },
+    'openai-responses': {
+        protocol: 'openai-responses',
+        createFormatAdapter: () => new ResponsesFormatAdapter(),
+        createMapper: () => new ResponsesResponseMapper()
+    },
+    'anthropic-messages': {
+        protocol: 'anthropic-messages',
+        createFormatAdapter: () => new AnthropicFormatAdapter(),
+        createMapper: () => new AnthropicResponseMapper()
+    },
+    'gemini-chat': {
+        protocol: 'gemini-chat',
+        createFormatAdapter: () => new GeminiFormatAdapter(),
+        createMapper: () => new GeminiResponseMapper()
+    }
+};
+function recordStage(recorder, stage, payload) {
+    if (!recorder)
+        return;
+    try {
+        recorder.record(stage, payload);
+    }
+    catch {
+        /* ignore */
+    }
+}
+function extractSseStream(payload) {
+    if (!payload || typeof payload !== 'object') {
+        return undefined;
+    }
+    const direct = payload.__sse_responses || payload.__sse_stream;
+    if (direct && typeof direct.pipe === 'function') {
+        return direct;
+    }
+    const nested = payload.data;
+    if (nested && typeof nested === 'object') {
+        const inner = nested.__sse_responses || nested.__sse_stream;
+        if (inner && typeof inner.pipe === 'function') {
+            return inner;
+        }
+    }
+    return undefined;
+}
+function resolveClientProtocol(entryEndpoint) {
+    const lowered = (entryEndpoint || '').toLowerCase();
+    if (lowered.includes('/v1/responses'))
+        return 'openai-responses';
+    if (lowered.includes('/v1/messages'))
+        return 'anthropic-messages';
+    return 'openai-chat';
+}
+async function maybeCreateSseStream(protocol, payload, requestId) {
+    const codec = defaultSseCodecRegistry.get(protocol);
+    if (!codec) {
+        const stream = new Readable({ read() { this.push(null); } });
+        return stream;
+    }
+    return codec.convertJsonToSse(payload, { requestId });
+}
+function supportsSseProtocol(protocol) {
+    return protocol === 'openai-chat' || protocol === 'openai-responses' || protocol === 'anthropic-messages';
+}
+function extractDisplayModel(context) {
+    const candidates = [
+        context.originalModelId,
+        context.clientModelId,
+        context.modelId
+    ];
+    for (const candidate of candidates) {
+        if (typeof candidate === 'string' && candidate.trim()) {
+            return candidate.trim();
+        }
+    }
+    return undefined;
+}
+function applyModelOverride(payload, model) {
+    if (!model || !payload || typeof payload !== 'object') {
+        return;
+    }
+    try {
+        payload.model = model;
+    }
+    catch {
+        /* ignore */
+    }
+}
+export async function convertProviderResponse(options) {
+    const clientProtocol = resolveClientProtocol(options.entryEndpoint);
+    const passthroughStream = extractSseStream(options.providerResponse);
+    const protocolsMatch = clientProtocol === options.providerProtocol;
+    const modelHint = typeof options.context.modelId === 'string' ? options.context.modelId : undefined;
+    const displayModel = extractDisplayModel(options.context);
+    let providerPayload = options.providerResponse;
+    if (passthroughStream) {
+        if (options.wantsStream && protocolsMatch && supportsSseProtocol(clientProtocol)) {
+            recordStage(options.stageRecorder, STAGES.clientMap, { passthrough: true, protocol: clientProtocol });
+            return { __sse_responses: passthroughStream };
+        }
+        if (supportsSseProtocol(options.providerProtocol)) {
+            try {
+                const codec = defaultSseCodecRegistry.get(options.providerProtocol);
+                const decoded = await codec.convertSseToJson(passthroughStream, {
+                    requestId: options.context.requestId,
+                    model: modelHint
+                });
+                if (decoded && typeof decoded === 'object') {
+                    providerPayload = decoded;
+                    recordStage(options.stageRecorder, STAGES.sseDecode, { protocol: options.providerProtocol });
+                }
+            }
+            catch (error) {
+                recordStage(options.stageRecorder, STAGES.sseDecode, {
+                    protocol: options.providerProtocol,
+                    error: error instanceof Error ? error.message : String(error)
+                });
+            }
+        }
+    }
+    const plan = PROVIDER_RESPONSE_REGISTRY[options.providerProtocol];
+    if (!plan) {
+        throw new Error(`Unknown provider protocol: ${options.providerProtocol}`);
+    }
+    const formatAdapter = plan.createFormatAdapter();
+    const mapper = plan.createMapper();
+    const formatEnvelope = await formatAdapter.parseResponse(providerPayload, options.context);
+    recordStage(options.stageRecorder, STAGES.formatParse, formatEnvelope);
+    const chatResponse = await mapper.toChatCompletion(formatEnvelope, options.context);
+    recordStage(options.stageRecorder, STAGES.semanticMap, chatResponse);
+    const governed = await runChatResponseToolFilters(chatResponse, {
+        entryEndpoint: options.entryEndpoint,
+        requestId: options.context.requestId,
+        profile: 'openai-chat'
+    });
+    recordStage(options.stageRecorder, STAGES.governance, governed);
+    const finalized = await finalizeOpenAIChatResponse(governed, {
+        requestId: options.context.requestId,
+        endpoint: options.entryEndpoint,
+        stream: options.wantsStream
+    });
+    applyModelOverride(finalized, displayModel);
+    recordStage(options.stageRecorder, STAGES.finalize, finalized);
+    const processedRequest = buildProcessedRequestFromChatResponse(finalized, {
+        stream: options.wantsStream
+    });
+    recordStage(options.stageRecorder, STAGES.processed, processedRequest);
+    let clientPayload;
+    if (clientProtocol === 'openai-chat') {
+        clientPayload = finalized;
+    }
+    else if (clientProtocol === 'anthropic-messages') {
+        clientPayload = buildAnthropicResponseFromChat(finalized);
+    }
+    else {
+        clientPayload = buildResponsesPayloadFromChat(finalized, {
+            requestId: options.context.requestId
+        });
+    }
+    applyModelOverride(clientPayload, displayModel);
+    recordStage(options.stageRecorder, STAGES.clientMap, clientPayload);
+    if (!options.wantsStream) {
+        return { body: clientPayload, format: clientProtocol };
+    }
+    recordStage(options.stageRecorder, STAGES.ssePre, { protocol: clientProtocol });
+    const sseStream = await maybeCreateSseStream(clientProtocol, clientPayload, options.context.requestId);
+    recordStage(options.stageRecorder, STAGES.ssePost, {});
+    return { __sse_responses: sseStream, format: clientProtocol };
+}

package/dist/conversion/hub/response/response-mappers.d.ts

@@ -0,0 +1,19 @@
+import type { FormatEnvelope } from '../types/format-envelope.js';
+import type { AdapterContext } from '../types/chat-envelope.js';
+import type { JsonObject } from '../types/json.js';
+export type ChatCompletionLike = JsonObject;
+export interface ResponseMapper {
+    toChatCompletion(format: FormatEnvelope, ctx: AdapterContext): Promise<ChatCompletionLike> | ChatCompletionLike;
+}
+export declare class OpenAIChatResponseMapper implements ResponseMapper {
+    toChatCompletion(format: FormatEnvelope, _ctx: AdapterContext): ChatCompletionLike;
+}
+export declare class ResponsesResponseMapper implements ResponseMapper {
+    toChatCompletion(format: FormatEnvelope, _ctx: AdapterContext): ChatCompletionLike;
+}
+export declare class AnthropicResponseMapper implements ResponseMapper {
+    toChatCompletion(format: FormatEnvelope, _ctx: AdapterContext): ChatCompletionLike;
+}
+export declare class GeminiResponseMapper implements ResponseMapper {
+    toChatCompletion(format: FormatEnvelope, _ctx: AdapterContext): ChatCompletionLike;
+}

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

@@ -0,0 +1,23 @@
+import { buildOpenAIChatFromGeminiResponse } from '../../codecs/gemini-openai-codec.js';
+import { buildChatResponseFromResponses } from '../../responses/responses-openai-bridge.js';
+import { buildOpenAIChatFromAnthropicMessage } from './response-runtime.js';
+export class OpenAIChatResponseMapper {
+    toChatCompletion(format, _ctx) {
+        return (format.payload ?? {});
+    }
+}
+export class ResponsesResponseMapper {
+    toChatCompletion(format, _ctx) {
+        return buildChatResponseFromResponses(format.payload ?? {});
+    }
+}
+export class AnthropicResponseMapper {
+    toChatCompletion(format, _ctx) {
+        return buildOpenAIChatFromAnthropicMessage(format.payload ?? {});
+    }
+}
+export class GeminiResponseMapper {
+    toChatCompletion(format, _ctx) {
+        return buildOpenAIChatFromGeminiResponse(format.payload ?? {});
+    }
+}

package/dist/conversion/hub/response/response-runtime.d.ts

@@ -0,0 +1,3 @@
+import type { JsonObject } from '../types/json.js';
+export declare function buildOpenAIChatFromAnthropicMessage(payload: JsonObject): JsonObject;
+export declare function buildAnthropicResponseFromChat(chatResponse: JsonObject): JsonObject;

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

@@ -0,0 +1,206 @@
+function flattenAnthropicContent(content) {
+    if (typeof content === 'string')
+        return content;
+    if (Array.isArray(content)) {
+        return content.map(flattenAnthropicContent).filter(Boolean).join('');
+    }
+    if (content && typeof content === 'object') {
+        const block = content;
+        if (typeof block.text === 'string')
+            return block.text;
+        if (typeof block.content === 'string')
+            return block.content;
+        if (Array.isArray(block.content))
+            return block.content.map(flattenAnthropicContent).filter(Boolean).join('');
+    }
+    return '';
+}
+export function buildOpenAIChatFromAnthropicMessage(payload) {
+    const content = Array.isArray(payload?.content) ? payload.content : [];
+    const textParts = [];
+    const toolCalls = [];
+    for (const part of content) {
+        if (!part || typeof part !== 'object')
+            continue;
+        const kind = String(part.type || '').toLowerCase();
+        if (kind === 'text' && typeof part.text === 'string') {
+            textParts.push(part.text);
+        }
+        else if (kind === 'tool_use') {
+            const name = typeof part.name === 'string'
+                ? String(part.name)
+                : '';
+            const id = typeof part.id === 'string'
+                ? String(part.id)
+                : `call_${Math.random().toString(36).slice(2, 10)}`;
+            const input = part.input;
+            let args = '';
+            if (typeof input === 'string') {
+                args = input;
+            }
+            else {
+                try {
+                    args = JSON.stringify(input ?? {});
+                }
+                catch {
+                    args = '{}';
+                }
+            }
+            if (name) {
+                toolCalls.push({ id, name, args });
+            }
+        }
+    }
+    const mapFinishReason = (reason) => {
+        switch (reason) {
+            case 'tool_use': return 'tool_calls';
+            case 'max_tokens': return 'length';
+            case 'stop_sequence': return 'content_filter';
+            default: return 'stop';
+        }
+    };
+    return {
+        id: typeof payload.id === 'string' ? payload.id : `chatcmpl_${Date.now()}`,
+        object: 'chat.completion',
+        created: typeof payload?.['created'] === 'number' ? payload['created'] : Math.floor(Date.now() / 1000),
+        model: typeof payload.model === 'string' ? payload.model : 'unknown',
+        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 }
+                    }))
+                }
+            }
+        ],
+        usage: payload['usage'] && typeof payload['usage'] === 'object'
+            ? payload['usage']
+            : undefined
+    };
+}
+export function buildAnthropicResponseFromChat(chatResponse) {
+    const choice = Array.isArray(chatResponse?.choices) ? chatResponse.choices[0] : undefined;
+    const message = choice && typeof choice === 'object' ? choice.message : undefined;
+    const text = flattenAnthropicContent(message?.content);
+    const toolCalls = Array.isArray(message?.tool_calls) ? message.tool_calls : [];
+    const contentBlocks = [];
+    if (text && text.trim().length) {
+        contentBlocks.push({ type: 'text', text });
+    }
+    for (const call of toolCalls) {
+        if (!call || typeof call !== 'object')
+            continue;
+        const fn = call.function || {};
+        if (typeof fn?.name !== 'string')
+            continue;
+        let parsedArgs = {};
+        const args = fn.arguments;
+        if (typeof args === 'string') {
+            try {
+                parsedArgs = JSON.parse(args);
+            }
+            catch {
+                parsedArgs = { _raw: args };
+            }
+        }
+        else {
+            parsedArgs = args ?? {};
+        }
+        contentBlocks.push({
+            type: 'tool_use',
+            id: typeof call.id === 'string' ? call.id : `call_${Math.random().toString(36).slice(2, 8)}`,
+            name: fn.name,
+            input: parsedArgs
+        });
+    }
+    const usage = chatResponse?.usage;
+    const stopReason = typeof choice?.finish_reason === 'string'
+        ? choice.finish_reason
+        : undefined;
+    const stopReasonMapped = (() => {
+        switch (stopReason) {
+            case 'tool_calls': return 'tool_use';
+            case 'length': return 'max_tokens';
+            case 'content_filter': return 'stop_sequence';
+            default: return 'end_turn';
+        }
+    })();
+    const raw = {
+        id: typeof chatResponse.id === 'string' ? chatResponse.id : `resp_${Date.now()}`,
+        type: 'message',
+        role: 'assistant',
+        content: contentBlocks,
+        model: typeof chatResponse.model === 'string' ? chatResponse.model : 'unknown',
+        stop_reason: stopReasonMapped,
+        usage: usage && typeof usage === 'object'
+            ? {
+                input_tokens: usage.prompt_tokens ?? 0,
+                output_tokens: usage.completion_tokens ?? 0
+            }
+            : undefined
+    };
+    return sanitizeAnthropicMessage(raw);
+}
+function sanitizeAnthropicMessage(message) {
+    const sanitized = {};
+    const allowedTopLevel = new Set(['id', 'type', 'role', 'content', 'model', 'stop_reason', 'stop_sequence', 'usage']);
+    for (const key of allowedTopLevel) {
+        if (message[key] !== undefined) {
+            sanitized[key] = message[key];
+        }
+    }
+    const content = Array.isArray(message.content) ? message.content : [];
+    sanitized.content = content
+        .map((block) => sanitizeContentBlock(block))
+        .filter((block) => block !== null);
+    const usage = message.usage;
+    if (usage && typeof usage === 'object') {
+        sanitized.usage = {
+            input_tokens: usage.input_tokens ?? 0,
+            output_tokens: usage.output_tokens ?? 0
+        };
+    }
+    return sanitized;
+}
+function sanitizeContentBlock(block) {
+    if (!block || typeof block !== 'object')
+        return null;
+    const type = typeof block.type === 'string' ? block.type : '';
+    if (type === 'text') {
+        if (typeof block.text !== 'string')
+            return null;
+        return { type: 'text', text: block.text };
+    }
+    if (type === 'tool_use') {
+        const id = typeof block.id === 'string' && block.id.trim() ? block.id : `call_${Math.random().toString(36).slice(2, 8)}`;
+        const name = typeof block.name === 'string' ? block.name : '';
+        if (!name)
+            return null;
+        return {
+            type: 'tool_use',
+            id,
+            name,
+            input: block.input ?? {}
+        };
+    }
+    if (type === 'tool_result') {
+        if (typeof block.tool_use_id !== 'string' || !block.tool_use_id.trim())
+            return null;
+        const sanitized = {
+            type: 'tool_result',
+            tool_use_id: block.tool_use_id,
+            content: block.content ?? ''
+        };
+        if (typeof block.is_error === 'boolean') {
+            sanitized.is_error = block.is_error;
+        }
+        return sanitized;
+    }
+    return null;
+}

package/dist/conversion/hub/semantic-mappers/anthropic-mapper.d.ts

@@ -0,0 +1,7 @@
+import type { SemanticMapper } from '../format-adapters/index.js';
+import type { AdapterContext, ChatEnvelope } from '../types/chat-envelope.js';
+import type { FormatEnvelope } from '../types/format-envelope.js';
+export declare class AnthropicSemanticMapper implements SemanticMapper {
+    toChat(format: FormatEnvelope, ctx: AdapterContext): Promise<ChatEnvelope>;
+    fromChat(chat: ChatEnvelope, ctx: AdapterContext): Promise<FormatEnvelope>;
+}