@jsonstudio/llms 0.6.938 → 0.6.1164

package/dist/conversion/hub/operation-table/operation-table-runner.d.ts

@@ -0,0 +1,18 @@
+import type { AdapterContext, ChatEnvelope } from '../types/chat-envelope.js';
+import type { FormatEnvelope } from '../types/format-envelope.js';
+import type { JsonObject } from '../types/json.js';
+export declare function applyHubOperationTableInbound(options: {
+    formatEnvelope: FormatEnvelope<JsonObject>;
+    chatEnvelope: ChatEnvelope;
+    adapterContext: AdapterContext;
+}): void;
+export declare function applyHubOperationTableOutboundPreMap(options: {
+    protocol: string;
+    chatEnvelope: ChatEnvelope;
+    adapterContext: AdapterContext;
+}): Promise<void>;
+export declare function applyHubOperationTableOutboundPostMap(options: {
+    chatEnvelope: ChatEnvelope;
+    formatEnvelope: FormatEnvelope<JsonObject>;
+    adapterContext: AdapterContext;
+}): void;

package/dist/conversion/hub/operation-table/operation-table-runner.js

@@ -0,0 +1,158 @@
+import { createBridgeActionState, runBridgeActionPipeline } from '../../shared/bridge-actions.js';
+import { resolveBridgePolicy, resolvePolicyActions } from '../../shared/bridge-policies.js';
+const INBOUND_BRIDGE_SPECS = {
+    'openai-chat': { protocol: 'openai-chat', stage: 'request_inbound', messages: 'chat_envelope' },
+    // Keep parity with the legacy semantic mapper behavior: do not pass messages[] into the action state
+    // for openai-responses, since the bridge actions here are used as metadata hooks only.
+    'openai-responses': { protocol: 'openai-responses', stage: 'request_inbound', messages: 'none', includeCapturedToolResults: true, moduleType: 'openai-responses' },
+    'anthropic-messages': { protocol: 'anthropic-messages', stage: 'request_inbound', messages: 'chat_envelope' },
+    'gemini-chat': { protocol: 'gemini-chat', stage: 'request_inbound', messages: 'chat_envelope' }
+};
+const OUTBOUND_BRIDGE_SPECS = {
+    'openai-chat': { protocol: 'openai-chat', stage: 'request_outbound', messages: 'format_payload_messages', includeCapturedToolResults: true },
+    // Keep parity: openai-responses outbound actions should not touch normalized messages.
+    'openai-responses': { protocol: 'openai-responses', stage: 'request_outbound', messages: 'none', moduleType: 'openai-responses' },
+    'anthropic-messages': { protocol: 'anthropic-messages', stage: 'request_outbound', messages: 'format_payload_messages', includeCapturedToolResults: true },
+    // Keep parity with legacy gemini mapper: outbound hooks operate on ChatEnvelope.messages (not Gemini contents).
+    'gemini-chat': { protocol: 'gemini-chat', stage: 'request_outbound', messages: 'chat_envelope', includeCapturedToolResults: true }
+};
+function isSupportedProtocol(protocol) {
+    return protocol === 'openai-chat' ||
+        protocol === 'openai-responses' ||
+        protocol === 'anthropic-messages' ||
+        protocol === 'gemini-chat';
+}
+function extractPayloadMessages(payload) {
+    const value = payload?.messages;
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    return value;
+}
+function buildCapturedToolResults(toolOutputs) {
+    if (!Array.isArray(toolOutputs) || toolOutputs.length === 0) {
+        return undefined;
+    }
+    return toolOutputs.map((entry) => ({
+        tool_call_id: entry.tool_call_id,
+        output: entry.content,
+        name: entry.name
+    }));
+}
+function applyBridgePolicy(spec, options) {
+    const bridgePolicy = resolveBridgePolicy({ protocol: spec.protocol, moduleType: spec.moduleType ?? spec.protocol });
+    const actions = resolvePolicyActions(bridgePolicy, spec.stage);
+    if (!actions?.length) {
+        return;
+    }
+    const metadata = options.chatEnvelope.metadata;
+    const messages = spec.messages === 'chat_envelope'
+        ? options.chatEnvelope.messages
+        : spec.messages === 'format_payload_messages'
+            ? extractPayloadMessages(options.payload)
+            : undefined;
+    const capturedToolResults = spec.includeCapturedToolResults
+        ? buildCapturedToolResults(options.chatEnvelope.toolOutputs)
+        : undefined;
+    const actionState = createBridgeActionState({
+        ...(messages ? { messages } : {}),
+        rawRequest: options.payload,
+        metadata,
+        ...(capturedToolResults ? { capturedToolResults } : {})
+    });
+    runBridgeActionPipeline({
+        stage: spec.stage,
+        actions,
+        protocol: bridgePolicy?.protocol ?? spec.protocol,
+        moduleType: bridgePolicy?.moduleType ?? spec.moduleType ?? spec.protocol,
+        requestId: options.requestId,
+        state: actionState
+    });
+    if (spec.messages === 'chat_envelope') {
+        options.chatEnvelope.messages = actionState.messages;
+    }
+}
+function normalizeToolContent(value) {
+    if (typeof value === 'string')
+        return value;
+    if (value == null)
+        return '';
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value ?? '');
+    }
+}
+function rebuildGeminiToolOutputsFromMessages(chatEnvelope) {
+    const messages = Array.isArray(chatEnvelope.messages) ? chatEnvelope.messages : [];
+    const missing = Array.isArray(chatEnvelope.metadata?.missingFields) ? chatEnvelope.metadata.missingFields : undefined;
+    const outputs = [];
+    messages.forEach((msg, index) => {
+        if (!msg || typeof msg !== 'object')
+            return;
+        if (msg.role !== 'tool')
+            return;
+        const callId = msg.tool_call_id || msg.id;
+        if (typeof callId !== 'string' || !callId.trim()) {
+            if (missing) {
+                missing.push({ path: `messages[${index}].tool_call_id`, reason: 'missing_tool_call_id' });
+            }
+            return;
+        }
+        outputs.push({
+            tool_call_id: callId.trim(),
+            content: normalizeToolContent(msg.content),
+            name: typeof msg.name === 'string' ? msg.name : undefined
+        });
+    });
+    chatEnvelope.toolOutputs = outputs.length ? outputs : undefined;
+}
+export function applyHubOperationTableInbound(options) {
+    const protocol = options.formatEnvelope.protocol;
+    if (!isSupportedProtocol(protocol)) {
+        return;
+    }
+    const payload = (options.formatEnvelope.payload ?? {});
+    const spec = INBOUND_BRIDGE_SPECS[protocol];
+    applyBridgePolicy(spec, {
+        requestId: options.adapterContext.requestId,
+        chatEnvelope: options.chatEnvelope,
+        payload,
+        adapterContext: options.adapterContext
+    });
+    if (protocol === 'gemini-chat') {
+        // Keep parity: gemini mapper rebuilds toolOutputs after inbound policy adjustments.
+        rebuildGeminiToolOutputsFromMessages(options.chatEnvelope);
+    }
+}
+export function applyHubOperationTableOutboundPreMap(options) {
+    if (options.protocol !== 'anthropic-messages' && options.protocol !== 'gemini-chat') {
+        return Promise.resolve();
+    }
+    // Ensure tool_use/tool_result ordering and per-session history for protocols that depend on it.
+    return (async () => {
+        try {
+            const { applyToolSessionCompat } = await import('../tool-session-compat.js');
+            await applyToolSessionCompat(options.chatEnvelope, options.adapterContext);
+        }
+        catch {
+            // best-effort compat; never block outbound mapping
+        }
+    })();
+}
+export function applyHubOperationTableOutboundPostMap(options) {
+    const protocol = options.formatEnvelope.protocol;
+    if (!isSupportedProtocol(protocol)) {
+        return;
+    }
+    const payload = (options.formatEnvelope.payload ?? {});
+    const spec = OUTBOUND_BRIDGE_SPECS[protocol];
+    applyBridgePolicy(spec, {
+        requestId: options.adapterContext.requestId,
+        chatEnvelope: options.chatEnvelope,
+        payload,
+        adapterContext: options.adapterContext
+    });
+    options.formatEnvelope.payload = payload;
+}

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

@@ -0,0 +1,8 @@
+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 {
+    private readonly chatMapper;
+    toChat(format: FormatEnvelope, ctx: AdapterContext): Promise<ChatEnvelope>;
+    fromChat(chat: ChatEnvelope, ctx: AdapterContext): Promise<FormatEnvelope>;
+}

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

@@ -0,0 +1,303 @@
+import { isJsonObject, jsonClone } from '../../types/json.js';
+import { buildOpenAIChatFromAnthropic, buildAnthropicRequestFromOpenAIChat } from '../../../codecs/anthropic-openai-codec.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;
+        }
+        return chatEnvelope;
+    }
+    async fromChat(chat, ctx) {
+        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 = [];
+        }
+        sanitizeAnthropicPayload(payload);
+        return {
+            protocol: 'anthropic-messages',
+            direction: 'response',
+            payload,
+            meta: {
+                context: ctx
+            }
+        };
+    }
+}

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

@@ -0,0 +1,8 @@
+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>;
+}