@widgetic/chat 0.1.4 → 0.1.5

package/dist/config.js

@@ -27,7 +27,7 @@ if (!env.PUBLIC_PRODUCTION_URL) {
     throw new Error('PUBLIC_PRODUCTION_URL environment variable is not set');
 }
 // Create and export the config object with proper typing
-export var config = {
+export const config = {
     API_URL: env.PUBLIC_API_URL,
     API_VERSION: env.PUBLIC_API_VERSION,
     INTERNAL_KEY: env.PUBLIC_INTERNAL_KEY,
@@ -43,23 +43,23 @@ export var config = {
  */
 export function createSdkConfig(options) {
     return new Configuration({
-        apiKey: function (name) { return (options === null || options === void 0 ? void 0 : options.apiKey) || config.API_KEY || config.INTERNAL_KEY || ''; },
-        basePath: (options === null || options === void 0 ? void 0 : options.basePath) || getApiUrl()
+        apiKey: (name) => options?.apiKey || config.API_KEY || config.INTERNAL_KEY || '',
+        basePath: options?.basePath || getApiUrl()
     });
 }
 /**
  * Gets the full API URL for the current environment
  */
 export function getApiUrl() {
-    var baseUrl = config.NODE_ENV === 'production'
+    const baseUrl = config.NODE_ENV === 'production'
         ? config.PRODUCTION_URL
         : config.API_URL;
-    return "".concat(baseUrl).concat(config.API_VERSION);
+    return `${baseUrl}${config.API_VERSION}`;
 }
 /**
  * Environment-specific settings
  */
-export var environment = {
+export const environment = {
     isProduction: config.NODE_ENV === 'production',
     apiUrl: getApiUrl(),
     // Use API_KEY if available, fall back to INTERNAL_KEY

package/dist/constants/colors.js

@@ -2,7 +2,7 @@
  * Message background colors for different states
  * These can be easily modified to change the appearance of messages
  */
-export var MESSAGE_COLORS = {
+export const MESSAGE_COLORS = {
     /** Background color for user messages in completed chats */
     USER_COMPLETED: '#C6FFD3', // Light green
     /** Background color for user messages in active (non-completed) chats */

package/dist/services/chatService.js

@@ -1,57 +1,12 @@
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
-    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-import { chatLog } from '../utils/logger.js';
-import { ConversationsApi, MessagesApi } from '@widgetic/api-sdk';
+import { chatLog, chatWarn } from '../utils/logger.js';
+import { ConversationsApi, MessagesApi, Configuration } from '@widgetic/api-sdk';
 /**
  * Chat service implementation using Widgetic API SDK
  */
-var WidgeticChatService = /** @class */ (function () {
-    function WidgeticChatService(configuration) {
+export class WidgeticChatService {
+    conversationsApi;
+    messagesApi;
+    constructor(configuration) {
         this.conversationsApi = new ConversationsApi(configuration);
         this.messagesApi = new MessagesApi(configuration);
         chatLog('ChatService initialized (mock mode)');
@@ -59,159 +14,116 @@ var WidgeticChatService = /** @class */ (function () {
     /**
      * Get all conversations for a given context (canvas + component)
      */
-    WidgeticChatService.prototype.getConversations = function (contextId) {
-        return __awaiter(this, void 0, Promise, function () {
-            var _a, canvasId, componentId;
-            return __generator(this, function (_b) {
-                _a = this.parseContextId(contextId), canvasId = _a[0], componentId = _a[1];
-                try {
-                    // Mock implementation for now
-                    chatLog('Getting conversations for:', { canvasId: canvasId, componentId: componentId });
-                    return [2 /*return*/, []];
-                }
-                catch (error) {
-                    console.error('Failed to get conversations:', error);
-                    throw new Error('Failed to load conversations');
-                }
-                return [2 /*return*/];
-            });
-        });
-    };
+    async getConversations(contextId) {
+        const [canvasId, componentId] = this.parseContextId(contextId);
+        try {
+            // Mock implementation for now
+            chatLog('Getting conversations for:', { canvasId, componentId });
+            return [];
+        }
+        catch (error) {
+            console.error('Failed to get conversations:', error);
+            throw new Error('Failed to load conversations');
+        }
+    }
     /**
      * Create a new conversation
      */
-    WidgeticChatService.prototype.createConversation = function (contextId, data) {
-        return __awaiter(this, void 0, Promise, function () {
-            var _a, canvasId, componentId, request, mockConversation;
-            return __generator(this, function (_b) {
-                _a = this.parseContextId(contextId), canvasId = _a[0], componentId = _a[1];
-                request = {
-                    title: data.title || 'New Chat',
-                    completed: false
-                };
-                try {
-                    chatLog('Creating conversation:', { canvasId: canvasId, componentId: componentId, request: request });
-                    mockConversation = {
-                        id: "conv_".concat(Date.now()),
-                        title: request.title,
-                        completed: request.completed,
-                        createdAt: new Date(),
-                        updatedAt: new Date(),
-                        _unreadCount: 0,
-                        _lastActivity: new Date(),
-                        _isActive: false
-                    };
-                    return [2 /*return*/, mockConversation];
-                }
-                catch (error) {
-                    console.error('Failed to create conversation:', error);
-                    throw new Error('Failed to create conversation');
-                }
-                return [2 /*return*/];
-            });
-        });
-    };
+    async createConversation(contextId, data) {
+        const [canvasId, componentId] = this.parseContextId(contextId);
+        const request = {
+            title: data.title || 'New Chat',
+            completed: false
+        };
+        try {
+            chatLog('Creating conversation:', { canvasId, componentId, request });
+            // Mock response
+            const mockConversation = {
+                id: `conv_${Date.now()}`,
+                title: request.title,
+                completed: request.completed,
+                createdAt: new Date(),
+                updatedAt: new Date(),
+                _unreadCount: 0,
+                _lastActivity: new Date(),
+                _isActive: false
+            };
+            return mockConversation;
+        }
+        catch (error) {
+            console.error('Failed to create conversation:', error);
+            throw new Error('Failed to create conversation');
+        }
+    }
     /**
      * Update an existing conversation
      */
-    WidgeticChatService.prototype.updateConversation = function (conversationId, updates) {
-        return __awaiter(this, void 0, Promise, function () {
-            return __generator(this, function (_a) {
-                // We need to extract canvas and component IDs from the conversation
-                // This would typically be stored in the client state or passed differently
-                throw new Error('Update conversation not yet implemented - need context IDs');
-            });
-        });
-    };
+    async updateConversation(conversationId, updates) {
+        // We need to extract canvas and component IDs from the conversation
+        // This would typically be stored in the client state or passed differently
+        throw new Error('Update conversation not yet implemented - need context IDs');
+    }
     /**
      * Delete a conversation
      */
-    WidgeticChatService.prototype.deleteConversation = function (conversationId) {
-        return __awaiter(this, void 0, Promise, function () {
-            return __generator(this, function (_a) {
-                // Similar issue - need canvas and component IDs
-                throw new Error('Delete conversation not yet implemented - need context IDs');
-            });
-        });
-    };
+    async deleteConversation(conversationId) {
+        // Similar issue - need canvas and component IDs
+        throw new Error('Delete conversation not yet implemented - need context IDs');
+    }
     /**
      * Get all messages for a conversation
      */
-    WidgeticChatService.prototype.getMessages = function (conversationId) {
-        return __awaiter(this, void 0, Promise, function () {
-            return __generator(this, function (_a) {
-                try {
-                    chatLog('Getting messages for conversation:', conversationId);
-                    return [2 /*return*/, []];
-                }
-                catch (error) {
-                    console.error('Failed to get messages:', error);
-                    return [2 /*return*/, []];
-                }
-                return [2 /*return*/];
-            });
-        });
-    };
+    async getMessages(conversationId) {
+        try {
+            chatLog('Getting messages for conversation:', conversationId);
+            return [];
+        }
+        catch (error) {
+            console.error('Failed to get messages:', error);
+            return [];
+        }
+    }
     /**
      * Send a new message
      */
-    WidgeticChatService.prototype.sendMessage = function (conversationId, data) {
-        return __awaiter(this, void 0, Promise, function () {
-            var processedAttachments, i, attachment, input, stableUrl, url, _a, _b, url, request, mockMessage, error_1;
-            var _c, _d, _e, _f;
-            return __generator(this, function (_g) {
-                switch (_g.label) {
-                    case 0:
-                        _g.trys.push([0, 11, , 12]);
-                        processedAttachments = [];
-                        if (!(data.attachments && data.attachments.length > 0)) return [3 /*break*/, 10];
-                        chatLog('Processing attachments:', data.attachments.length);
-                        i = 0;
-                        _g.label = 1;
-                    case 1:
-                        if (!(i < data.attachments.length)) return [3 /*break*/, 10];
-                        attachment = data.attachments[i];
-                        if (!(attachment && typeof attachment === 'object' && 'file' in attachment)) return [3 /*break*/, 6];
-                        input = attachment;
-                        stableUrl = input.uploadedUrl;
-                        _a = stableUrl;
-                        if (_a) return [3 /*break*/, 5];
-                        if (!input.file) return [3 /*break*/, 3];
-                        return [4 /*yield*/, this.fileToDataUrl(input.file)];
-                    case 2:
-                        _b = _g.sent();
-                        return [3 /*break*/, 4];
-                    case 3:
-                        _b = '';
-                        _g.label = 4;
-                    case 4:
-                        _a = (_b);
-                        _g.label = 5;
-                    case 5:
-                        url = _a;
+    async sendMessage(conversationId, data) {
+        try {
+            let processedAttachments = [];
+            if (data.attachments && data.attachments.length > 0) {
+                chatLog('Processing attachments:', data.attachments.length);
+                for (let i = 0; i < data.attachments.length; i++) {
+                    const attachment = data.attachments[i];
+                    if (attachment && typeof attachment === 'object' && 'file' in attachment) {
+                        const input = attachment;
+                        const isImage = (input.file?.type || '').startsWith('image/');
+                        const stableUrl = input.uploadedUrl || (isImage ? input.preview : '') || (input.file && !isImage
+                            ? URL.createObjectURL(input.file)
+                            : (input.preview || ''));
+                        const url = stableUrl || (input.file && isImage ? await this.fileToDataUrl(input.file) : '');
                         processedAttachments.push({
-                            id: "att_".concat(Date.now(), "_").concat(i, "_").concat(Math.random().toString(36).substr(2, 9)),
-                            url: url,
-                            file_type: ((_c = input.file) === null || _c === void 0 ? void 0 : _c.type) || 'image/png',
-                            file_name: ((_d = input.file) === null || _d === void 0 ? void 0 : _d.name) || 'attachment',
-                            file_size: (_e = input.file) === null || _e === void 0 ? void 0 : _e.size,
+                            id: `att_${Date.now()}_${i}_${Math.random().toString(36).substr(2, 9)}`,
+                            url,
+                            file_type: input.file?.type || 'image/png',
+                            file_name: input.file?.name || 'attachment',
+                            file_size: input.file?.size,
                             metadata: {
-                                originalName: (_f = input.file) === null || _f === void 0 ? void 0 : _f.name,
+                                originalName: input.file?.name,
                                 uploadedAt: new Date().toISOString(),
                                 storage: stableUrl ? 'upload-service' : 'inline-data-url',
                             },
                             created_at: new Date().toISOString(),
                             display_order: i + 1,
                         });
-                        return [3 /*break*/, 9];
-                    case 6:
-                        if (!(attachment instanceof File)) return [3 /*break*/, 8];
-                        return [4 /*yield*/, this.fileToDataUrl(attachment)];
-                    case 7:
-                        url = _g.sent();
+                        continue;
+                    }
+                    if (attachment instanceof File) {
+                        const isImage = attachment.type.startsWith('image/');
+                        const url = isImage
+                            ? await this.fileToDataUrl(attachment)
+                            : URL.createObjectURL(attachment);
                         processedAttachments.push({
-                            id: "att_".concat(Date.now(), "_").concat(i, "_").concat(Math.random().toString(36).substr(2, 9)),
-                            url: url,
+                            id: `att_${Date.now()}_${i}_${Math.random().toString(36).substr(2, 9)}`,
+                            url,
                             file_type: attachment.type,
                             file_name: attachment.name,
                             file_size: attachment.size,
@@ -223,130 +135,107 @@ var WidgeticChatService = /** @class */ (function () {
                             created_at: new Date().toISOString(),
                             display_order: i + 1,
                         });
-                        return [3 /*break*/, 9];
-                    case 8:
+                    }
+                    else {
                         processedAttachments.push(attachment);
-                        _g.label = 9;
-                    case 9:
-                        i++;
-                        return [3 /*break*/, 1];
-                    case 10:
-                        request = {
-                            messageContent: data.messageContent,
-                            messageType: 'user',
-                            attachments: processedAttachments
-                        };
-                        chatLog('Sending message:', { conversationId: conversationId, request: request });
-                        mockMessage = {
-                            id: "msg_".concat(Date.now(), "_").concat(Math.random().toString(36).substr(2, 9)),
-                            conversationId: conversationId,
-                            messageContent: data.messageContent,
-                            messageType: 'user',
-                            attachments: processedAttachments,
-                            isCommit: false,
-                            userId: 'test_user',
-                            createdAt: new Date(),
-                            updatedAt: new Date(),
-                            _optimistic: false,
-                            _failed: false,
-                            _retryCount: 0
-                        };
-                        chatLog('Mock message created:', mockMessage);
-                        return [2 /*return*/, mockMessage];
-                    case 11:
-                        error_1 = _g.sent();
-                        console.error('Failed to send message:', error_1);
-                        throw new Error('Failed to send message');
-                    case 12: return [2 /*return*/];
+                    }
                 }
-            });
-        });
-    };
+            }
+            const request = {
+                messageContent: data.messageContent,
+                messageType: 'user',
+                attachments: processedAttachments
+            };
+            chatLog('Sending message:', { conversationId, request });
+            // Mock response
+            const mockMessage = {
+                id: `msg_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+                conversationId,
+                messageContent: data.messageContent,
+                messageType: 'user',
+                attachments: processedAttachments,
+                isCommit: false,
+                userId: 'test_user',
+                createdAt: new Date(),
+                updatedAt: new Date(),
+                _optimistic: false,
+                _failed: false,
+                _retryCount: 0
+            };
+            chatLog('Mock message created:', mockMessage);
+            return mockMessage;
+        }
+        catch (error) {
+            console.error('Failed to send message:', error);
+            throw new Error('Failed to send message');
+        }
+    }
     /**
      * Update a message
      */
-    WidgeticChatService.prototype.updateMessage = function (messageId, updates) {
-        return __awaiter(this, void 0, Promise, function () {
-            return __generator(this, function (_a) {
-                chatLog('Update message not yet implemented:', messageId, updates);
-                throw new Error('Update message not yet implemented');
-            });
-        });
-    };
+    async updateMessage(messageId, updates) {
+        chatLog('Update message not yet implemented:', messageId, updates);
+        throw new Error('Update message not yet implemented');
+    }
     /**
      * Delete a message
      */
-    WidgeticChatService.prototype.deleteMessage = function (messageId) {
-        return __awaiter(this, void 0, Promise, function () {
-            return __generator(this, function (_a) {
-                chatLog('Delete message not yet implemented:', messageId);
-                throw new Error('Delete message not yet implemented');
-            });
-        });
-    };
+    async deleteMessage(messageId) {
+        chatLog('Delete message not yet implemented:', messageId);
+        throw new Error('Delete message not yet implemented');
+    }
     /**
      * Read a file as a data URL (persistable in DB until upload service exists).
      */
-    WidgeticChatService.prototype.fileToDataUrl = function (file) {
-        return __awaiter(this, void 0, Promise, function () {
-            return __generator(this, function (_a) {
-                chatLog('Reading attachment as data URL:', file.name);
-                return [2 /*return*/, new Promise(function (resolve, reject) {
-                        var reader = new FileReader();
-                        reader.onload = function () { return resolve(String(reader.result)); };
-                        reader.onerror = function () { return reject(reader.error); };
-                        reader.readAsDataURL(file);
-                    })];
-            });
+    async fileToDataUrl(file) {
+        chatLog('Reading attachment as data URL:', file.name);
+        return new Promise((resolve, reject) => {
+            const reader = new FileReader();
+            reader.onload = () => resolve(String(reader.result));
+            reader.onerror = () => reject(reader.error);
+            reader.readAsDataURL(file);
         });
-    };
+    }
     /** @deprecated Use fileToDataUrl — blob URLs are not reload-safe */
-    WidgeticChatService.prototype.uploadFile = function (file) {
-        return __awaiter(this, void 0, Promise, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.fileToDataUrl(file)];
-            });
-        });
-    };
+    async uploadFile(file) {
+        return this.fileToDataUrl(file);
+    }
     /**
      * Process AI response (placeholder for LLM integration)
      */
-    WidgeticChatService.prototype.processAIResponse = function (conversationId, message) {
-        return __awaiter(this, void 0, Promise, function () {
-            var aiResponse;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: 
-                    // This would integrate with the AI service to generate responses
-                    // For now, return a mock response
-                    // Add a small delay to ensure unique timestamp
-                    return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 10); })];
-                    case 1:
-                        // This would integrate with the AI service to generate responses
-                        // For now, return a mock response
-                        // Add a small delay to ensure unique timestamp
-                        _a.sent();
-                        aiResponse = __assign(__assign({}, message), { id: "ai_".concat(Date.now(), "_").concat(Math.random().toString(36).substr(2, 9)), messageType: 'assistant', messageContent: "AI response to: ".concat(message.messageContent || '[attachment only]'), createdAt: new Date(), updatedAt: new Date(), userId: 'ai_assistant', attachments: [], _optimistic: false, _failed: false, _retryCount: 0 });
-                        chatLog('AI response generated:', aiResponse);
-                        return [2 /*return*/, aiResponse];
-                }
-            });
-        });
-    };
+    async processAIResponse(conversationId, message) {
+        // This would integrate with the AI service to generate responses
+        // For now, return a mock response
+        // Add a small delay to ensure unique timestamp
+        await new Promise(resolve => setTimeout(resolve, 10));
+        const aiResponse = {
+            ...message,
+            id: `ai_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+            messageType: 'assistant',
+            messageContent: `AI response to: ${message.messageContent || '[attachment only]'}`,
+            createdAt: new Date(),
+            updatedAt: new Date(),
+            userId: 'ai_assistant',
+            attachments: [], // AI response doesn't inherit user attachments
+            _optimistic: false,
+            _failed: false,
+            _retryCount: 0
+        };
+        chatLog('AI response generated:', aiResponse);
+        return aiResponse;
+    }
     /**
      * Parse context ID to extract canvas and component IDs.
      * Supports "canvas_id:component_id" format or a single ID (used as both).
      */
-    WidgeticChatService.prototype.parseContextId = function (contextId) {
-        var parts = contextId.split(':');
+    parseContextId(contextId) {
+        const parts = contextId.split(':');
         if (parts.length === 2) {
             return [parts[0], parts[1]];
         }
         return [contextId, contextId];
-    };
-    return WidgeticChatService;
-}());
-export { WidgeticChatService };
+    }
+}
 /**
  * Create a chat service instance with the given configuration
  */

package/dist/stores/chatStore.d.ts

@@ -24,6 +24,7 @@ export declare const chatStore: {
         setMessages: (conversationId: string, messages: ChatMessage[]) => void;
         updateMessageId: (conversationId: string, oldId: string, newId: string) => void;
         updateMessageContent: (conversationId: string, messageId: string, messageContent: string) => void;
+        updateMessageAttachments: (conversationId: string, messageId: string, attachments: any[]) => void;
     };
 };
 /**