@jsonstudio/llms 0.6.938 → 0.6.1164

package/dist/conversion/hub/semantic-mappers/anthropic-mapper.js

@@ -1,365 +1 @@
-import { isJsonObject, jsonClone } from '../types/json.js';
-import { buildOpenAIChatFromAnthropic, buildAnthropicRequestFromOpenAIChat } from '../../codecs/anthropic-openai-codec.js';
-import { createBridgeActionState, runBridgeActionPipeline } from '../../shared/bridge-actions.js';
-import { resolveBridgePolicy, resolvePolicyActions } from '../../shared/bridge-policies.js';
-import { encodeMetadataPassthrough, extractMetadataPassthrough } from '../../shared/metadata-passthrough.js';
-import { buildAnthropicToolAliasMap } from '../../shared/anthropic-message-utils.js';
-import { ChatSemanticMapper } from './chat-mapper.js';
-import { ensureProtocolState, getProtocolState } from '../../shared/protocol-state.js';
-const ANTHROPIC_PARAMETER_KEYS = [
-    'model',
-    'temperature',
-    'top_p',
-    'top_k',
-    'max_tokens',
-    'max_output_tokens',
-    'metadata',
-    'stream',
-    'tool_choice'
-];
-const ANTHROPIC_TOP_LEVEL_FIELDS = new Set([
-    'model',
-    'messages',
-    'tools',
-    'system',
-    'stop_sequences',
-    'temperature',
-    'top_p',
-    'top_k',
-    'max_tokens',
-    'max_output_tokens',
-    'metadata',
-    'stream',
-    'tool_choice'
-]);
-const PASSTHROUGH_METADATA_PREFIX = 'rcc_passthrough_';
-const PASSTHROUGH_PARAMETERS = ['tool_choice'];
-function ensureSemantics(chat) {
-    if (!chat.semantics || typeof chat.semantics !== 'object') {
-        chat.semantics = {};
-    }
-    return chat.semantics;
-}
-function ensureAnthropicSemanticsNode(chat) {
-    const semantics = ensureSemantics(chat);
-    if (!semantics.anthropic || !isJsonObject(semantics.anthropic)) {
-        semantics.anthropic = {};
-    }
-    return semantics.anthropic;
-}
-function markExplicitEmptyTools(chat) {
-    const semantics = ensureSemantics(chat);
-    if (!semantics.tools || !isJsonObject(semantics.tools)) {
-        semantics.tools = {};
-    }
-    semantics.tools.explicitEmpty = true;
-}
-function readAnthropicSemantics(chat) {
-    if (!chat.semantics || typeof chat.semantics !== 'object') {
-        return undefined;
-    }
-    const node = chat.semantics.anthropic;
-    return node && isJsonObject(node) ? node : undefined;
-}
-function hasExplicitEmptyToolsSemantics(chat) {
-    if (!chat.semantics || typeof chat.semantics !== 'object') {
-        return false;
-    }
-    const toolsNode = chat.semantics.tools;
-    if (!toolsNode || !isJsonObject(toolsNode)) {
-        return false;
-    }
-    return Boolean(toolsNode.explicitEmpty);
-}
-function sanitizeAnthropicPayload(payload) {
-    for (const key of Object.keys(payload)) {
-        if (!ANTHROPIC_TOP_LEVEL_FIELDS.has(key)) {
-            delete payload[key];
-        }
-    }
-    return payload;
-}
-function collectParameters(payload) {
-    const params = {};
-    for (const key of ANTHROPIC_PARAMETER_KEYS) {
-        if (payload[key] !== undefined) {
-            params[key] = payload[key];
-        }
-    }
-    if (Array.isArray(payload.stop_sequences)) {
-        params.stop = payload.stop_sequences;
-    }
-    return Object.keys(params).length ? params : undefined;
-}
-function cloneAnthropicSystemBlocks(value) {
-    if (value === undefined || value === null) {
-        return undefined;
-    }
-    const blocks = Array.isArray(value) ? value : [value];
-    if (!blocks.length) {
-        return undefined;
-    }
-    return blocks.map((entry) => jsonClone(entry));
-}
-export class AnthropicSemanticMapper {
-    chatMapper = new ChatSemanticMapper();
-    async toChat(format, ctx) {
-        const payload = (format.payload ?? {});
-        const missing = [];
-        if (!Array.isArray(payload.messages))
-            missing.push({ path: 'messages', reason: 'absent' });
-        if (typeof payload.model !== 'string')
-            missing.push({ path: 'model', reason: 'absent' });
-        const passthrough = extractMetadataPassthrough(payload.metadata, {
-            prefix: PASSTHROUGH_METADATA_PREFIX,
-            keys: PASSTHROUGH_PARAMETERS
-        });
-        const openaiPayload = buildOpenAIChatFromAnthropic(payload);
-        const canonicalContext = {
-            ...ctx,
-            providerProtocol: 'openai-chat',
-            entryEndpoint: ctx.entryEndpoint || '/v1/chat/completions'
-        };
-        const chatEnvelope = await this.chatMapper.toChat({
-            protocol: 'openai-chat',
-            direction: 'request',
-            payload: openaiPayload
-        }, canonicalContext);
-        const metadata = chatEnvelope.metadata ?? { context: canonicalContext };
-        chatEnvelope.metadata = metadata;
-        metadata.context = canonicalContext;
-        let semanticsNode;
-        const resolveExtraFields = () => {
-            if (!isJsonObject(metadata.extraFields)) {
-                metadata.extraFields = {};
-            }
-            return metadata.extraFields;
-        };
-        const protocolState = ensureProtocolState(metadata, 'anthropic');
-        const systemBlocks = cloneAnthropicSystemBlocks(payload.system);
-        if (systemBlocks) {
-            protocolState.systemBlocks = systemBlocks;
-            semanticsNode = semanticsNode ?? ensureAnthropicSemanticsNode(chatEnvelope);
-            semanticsNode.systemBlocks = jsonClone(systemBlocks);
-        }
-        if (payload.tools && Array.isArray(payload.tools) && payload.tools.length === 0) {
-            metadata.toolsFieldPresent = true;
-            resolveExtraFields().toolsFieldPresent = true;
-            markExplicitEmptyTools(chatEnvelope);
-        }
-        const aliasMap = buildAnthropicToolAliasMap(payload.tools);
-        if (aliasMap) {
-            const extraFields = resolveExtraFields();
-            ctx.anthropicToolNameMap = aliasMap;
-            canonicalContext.anthropicToolNameMap = aliasMap;
-            metadata.anthropicToolNameMap = aliasMap;
-            extraFields.anthropicToolNameMap = aliasMap;
-            semanticsNode = semanticsNode ?? ensureAnthropicSemanticsNode(chatEnvelope);
-            semanticsNode.toolAliasMap = jsonClone(aliasMap);
-        }
-        if (Array.isArray(payload.messages) && payload.messages.length) {
-            const shapes = payload.messages.map((entry) => {
-                if (!entry || typeof entry !== 'object') {
-                    return 'unknown';
-                }
-                const rawContent = entry.content;
-                if (typeof rawContent === 'string') {
-                    return 'string';
-                }
-                if (Array.isArray(rawContent)) {
-                    return 'array';
-                }
-                if (rawContent === null || rawContent === undefined) {
-                    return 'null';
-                }
-                return typeof rawContent;
-            });
-            const extraFields = resolveExtraFields();
-            const mirrorNode = extraFields.anthropicMirror && typeof extraFields.anthropicMirror === 'object'
-                ? extraFields.anthropicMirror
-                : {};
-            mirrorNode.messageContentShape = shapes;
-            extraFields.anthropicMirror = mirrorNode;
-            semanticsNode = semanticsNode ?? ensureAnthropicSemanticsNode(chatEnvelope);
-            semanticsNode.mirror = jsonClone(mirrorNode);
-        }
-        if (missing.length) {
-            metadata.missingFields = Array.isArray(metadata.missingFields)
-                ? [...metadata.missingFields, ...missing]
-                : missing;
-        }
-        const providerMetadata = passthrough.metadata ??
-            (payload.metadata && isJsonObject(payload.metadata) ? jsonClone(payload.metadata) : undefined);
-        if (providerMetadata) {
-            metadata.providerMetadata = providerMetadata;
-            semanticsNode = semanticsNode ?? ensureAnthropicSemanticsNode(chatEnvelope);
-            semanticsNode.providerMetadata = jsonClone(providerMetadata);
-        }
-        const mergedParameters = { ...(chatEnvelope.parameters ?? {}) };
-        const mergeParameters = (source) => {
-            if (!source) {
-                return;
-            }
-            for (const [key, value] of Object.entries(source)) {
-                if (mergedParameters[key] !== undefined) {
-                    continue;
-                }
-                mergedParameters[key] = jsonClone(value);
-            }
-        };
-        mergeParameters(collectParameters(payload));
-        if (providerMetadata) {
-            mergedParameters.metadata = jsonClone(providerMetadata);
-        }
-        if (passthrough.passthrough) {
-            for (const [key, value] of Object.entries(passthrough.passthrough)) {
-                mergedParameters[key] = jsonClone(value);
-            }
-        }
-        if (Object.keys(mergedParameters).length) {
-            chatEnvelope.parameters = mergedParameters;
-        }
-        else {
-            delete chatEnvelope.parameters;
-        }
-        try {
-            const bridgePolicy = resolveBridgePolicy({ protocol: 'anthropic-messages' });
-            const actions = resolvePolicyActions(bridgePolicy, 'request_inbound');
-            if (actions?.length) {
-                const actionState = createBridgeActionState({
-                    messages: chatEnvelope.messages,
-                    rawRequest: payload,
-                    metadata: metadata
-                });
-                runBridgeActionPipeline({
-                    stage: 'request_inbound',
-                    actions,
-                    protocol: bridgePolicy?.protocol ?? 'anthropic-messages',
-                    moduleType: bridgePolicy?.moduleType ?? 'anthropic-messages',
-                    requestId: ctx.requestId,
-                    state: actionState
-                });
-            }
-        }
-        catch {
-            // best-effort metadata extraction
-        }
-        return chatEnvelope;
-    }
-    async fromChat(chat, ctx) {
-        // Ensure tool_use / tool_result ordering and per-session history for /v1/messages style entrypoints.
-        try {
-            const { applyToolSessionCompat } = await import('../tool-session-compat.js');
-            await applyToolSessionCompat(chat, ctx);
-        }
-        catch {
-            // best-effort compat; do not block outbound mapping
-        }
-        const model = chat.parameters?.model;
-        if (typeof model !== 'string' || !model.trim()) {
-            throw new Error('ChatEnvelope.parameters.model is required for anthropic-messages outbound conversion');
-        }
-        const baseRequest = {
-            model,
-            messages: chat.messages,
-            tools: chat.tools
-        };
-        const semanticsNode = readAnthropicSemantics(chat);
-        const explicitEmptyTools = (chat.metadata?.toolsFieldPresent === true) || hasExplicitEmptyToolsSemantics(chat);
-        const trimmedParameters = chat.parameters && typeof chat.parameters === 'object' ? chat.parameters : undefined;
-        if (trimmedParameters) {
-            for (const [key, value] of Object.entries(trimmedParameters)) {
-                if (ANTHROPIC_TOP_LEVEL_FIELDS.has(key) || key === 'stop') {
-                    if (key === 'messages' || key === 'tools') {
-                        continue;
-                    }
-                    baseRequest[key] = value;
-                }
-            }
-        }
-        const passthroughMetadata = encodeMetadataPassthrough(chat.parameters, {
-            prefix: PASSTHROUGH_METADATA_PREFIX,
-            keys: PASSTHROUGH_PARAMETERS
-        });
-        if (passthroughMetadata) {
-            const rawMetadata = baseRequest.metadata;
-            const existingMetadata = isJsonObject(rawMetadata)
-                ? jsonClone(rawMetadata)
-                : {};
-            for (const [key, value] of Object.entries(passthroughMetadata)) {
-                existingMetadata[key] = value;
-            }
-            baseRequest.metadata = existingMetadata;
-        }
-        if (baseRequest.max_output_tokens && !baseRequest.max_tokens) {
-            baseRequest.max_tokens = baseRequest.max_output_tokens;
-        }
-        // 出站阶段不再直接透传其它协议的 providerMetadata，避免跨协议打洞；
-        // Anthropic 自身入口的 metadata 已在入站阶段通过 collectParameters/encodeMetadataPassthrough
-        // 按白名单收集，这里仅依赖这些显式映射结果。
-        if (explicitEmptyTools && (!Array.isArray(chat.tools) || chat.tools.length === 0)) {
-            baseRequest.tools = [];
-        }
-        const protocolState = getProtocolState(chat.metadata, 'anthropic');
-        if (protocolState?.systemBlocks !== undefined) {
-            baseRequest.system = jsonClone(protocolState.systemBlocks);
-        }
-        else if (semanticsNode?.systemBlocks !== undefined) {
-            baseRequest.system = jsonClone(semanticsNode.systemBlocks);
-        }
-        if (chat.metadata &&
-            typeof chat.metadata === 'object' &&
-            chat.metadata.extraFields &&
-            typeof chat.metadata.extraFields === 'object' &&
-            chat.metadata.extraFields.anthropicMirror) {
-            baseRequest.__anthropicMirror = jsonClone(chat.metadata.extraFields.anthropicMirror ?? {});
-        }
-        else if (semanticsNode?.mirror && isJsonObject(semanticsNode.mirror)) {
-            baseRequest.__anthropicMirror = jsonClone(semanticsNode.mirror);
-        }
-        const payloadSource = buildAnthropicRequestFromOpenAIChat(baseRequest);
-        const payload = sanitizeAnthropicPayload(JSON.parse(JSON.stringify(payloadSource)));
-        if (chat.metadata?.toolsFieldPresent && (!Array.isArray(chat.tools) || chat.tools.length === 0)) {
-            payload.tools = [];
-        }
-        try {
-            const bridgePolicy = resolveBridgePolicy({ protocol: 'anthropic-messages' });
-            const actions = resolvePolicyActions(bridgePolicy, 'request_outbound');
-            if (actions?.length) {
-                const capturedToolResults = Array.isArray(chat.toolOutputs)
-                    ? chat.toolOutputs.map((entry) => ({
-                        tool_call_id: entry.tool_call_id,
-                        output: entry.content,
-                        name: entry.name
-                    }))
-                    : undefined;
-                const actionState = createBridgeActionState({
-                    messages: Array.isArray(payload.messages) ? payload.messages : undefined,
-                    rawRequest: payload,
-                    metadata: chat.metadata,
-                    capturedToolResults
-                });
-                runBridgeActionPipeline({
-                    stage: 'request_outbound',
-                    actions,
-                    protocol: bridgePolicy?.protocol ?? 'anthropic-messages',
-                    moduleType: bridgePolicy?.moduleType ?? 'anthropic-messages',
-                    requestId: ctx.requestId,
-                    state: actionState
-                });
-            }
-        }
-        catch {
-            // ignore metadata propagation failures
-        }
-        sanitizeAnthropicPayload(payload);
-        return {
-            protocol: 'anthropic-messages',
-            direction: 'response',
-            payload,
-            meta: {
-                context: ctx
-            }
-        };
-    }
-}
+export { AnthropicSemanticMapper } from '../operation-table/semantic-mappers/anthropic-mapper.js';

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

@@ -1,8 +1 @@
-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 function maybeAugmentApplyPatchErrorContent(content: string, toolName?: string): string;
-export declare class ChatSemanticMapper implements SemanticMapper {
-    toChat(format: FormatEnvelope, ctx: AdapterContext): Promise<ChatEnvelope>;
-    fromChat(chat: ChatEnvelope, ctx: AdapterContext): Promise<FormatEnvelope>;
-}
+export { ChatSemanticMapper, maybeAugmentApplyPatchErrorContent } from '../operation-table/semantic-mappers/chat-mapper.js';