@librechat/agents 3.1.78 → 3.1.79

package/dist/cjs/messages/format.cjs

@@ -173,6 +173,51 @@ function extractReasoningContent(part) {
     }
     return '';
 }
+function parseServerToolInput(args) {
+    if (typeof args === 'string') {
+        try {
+            const parsed = JSON.parse(args);
+            return parsed != null &&
+                typeof parsed === 'object' &&
+                !Array.isArray(parsed)
+                ? parsed
+                : {};
+        }
+        catch {
+            return {};
+        }
+    }
+    return args != null && typeof args === 'object' ? args : {};
+}
+function getTextContent(part) {
+    const { text } = part;
+    return typeof text === 'string' ? text : '';
+}
+function hasMeaningfulAssistantContent(part) {
+    if (part.type === _enum.ContentTypes.TEXT) {
+        return getTextContent(part).trim().length > 0;
+    }
+    if (part.type === _enum.ContentTypes.TOOL_CALL ||
+        part.type === _enum.ContentTypes.ERROR ||
+        part.type === _enum.ContentTypes.AGENT_UPDATE ||
+        part.type === _enum.ContentTypes.SUMMARY) {
+        return false;
+    }
+    if (part.type === _enum.ContentTypes.THINK ||
+        part.type === _enum.ContentTypes.THINKING ||
+        part.type === _enum.ContentTypes.REASONING ||
+        part.type === _enum.ContentTypes.REASONING_CONTENT ||
+        part.type === 'redacted_thinking') {
+        return extractReasoningContent(part).trim().length > 0;
+    }
+    return part.type != null && part.type !== '';
+}
+function getToolUseId(part) {
+    if (!('tool_use_id' in part) || typeof part.tool_use_id !== 'string') {
+        return undefined;
+    }
+    return part.tool_use_id;
+}
 /**
  * Helper function to format an assistant message
  * @param message The message to format
@@ -185,6 +230,8 @@ function formatAssistantMessage(message, options) {
     let lastAIMessage = null;
     let hasReasoning = false;
     let pendingReasoningContent = '';
+    const emittedServerToolUseIds = new Set();
+    const pendingServerToolUses = new Map();
     const shouldPreserveReasoningContent = options?.preserveReasoningContent === true;
     const takePendingReasoningContent = () => {
         if (!shouldPreserveReasoningContent || !pendingReasoningContent) {
@@ -213,11 +260,29 @@ function formatAssistantMessage(message, options) {
                 ? `${aiMessage.additional_kwargs.reasoning_content}${reasoningContent}`
                 : reasoningContent;
     };
+    const flushPendingServerToolUse = (toolUseId) => {
+        for (const [id, content] of pendingServerToolUses) {
+            pendingServerToolUses.delete(id);
+            if (id === toolUseId) {
+                currentContent.push(content);
+                emittedServerToolUseIds.add(id);
+                return;
+            }
+        }
+    };
     if (Array.isArray(message.content)) {
-        for (const part of message.content) {
+        const contentParts = message.content;
+        for (const part of contentParts) {
             if (part == null) {
                 continue;
             }
+            const toolUseId = getToolUseId(part);
+            if (toolUseId != null) {
+                flushPendingServerToolUse(toolUseId);
+            }
+            else if (hasMeaningfulAssistantContent(part)) {
+                pendingServerToolUses.clear();
+            }
             if (part.type === _enum.ContentTypes.TEXT && part.tool_call_ids) {
                 /*
                 If there's pending content, it needs to be aggregated as a single string to prepare for tool calls.
@@ -226,19 +291,18 @@ function formatAssistantMessage(message, options) {
                 if (currentContent.length > 0) {
                     let content = currentContent.reduce((acc, curr) => {
                         if (curr.type === _enum.ContentTypes.TEXT) {
-                            return `${acc}${String(curr[_enum.ContentTypes.TEXT] ?? '')}\n`;
+                            return `${acc}${getTextContent(curr)}\n`;
                         }
                         return acc;
                     }, '');
-                    content =
-                        `${content}\n${part[_enum.ContentTypes.TEXT] ?? part.text ?? ''}`.trim();
+                    content = `${content}\n${getTextContent(part)}`.trim();
                     lastAIMessage = createAIMessage(content);
                     formattedMessages.push(lastAIMessage);
                     currentContent = [];
                     continue;
                 }
                 // Create a new AIMessage with this text and prepare for tool calls
-                lastAIMessage = createAIMessage(part.text != null ? part.text : '');
+                lastAIMessage = createAIMessage(getTextContent(part));
                 formattedMessages.push(lastAIMessage);
             }
             else if (part.type === _enum.ContentTypes.TOOL_CALL) {
@@ -253,6 +317,21 @@ function formatAssistantMessage(message, options) {
                     (_tool_call.name === '' && (output == null || output === ''))) {
                     continue;
                 }
+                if (options?.provider === _enum.Providers.ANTHROPIC &&
+                    typeof _tool_call.id === 'string' &&
+                    _tool_call.id.startsWith(_enum.Constants.ANTHROPIC_SERVER_TOOL_PREFIX)) {
+                    if (emittedServerToolUseIds.has(_tool_call.id) ||
+                        pendingServerToolUses.has(_tool_call.id)) {
+                        continue;
+                    }
+                    pendingServerToolUses.set(_tool_call.id, {
+                        type: 'server_tool_use',
+                        id: _tool_call.id,
+                        name: _tool_call.name,
+                        input: parseServerToolInput(_args),
+                    });
+                    continue;
+                }
                 if (!lastAIMessage) {
                     // "Heal" the payload by creating an AIMessage to precede the tool call
                     lastAIMessage = createAIMessage('');
@@ -300,23 +379,26 @@ function formatAssistantMessage(message, options) {
                 continue;
             }
             else {
-                if (part.type === _enum.ContentTypes.TEXT &&
-                    !String(part.text ?? '').trim()) {
+                if (part.type === _enum.ContentTypes.TEXT && !getTextContent(part).trim()) {
                     continue;
                 }
                 currentContent.push(part);
             }
         }
+        for (const content of pendingServerToolUses.values()) {
+            currentContent.push(content);
+        }
     }
     if (hasReasoning && currentContent.length > 0) {
-        const content = currentContent
-            .reduce((acc, curr) => {
-            if (curr.type === _enum.ContentTypes.TEXT) {
-                return `${acc}${String(curr[_enum.ContentTypes.TEXT] ?? '')}\n`;
+        let content = '';
+        for (const part of currentContent) {
+            if (part.type !== _enum.ContentTypes.TEXT) {
+                formattedMessages.push(createAIMessage(langchain.toLangChainContent(currentContent)));
+                return formattedMessages;
             }
-            return acc;
-        }, '')
-            .trim();
+            content += `${getTextContent(part)}\n`;
+        }
+        content = content.trim();
         if (content) {
             formattedMessages.push(createAIMessage(content));
         }
@@ -826,6 +908,7 @@ skills, options) => {
         }
         const formattedMessages = formatAssistantMessage(processedMessage, {
             preserveReasoningContent: options?.provider === _enum.Providers.DEEPSEEK,
+            provider: options?.provider,
         });
         if (sourceMessageId != null && sourceMessageId !== '') {
             for (const formattedMessage of formattedMessages) {