@meshagent/meshagent 0.46.4 → 0.47.1

package/dist/browser/messaging-client.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MessagingClient = void 0;
+exports.MessagingClient = exports.MessagingStream = void 0;
 const completer_js_1 = require("./completer.js");
 const event_emitter_js_1 = require("./event-emitter.js");
 const participant_js_1 = require("./participant.js");
@@ -22,6 +22,256 @@ function bytesToBase64(bytes) {
     }
     return globalScope.btoa(binary);
 }
+function base64ToBytes(value) {
+    if (globalScope.Buffer != null) {
+        return new Uint8Array(globalScope.Buffer.from(value, "base64"));
+    }
+    const atob = globalThis.atob;
+    if (atob == null) {
+        throw new Error("base64 decoding is not available in this runtime");
+    }
+    const binary = atob(value);
+    return Uint8Array.from(binary, (character) => character.charCodeAt(0));
+}
+class MessagingStreamInput {
+    constructor() {
+        this.items = [];
+        this.signal = null;
+        this.active = null;
+        this.closed = false;
+        this.error = null;
+    }
+    enqueue(content, { wait = false } = {}) {
+        if (this.closed) {
+            return Promise.reject(this.error ?? new room_server_client_js_1.RoomServerException("the messaging stream is closed"));
+        }
+        const sent = wait ? new completer_js_1.Completer() : undefined;
+        this.items.push({ content, sent });
+        this.signal?.resolve();
+        this.signal = null;
+        return sent?.fut ?? Promise.resolve();
+    }
+    close(error = new room_server_client_js_1.RoomServerException("the messaging stream is closed")) {
+        if (this.closed) {
+            return;
+        }
+        this.closed = true;
+        this.error = error;
+        this.active?.sent?.reject(error);
+        this.active = null;
+        for (const item of this.items.splice(0)) {
+            item.sent?.reject(error);
+        }
+        this.signal?.resolve();
+        this.signal = null;
+    }
+    fail(error) {
+        this.close(error);
+    }
+    async *stream() {
+        try {
+            while (true) {
+                while (this.items.length === 0 && !this.closed) {
+                    this.signal ?? (this.signal = new completer_js_1.Completer());
+                    await this.signal.fut;
+                }
+                const item = this.items.shift();
+                if (item == null) {
+                    return;
+                }
+                this.active = item;
+                yield item.content;
+                item.sent?.resolve();
+                this.active = null;
+            }
+        }
+        finally {
+            if (this.active != null && this.closed) {
+                this.active.sent?.reject(this.error ?? new room_server_client_js_1.RoomServerException("the messaging stream is closed"));
+                this.active = null;
+            }
+        }
+    }
+}
+class MessagingStream {
+    constructor({ streamId, remoteParticipantId, input, output, inputClosed, onClosed, }) {
+        this.events = [];
+        this.eventSignal = null;
+        this.state = "accepted";
+        this.streamId = streamId;
+        this.remoteParticipantId = remoteParticipantId;
+        this.input = input;
+        this.output = output;
+        this.inputDone = Promise.resolve(inputClosed).catch((error) => {
+            this.input.fail(error);
+            this.push({
+                kind: "closed",
+                streamId: this.streamId,
+                reason: "error",
+                message: error instanceof Error ? error.message : String(error),
+            });
+            void this.output.return?.();
+            this.finish();
+        });
+        this.onClosed = onClosed;
+        void this.consumeOutput();
+    }
+    get closed() {
+        return this.state === "terminal";
+    }
+    push(event) {
+        if (this.state !== "accepted") {
+            return;
+        }
+        this.events.push(event);
+        this.eventSignal?.resolve();
+        this.eventSignal = null;
+    }
+    finish() {
+        if (this.state === "terminal") {
+            return;
+        }
+        this.state = "terminal";
+        this.input.close();
+        this.eventSignal?.resolve();
+        this.eventSignal = null;
+        void this.inputDone.finally(this.onClosed);
+    }
+    async consumeOutput() {
+        try {
+            while (true) {
+                const next = await this.output.next();
+                if (next.done) {
+                    return;
+                }
+                if (next.value instanceof response_js_1.ControlContent && next.value.method === "close") {
+                    this.push({
+                        kind: "client_disconnected",
+                        streamId: this.streamId,
+                        participantId: this.remoteParticipantId,
+                    });
+                    return;
+                }
+                if (!(next.value instanceof response_js_1.JsonContent)) {
+                    throw new room_server_client_js_1.RoomServerException("unexpected chunk from messaging.stream");
+                }
+                const value = next.value.json;
+                const kind = value["kind"];
+                if (kind === "message") {
+                    const type = value["type"];
+                    const message = value["message"];
+                    if (typeof type !== "string" || typeof message !== "object" || message == null || Array.isArray(message)) {
+                        throw new room_server_client_js_1.RoomServerException("invalid message chunk from messaging.stream");
+                    }
+                    const encodedAttachment = value["attachment_base64"];
+                    this.push({
+                        kind: "message",
+                        message: new room_event_js_1.RoomMessage({
+                            fromParticipantId: this.remoteParticipantId,
+                            type,
+                            message: message,
+                            attachment: typeof encodedAttachment === "string" && encodedAttachment !== ""
+                                ? base64ToBytes(encodedAttachment)
+                                : undefined,
+                        }),
+                    });
+                }
+                else if (kind === "client_disconnected" && typeof value["participant_id"] === "string") {
+                    this.push({
+                        kind,
+                        streamId: this.streamId,
+                        participantId: value["participant_id"],
+                    });
+                    return;
+                }
+                else if (kind === "closed") {
+                    this.push({
+                        kind,
+                        streamId: this.streamId,
+                        reason: typeof value["reason"] === "string" ? value["reason"] : "closed",
+                        message: typeof value["message"] === "string" ? value["message"] : undefined,
+                    });
+                    return;
+                }
+                else {
+                    throw new room_server_client_js_1.RoomServerException("unexpected chunk from messaging.stream");
+                }
+            }
+        }
+        catch (error) {
+            this.input.fail(error);
+            this.push({
+                kind: "closed",
+                streamId: this.streamId,
+                reason: "error",
+                message: error instanceof Error ? error.message : String(error),
+            });
+        }
+        finally {
+            this.finish();
+        }
+    }
+    content({ type, message, attachment, }) {
+        return new response_js_1.JsonContent({
+            json: {
+                type,
+                message_json: JSON.stringify(message),
+                ...(attachment == null ? {} : { attachment_base64: bytesToBase64(attachment) }),
+            },
+        });
+    }
+    sendMessageNowait(params) {
+        if (this.state !== "accepted") {
+            throw new room_server_client_js_1.RoomServerException("the messaging stream is closed");
+        }
+        void this.input.enqueue(this.content(params));
+    }
+    async sendMessage(params) {
+        if (this.state !== "accepted") {
+            throw new room_server_client_js_1.RoomServerException("the messaging stream is closed");
+        }
+        await this.input.enqueue(this.content(params), { wait: true });
+    }
+    async close() {
+        if (this.state === "terminal") {
+            await this.inputDone;
+            return;
+        }
+        this.input.close();
+        try {
+            await this.inputDone;
+        }
+        finally {
+            await this.output.return?.();
+            this.finish();
+        }
+    }
+    clientDisconnected(participantId) {
+        if (this.state === "terminal") {
+            return;
+        }
+        this.push({
+            kind: "client_disconnected",
+            streamId: this.streamId,
+            participantId,
+        });
+        this.finish();
+    }
+    async *[Symbol.asyncIterator]() {
+        while (true) {
+            while (this.events.length === 0 && this.state !== "terminal") {
+                this.eventSignal ?? (this.eventSignal = new completer_js_1.Completer());
+                await this.eventSignal.fut;
+            }
+            const event = this.events.shift();
+            if (event == null) {
+                return;
+            }
+            yield event;
+        }
+    }
+}
+exports.MessagingStream = MessagingStream;
 class MessagingClient extends event_emitter_js_1.EventEmitter {
     constructor({ room }) {
         super();
@@ -30,6 +280,8 @@ class MessagingClient extends event_emitter_js_1.EventEmitter {
         this._messageQueue = [];
         this._messageQueued = null;
         this._sendTask = null;
+        this._sendOperations = new Set();
+        this._streams = new Set();
         this._messageQueueClosed = false;
         this._desiredEnabled = false;
         this._online = false;
@@ -59,11 +311,12 @@ class MessagingClient extends event_emitter_js_1.EventEmitter {
         }
         return input;
     }
-    async _invoke({ operation, input, }) {
+    async _invoke({ operation, input, afterSend, }) {
         await this.client.invokeContent({
             toolkit: "messaging",
             tool: operation,
             input: new response_js_1.JsonContent({ json: input }),
+            afterSend,
         });
     }
     _invokeNowait({ operation, input, }) {
@@ -93,6 +346,8 @@ class MessagingClient extends event_emitter_js_1.EventEmitter {
         if (sendTask != null) {
             await sendTask;
         }
+        await Promise.all(this._sendOperations);
+        await Promise.all([...this._streams].map(async (stream) => stream.close()));
         this._desiredEnabled = false;
         this._clearCurrentConnectionState();
     }
@@ -156,6 +411,9 @@ class MessagingClient extends event_emitter_js_1.EventEmitter {
         }
     }
     _onRoomDisconnect({ reason: _reason }) {
+        for (const stream of [...this._streams]) {
+            stream.clientDisconnected(this.client.localParticipant?.id ?? stream.remoteParticipantId);
+        }
         this._clearCurrentConnectionState();
     }
     _onRoomReconnect() {
@@ -238,34 +496,52 @@ class MessagingClient extends event_emitter_js_1.EventEmitter {
                 });
                 continue;
             }
-            try {
-                await this._invoke({
-                    operation: "send",
-                    input: this._messageInput({
-                        toParticipantId: resolvedTo.id,
-                        type: message.type,
-                        message: message.message,
-                        attachment: message.attachment,
-                    }),
-                });
-                if (message.completer != null && !message.completer.completed) {
-                    message.completer.complete();
-                }
+            const dispatched = new completer_js_1.Completer();
+            const operation = this._sendQueuedMessage({
+                message,
+                resolvedTo,
+                afterSend: () => dispatched.resolve(),
+            });
+            this._sendOperations.add(operation);
+            void operation.then(() => {
+                this._sendOperations.delete(operation);
+                if (!dispatched.completed)
+                    dispatched.resolve();
+            }, () => {
+                this._sendOperations.delete(operation);
+                if (!dispatched.completed)
+                    dispatched.resolve();
+            });
+            await dispatched.fut;
+        }
+    }
+    async _sendQueuedMessage({ message, resolvedTo, afterSend, }) {
+        try {
+            await this._invoke({
+                operation: "send",
+                input: this._messageInput({
+                    toParticipantId: resolvedTo.id,
+                    type: message.type,
+                    message: message.message,
+                    attachment: message.attachment,
+                }),
+                afterSend,
+            });
+            if (message.completer != null && !message.completer.completed) {
+                message.completer.complete();
             }
-            catch (error) {
-                if (error instanceof room_server_client_js_1.RoomServerException) {
-                    const wrapped = this.client._coerceMessageSendError(error);
-                    if (wrapped.message === "the participant was not found") {
-                        this._markParticipantOffline(message.to);
-                        this._dropQueuedMessage({ message, error: wrapped });
-                        continue;
-                    }
-                    this._dropQueuedMessage({ message, error: wrapped });
-                    continue;
-                }
-                if (message.completer != null && !message.completer.completed) {
-                    message.completer.completeError(error);
+        }
+        catch (error) {
+            if (error instanceof room_server_client_js_1.RoomServerException) {
+                const wrapped = this.client._coerceMessageSendError(error);
+                if (wrapped.message === "the participant was not found") {
+                    this._markParticipantOffline(message.to);
                 }
+                this._dropQueuedMessage({ message, error: wrapped });
+                return;
+            }
+            if (message.completer != null && !message.completer.completed) {
+                message.completer.completeError(error);
             }
         }
     }
@@ -330,6 +606,49 @@ class MessagingClient extends event_emitter_js_1.EventEmitter {
             throw error;
         }
     }
+    async stream({ to, type, message, attachment, }) {
+        const input = new MessagingStreamInput();
+        void input.enqueue(new response_js_1.JsonContent({
+            json: {
+                to_participant_id: to.id,
+                type,
+                message_json: JSON.stringify(message),
+                ...(attachment == null ? {} : { attachment_base64: bytesToBase64(attachment) }),
+            },
+        }));
+        const outputResult = await this.client.invokeToolCall({
+            toolkit: "messaging",
+            tool: "stream",
+            input: input.stream(),
+            streamInput: true,
+        });
+        if (outputResult.kind !== "stream") {
+            input.close();
+            throw new room_server_client_js_1.RoomServerException("unexpected return type from messaging.stream");
+        }
+        const outputIterable = outputResult.stream;
+        const output = outputIterable[Symbol.asyncIterator]();
+        const accepted = await output.next();
+        if (accepted.done
+            || !(accepted.value instanceof response_js_1.JsonContent)
+            || accepted.value.json["kind"] !== "accepted"
+            || typeof accepted.value.json["stream_id"] !== "string") {
+            input.close();
+            await output.return?.();
+            throw new room_server_client_js_1.RoomServerException("messaging.stream did not acknowledge acceptance");
+        }
+        let stream;
+        stream = new MessagingStream({
+            streamId: accepted.value.json["stream_id"],
+            remoteParticipantId: to.id,
+            input,
+            output,
+            inputClosed: outputResult.inputClosed,
+            onClosed: () => this._streams.delete(stream),
+        });
+        this._streams.add(stream);
+        return stream;
+    }
     getParticipants() {
         return this.remoteParticipants;
     }
@@ -423,6 +742,9 @@ class MessagingClient extends event_emitter_js_1.EventEmitter {
         this._wakeMessageQueue();
         this._drainQueuedMessages({ error });
         this._desiredEnabled = false;
+        for (const stream of [...this._streams]) {
+            stream.clientDisconnected(this.client.localParticipant?.id ?? stream.remoteParticipantId);
+        }
         this._clearCurrentConnectionState();
         this.client.protocol.removeHandler("messaging.send", this._messageHandler);
         super.dispose();

package/dist/browser/participant-token.d.ts

@@ -404,6 +404,7 @@ export declare class ParticipantToken {
     addTunnelGrant(ports: number[]): void;
     addRoleGrant(role: string): void;
     addRoomGrant(roomName: string): void;
+    addSiteGrant(roomName: string): void;
     addApiGrant(grant: ApiScope): void;
     grantScope(name: string): string | ApiScope | undefined;
     getApiGrant(): ApiScope | undefined;

package/dist/browser/participant-token.js

@@ -1323,6 +1323,9 @@ class ParticipantToken {
     addRoomGrant(roomName) {
         this.grants.push(new ParticipantGrant({ name: "room", scope: roomName }));
     }
+    addSiteGrant(roomName) {
+        this.grants.push(new ParticipantGrant({ name: "site", scope: roomName }));
+    }
     addApiGrant(grant) {
         for (const existingGrant of this.grants) {
             if (existingGrant.name === "api") {

package/dist/browser/room-client.d.ts

@@ -189,7 +189,8 @@ export declare class RoomClient {
     }): void;
     _sendLocalAttributesNowait(attributes: Record<string, unknown>): void;
     _resendLocalAttributesNowait(): void;
-    sendRequest(type: string, request: RequestHeader, data?: Uint8Array): Promise<Content>;
+    sendRequest(type: string, request: RequestHeader, data?: Uint8Array, afterSend?: () => void): Promise<Content>;
+    private _dispatchRequest;
     call(params: {
         name: string;
         url: string;
@@ -216,6 +217,7 @@ export declare class RoomClient {
         input?: InvokeInput;
         participantId?: string;
         onBehalfOfId?: string;
+        afterSend?: () => void;
     }): Promise<Content>;
     invokeToolCall(params: {
         toolkit: string;
@@ -224,6 +226,7 @@ export declare class RoomClient {
         streamInput?: boolean;
         participantId?: string;
         onBehalfOfId?: string;
+        afterSend?: () => void;
     }): Promise<{
         kind: "content";
         content: Content;
@@ -247,7 +250,7 @@ export declare class RoomClient {
         participantId?: string;
         onBehalfOfId?: string;
     }): Promise<AsyncIterable<Content>>;
-    private _sendToolCallRequestChunk;
+    private _dispatchToolCallRequestChunk;
     private _streamInvokeToolRequestChunks;
     private _decodeToolCallContent;
     private _handleToolCallResponseChunk;

package/dist/browser/room-client.js

@@ -1146,7 +1146,12 @@ class RoomClient {
         }
         this._sendLocalAttributesNowait(attributes);
     }
-    async sendRequest(type, request, data) {
+    async sendRequest(type, request, data, afterSend) {
+        const response = this._dispatchRequest(type, request, data);
+        afterSend?.();
+        return await response;
+    }
+    _dispatchRequest(type, request, data) {
         this._raiseIfTerminal();
         if (this._entered && !this._connected && !this._allowDisconnectedRequests) {
             throw this._disconnectedError({ baseMessage: "room connection is disconnected" });
@@ -1155,8 +1160,8 @@ class RoomClient {
         const completer = new completer_js_1.Completer();
         this._pendingRequests.set(requestId, completer);
         try {
-            await this._protocolInstance.send(type, (0, utils_js_1.packMessage)(request, data), requestId);
-            return await completer.fut;
+            this._protocolInstance.sendNowait(type, (0, utils_js_1.packMessage)(request, data), { id: requestId });
+            return completer.fut;
         }
         catch (error) {
             this._pendingRequests.delete(requestId);
@@ -1239,6 +1244,7 @@ class RoomClient {
             input: this._normalizeInvokeInput(params.input ?? params.arguments),
             participantId: params.participantId,
             onBehalfOfId: params.onBehalfOfId,
+            afterSend: params.afterSend,
         });
         if (output.kind !== "content") {
             throw new room_server_client_js_1.RoomServerException("unexpected streamed output from " + params.toolkit + "." + params.tool);
@@ -1261,7 +1267,6 @@ class RoomClient {
         let requestTask;
         if (params.streamInput === true) {
             request["arguments"] = { type: "control", method: "open" };
-            requestTask = this._streamInvokeToolRequestChunks(toolCallId, params.input);
         }
         else {
             const input = params.input;
@@ -1278,9 +1283,14 @@ class RoomClient {
         if (params.onBehalfOfId != null) {
             request["on_behalf_of_id"] = params.onBehalfOfId;
         }
+        const responseRequest = this._dispatchRequest("room.invoke_tool", request, requestData);
+        params.afterSend?.();
+        if (params.streamInput === true) {
+            requestTask = this._streamInvokeToolRequestChunks(toolCallId, params.input);
+        }
         try {
             const response = await Promise.race([
-                this.sendRequest("room.invoke_tool", request, requestData),
+                responseRequest,
                 preOpenError.fut,
             ]);
             this._toolCallPreOpenErrors.delete(toolCallId);
@@ -1335,9 +1345,10 @@ class RoomClient {
         if (params.onBehalfOfId != null) {
             request["on_behalf_of_id"] = params.onBehalfOfId;
         }
+        const responseRequest = this._dispatchRequest("room.invoke_tool", request);
         const requestTask = this._streamInvokeToolRequestChunks(toolCallId, params.input);
         try {
-            const response = await this.sendRequest("room.invoke_tool", request);
+            const response = await responseRequest;
             await requestTask;
             if (response instanceof response_js_1.ControlContent && response.method === "open") {
                 throw new room_server_client_js_1.RoomServerException(`unexpected return type from ${params.toolkit}.${params.tool}`);
@@ -1368,6 +1379,7 @@ class RoomClient {
         if (params.onBehalfOfId != null) {
             request["on_behalf_of_id"] = params.onBehalfOfId;
         }
+        const responseRequest = this._dispatchRequest("room.invoke_tool", request);
         const requestTask = this._streamInvokeToolRequestChunks(toolCallId, params.input);
         void requestTask.catch((error) => {
             const stream = this._toolCallStreams.get(toolCallId);
@@ -1381,7 +1393,7 @@ class RoomClient {
         let response;
         try {
             response = await Promise.race([
-                this.sendRequest("room.invoke_tool", request),
+                responseRequest,
                 preOpenError.fut,
             ]);
         }
@@ -1403,24 +1415,27 @@ class RoomClient {
             },
         };
     }
-    async _sendToolCallRequestChunk(toolCallId, chunk) {
+    _dispatchToolCallRequestChunk(toolCallId, chunk) {
+        this._raiseIfTerminal();
+        if (this._entered && !this._connected && !this._allowDisconnectedRequests) {
+            throw this._disconnectedError({ baseMessage: "room connection is disconnected" });
+        }
         const packed = chunk.pack();
         const request = {
             tool_call_id: toolCallId,
             chunk: JSON.parse((0, utils_js_1.splitMessageHeader)(packed)),
         };
         const payload = (0, utils_js_1.splitMessagePayload)(packed);
-        await this.sendRequest("room.tool_call_request_chunk", request, payload.length > 0 ? payload : undefined);
+        this._protocolInstance.sendNowait("room.tool_call_request_chunk", (0, utils_js_1.packMessage)(request, payload.length > 0 ? payload : undefined));
     }
     async _streamInvokeToolRequestChunks(toolCallId, input) {
-        await Promise.resolve();
         try {
             for await (const item of input) {
-                await this._sendToolCallRequestChunk(toolCallId, item);
+                this._dispatchToolCallRequestChunk(toolCallId, item);
             }
         }
         finally {
-            await this._sendToolCallRequestChunk(toolCallId, new response_js_1.ControlContent({ method: "close" }));
+            this._dispatchToolCallRequestChunk(toolCallId, new response_js_1.ControlContent({ method: "close" }));
         }
     }
     _decodeToolCallContent(params) {

package/dist/esm/agent.js

@@ -511,10 +511,10 @@ class _RemoteToolkitWrapper {
             return false;
         }
     }
-    async _sendToolCallResponseChunk(messageId, toolCallId, chunk) {
+    _sendToolCallResponseChunk(messageId, toolCallId, chunk) {
         const [header, payload] = unpackMessage(chunk.pack());
         try {
-            await this.client.protocol.send("room.tool_call_response_chunk", packMessage({ tool_call_id: toolCallId, chunk: header }, payload.length > 0 ? payload : undefined), { id: messageId });
+            this.client.protocol.sendNowait("room.tool_call_response_chunk", packMessage({ tool_call_id: toolCallId, chunk: header }, payload.length > 0 ? payload : undefined), { id: messageId });
             return true;
         }
         catch (error) {
@@ -615,10 +615,10 @@ class _RemoteToolkitWrapper {
                     return;
                 for await (const chunk of output.stream) {
                     this.toolkit.validateOutputContent(tool, chunk);
-                    if (!await this._sendToolCallResponseChunk(messageId, toolCallId, chunk))
+                    if (!this._sendToolCallResponseChunk(messageId, toolCallId, chunk))
                         return;
                 }
-                await this._sendToolCallResponseChunk(messageId, toolCallId, new ControlContent({ method: "close" }));
+                this._sendToolCallResponseChunk(messageId, toolCallId, new ControlContent({ method: "close" }));
                 return;
             }
             throw new Error(`tool ${toolName} returned unsupported output`);
@@ -629,9 +629,9 @@ class _RemoteToolkitWrapper {
                 return;
             }
             if (!(error instanceof InvalidToolDataException)) {
-                await this._sendToolCallResponseChunk(messageId, toolCallId, new ErrorContent({ text: String(error) }));
+                this._sendToolCallResponseChunk(messageId, toolCallId, new ErrorContent({ text: String(error) }));
             }
-            await this._sendToolCallResponseChunk(messageId, toolCallId, new ControlContent({
+            this._sendToolCallResponseChunk(messageId, toolCallId, new ControlContent({
                 method: "close",
                 statusCode: error instanceof InvalidToolDataException ? ControlCloseStatus.INVALID_DATA : undefined,
                 message: error instanceof InvalidToolDataException ? error.message : undefined,