@massalabs/gossip-sdk 0.0.2-dev.20260331143013 → 0.0.2-dev.20260401160204

package/dist/core/SdkEventEmitter.d.ts

@@ -17,10 +17,14 @@ export declare enum SdkEventType {
     SEEKERS_UPDATED = "seekersUpdated",
     SESSION_STATUS_CHANGED = "sessionStatusChanged",
     DISCUSSION_UPDATED = "discussionUpdated",
+    WRITE_FAILED = "writeFailed",
+    MESSAGE_OPTIMISTIC = "messageOptimistic",
     ERROR = "error"
 }
 export interface SdkEventHandlers {
-    [SdkEventType.MESSAGE_RECEIVED]: (message: Message) => void;
+    [SdkEventType.MESSAGE_RECEIVED]: (message: Omit<Message, 'id'> & {
+        id?: number;
+    }) => void;
     [SdkEventType.MESSAGE_SENT]: (message: Message) => void;
     [SdkEventType.MESSAGE_READ]: (messageId: number) => void;
     [SdkEventType.MESSAGE_FAILED]: (message: Message, error: Error) => void;
@@ -31,6 +35,8 @@ export interface SdkEventHandlers {
     [SdkEventType.SEEKERS_UPDATED]: (seekers: Uint8Array[]) => void;
     [SdkEventType.SESSION_STATUS_CHANGED]: (contactUserId: string, status: SessionStatus) => void;
     [SdkEventType.DISCUSSION_UPDATED]: (contactUserId: string) => void;
+    [SdkEventType.WRITE_FAILED]: (messageId: Uint8Array | undefined, entityType: 'message' | 'discussion' | 'contact', error: Error) => void;
+    [SdkEventType.MESSAGE_OPTIMISTIC]: (message: Message) => void;
     [SdkEventType.ERROR]: (error: Error, context: string) => void;
 }
 export declare class SdkEventEmitter {

package/dist/core/SdkEventEmitter.js

@@ -19,6 +19,8 @@ export var SdkEventType;
     SdkEventType["SEEKERS_UPDATED"] = "seekersUpdated";
     SdkEventType["SESSION_STATUS_CHANGED"] = "sessionStatusChanged";
     SdkEventType["DISCUSSION_UPDATED"] = "discussionUpdated";
+    SdkEventType["WRITE_FAILED"] = "writeFailed";
+    SdkEventType["MESSAGE_OPTIMISTIC"] = "messageOptimistic";
     SdkEventType["ERROR"] = "error";
 })(SdkEventType || (SdkEventType = {}));
 // ─────────────────────────────────────────────────────────────────────────────
@@ -42,6 +44,8 @@ export class SdkEventEmitter {
                 [SdkEventType.SEEKERS_UPDATED]: new Set(),
                 [SdkEventType.SESSION_STATUS_CHANGED]: new Set(),
                 [SdkEventType.DISCUSSION_UPDATED]: new Set(),
+                [SdkEventType.WRITE_FAILED]: new Set(),
+                [SdkEventType.MESSAGE_OPTIMISTIC]: new Set(),
                 [SdkEventType.ERROR]: new Set(),
             }
         });

package/dist/services/discussion.js

