@meshagent/meshagent 0.44.11 → 0.44.12

package/dist/node/room-client.js

@@ -216,6 +216,7 @@ class RoomClient {
         this._eventEmitter = new event_emitter_js_1.EventEmitter();
         this._pendingRequests = new Map();
         this._toolCallStreams = new Map();
+        this._toolCallPreOpenErrors = new Map();
         this._ignoredResponseLabels = new Map();
         this._ready = new completer_js_1.Completer();
         this._roomClosed = new completer_js_1.Completer();
@@ -1199,13 +1200,10 @@ class RoomClient {
         }
         return toolkits;
     }
-    async invoke(params) {
-        const input = params.input ?? params.arguments ?? new response_js_1.EmptyContent();
-        const request = {
-            toolkit: params.toolkit,
-            tool: params.tool,
-        };
-        let requestData;
+    _normalizeInvokeInput(input) {
+        if (input === undefined) {
+            return new response_js_1.EmptyContent();
+        }
         if (input instanceof response_js_1.BinaryContent ||
             input instanceof response_js_1.EmptyContent ||
             input instanceof response_js_1.ErrorContent ||
@@ -1213,35 +1211,53 @@ class RoomClient {
             input instanceof response_js_1.JsonContent ||
             input instanceof response_js_1.LinkContent ||
             input instanceof response_js_1.TextContent) {
-            const packed = input.pack();
-            request["arguments"] = JSON.parse((0, utils_js_1.splitMessageHeader)(packed));
-            const payload = (0, utils_js_1.splitMessagePayload)(packed);
-            if (payload.length > 0) {
-                requestData = payload;
-            }
+            return input;
         }
-        else if (typeof input === "object" && input !== null && !Array.isArray(input)) {
-            request["arguments"] = {
-                type: "json",
-                json: input,
-            };
+        if (typeof input === "object" && input !== null && !Array.isArray(input)) {
+            return new response_js_1.JsonContent({ json: input });
         }
-        else {
-            throw new room_server_client_js_1.RoomServerException("invoke input must be a content value or JSON object");
-        }
-        if (params.participantId != null) {
-            request["participant_id"] = params.participantId;
-        }
-        if (params.onBehalfOfId != null) {
-            request["on_behalf_of_id"] = params.onBehalfOfId;
+        throw new room_server_client_js_1.RoomServerException("invoke input must be a content value or JSON object");
+    }
+    invoke(params) {
+        const outputPromise = this.invokeToolCall({
+            toolkit: params.toolkit,
+            tool: params.tool,
+            input: this._normalizeInvokeInput(params.input ?? params.arguments),
+            participantId: params.participantId,
+            onBehalfOfId: params.onBehalfOfId,
+        });
+        void outputPromise.catch(() => undefined);
+        return {
+            async *[Symbol.asyncIterator]() {
+                const output = await outputPromise;
+                if (output.kind === "stream") {
+                    yield* output.stream;
+                    return;
+                }
+                yield output.content;
+            },
+        };
+    }
+    async invokeContent(params) {
+        const output = await this.invokeToolCall({
+            toolkit: params.toolkit,
+            tool: params.tool,
+            input: this._normalizeInvokeInput(params.input ?? params.arguments),
+            participantId: params.participantId,
+            onBehalfOfId: params.onBehalfOfId,
+        });
+        if (output.kind !== "content") {
+            throw new room_server_client_js_1.RoomServerException("unexpected streamed output from " + params.toolkit + "." + params.tool);
         }
-        return await this.sendRequest("room.invoke_tool", request, requestData);
+        return output.content;
     }
     async invokeToolCall(params) {
         const toolCallId = `${Date.now()}-${Math.random().toString(16).slice(2)}`;
         const controller = new stream_controller_js_1.StreamController();
         const responseIterator = controller.stream[Symbol.asyncIterator]();
+        const preOpenError = new completer_js_1.Completer();
         this._toolCallStreams.set(toolCallId, controller);
+        this._toolCallPreOpenErrors.set(toolCallId, preOpenError);
         const request = {
             toolkit: params.toolkit,
             tool: params.tool,
@@ -1269,7 +1285,11 @@ class RoomClient {
             request["on_behalf_of_id"] = params.onBehalfOfId;
         }
         try {
-            const response = await this.sendRequest("room.invoke_tool", request, requestData);
+            const response = await Promise.race([
+                this.sendRequest("room.invoke_tool", request, requestData),
+                preOpenError.fut,
+            ]);
+            this._toolCallPreOpenErrors.delete(toolCallId);
             if (response instanceof response_js_1.ControlContent && response.method === "open") {
                 if (requestTask != null) {
                     void requestTask.catch((error) => {
@@ -1277,7 +1297,7 @@ class RoomClient {
                         if (stream == null) {
                             return;
                         }
-                        stream.add(new response_js_1.ErrorContent({ text: `request stream failed: ${String(error)}` }));
+                        stream.addError(error);
                         stream.close();
                         this._toolCallStreams.delete(toolCallId);
                     });
@@ -1301,6 +1321,7 @@ class RoomClient {
         }
         catch (error) {
             await Promise.resolve(requestTask).catch(() => undefined);
+            this._toolCallPreOpenErrors.delete(toolCallId);
             this._toolCallStreams.delete(toolCallId);
             controller.close();
             throw error;
@@ -1338,7 +1359,9 @@ class RoomClient {
         const toolCallId = `${Date.now()}-${Math.random().toString(16).slice(2)}`;
         const controller = new stream_controller_js_1.StreamController();
         const responseIterator = controller.stream[Symbol.asyncIterator]();
+        const preOpenError = new completer_js_1.Completer();
         this._toolCallStreams.set(toolCallId, controller);
+        this._toolCallPreOpenErrors.set(toolCallId, preOpenError);
         const request = {
             toolkit: params.toolkit,
             tool: params.tool,
@@ -1357,11 +1380,24 @@ class RoomClient {
             if (stream == null) {
                 return;
             }
-            stream.add(new response_js_1.ErrorContent({ text: `request stream failed: ${String(error)}` }));
+            stream.addError(error);
             stream.close();
             this._toolCallStreams.delete(toolCallId);
         });
-        const response = await this.sendRequest("room.invoke_tool", request);
+        let response;
+        try {
+            response = await Promise.race([
+                this.sendRequest("room.invoke_tool", request),
+                preOpenError.fut,
+            ]);
+        }
+        catch (error) {
+            this._toolCallPreOpenErrors.delete(toolCallId);
+            this._toolCallStreams.delete(toolCallId);
+            controller.close();
+            throw error;
+        }
+        this._toolCallPreOpenErrors.delete(toolCallId);
         if (!(response instanceof response_js_1.ControlContent) || response.method !== "open") {
             this._toolCallStreams.delete(toolCallId);
             controller.close();
@@ -1418,10 +1454,34 @@ class RoomClient {
             return;
         }
         const content = this._decodeToolCallContent({ header, payload });
+        const preOpenError = this._toolCallPreOpenErrors.get(toolCallId);
+        if (preOpenError != null && content instanceof response_js_1.ErrorContent) {
+            const error = new room_server_client_js_1.RoomServerException(content.text, content.code);
+            if (!preOpenError.completed) {
+                preOpenError.completeError(error);
+            }
+            stream.addError(error);
+            stream.close();
+            this._toolCallStreams.delete(toolCallId);
+            this._toolCallPreOpenErrors.delete(toolCallId);
+            return;
+        }
+        if (content instanceof response_js_1.ControlContent &&
+            content.method === "close" &&
+            content.statusCode !== undefined &&
+            content.statusCode !== response_js_1.ControlCloseStatus.NORMAL) {
+            const error = new room_server_client_js_1.RoomServerException(content.message ?? `tool call stream closed with status ${content.statusCode}`, undefined, { statusCode: content.statusCode });
+            stream.addError(error);
+            stream.close();
+            this._toolCallStreams.delete(toolCallId);
+            this._toolCallPreOpenErrors.delete(toolCallId);
+            return;
+        }
         stream.add(content);
         if (content instanceof response_js_1.ControlContent && content.method === "close") {
             stream.close();
             this._toolCallStreams.delete(toolCallId);
+            this._toolCallPreOpenErrors.delete(toolCallId);
         }
     }
     async _handleResponse(protocol, messageId, _type, data) {

package/dist/node/secrets-client.js

@@ -21,7 +21,7 @@ class SecretsClient {
         return new room_server_client_js_1.RoomServerException(`unexpected return type from secrets.${operation}`);
     }
     async invoke(operation, input) {
-        return await this.client.invoke({
+        return await this.client.invokeContent({
             toolkit: "secrets",
             tool: operation,
             input,

package/dist/node/services-client.js

@@ -53,7 +53,7 @@ class ServicesClient {
         return (await this.listWithState()).services;
     }
     async listWithState() {
-        const response = await this.room.invoke({
+        const response = await this.room.invokeContent({
             toolkit: "services",
             tool: "list",
             input: {},
@@ -77,7 +77,7 @@ class ServicesClient {
         };
     }
     async restart(params) {
-        const response = await this.room.invoke({
+        const response = await this.room.invokeContent({
             toolkit: "services",
             tool: "restart",
             input: {

package/dist/node/storage-client.d.ts

@@ -3,7 +3,7 @@ import { Protocol } from "./protocol.js";
 import { RoomEvent } from "./room-event.js";
 import { BinaryContent, FileContent } from "./response.js";
 import { EventEmitter } from "./event-emitter.js";
-type StorageClientRoom = Pick<RoomClient, "invoke" | "invokeStream" | "emit"> & {
+type StorageClientRoom = Pick<RoomClient, "invokeContent" | "invokeStream" | "emit"> & {
     isActiveProtocol(protocol: Protocol): boolean;
     protocol: Pick<Protocol, "addHandler">;
 };

package/dist/node/storage-client.js

@@ -137,7 +137,7 @@ class StorageClient extends event_emitter_js_1.EventEmitter {
         });
     }
     async _invoke(operation, input) {
-        return await this.client.invoke({
+        return await this.client.invokeContent({
             toolkit: "storage",
             tool: operation,
             input,

package/dist/node/stream-controller.d.ts

@@ -3,5 +3,6 @@ export declare class StreamController<T> {
     private subs;
     get stream(): AsyncIterable<T>;
     add(value: T): void;
+    addError(error: unknown): void;
     close(): void;
 }

package/dist/node/stream-controller.js

@@ -19,21 +19,26 @@ class StreamController {
                     if (sub.waiter) {
                         const w = sub.waiter;
                         sub.waiter = null;
-                        w({ done: true, value: undefined });
+                        w.resolve({ done: true, value: undefined });
                     }
                     self.subs.delete(sub);
                 };
                 return {
                     async next() {
                         if (sub.queue.length > 0) {
-                            return { done: false, value: sub.queue.shift() };
+                            const item = sub.queue.shift();
+                            if (item.kind === "error") {
+                                cleanup();
+                                return Promise.reject(item.error);
+                            }
+                            return { done: false, value: item.value };
                         }
                         if (self.closed) {
                             cleanup();
                             return { done: true, value: undefined };
                         }
-                        return new Promise(resolve => {
-                            sub.waiter = resolve;
+                        return new Promise((resolve, reject) => {
+                            sub.waiter = { resolve, reject };
                         });
                     },
                     async return() {
@@ -55,10 +60,25 @@ class StreamController {
             if (sub.waiter) {
                 const w = sub.waiter;
                 sub.waiter = null;
-                w({ done: false, value });
+                w.resolve({ done: false, value });
             }
             else {
-                sub.queue.push(value);
+                sub.queue.push({ kind: "value", value });
+            }
+        }
+    }
+    addError(error) {
+        if (this.closed)
+            return;
+        for (const sub of [...this.subs]) {
+            if (sub.waiter) {
+                const w = sub.waiter;
+                sub.waiter = null;
+                w.reject(error);
+                this.subs.delete(sub);
+            }
+            else {
+                sub.queue.push({ kind: "error", error });
             }
         }
     }
@@ -70,7 +90,7 @@ class StreamController {
             if (sub.waiter) {
                 const w = sub.waiter;
                 sub.waiter = null;
-                w({ done: true, value: undefined });
+                w.resolve({ done: true, value: undefined });
             }
         }
     }

package/dist/node/sync-client.js

@@ -164,7 +164,7 @@ class SyncClient extends event_emitter_js_1.EventEmitter {
         return new room_server_client_js_1.RoomServerException(`unexpected return type from sync.${operation}`);
     }
     async _invoke(operation, input) {
-        return await this.room.invoke({
+        return await this.room.invokeContent({
             toolkit: "sync",
             tool: operation,
             input,

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@meshagent/meshagent",
-    "version": "0.44.11",
+    "version": "0.44.12",
     "description": "Meshagent Client",
     "homepage": "https://github.com/meshagent/meshagent-ts",
     "scripts": {