@trainly/react 1.2.0 → 1.3.1

package/README.md

@@ -146,6 +146,533 @@ function MyApp() {
 - 🎨 **Pre-built UI**: `TrainlyFileManager` component with styling
 - 🔒 **Privacy-First**: Only works in V1 mode with OAuth authentication
 
+## 📚 **Detailed File Management Documentation**
+
+### **1. Listing Files**
+
+Get all files uploaded to the user's permanent subchat:
+
+```tsx
+import { useTrainly } from "@trainly/react";
+
+function FileList() {
+  const { listFiles } = useTrainly();
+
+  const handleListFiles = async () => {
+    try {
+      const result = await listFiles();
+
+      console.log(`Total files: ${result.total_files}`);
+      console.log(`Total storage: ${formatBytes(result.total_size_bytes)}`);
+
+      result.files.forEach((file) => {
+        console.log(`📄 ${file.filename}`);
+        console.log(`   Size: ${formatBytes(file.size_bytes)}`);
+        console.log(`   Chunks: ${file.chunk_count}`);
+        console.log(
+          `   Uploaded: ${new Date(parseInt(file.upload_date)).toLocaleDateString()}`,
+        );
+        console.log(`   ID: ${file.file_id}`);
+      });
+    } catch (error) {
+      console.error("Failed to list files:", error);
+    }
+  };
+
+  return <button onClick={handleListFiles}>List My Files</button>;
+}
+```
+
+**Response Structure:**
+
+```typescript
+interface FileListResult {
+  success: boolean;
+  files: FileInfo[];
+  total_files: number;
+  total_size_bytes: number;
+}
+
+interface FileInfo {
+  file_id: string; // Unique identifier for deletion
+  filename: string; // Original filename
+  upload_date: string; // Unix timestamp (milliseconds)
+  size_bytes: number; // File size in bytes
+  chunk_count: number; // Number of text chunks created
+}
+```
+
+### **2. Bulk Upload Files**
+
+Upload multiple files at once (up to 10 files per request):
+
+```tsx
+import { useTrainly } from "@trainly/react";
+
+function BulkFileUpload() {
+  const { bulkUploadFiles } = useTrainly();
+  const [selectedFiles, setSelectedFiles] = useState<File[]>([]);
+
+  const handleFileSelect = (event: React.ChangeEvent<HTMLInputElement>) => {
+    const files = Array.from(event.target.files || []);
+    if (files.length > 10) {
+      alert("Maximum 10 files allowed per bulk upload");
+      return;
+    }
+    setSelectedFiles(files);
+  };
+
+  const handleBulkUpload = async () => {
+    if (selectedFiles.length === 0) return;
+
+    try {
+      const result = await bulkUploadFiles(selectedFiles);
+
+      console.log(`Bulk upload completed: ${result.message}`);
+      console.log(
+        `Successful: ${result.successful_uploads}/${result.total_files}`,
+      );
+      console.log(`Total size: ${formatBytes(result.total_size_bytes)}`);
+
+      // Review individual file results
+      result.results.forEach((fileResult) => {
+        if (fileResult.success) {
+          console.log(`✅ ${fileResult.filename} - ${fileResult.message}`);
+        } else {
+          console.log(`❌ ${fileResult.filename} - ${fileResult.error}`);
+        }
+      });
+
+      // Clear selection after successful upload
+      setSelectedFiles([]);
+    } catch (error) {
+      console.error("Bulk upload failed:", error);
+    }
+  };
+
+  return (
+    <div>
+      <input
+        type="file"
+        multiple
+        accept=".pdf,.txt,.docx"
+        onChange={handleFileSelect}
+      />
+
+      {selectedFiles.length > 0 && (
+        <div>
+          <p>Selected files: {selectedFiles.length}</p>
+          <ul>
+            {selectedFiles.map((file, index) => (
+              <li key={index}>
+                {file.name} ({formatBytes(file.size)})
+              </li>
+            ))}
+          </ul>
+          <button onClick={handleBulkUpload}>
+            Upload {selectedFiles.length} Files
+          </button>
+        </div>
+      )}
+    </div>
+  );
+}
+
+// Helper function for formatting file sizes
+function formatBytes(bytes: number): string {
+  if (bytes === 0) return "0 Bytes";
+  const k = 1024;
+  const sizes = ["Bytes", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + " " + sizes[i];
+}
+```
+
+**Bulk Upload Features:**
+
+- ✅ **Efficient**: Upload up to 10 files in a single API call
+- ✅ **Detailed Results**: Individual success/failure status for each file
+- ✅ **Error Resilience**: Partial failures don't stop other files
+- ✅ **Progress Tracking**: Total size and success metrics
+- ✅ **Automatic Retry**: Token refresh handling built-in
+
+### **3. Deleting Files**
+
+Remove a specific file and free up storage space:
+
+```tsx
+import { useTrainly } from "@trainly/react";
+
+function FileDeleter() {
+  const { deleteFile, listFiles } = useTrainly();
+
+  const handleDeleteFile = async (fileId: string, filename: string) => {
+    // Always confirm before deletion
+    const confirmed = confirm(
+      `Delete "${filename}"? This will permanently remove the file and cannot be undone.`,
+    );
+
+    if (!confirmed) return;
+
+    try {
+      const result = await deleteFile(fileId);
+
+      console.log(`✅ ${result.message}`);
+      console.log(`🗑️ Deleted: ${result.filename}`);
+      console.log(`💾 Storage freed: ${formatBytes(result.size_bytes_freed)}`);
+      console.log(`📊 Chunks removed: ${result.chunks_deleted}`);
+
+      // Optionally refresh file list
+      await listFiles();
+    } catch (error) {
+      console.error("Failed to delete file:", error);
+      alert(`Failed to delete file: ${error.message}`);
+    }
+  };
+
+  // Example: Delete first file
+  const deleteFirstFile = async () => {
+    const files = await listFiles();
+    if (files.files.length > 0) {
+      const firstFile = files.files[0];
+      await handleDeleteFile(firstFile.file_id, firstFile.filename);
+    }
+  };
+
+  return <button onClick={deleteFirstFile}>Delete First File</button>;
+}
+```
+
+**Response Structure:**
+
+```typescript
+interface FileDeleteResult {
+  success: boolean;
+  message: string; // Human-readable success message
+  file_id: string; // ID of deleted file
+  filename: string; // Name of deleted file
+  chunks_deleted: number; // Number of chunks removed
+  size_bytes_freed: number; // Storage space freed up
+}
+```
+
+### **4. Pre-built File Manager Component**
+
+Use the ready-made component for complete file management:
+
+```tsx
+import { TrainlyFileManager } from "@trainly/react";
+
+function MyApp() {
+  return (
+    <TrainlyFileManager
+      // Optional: Custom CSS class
+      className="my-custom-styles"
+      // Callback when file is deleted
+      onFileDeleted={(fileId, filename) => {
+        console.log(`File deleted: ${filename} (ID: ${fileId})`);
+        // Update your app state, show notification, etc.
+      }}
+      // Error handling callback
+      onError={(error) => {
+        console.error("File operation failed:", error);
+        // Show user-friendly error message
+        alert(`Error: ${error.message}`);
+      }}
+      // Show upload button in component
+      showUploadButton={true}
+      // Maximum file size in MB
+      maxFileSize={5}
+    />
+  );
+}
+```
+
+**Component Features:**
+
+- 📋 **File List**: Shows all files with metadata
+- 🔄 **Auto-Refresh**: Updates after uploads/deletions
+- ⚠️ **Confirmation**: Asks before deleting files
+- 📊 **Storage Stats**: Shows total files and storage used
+- 🎨 **Styled**: Clean, professional appearance
+- 📱 **Responsive**: Works on mobile and desktop
+
+### **5. Complete Integration Example**
+
+Here's a full example showing all file operations together:
+
+```tsx
+import React from "react";
+import { useAuth } from "@clerk/nextjs"; // or your OAuth provider
+import { useTrainly, TrainlyFileManager } from "@trainly/react";
+
+export function CompleteFileExample() {
+  const { getToken } = useAuth();
+  const {
+    ask,
+    upload,
+    listFiles,
+    deleteFile,
+    connectWithOAuthToken,
+    isConnected,
+  } = useTrainly();
+
+  const [files, setFiles] = React.useState([]);
+  const [storageUsed, setStorageUsed] = React.useState(0);
+
+  // Connect to Trainly on mount
+  React.useEffect(() => {
+    async function connect() {
+      const token = await getToken();
+      if (token) {
+        await connectWithOAuthToken(token);
+      }
+    }
+    connect();
+  }, []);
+
+  // Load files when connected
+  React.useEffect(() => {
+    if (isConnected) {
+      refreshFiles();
+    }
+  }, [isConnected]);
+
+  const refreshFiles = async () => {
+    try {
+      const result = await listFiles();
+      setFiles(result.files);
+      setStorageUsed(result.total_size_bytes);
+    } catch (error) {
+      console.error("Failed to load files:", error);
+    }
+  };
+
+  const handleBulkDelete = async () => {
+    if (files.length === 0) {
+      alert("No files to delete");
+      return;
+    }
+
+    const confirmed = confirm(
+      `Delete ALL ${files.length} files? This cannot be undone.`,
+    );
+    if (!confirmed) return;
+
+    let deletedCount = 0;
+    let totalFreed = 0;
+
+    for (const file of files) {
+      try {
+        const result = await deleteFile(file.file_id);
+        deletedCount++;
+        totalFreed += result.size_bytes_freed;
+        console.log(`Deleted: ${result.filename}`);
+      } catch (error) {
+        console.error(`Failed to delete ${file.filename}:`, error);
+      }
+    }
+
+    alert(`Deleted ${deletedCount} files, freed ${formatBytes(totalFreed)}`);
+    await refreshFiles();
+  };
+
+  const formatBytes = (bytes) => {
+    if (bytes === 0) return "0 Bytes";
+    const k = 1024;
+    const sizes = ["Bytes", "KB", "MB", "GB"];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return Math.round((bytes / Math.pow(k, i)) * 100) / 100 + " " + sizes[i];
+  };
+
+  if (!isConnected) {
+    return <div>Connecting to Trainly...</div>;
+  }
+
+  return (
+    <div style={{ maxWidth: "800px", margin: "0 auto", padding: "20px" }}>
+      <h1>📁 My File Workspace</h1>
+
+      {/* Storage Overview */}
+      <div
+        style={{
+          background: "#f8fafc",
+          padding: "20px",
+          borderRadius: "8px",
+          marginBottom: "20px",
+        }}
+      >
+        <h3>Storage Overview</h3>
+        <p>
+          <strong>{files.length} files</strong> using{" "}
+          <strong>{formatBytes(storageUsed)}</strong>
+        </p>
+        <div style={{ display: "flex", gap: "10px", marginTop: "10px" }}>
+          <button onClick={refreshFiles}>🔄 Refresh</button>
+          <button
+            onClick={handleBulkDelete}
+            disabled={files.length === 0}
+            style={{ background: "#dc2626", color: "white" }}
+          >
+            🗑️ Delete All Files
+          </button>
+        </div>
+      </div>
+
+      {/* File Manager Component */}
+      <TrainlyFileManager
+        onFileDeleted={(fileId, filename) => {
+          console.log(`File deleted: ${filename}`);
+          // Update local state
+          setFiles((prev) => prev.filter((f) => f.file_id !== fileId));
+          refreshFiles(); // Refresh to get accurate totals
+        }}
+        onError={(error) => {
+          alert(`Error: ${error.message}`);
+        }}
+        showUploadButton={true}
+        maxFileSize={5}
+      />
+
+      {/* AI Integration */}
+      <div
+        style={{
+          marginTop: "30px",
+          padding: "20px",
+          background: "#f0f9ff",
+          borderRadius: "8px",
+        }}
+      >
+        <h3>🤖 Ask AI About Your Files</h3>
+        <button
+          onClick={async () => {
+            const answer = await ask(
+              "What files do I have? Give me a summary of each.",
+            );
+            alert(`AI Response:\n\n${answer}`);
+          }}
+          style={{ background: "#059669", color: "white" }}
+        >
+          Get File Summary from AI
+        </button>
+      </div>
+    </div>
+  );
+}
+```
+
+### **6. Error Handling Best Practices**
+
+```tsx
+import { useTrainly } from "@trainly/react";
+
+function RobustFileManager() {
+  const { deleteFile, listFiles } = useTrainly();
+
+  const safeDeleteFile = async (fileId: string, filename: string) => {
+    try {
+      // 1. Confirm with user
+      const confirmed = confirm(`Delete "${filename}"?`);
+      if (!confirmed) return;
+
+      // 2. Attempt deletion
+      const result = await deleteFile(fileId);
+
+      // 3. Success feedback
+      console.log(`✅ Success: ${result.message}`);
+      return result;
+    } catch (error) {
+      // 4. Handle specific error types
+      if (error.message.includes("404")) {
+        alert("File not found - it may have already been deleted");
+      } else if (error.message.includes("401")) {
+        alert("Authentication expired - please refresh the page");
+      } else {
+        alert(`Failed to delete file: ${error.message}`);
+      }
+
+      console.error("Delete error:", error);
+      throw error;
+    }
+  };
+
+  const safeListFiles = async () => {
+    try {
+      return await listFiles();
+    } catch (error) {
+      console.error("List files error:", error);
+
+      if (error.message.includes("V1 mode")) {
+        alert("File management requires V1 OAuth authentication");
+      } else {
+        alert(`Failed to load files: ${error.message}`);
+      }
+
+      return { success: false, files: [], total_files: 0, total_size_bytes: 0 };
+    }
+  };
+
+  return (
+    <div>
+      <button onClick={() => safeListFiles()}>Safe List Files</button>
+      <button onClick={() => safeDeleteFile("file_123", "example.pdf")}>
+        Safe Delete Example
+      </button>
+    </div>
+  );
+}
+```
+
+### **7. TypeScript Support**
+
+Full TypeScript definitions included:
+
+```typescript
+// Import types for better development experience
+import type {
+  FileInfo,
+  FileListResult,
+  FileDeleteResult,
+  TrainlyFileManagerProps,
+} from "@trainly/react";
+
+// Type-safe file operations
+const handleTypedFileOps = async () => {
+  const fileList: FileListResult = await listFiles();
+  const deleteResult: FileDeleteResult = await deleteFile("file_123");
+
+  // Full IntelliSense support
+  console.log(deleteResult.size_bytes_freed);
+  console.log(fileList.total_size_bytes);
+};
+```
+
+### **8. Security & Privacy Notes**
+
+- 🔒 **V1 Only**: File management only works with V1 Trusted Issuer authentication
+- 👤 **User Isolation**: Users can only see and delete their own files
+- 🛡️ **No Raw Access**: Developers never see file content, only AI responses
+- 📊 **Privacy-Safe Analytics**: Storage tracking without exposing user data
+- ⚠️ **Permanent Deletion**: Deleted files cannot be recovered
+- 🔐 **OAuth Required**: Must be authenticated with valid OAuth token
+
+### **9. Storage Management**
+
+File operations automatically update storage analytics:
+
+```tsx
+// Storage is tracked automatically
+const result = await deleteFile(fileId);
+console.log(`Freed ${result.size_bytes_freed} bytes`);
+
+// Check total storage
+const files = await listFiles();
+console.log(`Using ${files.total_size_bytes} bytes total`);
+
+// Parent app analytics are updated automatically
+// (visible in Trainly dashboard for developers)
+```
+
 ---
 
 ## 🚀 Original Quick Start (Legacy)

package/dist/TrainlyProvider.js

@@ -389,7 +389,7 @@ export function TrainlyProvider(_a) {
             }
         });
     }); };
