@illuma-ai/agents 1.0.81

package/dist/cjs/llm/anthropic/utils/message_inputs.cjs

@@ -0,0 +1,630 @@
+'use strict';
+
+var messages = require('@langchain/core/messages');
+var types = require('../types.cjs');
+
+/* eslint-disable @typescript-eslint/explicit-function-return-type */
+/* eslint-disable no-console */
+/**
+ * This util file contains functions for converting LangChain messages to Anthropic messages.
+ */
+function _formatImage(imageUrl) {
+    const parsed = messages.parseBase64DataUrl({ dataUrl: imageUrl });
+    if (parsed) {
+        return {
+            type: 'base64',
+            media_type: parsed.mime_type,
+            data: parsed.data,
+        };
+    }
+    let parsedUrl;
+    try {
+        parsedUrl = new URL(imageUrl);
+    }
+    catch {
+        throw new Error([
+            `Malformed image URL: ${JSON.stringify(imageUrl)}. Content blocks of type 'image_url' must be a valid http, https, or base64-encoded data URL.`,
+            'Example: data:image/png;base64,/9j/4AAQSk...',
+            'Example: https://example.com/image.jpg',
+        ].join('\n\n'));
+    }
+    if (parsedUrl.protocol === 'http:' || parsedUrl.protocol === 'https:') {
+        return {
+            type: 'url',
+            url: imageUrl,
+        };
+    }
+    throw new Error([
+        `Invalid image URL protocol: ${JSON.stringify(parsedUrl.protocol)}. Anthropic only supports images as http, https, or base64-encoded data URLs on 'image_url' content blocks.`,
+        'Example: data:image/png;base64,/9j/4AAQSk...',
+        'Example: https://example.com/image.jpg',
+    ].join('\n\n'));
+}
+function _ensureMessageContents(messages$1) {
+    // Merge runs of human/tool messages into single human messages with content blocks.
+    const updatedMsgs = [];
+    for (const message of messages$1) {
+        if (message._getType() === 'tool') {
+            if (typeof message.content === 'string') {
+                const previousMessage = updatedMsgs[updatedMsgs.length - 1];
+                if (previousMessage._getType() === 'human' &&
+                    Array.isArray(previousMessage.content) &&
+                    'type' in previousMessage.content[0] &&
+                    previousMessage.content[0].type === 'tool_result') {
+                    // If the previous message was a tool result, we merge this tool message into it.
+                    previousMessage.content.push({
+                        type: 'tool_result',
+                        content: message.content,
+                        tool_use_id: message.tool_call_id,
+                    });
+                }
+                else {
+                    // If not, we create a new human message with the tool result.
+                    updatedMsgs.push(new messages.HumanMessage({
+                        content: [
+                            {
+                                type: 'tool_result',
+                                content: message.content,
+                                tool_use_id: message.tool_call_id,
+                            },
+                        ],
+                    }));
+                }
+            }
+            else {
+                updatedMsgs.push(new messages.HumanMessage({
+                    content: [
+                        {
+                            type: 'tool_result',
+                            // rare case: message.content could be undefined
+                            ...(message.content != null
+                                ? { content: _formatContent(message) }
+                                : {}),
+                            tool_use_id: message.tool_call_id,
+                        },
+                    ],
+                }));
+            }
+        }
+        else {
+            updatedMsgs.push(message);
+        }
+    }
+    return updatedMsgs;
+}
+function _convertLangChainToolCallToAnthropic(toolCall) {
+    if (toolCall.id === undefined) {
+        throw new Error('Anthropic requires all tool calls to have an "id".');
+    }
+    return {
+        type: 'tool_use',
+        id: toolCall.id,
+        name: toolCall.name,
+        input: toolCall.args,
+    };
+}
+const standardContentBlockConverter = {
+    providerName: 'anthropic',
+    fromStandardTextBlock(block) {
+        return {
+            type: 'text',
+            text: block.text,
+            ...('citations' in (block.metadata ?? {})
+                ? { citations: block.metadata.citations }
+                : {}),
+            ...('cache_control' in (block.metadata ?? {})
+                ? { cache_control: block.metadata.cache_control }
+                : {}),
+        };
+    },
+    fromStandardImageBlock(block) {
+        if (block.source_type === 'url') {
+            const data = messages.parseBase64DataUrl({
+                dataUrl: block.url,
+                asTypedArray: false,
+            });
+            if (data) {
+                return {
+                    type: 'image',
+                    source: {
+                        type: 'base64',
+                        data: data.data,
+                        media_type: data.mime_type,
+                    },
+                    ...('cache_control' in (block.metadata ?? {})
+                        ? { cache_control: block.metadata.cache_control }
+                        : {}),
+                };
+            }
+            else {
+                return {
+                    type: 'image',
+                    source: {
+                        type: 'url',
+                        url: block.url,
+                        media_type: block.mime_type ?? '',
+                    },
+                    ...('cache_control' in (block.metadata ?? {})
+                        ? { cache_control: block.metadata.cache_control }
+                        : {}),
+                };
+            }
+        }
+        else {
+            if (block.source_type === 'base64') {
+                return {
+                    type: 'image',
+                    source: {
+                        type: 'base64',
+                        data: block.data,
+                        media_type: block.mime_type ?? '',
+                    },
+                    ...('cache_control' in (block.metadata ?? {})
+                        ? { cache_control: block.metadata.cache_control }
+                        : {}),
+                };
+            }
+            else {
+                throw new Error(`Unsupported image source type: ${block.source_type}`);
+            }
+        }
+    },
+    fromStandardFileBlock(block) {
+        const mime_type = (block.mime_type ?? '').split(';')[0];
+        if (block.source_type === 'url') {
+            if (mime_type === 'application/pdf' || mime_type === '') {
+                return {
+                    type: 'document',
+                    source: {
+                        type: 'url',
+                        url: block.url,
+                        media_type: block.mime_type ?? '',
+                    },
+                    ...('cache_control' in (block.metadata ?? {})
+                        ? { cache_control: block.metadata.cache_control }
+                        : {}),
+                    ...('citations' in (block.metadata ?? {})
+                        ? { citations: block.metadata.citations }
+                        : {}),
+                    ...('context' in (block.metadata ?? {})
+                        ? { context: block.metadata.context }
+                        : {}),
+                    ...('title' in (block.metadata ?? {})
+                        ? { title: block.metadata.title }
+                        : {}),
+                };
+            }
+            throw new Error(`Unsupported file mime type for file url source: ${block.mime_type}`);
+        }
+        else if (block.source_type === 'text') {
+            if (mime_type === 'text/plain' || mime_type === '') {
+                return {
+                    type: 'document',
+                    source: {
+                        type: 'text',
+                        data: block.text,
+                        media_type: block.mime_type ?? '',
+                    },
+                    ...('cache_control' in (block.metadata ?? {})
+                        ? { cache_control: block.metadata.cache_control }
+                        : {}),
+                    ...('citations' in (block.metadata ?? {})
+                        ? { citations: block.metadata.citations }
+                        : {}),
+                    ...('context' in (block.metadata ?? {})
+                        ? { context: block.metadata.context }
+                        : {}),
+                    ...('title' in (block.metadata ?? {})
+                        ? { title: block.metadata.title }
+                        : {}),
+                };
+            }
+            else {
+                throw new Error(`Unsupported file mime type for file text source: ${block.mime_type}`);
+            }
+        }
+        else if (block.source_type === 'base64') {
+            if (mime_type === 'application/pdf' || mime_type === '') {
+                return {
+                    type: 'document',
+                    source: {
+                        type: 'base64',
+                        data: block.data,
+                        media_type: 'application/pdf',
+                    },
+                    ...('cache_control' in (block.metadata ?? {})
+                        ? { cache_control: block.metadata.cache_control }
+                        : {}),
+                    ...('citations' in (block.metadata ?? {})
+                        ? { citations: block.metadata.citations }
+                        : {}),
+                    ...('context' in (block.metadata ?? {})
+                        ? { context: block.metadata.context }
+                        : {}),
+                    ...('title' in (block.metadata ?? {})
+                        ? { title: block.metadata.title }
+                        : {}),
+                };
+            }
+            else if (['image/jpeg', 'image/png', 'image/gif', 'image/webp'].includes(mime_type)) {
+                return {
+                    type: 'document',
+                    source: {
+                        type: 'content',
+                        content: [
+                            {
+                                type: 'image',
+                                source: {
+                                    type: 'base64',
+                                    data: block.data,
+                                    media_type: mime_type,
+                                },
+                            },
+                        ],
+                    },
+                    ...('cache_control' in (block.metadata ?? {})
+                        ? { cache_control: block.metadata.cache_control }
+                        : {}),
+                    ...('citations' in (block.metadata ?? {})
+                        ? { citations: block.metadata.citations }
+                        : {}),
+                    ...('context' in (block.metadata ?? {})
+                        ? { context: block.metadata.context }
+                        : {}),
+                    ...('title' in (block.metadata ?? {})
+                        ? { title: block.metadata.title }
+                        : {}),
+                };
+            }
+            else {
+                throw new Error(`Unsupported file mime type for file base64 source: ${block.mime_type}`);
+            }
+        }
+        else {
+            throw new Error(`Unsupported file source type: ${block.source_type}`);
+        }
+    },
+};
+function _formatContent(message) {
+    const toolTypes = [
+        'tool_use',
+        'tool_result',
+        'input_json_delta',
+        'server_tool_use',
+        'web_search_tool_result',
+        'web_search_result',
+    ];
+    const textTypes = ['text', 'text_delta'];
+    const { content } = message;
+    if (typeof content === 'string') {
+        return content;
+    }
+    else {
+        const contentBlocks = content.map((contentPart) => {
+            /**
+             * Handle malformed blocks that have server tool fields mixed with text type.
+             * These can occur when server_tool_use blocks get mislabeled during aggregation.
+             * Correct their type ONLY if we can confirm it's a server tool by checking the ID prefix.
+             * Anthropic needs both server_tool_use and web_search_tool_result blocks for citations to work.
+             */
+            if ('id' in contentPart &&
+                'name' in contentPart &&
+                'input' in contentPart &&
+                contentPart.type === 'text') {
+                const rawPart = contentPart;
+                const id = rawPart.id;
+                // Only correct if this is definitely a server tool (ID starts with 'srvtoolu_')
+                if (id && id.startsWith('srvtoolu_')) {
+                    let input = rawPart.input;
+                    // Ensure input is an object
+                    if (typeof input === 'string') {
+                        try {
+                            input = JSON.parse(input);
+                        }
+                        catch {
+                            input = {};
+                        }
+                    }
+                    const corrected = {
+                        type: 'server_tool_use',
+                        id,
+                        name: 'web_search',
+                        input: input,
+                    };
+                    return corrected;
+                }
+                // If it's not a server tool, skip it (return null to filter it out)
+                return null;
+            }
+            /**
+             * Handle malformed web_search_tool_result blocks marked as text.
+             * These have tool_use_id and nested content - fix their type instead of filtering.
+             * Only correct if we can confirm it's a web search result by checking the tool_use_id prefix.
+             *
+             * Handles both success results (array content) and error results (object with error_code).
+             */
+            if ('tool_use_id' in contentPart &&
+                'content' in contentPart &&
+                contentPart.type === 'text') {
+                const rawPart = contentPart;
+                const toolUseId = rawPart.tool_use_id;
+                const content = rawPart.content;
+                // Only correct if this is definitely a server tool result (tool_use_id starts with 'srvtoolu_')
+                if (toolUseId && toolUseId.startsWith('srvtoolu_')) {
+                    // Verify content is either an array (success) or error object
+                    const isValidContent = Array.isArray(content) ||
+                        (content != null &&
+                            typeof content === 'object' &&
+                            'type' in content &&
+                            content.type ===
+                                'web_search_tool_result_error');
+                    if (isValidContent) {
+                        const corrected = {
+                            type: 'web_search_tool_result',
+                            tool_use_id: toolUseId,
+                            content: content,
+                        };
+                        return corrected;
+                    }
+                }
+                // If it's not a recognized server tool result format, skip it (return null to filter it out)
+                return null;
+            }
+            if (messages.isDataContentBlock(contentPart)) {
+                return messages.convertToProviderContentBlock(contentPart, standardContentBlockConverter);
+            }
+            const cacheControl = 'cache_control' in contentPart ? contentPart.cache_control : undefined;
+            if (contentPart.type === 'image_url') {
+                let source;
+                if (typeof contentPart.image_url === 'string') {
+                    source = _formatImage(contentPart.image_url);
+                }
+                else {
+                    source = _formatImage(contentPart.image_url.url);
+                }
+                return {
+                    type: 'image', // Explicitly setting the type as "image"
+                    source,
+                    ...(cacheControl ? { cache_control: cacheControl } : {}),
+                };
+            }
+            else if (types.isAnthropicImageBlockParam(contentPart)) {
+                return contentPart;
+            }
+            else if (contentPart.type === 'document') {
+                // PDF
+                return {
+                    ...contentPart,
+                    ...(cacheControl ? { cache_control: cacheControl } : {}),
+                };
+            }
+            else if (contentPart.type === 'thinking') {
+                const block = {
+                    type: 'thinking', // Explicitly setting the type as "thinking"
+                    thinking: contentPart.thinking,
+                    signature: contentPart.signature,
+                    ...(cacheControl ? { cache_control: cacheControl } : {}),
+                };
+                return block;
+            }
+            else if (contentPart.type === 'redacted_thinking') {
+                const block = {
+                    type: 'redacted_thinking', // Explicitly setting the type as "redacted_thinking"
+                    data: contentPart.data,
+                    ...(cacheControl ? { cache_control: cacheControl } : {}),
+                };
+                return block;
+            }
+            else if (contentPart.type === 'search_result') {
+                const block = {
+                    type: 'search_result', // Explicitly setting the type as "search_result"
+                    title: contentPart.title,
+                    source: contentPart.source,
+                    ...('cache_control' in contentPart && contentPart.cache_control
+                        ? { cache_control: contentPart.cache_control }
+                        : {}),
+                    ...('citations' in contentPart && contentPart.citations
+                        ? { citations: contentPart.citations }
+                        : {}),
+                    content: contentPart.content,
+                };
+                return block;
+            }
+            else if (textTypes.find((t) => t === contentPart.type) &&
+                'text' in contentPart) {
+                // Assuming contentPart is of type MessageContentText here
+                return {
+                    type: 'text', // Explicitly setting the type as "text"
+                    text: contentPart.text,
+                    ...(cacheControl ? { cache_control: cacheControl } : {}),
+                    ...('citations' in contentPart && contentPart.citations
+                        ? { citations: contentPart.citations }
+                        : {}),
+                };
+            }
+            else if (toolTypes.find((t) => t === contentPart.type)) {
+                const contentPartCopy = { ...contentPart };
+                if ('index' in contentPartCopy) {
+                    // Anthropic does not support passing the index field here, so we remove it.
+                    delete contentPartCopy.index;
+                }
+                if (contentPartCopy.type === 'input_json_delta') {
+                    // `input_json_delta` type only represents yielding partial tool inputs
+                    // and is not a valid type for Anthropic messages.
+                    contentPartCopy.type = 'tool_use';
+                }
+                if ('input' in contentPartCopy) {
+                    // Anthropic tool use inputs should be valid objects, when applicable.
+                    if (typeof contentPartCopy.input === 'string') {
+                        try {
+                            contentPartCopy.input = JSON.parse(contentPartCopy.input);
+                        }
+                        catch {
+                            contentPartCopy.input = {};
+                        }
+                    }
+                }
+                /**
+                 * For multi-turn conversations with citations, we must preserve ALL blocks
+                 * including server_tool_use, web_search_tool_result, and web_search_result.
+                 * Citations reference search results by index, so filtering changes indices and breaks references.
+                 *
+                 * The ToolNode already handles skipping server tool invocations via the srvtoolu_ prefix check.
+                 */
+                // TODO: Fix when SDK types are fixed
+                return {
+                    ...contentPartCopy,
+                    ...(cacheControl ? { cache_control: cacheControl } : {}),
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                };
+            }
+            else if ('functionCall' in contentPart &&
+                contentPart.functionCall &&
+                typeof contentPart.functionCall === 'object' &&
+                messages.isAIMessage(message)) {
+                const correspondingToolCall = message.tool_calls?.find((toolCall) => toolCall.name === contentPart.functionCall.name);
+                if (!correspondingToolCall) {
+                    throw new Error(`Could not find tool call for function call ${contentPart.functionCall.name}`);
+                }
+                // Google GenAI models include a `functionCall` object inside content. We should ignore it as Anthropic will not support it.
+                return {
+                    id: correspondingToolCall.id,
+                    type: 'tool_use',
+                    name: correspondingToolCall.name,
+                    input: contentPart.functionCall.args,
+                };
+            }
+            else {
+                console.error('Unsupported content part:', JSON.stringify(contentPart, null, 2));
+                throw new Error('Unsupported message content format');
+            }
+        });
+        return contentBlocks.filter((block) => block !== null);
+    }
+}
+/**
+ * Formats messages as a prompt for the model.
+ * Used in LangSmith, export is important here.
+ * @param messages The base messages to format as a prompt.
+ * @returns The formatted prompt.
+ */
+function _convertMessagesToAnthropicPayload(messages$1) {
+    const mergedMessages = _ensureMessageContents(messages$1);
+    let system;
+    if (mergedMessages.length > 0 && mergedMessages[0]._getType() === 'system') {
+        system = messages$1[0].content;
+    }
+    const conversationMessages = system !== undefined ? mergedMessages.slice(1) : mergedMessages;
+    const formattedMessages = conversationMessages.map((message) => {
+        let role;
+        if (message._getType() === 'human') {
+            role = 'user';
+        }
+        else if (message._getType() === 'ai') {
+            role = 'assistant';
+        }
+        else if (message._getType() === 'tool') {
+            role = 'user';
+        }
+        else if (message._getType() === 'system') {
+            throw new Error('System messages are only permitted as the first passed message.');
+        }
+        else {
+            throw new Error(`Message type "${message._getType()}" is not supported.`);
+        }
+        if (messages.isAIMessage(message) && !!message.tool_calls?.length) {
+            if (typeof message.content === 'string') {
+                if (message.content === '') {
+                    return {
+                        role,
+                        content: message.tool_calls.map(_convertLangChainToolCallToAnthropic),
+                    };
+                }
+                else {
+                    return {
+                        role,
+                        content: [
+                            { type: 'text', text: message.content },
+                            ...message.tool_calls.map(_convertLangChainToolCallToAnthropic),
+                        ],
+                    };
+                }
+            }
+            else {
+                const { content } = message;
+                const hasMismatchedToolCalls = !message.tool_calls.every((toolCall) => !!content.find((contentPart) => (contentPart.type === 'tool_use' ||
+                    contentPart.type === 'input_json_delta' ||
+                    contentPart.type === 'server_tool_use') &&
+                    contentPart.id === toolCall.id));
+                if (hasMismatchedToolCalls) {
+                    console.warn('The "tool_calls" field on a message is only respected if content is a string.');
+                }
+                return {
+                    role,
+                    content: _formatContent(message),
+                };
+            }
+        }
+        else {
+            return {
+                role,
+                content: _formatContent(message),
+            };
+        }
+    });
+    return {
+        messages: mergeMessages(formattedMessages),
+        system,
+    };
+}
+function mergeMessages(messages) {
+    if (!messages || messages.length <= 1) {
+        return messages;
+    }
+    const result = [];
+    let currentMessage = messages[0];
+    const normalizeContent = (content) => {
+        if (typeof content === 'string') {
+            return [
+                {
+                    type: 'text',
+                    text: content,
+                },
+            ];
+        }
+        return content;
+    };
+    const isToolResultMessage = (msg) => {
+        if (msg.role !== 'user')
+            return false;
+        if (typeof msg.content === 'string') {
+            return false;
+        }
+        return (Array.isArray(msg.content) &&
+            msg.content.every((item) => item.type === 'tool_result'));
+    };
+    for (let i = 1; i < messages.length; i += 1) {
+        const nextMessage = messages[i];
+        if (isToolResultMessage(currentMessage) &&
+            isToolResultMessage(nextMessage)) {
+            // Merge the messages by combining their content arrays
+            currentMessage = {
+                ...currentMessage,
+                content: [
+                    ...normalizeContent(currentMessage.content),
+                    ...normalizeContent(nextMessage.content),
+                ],
+            };
+        }
+        else {
+            result.push(currentMessage);
+            currentMessage = nextMessage;
+        }
+    }
+    result.push(currentMessage);
+    return result;
+}
+
+exports._convertLangChainToolCallToAnthropic = _convertLangChainToolCallToAnthropic;
+exports._convertMessagesToAnthropicPayload = _convertMessagesToAnthropicPayload;
+//# sourceMappingURL=message_inputs.cjs.map