@trainly/react 1.1.3 → 1.3.1

package/dist/TrainlyProvider.js

@@ -389,8 +389,176 @@ export function TrainlyProvider(_a) {
             }
         });
     }); };
+    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) {
+                case 0:
+                    _a.trys.push([0, 2, 10, 11]);
+                    setIsLoading(true);
+                    setError(null);
+                    return [4 /*yield*/, client.bulkUploadFiles(files)];
+                case 1:
+                    result = _a.sent();
+                    return [2 /*return*/, result];
+                case 2:
+                    err_6 = _a.sent();
+                    errorMessage = err_6 instanceof Error ? err_6.message : String(err_6);
+                    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 bulk upload, 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.bulkUploadFiles(files)];
+                case 6:
+                    result = _a.sent();
+                    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 during bulk upload:", refreshError_3);
+                    return [3 /*break*/, 9];
+                case 9:
+                    error_6 = {
+                        code: "BULK_UPLOAD_FAILED",
+                        message: "Failed to upload files",
+                        details: err_6,
+                    };
+                    setError(error_6);
+                    throw error_6;
+                case 10:
+                    setIsLoading(false);
+                    return [7 /*endfinally*/];
+                case 11: return [2 /*return*/];
+            }
+        });
+    }); };
+    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) {
+                case 0:
+                    _a.trys.push([0, 2, 10, 11]);
+                    setIsLoading(true);
+                    setError(null);
+                    return [4 /*yield*/, client.listFiles()];
+                case 1:
+                    result = _a.sent();
+                    return [2 /*return*/, result];
+                case 2:
+                    err_7 = _a.sent();
+                    errorMessage = err_7 instanceof Error ? err_7.message : String(err_7);
+                    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 listing, 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.listFiles()];
+                case 6:
+                    result = _a.sent();
+                    console.log("✅ File listing succeeded after token refresh");
+                    return [2 /*return*/, result];
+                case 7: return [3 /*break*/, 9];
+                case 8:
+                    refreshError_4 = _a.sent();
+                    console.error("❌ Token refresh failed:", refreshError_4);
+                    return [3 /*break*/, 9];
+                case 9:
+                    error_7 = {
+                        code: "LIST_FILES_FAILED",
+                        message: "Failed to list files",
+                        details: err_7,
+                    };
+                    setError(error_7);
+                    throw error_7;
+                case 10:
+                    setIsLoading(false);
+                    return [7 /*endfinally*/];
+                case 11: return [2 /*return*/];
+            }
+        });
+    }); };
+    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_6;
+        var userMessage, response, assistantMessage_1, err_9;
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
@@ -417,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_6 = _a.sent();
+                    err_9 = _a.sent();
                     // Error is already set by askWithCitations
-                    console.error("Failed to send message:", err_6);
+                    console.error("Failed to send message:", err_9);
                     return [3 /*break*/, 4];
                 case 4: return [2 /*return*/];
             }
@@ -432,6 +600,9 @@ 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
         isLoading: isLoading,
         isConnected: isConnected,

package/dist/api/TrainlyClient.d.ts

@@ -1,4 +1,4 @@
-import { TrainlyConfig, Citation, UploadResult } from "../types";
+import { TrainlyConfig, Citation, UploadResult, FileListResult, FileDeleteResult, BulkUploadResult } from "../types";
 interface QueryResponse {
     answer: string;
     citations?: Citation[];
@@ -19,6 +19,9 @@ 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;
     private generateAnonymousId;
 }

package/dist/api/TrainlyClient.js

@@ -324,6 +324,189 @@ 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;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.scopedToken) {
+                            throw new Error("Not connected. Call connect() or connectWithOAuthToken() first.");
+                        }
+                        if (!(this.isV1Mode && this.config.appId)) return [3 /*break*/, 5];
+                        return [4 /*yield*/, fetch("".concat(this.config.baseUrl, "/v1/me/chats/files"), {
+                                method: "GET",
+                                headers: {
+                                    Authorization: "Bearer ".concat(this.scopedToken),
+                                    "X-App-ID": this.config.appId,
+                                },
+                            })];
+                    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 list files failed: ".concat(error.detail || response.statusText));
+                    case 3: return [4 /*yield*/, response.json()];
+                    case 4:
+                        data = _a.sent();
+                        return [2 /*return*/, data];
+                    case 5: 
+                    // For other modes, this functionality is not yet implemented
+                    // as it requires chat-specific API endpoints
+                    throw new Error("File listing is currently only available in V1 Trusted Issuer mode");
+                }
+            });
+        });
+    };
+    TrainlyClient.prototype.deleteFile = function (fileId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response, error, data;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.scopedToken) {
+                            throw new Error("Not connected. Call connect() or connectWithOAuthToken() first.");
+                        }
+                        if (!fileId) {
+                            throw new Error("File ID is required");
+                        }
+                        if (!(this.isV1Mode && this.config.appId)) return [3 /*break*/, 5];
+                        return [4 /*yield*/, fetch("".concat(this.config.baseUrl, "/v1/me/chats/files/").concat(encodeURIComponent(fileId)), {
+                                method: "DELETE",
+                                headers: {
+                                    Authorization: "Bearer ".concat(this.scopedToken),
+                                    "X-App-ID": this.config.appId,
+                                },
+                            })];
+                    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 delete file failed: ".concat(error.detail || response.statusText));
+                    case 3: return [4 /*yield*/, response.json()];
+                    case 4:
+                        data = _a.sent();
+                        return [2 /*return*/, data];
+                    case 5: 
+                    // For other modes, this functionality is not yet implemented
+                    // as it requires chat-specific API endpoints
+                    throw new Error("File deletion is currently only available in V1 Trusted Issuer mode");
+                }
+            });
+        });
+    };
     TrainlyClient.prototype.extractChatId = function () {
         if (!this.config.apiKey) {
             throw new Error("API key not provided");

package/dist/components/TrainlyFileManager.d.ts

@@ -0,0 +1,8 @@
+export interface TrainlyFileManagerProps {
+    className?: string;
+    onFileDeleted?: (fileId: string, filename: string) => void;
+    onError?: (error: Error) => void;
+    showUploadButton?: boolean;
+    maxFileSize?: number;
+}
+export declare function TrainlyFileManager({ className, onFileDeleted, onError, showUploadButton, maxFileSize, }: TrainlyFileManagerProps): import("react/jsx-runtime").JSX.Element;