@meshagent/meshagent 0.35.6 → 0.35.7

package/dist/node/messaging-client.js

@@ -1,14 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MessageStreamReader = exports.MessageStreamWriter = exports.MessagingClient = exports.MessageStreamChunk = void 0;
-const uuid_1 = require("uuid");
+exports.MessagingClient = void 0;
 const event_emitter_1 = require("./event-emitter");
+const completer_1 = require("./completer");
 const participant_1 = require("./participant");
 const room_event_1 = require("./room-event");
 const room_server_client_1 = require("./room-server-client");
 const utils_1 = require("./utils");
-const stream_controller_1 = require("./stream-controller");
-const completer_1 = require("./completer");
 const globalScope = globalThis;
 function bytesToBase64(bytes) {
     if (globalScope.Buffer) {
@@ -23,21 +21,18 @@ function bytesToBase64(bytes) {
     }
     return globalScope.btoa(binary);
 }
-class MessageStreamChunk {
-    constructor({ header, data }) {
-        this.header = header;
-        this.data = data;
-    }
-}
-exports.MessageStreamChunk = MessageStreamChunk;
 class MessagingClient extends event_emitter_1.EventEmitter {
     constructor({ room }) {
         super();
-        this._streamWriters = {};
-        this._streamReaders = {};
+        this._messageHandler = this._handleMessageSend.bind(this);
         this._participants = {};
+        this._messageQueue = [];
+        this._messageQueued = null;
+        this._sendTask = null;
+        this._messageQueueClosed = false;
+        this._enabled = false;
         this.client = room;
-        this.client.protocol.addHandler("messaging.send", this._handleMessageSend.bind(this));
+        this.client.protocol.addHandler("messaging.send", this._messageHandler);
     }
     _messageInput(params) {
         const input = {
@@ -52,6 +47,16 @@ class MessagingClient extends event_emitter_1.EventEmitter {
         }
         return input;
     }
+    _syntheticMessageEvent(params) {
+        return new room_event_1.RoomMessageEvent({
+            message: new room_event_1.RoomMessage({
+                fromParticipantId: params.fromParticipantId,
+                type: params.type,
+                message: params.message,
+                local: true,
+            }),
+        });
+    }
     _removeParticipant(participantId) {
         const participant = this._participants[participantId];
         if (participant === undefined) {
@@ -59,15 +64,24 @@ class MessagingClient extends event_emitter_1.EventEmitter {
         }
         participant._setOnline(false);
         delete this._participants[participantId];
-        for (const [streamId, reader] of Object.entries(this._streamReaders)) {
-            if (reader._to.id !== participant.id) {
-                continue;
-            }
-            reader._controller.close();
-            delete this._streamReaders[streamId];
-        }
         return participant;
     }
+    _markParticipantOffline(participant) {
+        if (!(participant instanceof participant_1.RemoteParticipant)) {
+            return;
+        }
+        participant._setOnline(false);
+        const current = this._participants[participant.id];
+        if (current === undefined) {
+            return;
+        }
+        this._removeParticipant(participant.id);
+        this.emit("participant_removed", this._syntheticMessageEvent({
+            fromParticipantId: participant.id,
+            type: "participant.disabled",
+            message: { id: participant.id },
+        }));
+    }
     _resolveMessageRecipient(to) {
         if (!(to instanceof participant_1.RemoteParticipant)) {
             return to;
@@ -77,46 +91,131 @@ class MessagingClient extends event_emitter_1.EventEmitter {
         }
         return this._participants[to.id] ?? null;
     }
-    _participantNotFound(ignoreOffline) {
-        if (ignoreOffline) {
-            return null;
+    _queueMessage(message) {
+        if (this._sendTask === null) {
+            throw new room_server_client_1.RoomServerException("Cannot send messages because messaging has not been started");
+        }
+        this._messageQueue.push(message);
+        const waiter = this._messageQueued;
+        if (waiter !== null) {
+            this._messageQueued = null;
+            waiter.complete();
+        }
+    }
+    _rejectQueuedMessages(error) {
+        while (this._messageQueue.length > 0) {
+            const message = this._messageQueue.shift();
+            message?.completer?.completeError(error);
+        }
+    }
+    _isParticipantNotFound(error) {
+        return error instanceof room_server_client_1.RoomServerException && error.message === "the participant was not found";
+    }
+    async _nextQueuedMessage() {
+        while (this._messageQueue.length === 0) {
+            if (this._messageQueueClosed) {
+                return null;
+            }
+            if (this._messageQueued === null) {
+                this._messageQueued = new completer_1.Completer();
+            }
+            await this._messageQueued.fut;
+        }
+        return this._messageQueue.shift() ?? null;
+    }
+    async _sendMessages() {
+        while (true) {
+            const queued = await this._nextQueuedMessage();
+            if (queued === null) {
+                return;
+            }
+            const resolvedTo = this._resolveMessageRecipient(queued.to);
+            if (resolvedTo === null) {
+                const error = new room_server_client_1.RoomServerException("the participant was not found");
+                if (queued.dropIfOffline) {
+                    queued.completer?.complete();
+                }
+                else {
+                    queued.completer?.completeError(error);
+                }
+                continue;
+            }
+            try {
+                await this.client.invoke({
+                    toolkit: "messaging",
+                    tool: "send",
+                    input: this._messageInput({
+                        toParticipantId: resolvedTo.id,
+                        type: queued.type,
+                        message: queued.message,
+                        attachment: queued.attachment,
+                    }),
+                });
+                queued.completer?.complete();
+            }
+            catch (error) {
+                if (this._isParticipantNotFound(error)) {
+                    this._markParticipantOffline(queued.to);
+                    if (queued.dropIfOffline) {
+                        queued.completer?.complete();
+                        continue;
+                    }
+                }
+                queued.completer?.completeError(error);
+            }
         }
-        throw new room_server_client_1.RoomServerException("the participant was not found");
     }
-    async createStream({ to, header }) {
-        const streamId = (0, uuid_1.v4)();
+    async start() {
+        if (this._sendTask !== null) {
+            return;
+        }
+        this._messageQueueClosed = false;
+        this._sendTask = this._sendMessages();
+    }
+    async stop() {
+        if (this._sendTask === null) {
+            this._enabled = false;
+            return;
+        }
+        this._messageQueueClosed = true;
+        const waiter = this._messageQueued;
+        if (waiter !== null) {
+            this._messageQueued = null;
+            waiter.complete();
+        }
+        const sendTask = this._sendTask;
+        this._sendTask = null;
+        await sendTask;
+        this._enabled = false;
+    }
+    async sendMessage({ to, type, message, attachment, ignoreOffline = false }) {
         const completer = new completer_1.Completer();
-        this._streamWriters[streamId] = completer;
-        await this.sendMessage({
+        this._queueMessage({
             to,
-            type: "stream.open",
-            message: { stream_id: streamId, header },
+            type,
+            message,
+            attachment,
+            dropIfOffline: ignoreOffline,
+            completer,
         });
-        return completer.fut;
+        await completer.fut;
     }
-    async sendMessage({ to, type, message, attachment, ignoreOffline = false }) {
-        const resolvedTo = this._resolveMessageRecipient(to) ?? this._participantNotFound(ignoreOffline);
-        if (resolvedTo === null) {
-            return;
-        }
-        await this.client.invoke({
-            toolkit: "messaging",
-            tool: "send",
-            input: this._messageInput({
-                toParticipantId: resolvedTo.id,
-                type,
-                message,
-                attachment,
-            }),
+    sendMessageNowait({ to, type, message, attachment }) {
+        this._queueMessage({
+            to,
+            type,
+            message,
+            attachment,
+            dropIfOffline: true,
         });
     }
-    async enable(onStreamAccept) {
+    async enable() {
         await this.client.invoke({
             toolkit: "messaging",
             tool: "enable",
             input: {},
         });
-        this._onStreamAcceptCallback = onStreamAccept;
+        this._enabled = true;
     }
     async disable() {
         await this.client.invoke({
@@ -124,6 +223,7 @@ class MessagingClient extends event_emitter_1.EventEmitter {
             tool: "disable",
             input: {},
         });
+        this._enabled = false;
     }
     async broadcastMessage({ type, message, attachment }) {
         await this.client.invoke({
@@ -135,6 +235,23 @@ class MessagingClient extends event_emitter_1.EventEmitter {
     get remoteParticipants() {
         return Object.values(this._participants);
     }
+    get isEnabled() {
+        return this._enabled;
+    }
+    getParticipants() {
+        return this.remoteParticipants;
+    }
+    getParticipant(id) {
+        return this._participants[id] ?? null;
+    }
+    getParticipantByName(name) {
+        for (const participant of this.remoteParticipants) {
+            if (participant.getAttribute("name") === name) {
+                return participant;
+            }
+        }
+        return null;
+    }
     async _handleMessageSend(protocol, messageId, type, bytes) {
         const headerStr = (0, utils_1.splitMessageHeader)(bytes || new Uint8Array());
         const payload = (0, utils_1.splitMessagePayload)(bytes || new Uint8Array());
@@ -158,21 +275,6 @@ class MessagingClient extends event_emitter_1.EventEmitter {
             case "participant.disabled":
                 this._onParticipantDisabled(message);
                 break;
-            case "stream.open":
-                this._onStreamOpen(message);
-                break;
-            case "stream.accept":
-                this._onStreamAccept(message);
-                break;
-            case "stream.reject":
-                this._onStreamReject(message);
-                break;
-            case "stream.chunk":
-                this._onStreamChunk(message);
-                break;
-            case "stream.close":
-                this._onStreamClose(message);
-                break;
         }
         const messageEvent = new room_event_1.RoomMessageEvent({ message });
         this.client.emit(messageEvent);
@@ -181,20 +283,17 @@ class MessagingClient extends event_emitter_1.EventEmitter {
     _onParticipantEnabled(message) {
         const data = message.message;
         const p = new participant_1.RemoteParticipant(this.client, data["id"], data["role"], true);
-        for (const [k, v] of Object.entries(data["attributes"] || {})) {
-            p._attributes[k] = v;
-        }
+        p._setAttributes(data["attributes"] ?? {});
         this._participants[data["id"]] = p;
         this.emit("participant_added", { message });
     }
     _onParticipantAttributes(message) {
         const part = this._participants[message.fromParticipantId];
-        if (!part)
+        if (!part) {
             return;
-        const attrObj = message.message["attributes"];
-        for (const [k, v] of Object.entries(attrObj)) {
-            part._attributes[k] = v;
         }
+        const attrObj = message.message["attributes"];
+        part._setAttributes(attrObj);
         this.emit("participant_attributes_updated", { message });
     }
     _onParticipantDisabled(message) {
@@ -207,127 +306,24 @@ class MessagingClient extends event_emitter_1.EventEmitter {
         const participants = message.message["participants"];
         for (const data of participants) {
             const rp = new participant_1.RemoteParticipant(this.client, data["id"], data["role"], true);
-            for (const [k, v] of Object.entries(data["attributes"] || {})) {
-                rp._attributes[k] = v;
-            }
+            rp._setAttributes(data["attributes"] ?? {});
             this._participants[data["id"]] = rp;
         }
+        this._enabled = true;
         this.emit("messaging_enabled", { message });
     }
-    _onStreamOpen(message) {
-        const from = [...this.remoteParticipants]
-            .find((x) => x.id === message.fromParticipantId);
-        if (!from)
-            return;
-        const streamId = message.message["stream_id"];
-        const controller = new stream_controller_1.StreamController();
-        const reader = new MessageStreamReader({
-            streamId,
-            to: from,
-            client: this,
-            controller,
-        });
-        try {
-            if (!this._onStreamAcceptCallback) {
-                throw new Error("streams are not allowed by this client");
-            }
-            this._onStreamAcceptCallback(reader);
-            void this.sendMessage({
-                to: from,
-                type: "stream.accept",
-                message: { stream_id: streamId },
-                ignoreOffline: true,
-            }).catch((error) => {
-                console.warn("unable to send stream response", error);
-            });
-        }
-        catch (e) {
-            void this.sendMessage({
-                to: from,
-                type: "stream.reject",
-                message: { stream_id: streamId, error: String(e) },
-                ignoreOffline: true,
-            }).catch((error) => {
-                console.warn("unable to send stream response", error);
-            });
-        }
-        this._streamReaders[streamId] = reader;
-        this.emit("stream_opened", { message });
-    }
-    _onStreamAccept(message) {
-        const streamId = message.message["stream_id"];
-        const writerCompleter = this._streamWriters[streamId];
-        if (!writerCompleter)
-            return;
-        const from = [...this.remoteParticipants].find((x) => x.id === message.fromParticipantId);
-        if (!from)
-            return;
-        writerCompleter.complete(new MessageStreamWriter({
-            streamId,
-            to: from,
-            client: this,
-        }));
-    }
-    _onStreamReject(message) {
-        const streamId = message.message["stream_id"];
-        const writerCompleter = this._streamWriters[streamId];
-        if (!writerCompleter)
-            return;
-        writerCompleter.completeError(new Error("The stream was rejected by the remote client"));
-    }
-    _onStreamChunk(message) {
-        const streamId = message.message["stream_id"];
-        const reader = this._streamReaders[streamId];
-        if (!reader)
-            return;
-        reader._controller.add(new MessageStreamChunk({
-            header: message.message,
-            data: message.attachment,
-        }));
-    }
-    _onStreamClose(message) {
-        const streamId = message.message["stream_id"];
-        const reader = this._streamReaders[streamId];
-        if (!reader)
-            return;
-        reader._controller.close();
-        delete this._streamReaders[streamId];
-    }
     dispose() {
+        const error = new room_server_client_1.RoomServerException("messaging client disposed");
+        this._messageQueueClosed = true;
+        this._enabled = false;
+        this._rejectQueuedMessages(error);
+        const waiter = this._messageQueued;
+        if (waiter !== null) {
+            this._messageQueued = null;
+            waiter.complete();
+        }
         super.dispose();
         this.client.protocol.removeHandler("messaging.send");
     }
 }
 exports.MessagingClient = MessagingClient;
-class MessageStreamWriter {
-    constructor({ streamId, to, client }) {
-        this._streamId = streamId;
-        this._to = to;
-        this._client = client;
-    }
-    async write(chunk) {
-        await this._client.sendMessage({
-            to: this._to,
-            type: "stream.chunk",
-            message: { stream_id: this._streamId, header: chunk.header },
-            attachment: chunk.data,
-        });
-    }
-    async close() {
-        await this._client.sendMessage({
-            to: this._to,
-            type: "stream.close",
-            message: { stream_id: this._streamId },
-        });
-    }
-}
-exports.MessageStreamWriter = MessageStreamWriter;
-class MessageStreamReader {
-    constructor({ streamId, to, client, controller }) {
-        this._streamId = streamId;
-        this._to = to;
-        this._client = client;
-        this._controller = controller;
-    }
-}
-exports.MessageStreamReader = MessageStreamReader;

package/dist/node/participant.d.ts

@@ -2,11 +2,13 @@ import { RoomClient } from "./room-client";
 export declare abstract class Participant {
     readonly id: string;
     protected readonly client: RoomClient;
-    protected _attributes: Record<string, any>;
+    protected _attributes: Record<string, unknown>;
     protected _connections: string[];
     constructor(client: RoomClient, id: string);
     get connections(): ReadonlyArray<string>;
-    getAttribute(name: string): any;
+    getAttribute(name: string): unknown;
+    _setAttribute(name: string, value: unknown): void;
+    _setAttributes(attributes: Record<string, unknown>): void;
 }
 export declare class RemoteParticipant extends Participant {
     readonly role: string;
@@ -16,5 +18,5 @@ export declare class RemoteParticipant extends Participant {
 }
 export declare class LocalParticipant extends Participant {
     constructor(client: RoomClient, id: string);
-    setAttribute(name: string, value: any): Promise<void>;
+    setAttribute(name: string, value: unknown): Promise<void>;
 }

package/dist/node/participant.js

@@ -15,6 +15,14 @@ class Participant {
     getAttribute(name) {
         return this._attributes[name];
     }
+    _setAttribute(name, value) {
+        this._attributes[name] = value;
+    }
+    _setAttributes(attributes) {
+        for (const [name, value] of Object.entries(attributes)) {
+            this._setAttribute(name, value);
+        }
+    }
 }
 exports.Participant = Participant;
 class RemoteParticipant extends Participant {
@@ -33,7 +41,7 @@ class LocalParticipant extends Participant {
         super(client, id);
     }
     async setAttribute(name, value) {
-        this._attributes[name] = value;
+        this._setAttribute(name, value);
         try {
             const payload = (0, utils_1.packMessage)({ [name]: value });
             await this.client.protocol.send("set_attributes", payload);

package/dist/node/room-client.js

@@ -49,6 +49,7 @@ class RoomClient {
         return this._ready.fut;
     }
     async start({ onDone, onError } = {}) {
+        await this.messaging.start();
         this.sync.start({ onDone, onError });
         await this.ready;
     }
@@ -58,6 +59,7 @@ class RoomClient {
             pr?.reject(new Error("Disposed"));
             this._pendingRequests.delete(prKey);
         }
+        this.messaging.dispose();
         this.sync.dispose();
         for (const stream of this._toolCallStreams.values()) {
             stream.close();

package/dist/node/room-event.d.ts

@@ -34,16 +34,20 @@ export declare class FileCreatedEvent extends RoomEvent {
 }
 export declare class FileDeletedEvent extends RoomEvent {
     path: string;
-    constructor({ path }: {
+    participantId: string;
+    constructor({ path, participantId }: {
         path: string;
+        participantId: string;
     });
     get name(): string;
     get description(): string;
 }
 export declare class FileUpdatedEvent extends RoomEvent {
     path: string;
-    constructor({ path }: {
+    participantId: string;
+    constructor({ path, participantId }: {
         path: string;
+        participantId: string;
     });
     get name(): string;
     get description(): string;

package/dist/node/room-event.js

@@ -41,9 +41,10 @@ class FileCreatedEvent extends RoomEvent {
 }
 exports.FileCreatedEvent = FileCreatedEvent;
 class FileDeletedEvent extends RoomEvent {
-    constructor({ path }) {
+    constructor({ path, participantId }) {
         super();
         this.path = path;
+        this.participantId = participantId;
     }
     get name() {
         return "file deleted";
@@ -54,9 +55,10 @@ class FileDeletedEvent extends RoomEvent {
 }
 exports.FileDeletedEvent = FileDeletedEvent;
 class FileUpdatedEvent extends RoomEvent {
-    constructor({ path }) {
+    constructor({ path, participantId }) {
         super();
         this.path = path;
+        this.participantId = participantId;
     }
     get name() {
         return "file updated";