push

src/routes/chatRoutes.ts

@@ -42,9 +42,11 @@ const upload = multer({
  *       Send a text message and/or files to an agent. The system handles communication with any agent endpoint format.
  *       
  *       **Agent Communication Protocol:**
- *       - Files are uploaded to IPFS first, then URLs are sent to the agent endpoint
+ *       - Files are sent directly to agent endpoints (not uploaded to IPFS)
+ *       - Files are stored temporarily in memory during processing
+ *       - File metadata is stored in chat history with 1-hour expiration
  *       - For text-only messages: Sends JSON payload to agent endpoint
- *       - For messages with files: Sends multipart/form-data with file URLs (IPFS hashes)
+ *       - For messages with files: Sends multipart/form-data with actual file buffers
  *       - Supports custom headers via agent metadata (agent.metadata.headers)
  *       - Works with any agent endpoint format (REST, GraphQL, custom APIs)
  *       

src/services/chatProtocol.ts

@@ -3,7 +3,6 @@ import FormData from 'form-data';
 import { Agent } from '../entities/Agent';
 import { ChatMessage, MessageRole } from '../entities/ChatMessage';
 import { AppDataSource } from '../config/database';
-import { IpfsService } from './ipfsService';
 
 export interface ChatRequest {
   message: string;
@@ -34,32 +33,22 @@ export interface ChatResponse {
  */
 export class ChatProtocolService {
   private timeout: number;
-  private ipfsService: IpfsService;
   private maxFileSize: number;
 
   constructor() {
     this.timeout = parseInt(process.env.AGENT_CHAT_TIMEOUT || '30000');
-    this.ipfsService = new IpfsService();
     this.maxFileSize = parseInt(process.env.MAX_FILE_SIZE || '10485760'); // 10MB default
   }
 
   /**
-   * Upload files to IPFS
+   * Validate files (no IPFS upload - files stored temporarily in memory)
+   * Files are kept in memory during request processing and sent directly to agent endpoints
    */
-  private async uploadFiles(files: ChatRequest['files']): Promise<Array<{
-    fieldname: string;
-    originalname: string;
-    mimetype: string;
-    size: number;
-    ipfsHash: string;
-    url: string;
-  }>> {
+  private validateFiles(files: ChatRequest['files']): void {
     if (!files || files.length === 0) {
-      return [];
+      return;
     }
 
-    const uploadedFiles = [];
-
     for (const file of files) {
       // Validate file size
       if (file.size > this.maxFileSize) {
@@ -67,33 +56,7 @@ export class ChatProtocolService {
           `File ${file.originalname} exceeds maximum size of ${this.maxFileSize} bytes`
         );
       }
-
-      // Upload to IPFS
-      try {
-        const fileObj = new File(
-          [file.buffer],
-          file.originalname,
-          { type: file.mimetype }
-        );
-
-        const upload = await this.ipfsService.uploadFile(fileObj);
-        const gatewayUrl = this.ipfsService.getGatewayUrl(upload.cid);
-        
-        uploadedFiles.push({
-          fieldname: file.fieldname,
-          originalname: file.originalname,
-          mimetype: file.mimetype,
-          size: file.size,
-          ipfsHash: upload.cid,
-          url: gatewayUrl,
-        });
-      } catch (error) {
-        console.error(`Error uploading file ${file.originalname}:`, error);
-        throw new Error(`Failed to upload file ${file.originalname} to IPFS`);
-      }
     }
-
-    return uploadedFiles;
   }
 
   /**
@@ -110,23 +73,39 @@ export class ChatProtocolService {
         throw new Error(`Message exceeds maximum length of ${maxLength} characters`);
       }
 
-      // Upload files to IPFS if present
+      // Store files temporarily (don't upload to IPFS)
+      // Files will be available for 1 hour before cleanup
       let uploadedFiles: Array<{
         fieldname: string;
         originalname: string;
         mimetype: string;
         size: number;
-        ipfsHash: string;
-        url: string;
+        buffer: Buffer;
+        tempUrl?: string; // Temporary URL for chat viewing
+        expiresAt: Date; // Cleanup after 1 hour
       }> = [];
 
       if (request.files && request.files.length > 0) {
-        uploadedFiles = await this.uploadFiles(request.files);
+        // Validate files first
+        this.validateFiles(request.files);
+        
+        // Store files temporarily without IPFS upload
+        // Files are kept in memory during request processing
+        // Metadata stored in DB with 1-hour expiration timestamp
+        const oneHourFromNow = new Date(Date.now() + 60 * 60 * 1000);
+        uploadedFiles = request.files.map(file => ({
+          fieldname: file.fieldname,
+          originalname: file.originalname,
+          mimetype: file.mimetype,
+          size: file.size,
+          buffer: file.buffer,
+          expiresAt: oneHourFromNow,
+        }));
       }
 
       const conversationId = request.conversationId || this.generateConversationId();
 
-      // Build metadata with file information
+        // Build metadata with file information (temporary storage, no IPFS)
       const metadata = {
         ...request.metadata,
         agentId: agent.id,
@@ -137,8 +116,8 @@ export class ChatProtocolService {
             originalname: f.originalname,
             mimetype: f.mimetype,
             size: f.size,
-            ipfsHash: f.ipfsHash,
-            url: f.url,
+            expiresAt: f.expiresAt.toISOString(),
+            // Note: Files are stored temporarily, not on IPFS
           })),
         }),
       };
@@ -164,13 +143,52 @@ export class ChatProtocolService {
           formData.append('systemPrompt', agent.promptTemplate);
         }
 
-        // Add file information (not the actual files, just metadata with URLs)
-        uploadedFiles.forEach((file, index) => {
-          formData.append(`file_${index}_url`, file.url);
-          formData.append(`file_${index}_hash`, file.ipfsHash);
-          formData.append(`file_${index}_name`, file.originalname);
-          formData.append(`file_${index}_type`, file.mimetype);
-        });
+        // Send actual files directly to agent endpoint (no IPFS upload)
+        // Use smart field naming based on file type and count
+        if (request.files && request.files.length > 0) {
+          const audioFiles = request.files.filter(f => f.mimetype.startsWith('audio/'));
+          
+          // If single audio file, use 'audio_file' (common for transcription agents)
+          if (audioFiles.length === 1 && request.files.length === 1) {
+            const audioFile = request.files.find(f => f.mimetype.startsWith('audio/'));
+            if (audioFile) {
+              formData.append('audio_file', audioFile.buffer, {
+                filename: audioFile.originalname,
+                contentType: audioFile.mimetype,
+              });
+            }
+          }
+          // If single file of any type, use 'file'
+          else if (request.files.length === 1) {
+            const file = request.files[0];
+            formData.append('file', file.buffer, {
+              filename: file.originalname,
+              contentType: file.mimetype,
+            });
+          }
+          // Multiple files - use 'files' array or indexed fields
+          else {
+            request.files.forEach((file, index) => {
+              // Try common field names first
+              if (file.mimetype.startsWith('audio/')) {
+                formData.append(`audio_file${index > 0 ? `_${index}` : ''}`, file.buffer, {
+                  filename: file.originalname,
+                  contentType: file.mimetype,
+                });
+              } else if (file.mimetype.startsWith('image/')) {
+                formData.append(`image_file${index > 0 ? `_${index}` : ''}`, file.buffer, {
+                  filename: file.originalname,
+                  contentType: file.mimetype,
+                });
+              } else {
+                formData.append(`file${index > 0 ? `_${index}` : ''}`, file.buffer, {
+                  filename: file.originalname,
+                  contentType: file.mimetype,
+                });
+              }
+            });
+          }
+        }
 
         response = await axios.post(agent.endpoint, formData, {
           timeout: this.timeout,
@@ -207,7 +225,7 @@ export class ChatProtocolService {
         ? `\n[Files: ${uploadedFiles.map(f => f.originalname).join(', ')}]`
         : '';
 
-      // Save message to database
+      // Save message to database with file metadata (files stored temporarily, not on IPFS)
       await this.saveMessage({
         agentId: agent.id,
         userId: request.userId,
@@ -215,7 +233,15 @@ export class ChatProtocolService {
         content: userContent + filesInfo,
         metadata: {
           ...metadata,
-          files: uploadedFiles,
+          files: uploadedFiles.map(f => ({
+            fieldname: f.fieldname,
+            originalname: f.originalname,
+            mimetype: f.mimetype,
+            size: f.size,
+            expiresAt: f.expiresAt.toISOString(),
+            // Note: File buffers are not stored in DB, only metadata
+            // Files are available temporarily in memory for 1 hour
+          })),
         },
       });