@@ -273,8 +273,10 @@ export class DiscussionService {
      */
     async start(contact, payload) {
         const result = await this.initialize(contact, payload);
-        if (result.success)
+        if (result.success) {
             await this.refreshService?.stateUpdate();
+            this.eventEmitter.emit(SdkEventType.DISCUSSION_UPDATED, contact.userId);
+        }
         return result;
     }
     /**

package/dist/services/message.d.ts

@@ -45,6 +45,8 @@ export declare class MessageService {
     private processingContacts;
     private isFetchingMessages;
     private queries;
+    /** Emit MESSAGE_RECEIVED with a Message that may not have a DB id yet */
+    private emitMessageReceived;
     constructor(messageProtocol: IMessageProtocol, session: SessionModule, eventEmitter: SdkEventEmitter, config: SdkConfig | undefined, queries: Queries);
     setRefreshService(refreshService: RefreshService): void;
     setQueueManager(queueManager: QueueManager): void;
@@ -89,8 +91,15 @@ export declare class MessageService {
     getVisibleMessages(contactUserId: string): Promise<Message[]>;
     /** Get all non-deleted reaction messages for a contact. */
     getReactions(contactUserId: string): Promise<Message[]>;
-    /** Send a message, queued via QueueManager if available */
+    /** Send a message and await the full DB write + queue pipeline. */
     send(message: Omit<Message, 'id'>): Promise<SendMessageResult>;
+    /**
+     * Optimistic send: generates messageId, emits MESSAGE_OPTIMISTIC immediately,
+     * and persists in the background. Returns synchronously.
+     */
+    send(message: Omit<Message, 'id'>, options: {
+        optimistic: true;
+    }): SendMessageResult;
     /**
      * Send a text message (simplified).
      * Builds the Message internally, sends it via queue, and triggers state update.

package/dist/services/message.js

@@ -143,6 +143,10 @@ export function rowToMessage(row) {
 const sleep = (ms) => new Promise(res => setTimeout(res, ms));
 const logger = new Logger('MessageService');
 export class MessageService {
+    /** Emit MESSAGE_RECEIVED with a Message that may not have a DB id yet */
+    emitMessageReceived(message) {
+        this.eventEmitter.emit(SdkEventType.MESSAGE_RECEIVED, message);
+    }
     constructor(messageProtocol, session, eventEmitter, config = defaultSdkConfig, queries) {
         Object.defineProperty(this, "messageProtocol", {
             enumerable: true,
@@ -400,11 +404,26 @@ export class MessageService {
                     });
                     continue;
                 }
-                await this.queries.messages.updateById(target.id, {
-                    content: '[Message deleted]',
-                    type: MessageType.DELETED,
-                });
-                // Do not insert a new message row for delete control messages
+                if (target.type === MessageType.REACTION) {
+                    // Reaction delete: hard-delete the row, not "[Message deleted]"
+                    await this.queries.messages.deleteById(target.id);
+                    this.emitMessageReceived({
+                        ...target,
+                        type: MessageType.DELETED,
+                    });
+                }
+                else {
+                    // Regular message delete: mark as deleted
+                    this.emitMessageReceived({
+                        ...target,
+                        content: '[Message deleted]',
+                        type: MessageType.DELETED,
+                    });
+                    await this.queries.messages.updateById(target.id, {
+                        content: '[Message deleted]',
+                        type: MessageType.DELETED,
+                    });
+                }
                 continue;
             }
             // Handle edit control messages by updating the referenced message in-place
@@ -420,6 +439,12 @@ export class MessageService {
                     ...(target.metadata ?? {}),
                     edited: true,
                 };
+                // Emit before DB write so UI updates instantly
+                this.emitMessageReceived({
+                    ...target,
+                    content: message.content,
+                    metadata: mergedMetadata,
+                });
                 await this.queries.messages.updateById(target.id, {
                     content: message.content,
                     metadata: serializeMetadata(mergedMetadata),
@@ -452,6 +477,18 @@ export class MessageService {
                     });
                     continue;
                 }
+                // Emit before DB write so UI updates instantly
+                this.emitMessageReceived({
+                    messageId: message.messageId,
+                    ownerUserId,
+                    contactUserId: discussion.contactUserId,
+                    content: message.content,
+                    type: MessageType.REACTION,
+                    direction: MessageDirection.INCOMING,
+                    status: MessageStatus.DELIVERED,
+                    timestamp: message.sentAt,
+                    reactionOf: message.reactionOf,
+                });
                 const id = await this.queries.messages.insert({
                     messageId: message.messageId,
                     ownerUserId,
@@ -493,6 +530,20 @@ export class MessageService {
                     });
                 }
             }
+            const incomingMsg = {
+                messageId: message.messageId,
+                ownerUserId,
+                contactUserId: discussion.contactUserId,
+                content: message.content,
+                type: message.type,
+                direction: MessageDirection.INCOMING,
+                status: MessageStatus.DELIVERED,
+                timestamp: message.sentAt,
+                replyTo: message.replyTo,
+                forwardOf: message.forwardOf,
+            };
+            // Emit before DB write — UI shows message instantly
+            this.emitMessageReceived(incomingMsg);
             const id = await this.queries.messages.insert({
                 messageId: message.messageId,
                 ownerUserId,
@@ -517,11 +568,8 @@ export class MessageService {
             });
             await this.queries.discussions.incrementUnreadCount(discussion.id);
             storedIds.push(id);
-            // Emit event for new message
-            const row = await this.queries.messages.getById(id);
-            if (row) {
-                this.eventEmitter.emit(SdkEventType.MESSAGE_RECEIVED, rowToMessage(row));
-            }
+            // Re-emit with DB id so the store patches the optimistic message
+            this.emitMessageReceived({ ...incomingMsg, id });
         }
         return storedIds;
     }
