@widgetic/chat 0.1.4

package/dist/services/chatService.js

@@ -0,0 +1,355 @@
+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';
+/**
+ * Chat service implementation using Widgetic API SDK
+ */
+var WidgeticChatService = /** @class */ (function () {
+    function WidgeticChatService(configuration) {
+        this.conversationsApi = new ConversationsApi(configuration);
+        this.messagesApi = new MessagesApi(configuration);
+        chatLog('ChatService initialized (mock mode)');
+    }
+    /**
+     * 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*/];
+            });
+        });
+    };
+    /**
+     * 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*/];
+            });
+        });
+    };
+    /**
+     * 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');
+            });
+        });
+    };
+    /**
+     * 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');
+            });
+        });
+    };
+    /**
+     * 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*/];
+            });
+        });
+    };
+    /**
+     * 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;
+                        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,
+                            metadata: {
+                                originalName: (_f = input.file) === null || _f === void 0 ? void 0 : _f.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();
+                        processedAttachments.push({
+                            id: "att_".concat(Date.now(), "_").concat(i, "_").concat(Math.random().toString(36).substr(2, 9)),
+                            url: url,
+                            file_type: attachment.type,
+                            file_name: attachment.name,
+                            file_size: attachment.size,
+                            metadata: {
+                                originalName: attachment.name,
+                                uploadedAt: new Date().toISOString(),
+                                storage: 'inline-data-url',
+                            },
+                            created_at: new Date().toISOString(),
+                            display_order: i + 1,
+                        });
+                        return [3 /*break*/, 9];
+                    case 8:
+                        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*/];
+                }
+            });
+        });
+    };
+    /**
+     * 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');
+            });
+        });
+    };
+    /**
+     * 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');
+            });
+        });
+    };
+    /**
+     * 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);
+                    })];
+            });
+        });
+    };
+    /** @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)];
+            });
+        });
+    };
+    /**
+     * 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];
+                }
+            });
+        });
+    };
+    /**
+     * 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(':');
+        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
+ */
+export function createChatService(configuration) {
+    return new WidgeticChatService(configuration);
+}

package/dist/services/index.d.ts

@@ -0,0 +1,2 @@
+export { WidgeticChatService, createChatService } from './chatService.js';
+export type { ChatService, ChatInstance, ChatFactory } from '../types/index.js';

package/dist/services/index.js

@@ -0,0 +1,2 @@
+// Chat Service
+export { WidgeticChatService, createChatService } from './chatService.js';

package/dist/stores/chatStore.d.ts

@@ -0,0 +1,46 @@
+import type { ChatState, ChatAction, ChatMessage, ChatConversation, InputState, UIState, ActiveContextState } from '../types/index.js';
+/**
+ * Main chat store instance
+ */
+export declare const chatStore: {
+    subscribe: (this: void, run: import("svelte/store").Subscriber<ChatState>, invalidate?: () => void) => import("svelte/store").Unsubscriber;
+    /**
+     * Dispatch actions to update the store
+     */
+    dispatch: (action: ChatAction) => void;
+    /**
+     * Reset the store to initial state
+     */
+    reset: () => void;
+    /**
+     * Helper methods for common operations
+     */
+    actions: {
+        setActiveContext: (contextId: string | null, isExpanded?: boolean) => void;
+        updateInput: (updates: Partial<InputState>) => void;
+        updateUI: (updates: Partial<UIState>) => void;
+        addMessage: (conversationId: string, message: ChatMessage) => void;
+        setConversations: (contextId: string, conversations: ChatConversation[]) => void;
+        setMessages: (conversationId: string, messages: ChatMessage[]) => void;
+        updateMessageId: (conversationId: string, oldId: string, newId: string) => void;
+        updateMessageContent: (conversationId: string, messageId: string, messageContent: string) => void;
+    };
+};
+/**
+ * Derived stores for specific parts of the state
+ */
+export declare const activeContext: {
+    subscribe: (callback: (value: ActiveContextState) => void) => import("svelte/store").Unsubscriber;
+};
+export declare const inputState: {
+    subscribe: (callback: (value: InputState) => void) => import("svelte/store").Unsubscriber;
+};
+export declare const uiState: {
+    subscribe: (callback: (value: UIState) => void) => import("svelte/store").Unsubscriber;
+};
+/**
+ * Reactive getters for current state
+ */
+export declare const getCurrentState: () => ChatState;
+export declare const getCurrentMessages: (conversationId: string) => ChatMessage[];
+export declare const getCurrentConversations: (contextId: string) => ChatConversation[];

package/dist/stores/chatStore.js

