🔗 fix: File Citation Processing to Use Tool Artifacts

api/server/controllers/agents/callbacks.js

@@ -11,6 +11,7 @@ const {
   handleToolCalls,
   ChatModelStreamHandler,
 } = require('@librechat/agents');
+const { processFileCitations } = require('~/server/services/Files/Citations');
 const { processCodeOutput } = require('~/server/services/Files/Code/process');
 const { loadAuthValues } = require('~/server/services/Tools/credentials');
 const { saveBase64Image } = require('~/server/services/Files/process');
@@ -238,6 +239,31 @@ function createToolEndCallback({ req, res, artifactPromises }) {
       return;
     }
 
+    if (output.artifact[Tools.file_search]) {
+      artifactPromises.push(
+        (async () => {
+          const user = req.user;
+          const attachment = await processFileCitations({
+            user,
+            metadata,
+            toolArtifact: output.artifact,
+            toolCallId: output.tool_call_id,
+          });
+          if (!attachment) {
+            return null;
+          }
+          if (!res.headersSent) {
+            return attachment;
+          }
+          res.write(`event: attachment\ndata: ${JSON.stringify(attachment)}\n\n`);
+          return attachment;
+        })().catch((error) => {
+          logger.error('Error processing file citations:', error);
+          return null;
+        }),
+      );
+    }
+
     if (output.artifact[Tools.web_search]) {
       artifactPromises.push(
         (async () => {

api/server/controllers/agents/client.js

@@ -49,7 +49,6 @@ const BaseClient = require('~/app/clients/BaseClient');
 const { getRoleByName } = require('~/models/Role');
 const { loadAgent } = require('~/models/Agent');
 const { getMCPManager } = require('~/config');
-const { processAgentResponse } = require('~/app/clients/agents/processAgentResponse');
 
 const omitTitleOptions = new Set([
   'stream',
@@ -1036,27 +1035,6 @@ class AgentClient extends BaseClient {
           this.artifactPromises.push(...attachments);
         }
 
-        // Process agent response to capture file references and create attachments
-
-        const processedResponse = await processAgentResponse(
-          {
-            messageId: this.responseMessageId,
-            attachments: this.artifactPromises,
-          },
-          this.user ?? this.options.req.user?.id,
-          this.conversationId,
-          this.contentParts,
-          this.options.req.user,
-        );
-
-        // Update artifact promises with any new attachments from agent response
-        if (processedResponse.attachments && processedResponse.attachments.length > 0) {
-          // Add new attachments to existing artifactPromises
-          processedResponse.attachments.forEach((attachment) => {
-            this.artifactPromises.push(Promise.resolve(attachment));
-          });
-        }
-
         await this.recordCollectedUsage({ context: 'message' });
       } catch (err) {
         logger.error(

api/server/services/Files/Citations/index.js

@@ -0,0 +1,149 @@
+const { nanoid } = require('nanoid');
+const { checkAccess } = require('@librechat/api');
+const { Tools, PermissionTypes, Permissions } = require('librechat-data-provider');
+const { getCustomConfig } = require('~/server/services/Config/getCustomConfig');
+const { getRoleByName } = require('~/models/Role');
+const { logger } = require('~/config');
+const { Files } = require('~/models');
+
+/**
+ * Process file search results from tool calls
+ * @param {Object} options
+ * @param {IUser} options.user - The user object
+ * @param {GraphRunnableConfig['configurable']} options.metadata - The metadata
+ * @param {any} options.toolArtifact - The tool artifact containing structured data
+ * @param {string} options.toolCallId - The tool call ID
+ * @returns {Promise<Object|null>} The file search attachment or null
+ */
+async function processFileCitations({ user, toolArtifact, toolCallId, metadata }) {
+  try {
+    if (!toolArtifact?.[Tools.file_search]?.sources) {
+      return null;
+    }
+
+    if (user) {
+      try {
+        const hasFileCitationsAccess = await checkAccess({
+          user,
+          permissionType: PermissionTypes.FILE_CITATIONS,
+          permissions: [Permissions.USE],
+          getRoleByName,
+        });
+
+        if (!hasFileCitationsAccess) {
+          logger.debug(
+            `[processFileCitations] User ${user.id} does not have FILE_CITATIONS permission`,
+          );
+          return null;
+        }
+      } catch (error) {
+        logger.error(
+          `[processFileCitations] Permission check failed for FILE_CITATIONS: ${error.message}`,
+        );
+        logger.debug(`[processFileCitations] Proceeding with citations due to permission error`);
+      }
+    }
+
+    const customConfig = await getCustomConfig();
+    const maxCitations = customConfig?.endpoints?.agents?.maxCitations ?? 30;
+    const maxCitationsPerFile = customConfig?.endpoints?.agents?.maxCitationsPerFile ?? 5;
+    const minRelevanceScore = customConfig?.endpoints?.agents?.minRelevanceScore ?? 0.45;
+
+    const sources = toolArtifact[Tools.file_search].sources || [];
+    const filteredSources = sources.filter((source) => source.relevance >= minRelevanceScore);
+    if (filteredSources.length === 0) {
+      logger.debug(
+        `[processFileCitations] No sources above relevance threshold of ${minRelevanceScore}`,
+      );
+      return null;
+    }
+
+    const selectedSources = applyCitationLimits(filteredSources, maxCitations, maxCitationsPerFile);
+    const enhancedSources = await enhanceSourcesWithMetadata(selectedSources, customConfig);
+
+    if (enhancedSources.length > 0) {
+      const fileSearchAttachment = {
+        type: Tools.file_search,
+        [Tools.file_search]: { sources: enhancedSources },
+        toolCallId: toolCallId,
+        messageId: metadata.run_id,
+        conversationId: metadata.thread_id,
+        name: `${Tools.file_search}_file_search_results_${nanoid()}`,
+      };
+
+      return fileSearchAttachment;
+    }
+
+    return null;
+  } catch (error) {
+    logger.error('[processFileCitations] Error processing file citations:', error);
+    return null;
+  }
+}
+
+/**
+ * Apply citation limits to sources
+ * @param {Array} sources - All sources
+ * @param {number} maxCitations - Maximum total citations
+ * @param {number} maxCitationsPerFile - Maximum citations per file
+ * @returns {Array} Selected sources
+ */
+function applyCitationLimits(sources, maxCitations, maxCitationsPerFile) {
+  const byFile = {};
+  sources.forEach((source) => {
+    if (!byFile[source.fileId]) {
+      byFile[source.fileId] = [];
+    }
+    byFile[source.fileId].push(source);
+  });
+
+  const representatives = [];
+  for (const fileId in byFile) {
+    const fileSources = byFile[fileId].sort((a, b) => b.relevance - a.relevance);
+    const selectedFromFile = fileSources.slice(0, maxCitationsPerFile);
+    representatives.push(...selectedFromFile);
+  }
+
+  return representatives.sort((a, b) => b.relevance - a.relevance).slice(0, maxCitations);
+}
+
+/**
+ * Enhance sources with file metadata from database
+ * @param {Array} sources - Selected sources
+ * @param {Object} customConfig - Custom configuration
+ * @returns {Promise<Array>} Enhanced sources
+ */
+async function enhanceSourcesWithMetadata(sources, customConfig) {
+  const fileIds = [...new Set(sources.map((source) => source.fileId))];
+
+  let fileMetadataMap = {};
+  try {
+    const files = await Files.find({ file_id: { $in: fileIds } });
+    fileMetadataMap = files.reduce((map, file) => {
+      map[file.file_id] = file;
+      return map;
+    }, {});
+  } catch (error) {
+    logger.error('[enhanceSourcesWithMetadata] Error looking up file metadata:', error);
+  }
+
+  return sources.map((source) => {
+    const fileRecord = fileMetadataMap[source.fileId] || {};
+    const configuredStorageType = fileRecord.source || customConfig?.fileStrategy || 'local';
+
+    return {
+      ...source,
+      fileName: fileRecord.filename || source.fileName || 'Unknown File',
+      metadata: {
+        ...source.metadata,
+        storageType: configuredStorageType,
+      },
+    };
+  });
+}
+
+module.exports = {
+  applyCitationLimits,
+  processFileCitations,
+  enhanceSourcesWithMetadata,
+};