@@ -591,11 +639,14 @@ export class MessageService {
             return { success: false, error: 'Discussion not found' };
         }
         // Generate a random messageId for deduplication (not for keep-alive or retention policy)
-        const randomMessageId = message.type !== MessageType.KEEP_ALIVE &&
-            message.type !== MessageType.RETENTION_POLICY
-            ? crypto.getRandomValues(new Uint8Array(MESSAGE_ID_SIZE))
-            : undefined;
-        message.messageId = randomMessageId;
+        // Skip if already provided (e.g., from optimistic send)
+        if (!message.messageId) {
+            const randomMessageId = message.type !== MessageType.KEEP_ALIVE &&
+                message.type !== MessageType.RETENTION_POLICY
+                ? crypto.getRandomValues(new Uint8Array(MESSAGE_ID_SIZE))
+                : undefined;
+            message.messageId = randomMessageId;
+        }
         // Add message as WAITING_SESSION
         let messageId;
         try {
@@ -986,12 +1037,42 @@ export class MessageService {
         const rows = await this.queries.messages.getReactionsByOwnerAndContact(this.session.userIdEncoded, contactUserId);
         return rows.map(rowToMessage);
     }
-    /** Send a message, queued via QueueManager if available */
-    async send(message) {
-        if (this.queueManager) {
-            return this.queueManager.enqueue(message.contactUserId, () => this.sendMessage(message));
+    send(message, options) {
+        if (!options?.optimistic) {
+            if (this.queueManager) {
+                return this.queueManager.enqueue(message.contactUserId, () => this.sendMessage(message));
+            }
+            return this.sendMessage(message);
+        }
+        const log = logger.forMethod('send:optimistic');
+        const peerId = decodeUserId(message.contactUserId);
+        if (peerId.length !== 32) {
+            return {
+                success: false,
+                error: 'Invalid contact userId (must be 32 bytes)',
+            };
         }
-        return this.sendMessage(message);
+        const messageId = message.type !== MessageType.KEEP_ALIVE &&
+            message.type !== MessageType.RETENTION_POLICY
+            ? crypto.getRandomValues(new Uint8Array(MESSAGE_ID_SIZE))
+            : undefined;
+        const optimisticMessage = {
+            ...message,
+            messageId,
+            status: MessageStatus.WAITING_SESSION,
+        };
+        this.eventEmitter.emit(SdkEventType.MESSAGE_OPTIMISTIC, optimisticMessage);
+        log.info('optimistic send', { messageType: message.type });
+        // Persist in background (non-optimistic path)
+        this.send({ ...message, messageId }).then(result => {
+            if (!result.success) {
+                this.eventEmitter.emit(SdkEventType.WRITE_FAILED, messageId, 'message', new Error(result.error ?? 'Unknown error'));
+            }
+        }, error => {
+            log.error('optimistic send failed', { error });
+            this.eventEmitter.emit(SdkEventType.WRITE_FAILED, messageId, 'message', error instanceof Error ? error : new Error(String(error)));
+        });
+        return { success: true, message: optimisticMessage };
     }
     /**
      * Send a text message (simplified).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@massalabs/gossip-sdk",
-  "version": "0.0.2-dev.20260331143013",
+  "version": "0.0.2-dev.20260401160204",
   "description": "Gossip SDK for automation, chatbot, and integration use cases",
   "type": "module",
   "main": "./dist/index.js",