@jsonstudio/llms 0.4.5 → 0.6.0

package/dist/conversion/shared/anthropic-message-utils.js

@@ -49,9 +49,112 @@ function requireSystemText(block, context) {
     }
     return text;
 }
+const ANTHROPIC_TOOL_NAME_ALIASES = new Map([
+    ['bash', 'shell_command'],
+    ['shell', 'shell_command'],
+    ['terminal', 'shell_command']
+]);
+const CANONICAL_TO_ANTHROPIC_TOOL_NAMES = new Map([['shell_command', 'Bash']]);
+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'
+]);
+export function normalizeAnthropicToolName(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    const lower = trimmed.toLowerCase();
+    const alias = ANTHROPIC_TOOL_NAME_ALIASES.get(lower);
+    if (alias) {
+        return alias;
+    }
+    if (lower.startsWith('mcp__')) {
+        return lower;
+    }
+    return lower;
+}
+export function denormalizeAnthropicToolName(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    const lower = trimmed.toLowerCase();
+    const mapped = CANONICAL_TO_ANTHROPIC_TOOL_NAMES.get(lower);
+    if (mapped) {
+        return mapped;
+    }
+    if (lower.startsWith('mcp__')) {
+        return trimmed;
+    }
+    return trimmed;
+}
+function invertAnthropicAliasMap(source) {
+    if (!source) {
+        return undefined;
+    }
+    const inverted = {};
+    for (const [canonical, raw] of Object.entries(source)) {
+        if (typeof canonical !== 'string' || typeof raw !== 'string') {
+            continue;
+        }
+        const trimmedCanonical = canonical.trim();
+        const trimmedRaw = raw.trim();
+        if (!trimmedCanonical.length) {
+            continue;
+        }
+        if (trimmedRaw.length) {
+            inverted[trimmedRaw.toLowerCase()] = trimmedCanonical;
+        }
+        if (!inverted[trimmedCanonical.toLowerCase()]) {
+            inverted[trimmedCanonical.toLowerCase()] = trimmedCanonical;
+        }
+    }
+    return Object.keys(inverted).length ? inverted : undefined;
+}
 export function buildOpenAIChatFromAnthropic(payload) {
     const newMessages = [];
     const body = isObject(payload) ? payload : {};
+    const canonicalAliasMap = coerceAliasRecord(buildAnthropicToolAliasMap(body.tools));
+    const reverseAliasMap = invertAnthropicAliasMap(canonicalAliasMap);
+    const resolveToolName = (candidate) => {
+        if (typeof candidate !== 'string') {
+            return '';
+        }
+        const trimmed = candidate.trim();
+        if (!trimmed.length) {
+            return trimmed;
+        }
+        const normalized = normalizeAnthropicToolName(trimmed) ?? trimmed;
+        if (reverseAliasMap) {
+            const direct = reverseAliasMap[trimmed.toLowerCase()];
+            if (typeof direct === 'string' && direct.trim().length) {
+                return direct.trim();
+            }
+            const normalizedLookup = reverseAliasMap[normalized.toLowerCase()];
+            if (typeof normalizedLookup === 'string' && normalizedLookup.trim().length) {
+                return normalizedLookup.trim();
+            }
+        }
+        return normalized;
+    };
     const rawSystem = body.system;
     const systemBlocks = Array.isArray(rawSystem)
         ? rawSystem
@@ -107,7 +210,8 @@ export function buildOpenAIChatFromAnthropic(payload) {
                 const id = requireTrimmedString(block.id, 'tool_use.id');
                 const input = block.input ?? {};
                 const args = safeJson(input);
-                toolCalls.push({ id, type: 'function', function: { name, arguments: args } });
+                const canonicalName = resolveToolName(name) || name;
+                toolCalls.push({ id, type: 'function', function: { name: canonicalName, arguments: args } });
             }
             else if (t === 'tool_result') {
                 const callId = requireTrimmedString(block.tool_call_id ??
@@ -131,16 +235,17 @@ export function buildOpenAIChatFromAnthropic(payload) {
         }
         const combinedText = textParts.join('\n');
         const normalized = normalizeChatMessageContent(combinedText);
+        const hasRawText = typeof combinedText === 'string' && combinedText.trim().length > 0;
         const mergedReasoning = [...reasoningParts];
         if (typeof normalized.reasoningText === 'string' && normalized.reasoningText.trim().length) {
             mergedReasoning.push(normalized.reasoningText.trim());
         }
         const hasText = typeof normalized.contentText === 'string' && normalized.contentText.length > 0;
         const hasReasoning = mergedReasoning.length > 0;
-        if (hasText || toolCalls.length > 0 || hasReasoning) {
+        if (hasText || hasRawText || toolCalls.length > 0 || hasReasoning) {
             const msg = {
                 role,
-                content: normalized.contentText ?? combinedText ?? ''
+                content: (hasText ? normalized.contentText : undefined) ?? combinedText ?? ''
             };
             if (toolCalls.length)
                 msg.tool_calls = toolCalls;
@@ -192,7 +297,7 @@ export function buildOpenAIChatFromAnthropic(payload) {
     }
     return request;
 }
-export function buildAnthropicFromOpenAIChat(oa) {
+export function buildAnthropicFromOpenAIChat(oa, options) {
     const mapFinishReason = (reason) => {
         if (typeof reason !== 'string' || !reason.trim().length) {
             return undefined;
@@ -239,11 +344,13 @@ export function buildAnthropicFromOpenAIChat(oa) {
         blocks.push({ type: 'thinking', text: reasoningField.trim() });
     }
     const toolCalls = Array.isArray(msg?.tool_calls) ? msg.tool_calls : [];
+    const toolNameResolver = createAnthropicToolNameResolver(options?.toolNameMap ?? extractToolNameMapFromPayload(oa));
     for (const tc of toolCalls) {
         try {
             const id = requireTrimmedString(tc?.id, 'chat.tool_call.id');
             const fn = isObject(tc?.function) ? tc.function : {};
-            const name = requireTrimmedString(fn.name, 'chat.tool_call.function.name');
+            const canonicalName = requireTrimmedString(fn.name, 'chat.tool_call.function.name');
+            const name = toolNameResolver ? toolNameResolver(canonicalName) : canonicalName;
             const argsRaw = fn.arguments;
             let input;
             if (typeof argsRaw === 'string') {
@@ -271,16 +378,143 @@ export function buildAnthropicFromOpenAIChat(oa) {
         typeof body.choices[0]?.finish_reason === 'string'
         ? String(body.choices[0].finish_reason).trim()
         : undefined;
-    const stopReason = mapFinishReason(finishReason);
+    const stopReasonCandidate = mapFinishReason(finishReason) ||
+        mapFinishReason(typeof primary?.finish_reason === 'string' ? String(primary.finish_reason) : undefined) ||
+        (typeof body?.stop_reason === 'string' ? String(body.stop_reason).trim() : undefined) ||
+        (typeof primary?.stop_reason === 'string' ? String(primary.stop_reason).trim() : undefined);
+    const hasToolCalls = toolCalls.length > 0;
+    const stopReason = stopReasonCandidate ?? (hasToolCalls ? 'tool_use' : 'end_turn');
+    const resolveResponseId = () => {
+        const preferred = [
+            body?.id,
+            body?.response?.id,
+            body?.response_id
+        ];
+        for (const candidateRaw of preferred) {
+            if (typeof candidateRaw !== 'string')
+                continue;
+            const candidate = candidateRaw.trim();
+            if (!candidate.length)
+                continue;
+            if (candidate.startsWith('resp_')) {
+                return candidate;
+            }
+        }
+        const fromRequest = typeof options?.requestId === 'string' && options.requestId.trim().startsWith('resp_')
+            ? options.requestId.trim()
+            : undefined;
+        return fromRequest ?? `resp_${Date.now()}`;
+    };
+    const resolveCreated = () => {
+        const candidateNumbers = [
+            body?.created,
+            body?.created_at,
+            body?.response?.created,
+            body?.response?.created_at
+        ];
+        for (const candidate of candidateNumbers) {
+            if (typeof candidate === 'number' && Number.isFinite(candidate)) {
+                return Math.floor(candidate);
+            }
+        }
+        return Math.floor(Date.now() / 1000);
+    };
     return {
-        id: `resp_${Date.now()}`,
+        id: resolveResponseId(),
         type: 'message',
         role,
         model: String(body.model || 'unknown'),
-        created: Math.floor(Date.now() / 1000),
+        created: resolveCreated(),
         content: blocks,
         usage: inputTokens || outputTokens ? { input_tokens: inputTokens, output_tokens: outputTokens } : undefined,
-        ...(stopReason ? { stop_reason: stopReason } : {})
+        stop_reason: stopReason
+    };
+}
+function extractToolNameMapFromPayload(payload) {
+    if (!payload || typeof payload !== 'object') {
+        return undefined;
+    }
+    const candidateSources = [
+        payload.anthropicToolNameMap,
+        payload.__anthropicToolNameMap,
+        payload.metadata &&
+            typeof payload.metadata === 'object'
+            ? payload.metadata.anthropicToolNameMap
+            : undefined,
+        payload.metadata &&
+            typeof payload.metadata === 'object'
+            ? payload.metadata.extraFields &&
+                typeof payload.metadata.extraFields === 'object'
+                ? payload.metadata.extraFields.anthropicToolNameMap
+                : undefined
+            : undefined,
+        payload.metadata &&
+            typeof payload.metadata === 'object' &&
+            payload.metadata.capturedContext &&
+            typeof payload.metadata.capturedContext === 'object'
+            ? (payload.metadata.capturedContext.__hub_capture &&
+                typeof payload.metadata.capturedContext.__hub_capture === 'object'
+                ? payload.metadata.capturedContext.__hub_capture.extraFields &&
+                    typeof payload.metadata.capturedContext.__hub_capture.extraFields === 'object'
+                    ? payload.metadata.capturedContext.__hub_capture.extraFields
+                    : undefined
+                : undefined)
+            : undefined
+    ];
+    for (const candidate of candidateSources) {
+        const map = coerceAliasRecord(candidate);
+        if (map) {
+            return map;
+        }
+    }
+    return undefined;
+}
+function coerceAliasRecord(candidate) {
+    if (!candidate || typeof candidate !== 'object' || Array.isArray(candidate)) {
+        return undefined;
+    }
+    let hasEntry = false;
+    const output = {};
+    for (const [key, value] of Object.entries(candidate)) {
+        if (typeof key !== 'string' || typeof value !== 'string') {
+            continue;
+        }
+        const trimmedKey = key.trim();
+        if (!trimmedKey.length) {
+            continue;
+        }
+        output[trimmedKey] = value;
+        hasEntry = true;
+    }
+    return hasEntry ? output : undefined;
+}
+function createAnthropicToolNameResolver(source) {
+    if (!source) {
+        return undefined;
+    }
+    const lookup = new Map();
+    for (const [key, value] of Object.entries(source)) {
+        if (typeof key !== 'string' || typeof value !== 'string')
+            continue;
+        const canonical = key.trim();
+        if (!canonical.length)
+            continue;
+        const alias = value.trim() || canonical;
+        lookup.set(canonical, alias);
+        const lower = canonical.toLowerCase();
+        if (!lookup.has(lower)) {
+            lookup.set(lower, alias);
+        }
+    }
+    if (!lookup.size) {
+        return undefined;
+    }
+    return (name) => {
+        const trimmed = name.trim();
+        if (!trimmed.length) {
+            return name;
+        }
+        return lookup.get(trimmed) ?? lookup.get(trimmed.toLowerCase()) ?? trimmed;
     };
 }
 export function buildAnthropicRequestFromOpenAIChat(chatReq) {
@@ -323,6 +557,8 @@ export function buildAnthropicRequestFromOpenAIChat(chatReq) {
         return '';
     };
     const msgs = Array.isArray(requestBody?.messages) ? requestBody.messages : [];
+    const mirrorShapes = extractMirrorShapesFromRequest(requestBody);
+    let mirrorIndex = 0;
     const knownToolCallIds = new Set();
     for (const m of msgs) {
         if (!m || typeof m !== 'object')
@@ -375,6 +611,11 @@ export function buildAnthropicRequestFromOpenAIChat(chatReq) {
         if (!m || typeof m !== 'object')
             continue;
         const role = String(m.role || 'user');
+        let targetShape;
+        if (role !== 'system' && Array.isArray(mirrorShapes)) {
+            targetShape = mirrorShapes[mirrorIndex];
+            mirrorIndex += 1;
+        }
         const text = collectText(m.content).trim();
         if (role === 'system') {
             if (!text) {
@@ -426,7 +667,12 @@ export function buildAnthropicRequestFromOpenAIChat(chatReq) {
             blocks.push({ type: 'tool_use', id, name, input });
         }
         if (blocks.length > 0) {
-            messages.push({ role, content: blocks });
+            const hasStructuredBlocks = blocks.some((block) => block && typeof block === 'object' && block.type !== 'text');
+            let contentNode = blocks;
+            if (targetShape === 'string' || (!targetShape && !hasStructuredBlocks)) {
+                contentNode = text;
+            }
+            messages.push({ role, content: contentNode });
         }
     }
     const out = { model };
@@ -467,7 +713,7 @@ export function buildAnthropicRequestFromOpenAIChat(chatReq) {
     else if (Array.isArray(stop) && stop.length > 0) {
         out.stop_sequences = stop.map((s) => String(s)).filter(Boolean);
     }
-    return out;
+    return pruneAnthropicRequest(out);
 }
 function isPlainRecord(value) {
     return !!value && typeof value === 'object' && !Array.isArray(value);
@@ -560,7 +806,7 @@ function convertBridgeToolToAnthropic(def) {
         name,
         input_schema: inputSchema
     };
-    if (description) {
+    if (description !== undefined) {
         tool.description = description;
     }
     return tool;
@@ -570,13 +816,13 @@ export function mapAnthropicToolsToChat(rawTools, missing) {
     if (prepared === undefined) {
         return undefined;
     }
-    return mapBridgeToolsToChat(prepared);
+    return mapBridgeToolsToChat(prepared, { sanitizeName: normalizeAnthropicToolName });
 }
 export function mapChatToolsToAnthropicTools(rawTools) {
     if (!Array.isArray(rawTools) || rawTools.length === 0) {
         return undefined;
     }
-    const bridgeDefs = mapChatToolsToBridge(rawTools);
+    const bridgeDefs = mapChatToolsToBridge(rawTools, { sanitizeName: denormalizeAnthropicToolName });
     if (!bridgeDefs || !bridgeDefs.length) {
         return undefined;
     }
@@ -585,3 +831,77 @@ export function mapChatToolsToAnthropicTools(rawTools) {
         .filter((entry) => !!entry);
     return converted.length ? converted : undefined;
 }
+function pruneAnthropicRequest(payload) {
+    for (const key of Object.keys(payload)) {
+        if (!ANTHROPIC_TOP_LEVEL_FIELDS.has(key)) {
+            delete payload[key];
+        }
+    }
+    return payload;
+}
+function extractMirrorShapesFromRequest(source) {
+    const directMirror = source &&
+        typeof source === 'object' &&
+        source.__anthropicMirror &&
+        typeof source.__anthropicMirror === 'object'
+        ? source.__anthropicMirror
+        : extractMirrorFromMetadata(source);
+    if (!directMirror) {
+        return undefined;
+    }
+    const shapes = directMirror.messageContentShape;
+    if (!Array.isArray(shapes)) {
+        return undefined;
+    }
+    return shapes.map((entry) => (typeof entry === 'string' ? entry : String(entry ?? '')));
+}
+function extractMirrorFromMetadata(source) {
+    if (!source || typeof source !== 'object') {
+        return undefined;
+    }
+    const metadata = source.metadata;
+    if (!metadata || typeof metadata !== 'object') {
+        return undefined;
+    }
+    const extraFields = metadata.extraFields;
+    if (!extraFields || typeof extraFields !== 'object') {
+        return undefined;
+    }
+    const mirror = extraFields.anthropicMirror;
+    return mirror && typeof mirror === 'object' ? mirror : undefined;
+}
+export function buildAnthropicToolAliasMap(rawTools) {
+    if (!Array.isArray(rawTools) || rawTools.length === 0) {
+        return undefined;
+    }
+    const aliasMap = new Map();
+    for (const entry of rawTools) {
+        if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
+            continue;
+        }
+        const rawName = typeof entry.name === 'string'
+            ? entry.name.trim()
+            : undefined;
+        if (!rawName) {
+            continue;
+        }
+        const normalized = normalizeAnthropicToolName(rawName) ?? rawName;
+        const canonicalKey = normalized.trim();
+        if (!canonicalKey.length) {
+            continue;
+        }
+        aliasMap.set(canonicalKey, rawName);
+        const lowerKey = canonicalKey.toLowerCase();
+        if (lowerKey !== canonicalKey && !aliasMap.has(lowerKey)) {
+            aliasMap.set(lowerKey, rawName);
+        }
+    }
+    if (!aliasMap.size) {
+        return undefined;
+    }
+    const serialized = {};
+    for (const [key, value] of aliasMap.entries()) {
+        serialized[key] = value;
+    }
+    return serialized;
+}