@@ -0,0 +1,219 @@
+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 __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+import { writable } from 'svelte/store';
+import { chatLog } from '../utils/logger.js';
+/**
+ * Initial state for the chat store
+ */
+var initialState = {
+    activeContext: {
+        contextId: null,
+        isExpanded: false
+    },
+    input: {
+        text: '',
+        attachments: [],
+        isRecording: false,
+        isSending: false,
+        isUploading: false,
+        uploadProgress: {},
+        history: [],
+        historyIndex: -1
+    },
+    ui: {
+        isExpanded: false,
+        isLoading: false,
+        activeTab: 'chat',
+        errorMessage: null,
+        lastAction: null
+    },
+    messages: {
+        byConversationId: {},
+        isLoading: {},
+        errors: {}
+    },
+    conversations: {
+        byContextId: {},
+        isLoading: {},
+        errors: {}
+    },
+    availableContexts: []
+};
+/**
+ * Create the chat store with rune-like reactive state
+ */
+function createChatStore() {
+    var _a = writable(initialState), subscribe = _a.subscribe, set = _a.set, update = _a.update;
+    return {
+        subscribe: subscribe,
+        /**
+         * Dispatch actions to update the store
+         */
+        dispatch: function (action) {
+            update(function (state) {
+                var _a, _b, _c, _d, _e, _f;
+                var _g;
+                chatLog("Chat Action: ".concat(action.type), action.payload);
+                switch (action.type) {
+                    case 'SET_ACTIVE_CONTEXT':
+                        return __assign(__assign({}, state), { activeContext: __assign(__assign({}, state.activeContext), { contextId: action.payload.contextId, isExpanded: (_g = action.payload.isExpanded) !== null && _g !== void 0 ? _g : state.activeContext.isExpanded, expandedAt: action.payload.contextId ? new Date() : undefined }) });
+                    case 'UPDATE_INPUT':
+                        return __assign(__assign({}, state), { input: __assign(__assign({}, state.input), action.payload) });
+                    case 'UPDATE_UI':
+                        return __assign(__assign({}, state), { ui: __assign(__assign({}, state.ui), action.payload) });
+                    case 'ADD_MESSAGE':
+                        var _h = action.payload, conversationId = _h.conversationId, message = _h.message;
+                        return __assign(__assign({}, state), { messages: __assign(__assign({}, state.messages), { byConversationId: __assign(__assign({}, state.messages.byConversationId), (_a = {}, _a[conversationId] = __spreadArray(__spreadArray([], (state.messages.byConversationId[conversationId] || []), true), [
+                                    message
+                                ], false), _a)) }) });
+                    case 'UPDATE_MESSAGE':
+                        var _j = action.payload, convId = _j.conversationId, messageId_1 = _j.messageId, updates_1 = _j.updates;
+                        var existingMessages = state.messages.byConversationId[convId] || [];
+                        return __assign(__assign({}, state), { messages: __assign(__assign({}, state.messages), { byConversationId: __assign(__assign({}, state.messages.byConversationId), (_b = {}, _b[convId] = existingMessages.map(function (msg) {
+                                    return msg.id === messageId_1 ? __assign(__assign({}, msg), updates_1) : msg;
+                                }), _b)) }) });
+                    case 'ADD_CONVERSATION':
+                        var _k = action.payload, contextId = _k.contextId, conversation = _k.conversation;
+                        return __assign(__assign({}, state), { conversations: __assign(__assign({}, state.conversations), { byContextId: __assign(__assign({}, state.conversations.byContextId), (_c = {}, _c[contextId] = __spreadArray(__spreadArray([], (state.conversations.byContextId[contextId] || []), true), [
+                                    conversation
+                                ], false), _c)) }) });
+                    case 'UPDATE_CONVERSATION':
+                        var _l = action.payload, ctxId = _l.contextId, convIdUpd_1 = _l.conversationId, convUpdates_1 = _l.updates;
+                        var existingConversations = state.conversations.byContextId[ctxId] || [];
+                        return __assign(__assign({}, state), { conversations: __assign(__assign({}, state.conversations), { byContextId: __assign(__assign({}, state.conversations.byContextId), (_d = {}, _d[ctxId] = existingConversations.map(function (conv) {
+                                    return conv.id === convIdUpd_1 ? __assign(__assign({}, conv), convUpdates_1) : conv;
+                                }), _d)) }) });
+                    case 'SET_LOADING':
+                        var _m = action.payload, key = _m.key, loading = _m.loading;
+                        return __assign(__assign({}, state), { messages: __assign(__assign({}, state.messages), { isLoading: __assign(__assign({}, state.messages.isLoading), (_e = {}, _e[key] = loading, _e)) }) });
+                    case 'SET_ERROR':
+                        var _o = action.payload, errorKey = _o.key, error = _o.error;
+                        return __assign(__assign({}, state), { messages: __assign(__assign({}, state.messages), { errors: __assign(__assign({}, state.messages.errors), (_f = {}, _f[errorKey] = error, _f)) }) });
+                    default:
+                        chatLog("Unknown action type: ".concat(action.type));
+                        return state;
+                }
+            });
+        },
+        /**
+         * Reset the store to initial state
+         */
+        reset: function () { return set(initialState); },
+        /**
+         * Helper methods for common operations
+         */
+        actions: {
+            setActiveContext: function (contextId, isExpanded) {
+                update(function (state) { return (__assign(__assign({}, state), { activeContext: {
+                        contextId: contextId,
+                        isExpanded: isExpanded !== null && isExpanded !== void 0 ? isExpanded : state.activeContext.isExpanded,
+                        expandedAt: contextId ? new Date() : undefined
+                    } })); });
+            },
+            updateInput: function (updates) {
+                update(function (state) { return (__assign(__assign({}, state), { input: __assign(__assign({}, state.input), updates) })); });
+            },
+            updateUI: function (updates) {
+                update(function (state) { return (__assign(__assign({}, state), { ui: __assign(__assign({}, state.ui), updates) })); });
+            },
+            addMessage: function (conversationId, message) {
+                update(function (state) {
+                    var _a;
+                    return (__assign(__assign({}, state), { messages: __assign(__assign({}, state.messages), { byConversationId: __assign(__assign({}, state.messages.byConversationId), (_a = {}, _a[conversationId] = __spreadArray(__spreadArray([], (state.messages.byConversationId[conversationId] || []), true), [
+                                message
+                            ], false), _a)) }) }));
+                });
+            },
+            setConversations: function (contextId, conversations) {
+                update(function (state) {
+                    var _a;
+                    return (__assign(__assign({}, state), { conversations: __assign(__assign({}, state.conversations), { byContextId: __assign(__assign({}, state.conversations.byContextId), (_a = {}, _a[contextId] = conversations, _a)) }) }));
+                });
+            },
+            setMessages: function (conversationId, messages) {
+                update(function (state) {
+                    var _a;
+                    return (__assign(__assign({}, state), { messages: __assign(__assign({}, state.messages), { byConversationId: __assign(__assign({}, state.messages.byConversationId), (_a = {}, _a[conversationId] = messages, _a)) }) }));
+                });
+            },
+            updateMessageId: function (conversationId, oldId, newId) {
+                update(function (state) {
+                    var _a;
+                    var msgs = state.messages.byConversationId[conversationId];
+                    if (!msgs)
+                        return state;
+                    return __assign(__assign({}, state), { messages: __assign(__assign({}, state.messages), { byConversationId: __assign(__assign({}, state.messages.byConversationId), (_a = {}, _a[conversationId] = msgs.map(function (msg) {
+                                return msg.id === oldId ? __assign(__assign({}, msg), { id: newId }) : msg;
+                            }), _a)) }) });
+                });
+            },
+            updateMessageContent: function (conversationId, messageId, messageContent) {
+                update(function (state) {
+                    var _a;
+                    var msgs = state.messages.byConversationId[conversationId];
+                    if (!msgs)
+                        return state;
+                    return __assign(__assign({}, state), { messages: __assign(__assign({}, state.messages), { byConversationId: __assign(__assign({}, state.messages.byConversationId), (_a = {}, _a[conversationId] = msgs.map(function (msg) {
+                                return msg.id === messageId ? __assign(__assign({}, msg), { messageContent: messageContent }) : msg;
+                            }), _a)) }) });
+                });
+            }
+        }
+    };
+}
+/**
+ * Main chat store instance
+ */
+export var chatStore = createChatStore();
+/**
+ * Derived stores for specific parts of the state
+ */
+export var activeContext = {
+    subscribe: function (callback) {
+        return chatStore.subscribe(function (state) { return callback(state.activeContext); });
+    }
+};
+export var inputState = {
+    subscribe: function (callback) {
+        return chatStore.subscribe(function (state) { return callback(state.input); });
+    }
+};
+export var uiState = {
+    subscribe: function (callback) {
+        return chatStore.subscribe(function (state) { return callback(state.ui); });
+    }
+};
+/**
+ * Reactive getters for current state
+ */
+export var getCurrentState = function () {
+    var currentState;
+    chatStore.subscribe(function (state) { currentState = state; })();
+    return currentState;
+};
+export var getCurrentMessages = function (conversationId) {
+    var state = getCurrentState();
+    return state.messages.byConversationId[conversationId] || [];
+};
+export var getCurrentConversations = function (contextId) {
+    var state = getCurrentState();
+    return state.conversations.byContextId[contextId] || [];
+};

package/dist/stores/index.d.ts

@@ -0,0 +1,2 @@
+export { chatStore, activeContext, inputState, uiState, getCurrentState, getCurrentMessages, getCurrentConversations } from './chatStore.js';
+export type { ChatState, ChatAction, InputState, UIState, ActiveContextState, MessageState, ConversationState } from '../types/index.js';

package/dist/stores/index.js

@@ -0,0 +1,2 @@
+// Main chat store
+export { chatStore, activeContext, inputState, uiState, getCurrentState, getCurrentMessages, getCurrentConversations } from './chatStore.js';