-    var listFiles = function () { return __awaiter(_this, void 0, void 0, function () {
+    var bulkUploadFiles = function (files) { return __awaiter(_this, void 0, void 0, function () {
         var result, err_6, errorMessage, newToken, result, refreshError_3, error_6;
         return __generator(this, function (_a) {
             switch (_a.label) {
@@ -397,7 +397,7 @@ export function TrainlyProvider(_a) {
                     _a.trys.push([0, 2, 10, 11]);
                     setIsLoading(true);
                     setError(null);
-                    return [4 /*yield*/, client.listFiles()];
+                    return [4 /*yield*/, client.bulkUploadFiles(files)];
                 case 1:
                     result = _a.sent();
                     return [2 /*return*/, result];
@@ -412,7 +412,7 @@ export function TrainlyProvider(_a) {
                     _a.label = 3;
                 case 3:
                     _a.trys.push([3, 8, , 9]);
-                    console.log("🔄 Token expired during file listing, refreshing...");
+                    console.log("🔄 Token expired during bulk upload, refreshing...");
                     return [4 /*yield*/, getToken()];
                 case 4:
                     newToken = _a.sent();
@@ -420,20 +420,20 @@ export function TrainlyProvider(_a) {
                     return [4 /*yield*/, client.connectWithOAuthToken(newToken)];
                 case 5:
                     _a.sent();
-                    return [4 /*yield*/, client.listFiles()];
+                    return [4 /*yield*/, client.bulkUploadFiles(files)];
                 case 6:
                     result = _a.sent();
-                    console.log("✅ File listing succeeded after token refresh");
+                    console.log("✅ Bulk upload succeeded after token refresh");
                     return [2 /*return*/, result];
                 case 7: return [3 /*break*/, 9];
                 case 8:
                     refreshError_3 = _a.sent();
-                    console.error("❌ Token refresh failed:", refreshError_3);
+                    console.error("❌ Token refresh failed during bulk upload:", refreshError_3);
                     return [3 /*break*/, 9];
                 case 9:
                     error_6 = {
-                        code: "LIST_FILES_FAILED",
-                        message: "Failed to list files",
+                        code: "BULK_UPLOAD_FAILED",
+                        message: "Failed to upload files",
                         details: err_6,
                     };
                     setError(error_6);
@@ -445,7 +445,7 @@ export function TrainlyProvider(_a) {
             }
         });
     }); };
-    var deleteFile = function (fileId) { return __awaiter(_this, void 0, void 0, function () {
+    var listFiles = function () { return __awaiter(_this, void 0, void 0, function () {
         var result, err_7, errorMessage, newToken, result, refreshError_4, error_7;
         return __generator(this, function (_a) {
             switch (_a.label) {
@@ -453,7 +453,7 @@ export function TrainlyProvider(_a) {
                     _a.trys.push([0, 2, 10, 11]);
                     setIsLoading(true);
                     setError(null);
-                    return [4 /*yield*/, client.deleteFile(fileId)];
+                    return [4 /*yield*/, client.listFiles()];
                 case 1:
                     result = _a.sent();
                     return [2 /*return*/, result];
@@ -468,7 +468,7 @@ export function TrainlyProvider(_a) {
                     _a.label = 3;
                 case 3:
                     _a.trys.push([3, 8, , 9]);
-                    console.log("🔄 Token expired during file deletion, refreshing...");
+                    console.log("🔄 Token expired during file listing, refreshing...");
                     return [4 /*yield*/, getToken()];
                 case 4:
                     newToken = _a.sent();
@@ -476,10 +476,10 @@ export function TrainlyProvider(_a) {
                     return [4 /*yield*/, client.connectWithOAuthToken(newToken)];
                 case 5:
                     _a.sent();
-                    return [4 /*yield*/, client.deleteFile(fileId)];
+                    return [4 /*yield*/, client.listFiles()];
                 case 6:
                     result = _a.sent();
-                    console.log("✅ File deletion succeeded after token refresh");
+                    console.log("✅ File listing succeeded after token refresh");
                     return [2 /*return*/, result];
                 case 7: return [3 /*break*/, 9];
                 case 8:
@@ -488,8 +488,8 @@ export function TrainlyProvider(_a) {
                     return [3 /*break*/, 9];
                 case 9:
                     error_7 = {
-                        code: "DELETE_FILE_FAILED",
-                        message: "Failed to delete file",
+                        code: "LIST_FILES_FAILED",
+                        message: "Failed to list files",
                         details: err_7,
                     };
                     setError(error_7);
@@ -501,8 +501,64 @@ export function TrainlyProvider(_a) {
             }
         });
     }); };
+    var deleteFile = function (fileId) { return __awaiter(_this, void 0, void 0, function () {
+        var result, err_8, errorMessage, newToken, result, refreshError_5, error_8;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    _a.trys.push([0, 2, 10, 11]);
+                    setIsLoading(true);
+                    setError(null);
+                    return [4 /*yield*/, client.deleteFile(fileId)];
+                case 1:
+                    result = _a.sent();
+                    return [2 /*return*/, result];
+                case 2:
+                    err_8 = _a.sent();
+                    errorMessage = err_8 instanceof Error ? err_8.message : String(err_8);
+                    if (!(getToken &&
+                        appId &&
+                        (errorMessage.includes("401") ||
+                            errorMessage.includes("authentication") ||
+                            errorMessage.includes("Unauthorized")))) return [3 /*break*/, 9];
+                    _a.label = 3;
+                case 3:
+                    _a.trys.push([3, 8, , 9]);
+                    console.log("🔄 Token expired during file deletion, refreshing...");
+                    return [4 /*yield*/, getToken()];
+                case 4:
+                    newToken = _a.sent();
+                    if (!newToken) return [3 /*break*/, 7];
+                    return [4 /*yield*/, client.connectWithOAuthToken(newToken)];
+                case 5:
+                    _a.sent();
+                    return [4 /*yield*/, client.deleteFile(fileId)];
+                case 6:
+                    result = _a.sent();
+                    console.log("✅ File deletion succeeded after token refresh");
+                    return [2 /*return*/, result];
+                case 7: return [3 /*break*/, 9];
+                case 8:
+                    refreshError_5 = _a.sent();
+                    console.error("❌ Token refresh failed:", refreshError_5);
+                    return [3 /*break*/, 9];
+                case 9:
+                    error_8 = {
+                        code: "DELETE_FILE_FAILED",
+                        message: "Failed to delete file",
+                        details: err_8,
+                    };
+                    setError(error_8);
+                    throw error_8;
+                case 10:
+                    setIsLoading(false);
+                    return [7 /*endfinally*/];
+                case 11: return [2 /*return*/];
+            }
+        });
+    }); };
     var sendMessage = function (content) { return __awaiter(_this, void 0, void 0, function () {
-        var userMessage, response, assistantMessage_1, err_8;
+        var userMessage, response, assistantMessage_1, err_9;
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
@@ -529,9 +585,9 @@ export function TrainlyProvider(_a) {
                     setMessages(function (prev) { return __spreadArray(__spreadArray([], prev, true), [assistantMessage_1], false); });
                     return [3 /*break*/, 4];
                 case 3:
-                    err_8 = _a.sent();
+                    err_9 = _a.sent();
                     // Error is already set by askWithCitations
-                    console.error("Failed to send message:", err_8);
+                    console.error("Failed to send message:", err_9);
                     return [3 /*break*/, 4];
                 case 4: return [2 /*return*/];
             }
@@ -544,6 +600,7 @@ export function TrainlyProvider(_a) {
         ask: ask,
         askWithCitations: askWithCitations,
         upload: upload,
+        bulkUploadFiles: bulkUploadFiles, // NEW: Bulk file upload method
         listFiles: listFiles, // NEW: File management methods
         deleteFile: deleteFile,
         connectWithOAuthToken: connectWithOAuthToken, // NEW: V1 OAuth connection method

package/dist/api/TrainlyClient.d.ts

@@ -1,4 +1,4 @@
-import { TrainlyConfig, Citation, UploadResult, FileListResult, FileDeleteResult } from "../types";
+import { TrainlyConfig, Citation, UploadResult, FileListResult, FileDeleteResult, BulkUploadResult } from "../types";
 interface QueryResponse {
     answer: string;
     citations?: Citation[];
@@ -19,6 +19,7 @@ export declare class TrainlyClient {
         includeCitations?: boolean;
     }): Promise<QueryResponse>;
     upload(file: File): Promise<UploadResult>;
+    bulkUploadFiles(files: File[]): Promise<BulkUploadResult>;
     listFiles(): Promise<FileListResult>;
     deleteFile(fileId: string): Promise<FileDeleteResult>;
     private extractChatId;

package/dist/api/TrainlyClient.js

@@ -324,6 +324,114 @@ var TrainlyClient = /** @class */ (function () {
             });
         });
     };
+    TrainlyClient.prototype.bulkUploadFiles = function (files) {
+        return __awaiter(this, void 0, void 0, function () {
+            var formData_1, response, error, data, results, successful_uploads, total_size_bytes, _i, files_1, file, uploadResult, error_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.scopedToken) {
+                            throw new Error("Not connected. Call connect() or connectWithOAuthToken() first.");
+                        }
+                        if (!files || files.length === 0) {
+                            throw new Error("No files provided for bulk upload.");
+                        }
+                        if (files.length > 10) {
+                            throw new Error("Too many files. Maximum 10 files per bulk upload.");
+                        }
+                        if (!(this.isV1Mode && this.config.appId)) return [3 /*break*/, 5];
+                        formData_1 = new FormData();
+                        // Append all files to the form data
+                        files.forEach(function (file) {
+                            formData_1.append("files", file);
+                        });
+                        return [4 /*yield*/, fetch("".concat(this.config.baseUrl, "/v1/me/chats/files/upload-bulk"), {
+                                method: "POST",
+                                headers: {
+                                    Authorization: "Bearer ".concat(this.scopedToken),
+                                    "X-App-ID": this.config.appId,
+                                },
+                                body: formData_1,
+                            })];
+                    case 1:
+                        response = _a.sent();
+                        if (!!response.ok) return [3 /*break*/, 3];
+                        return [4 /*yield*/, response.json()];
+                    case 2:
+                        error = _a.sent();
+                        throw new Error("V1 bulk upload failed: ".concat(error.detail || response.statusText));
+                    case 3: return [4 /*yield*/, response.json()];
+                    case 4:
+                        data = _a.sent();
+                        return [2 /*return*/, {
+                                success: data.success,
+                                total_files: data.total_files,
+                                successful_uploads: data.successful_uploads,
+                                failed_uploads: data.failed_uploads,
+                                total_size_bytes: data.total_size_bytes,
+                                chat_id: data.chat_id,
+                                user_id: data.user_id,
+                                results: data.results,
+                                message: data.message,
+                            }];
+                    case 5:
+                        results = [];
+                        successful_uploads = 0;
+                        total_size_bytes = 0;
+                        _i = 0, files_1 = files;
+                        _a.label = 6;
+                    case 6:
+                        if (!(_i < files_1.length)) return [3 /*break*/, 11];
+                        file = files_1[_i];
+                        _a.label = 7;
+                    case 7:
+                        _a.trys.push([7, 9, , 10]);
+                        return [4 /*yield*/, this.upload(file)];
+                    case 8:
+                        uploadResult = _a.sent();
+                        results.push({
+                            filename: uploadResult.filename,
+                            success: uploadResult.success,
+                            error: null,
+                            file_id: null, // Single upload doesn't return file_id
+                            size_bytes: uploadResult.size,
+                            processing_status: uploadResult.success ? "completed" : "failed",
+                            message: uploadResult.message,
+                        });
+                        if (uploadResult.success) {
+                            successful_uploads++;
+                            total_size_bytes += uploadResult.size;
+                        }
+                        return [3 /*break*/, 10];
+                    case 9:
+                        error_1 = _a.sent();
+                        results.push({
+                            filename: file.name,
+                            success: false,
+                            error: error_1 instanceof Error ? error_1.message : String(error_1),
+                            file_id: null,
+                            size_bytes: file.size,
+                            processing_status: "failed",
+                        });
+                        return [3 /*break*/, 10];
+                    case 10:
+                        _i++;
+                        return [3 /*break*/, 6];
+                    case 11: return [2 /*return*/, {
+                            success: successful_uploads > 0,
+                            total_files: files.length,
+                            successful_uploads: successful_uploads,
+                            failed_uploads: files.length - successful_uploads,
+                            total_size_bytes: total_size_bytes,
+                            chat_id: this.currentUserId || "",
+                            user_id: this.currentUserId || "",
+                            results: results,
+                            message: "Bulk upload completed: ".concat(successful_uploads, "/").concat(files.length, " files processed successfully"),
+                        }];
+                }
+            });
+        });
+    };
     TrainlyClient.prototype.listFiles = function () {
         return __awaiter(this, void 0, void 0, function () {
             var response, error, data;

package/dist/types.d.ts

@@ -34,6 +34,26 @@ export interface UploadResult {
     size: number;
     message?: string;
 }
+export interface BulkUploadFileResult {
+    filename: string;
+    success: boolean;
+    error: string | null;
+    file_id: string | null;
+    size_bytes: number;
+    processing_status: string;
+    message?: string;
+}
+export interface BulkUploadResult {
+    success: boolean;
+    total_files: number;
+    successful_uploads: number;
+    failed_uploads: number;
+    total_size_bytes: number;
+    chat_id: string;
+    user_id: string;
+    results: BulkUploadFileResult[];
+    message: string;
+}
 export interface FileInfo {
     file_id: string;
     filename: string;
@@ -76,6 +96,7 @@ export interface TrainlyContextValue {
     upload: (file: File) => Promise<UploadResult>;
     listFiles: () => Promise<FileListResult>;
     deleteFile: (fileId: string) => Promise<FileDeleteResult>;
+    bulkUploadFiles: (files: File[]) => Promise<BulkUploadResult>;
     connectWithOAuthToken: (idToken: string) => Promise<void>;
     isLoading: boolean;
     isConnected: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trainly/react",
-  "version": "1.2.0",
+  "version": "1.3.1",
   "description": "Dead simple RAG integration for React apps with OAuth authentication",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",