@meshagent/meshagent 0.44.11 → 0.44.13

package/dist/browser/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/browser/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/browser/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/browser/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/browser/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/browser/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/browser/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/browser/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/dist/esm/agent-client.js

@@ -136,7 +136,7 @@ export class AgentsClient {
     }
     async invokeTool(params) {
         if (params.input === undefined) {
-            return await this.client.invoke({
+            return await this.client.invokeContent({
                 toolkit: params.toolkit,
                 tool: params.tool,
                 arguments: params.arguments ?? {},

package/dist/esm/containers-client.js

@@ -399,7 +399,7 @@ export class ContainersClient {
         return new RoomServerException(`unexpected return type from containers.${operation}`);
     }
     async invoke(operation, input) {
-        return await this.room.invoke({
+        return await this.room.invokeContent({
             toolkit: "containers",
             tool: operation,
             input,

package/dist/esm/datasets-client.d.ts

@@ -173,7 +173,7 @@ export type DatasetRecord = Record<string, DatasetValue>;
 export type DatasetRows = DatasetRecord[];
 export type DatasetRowChunks = AsyncIterable<DatasetRows> | Iterable<DatasetRows>;
 export type DatasetWhere = string | Record<string, DatasetValue>;
-type DatasetRoomInvoker = Pick<RoomClient, "invoke" | "invokeStream">;
+type DatasetRoomInvoker = Pick<RoomClient, "invokeContent" | "invokeStream">;
 export declare class DatasetUuid {
     readonly value: string;
     constructor(value: string);

package/dist/esm/datasets-client.js

@@ -715,7 +715,7 @@ export class DatasetsClient {
         return new RoomServerException(`unexpected return type from datasets.${operation}`);
     }
     async invoke(operation, input) {
-        const response = await this.room.invoke({ toolkit: "dataset", tool: operation, input });
+        const response = await this.room.invokeContent({ toolkit: "dataset", tool: operation, input });
         if (response instanceof JsonContent) {
             return response;
         }
@@ -725,7 +725,7 @@ export class DatasetsClient {
         return null;
     }
     async invokeContent(operation, input) {
-        return await this.room.invoke({ toolkit: "dataset", tool: operation, input });
+        return await this.room.invokeContent({ toolkit: "dataset", tool: operation, input });
     }
     async invokeStream(operation, input) {
         return await this.room.invokeStream({ toolkit: "dataset", tool: operation, input });
@@ -901,7 +901,7 @@ export class DatasetsClient {
         await this.drainWriteStream("create_table", input);
     }
     async dropTable({ name, ignoreMissing = false, namespace, branch }) {
-        await this.room.invoke({
+        await this.room.invokeContent({
             toolkit: "dataset",
             tool: "drop_table",
             input: {
@@ -956,7 +956,7 @@ export class DatasetsClient {
         });
     }
     async dropIndex({ table, name, namespace, branch }) {
-        await this.room.invoke({
+        await this.room.invokeContent({
             toolkit: "dataset",
             tool: "drop_index",
             input: { table, name, namespace: namespace ?? null, branch: branch ?? null },
@@ -975,7 +975,7 @@ export class DatasetsClient {
             }));
             return;
         }
-        await this.room.invoke({
+        await this.room.invokeContent({
             toolkit: "dataset",
             tool: "add_columns",
             input: {
@@ -987,7 +987,7 @@ export class DatasetsClient {
         });
     }
     async dropColumns({ table, columns, namespace, branch }) {
-        await this.room.invoke({
+        await this.room.invokeContent({
             toolkit: "dataset",
             tool: "drop_columns",
             input: { table, columns, namespace: namespace ?? null, branch: branch ?? null },
@@ -1009,7 +1009,7 @@ export class DatasetsClient {
         await this.drainWriteStream("insert", input);
     }
     async update({ table, where, values, namespace, branch }) {
-        await this.room.invoke({
+        await this.room.invokeContent({
             toolkit: "dataset",
             tool: "update",
             input: {
@@ -1022,7 +1022,7 @@ export class DatasetsClient {
         });
     }
     async delete({ table, where, namespace, branch }) {
-        await this.room.invoke({
+        await this.room.invokeContent({
             toolkit: "dataset",
             tool: "delete",
             input: { table, where, namespace: namespace ?? null, branch: branch ?? null },
@@ -1134,13 +1134,13 @@ export class DatasetsClient {
         });
     }
     async closeSqlQuery({ queryId }) {
-        const response = await this.room.invoke({ toolkit: "dataset", tool: "close_sql_query", input: { query_id: queryId } });
+        const response = await this.room.invokeContent({ toolkit: "dataset", tool: "close_sql_query", input: { query_id: queryId } });
         if (!(response instanceof EmptyContent)) {
             throw this._unexpectedResponseError("close_sql_query");
         }
     }
     async cancelSqlQuery({ queryId }) {
-        const response = await this.room.invoke({ toolkit: "dataset", tool: "cancel_sql_query", input: { query_id: queryId } });
+        const response = await this.room.invokeContent({ toolkit: "dataset", tool: "cancel_sql_query", input: { query_id: queryId } });
         if (!(response instanceof JsonContent)
             || !["cancelled", "cancelling", "not_cancellable"].includes(response.json.status)) {
             throw this._unexpectedResponseError("cancel_sql_query");
@@ -1296,7 +1296,7 @@ export class DatasetsClient {
         return response.json.count;
     }
     async inspect({ table, namespace, branch, version }) {
-        const response = await this.room.invoke({
+        const response = await this.room.invokeContent({
             toolkit: "dataset",
             tool: "inspect",
             input: {
@@ -1341,7 +1341,7 @@ export class DatasetsClient {
         return tableStatsFromJson(response.json);
     }
     async restore({ table, version, namespace, branch }) {
-        await this.room.invoke({
+        await this.room.invokeContent({
             toolkit: "dataset",
             tool: "restore",
             input: { table, version, namespace: namespace ?? null, branch: branch ?? null },
@@ -1359,7 +1359,7 @@ export class DatasetsClient {
         return response.json.versions.map((version) => tableVersionFromJson(version));
     }
     async createIndex({ table, config, namespace, branch }) {
-        await this.room.invoke({
+        await this.room.invokeContent({
             toolkit: "dataset",
             tool: "create_index",
             input: { table, config, namespace: namespace ?? null, branch: branch ?? null },
@@ -1387,7 +1387,7 @@ export class DatasetsClient {
         return response.json.branches.map((branch) => tableBranchFromJson(branch));
     }
     async createBranch({ branch, fromBranch, namespace }) {
-        await this.room.invoke({
+        await this.room.invokeContent({
             toolkit: "dataset",
             tool: "create_branch",
             input: {
@@ -1398,7 +1398,7 @@ export class DatasetsClient {
         });
     }
     async deleteBranch({ branch, namespace }) {
-        await this.room.invoke({
+        await this.room.invokeContent({
             toolkit: "dataset",
             tool: "delete_branch",
             input: { branch, namespace: namespace ?? null },

package/dist/esm/developer-client.js

@@ -21,7 +21,7 @@ export class DeveloperClient extends EventEmitter {
         this._emitDeveloperLog(rawJson["type"], rawJson["data"]);
     }
     async log(type, data) {
-        await this.client.invoke({
+        await this.client.invokeContent({
             toolkit: "developer",
             tool: "log",
             input: { type, data },

package/dist/esm/entrypoint.js

@@ -10,7 +10,12 @@ var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __commonJS = (cb, mod) => function __require() {
-    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+    try {
+        return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+    }
+    catch (e) {
+        throw mod = 0, e;
+    }
 };
 var __copyProps = (to, from2, except, desc) => {
     if (from2 && typeof from2 === "object" || typeof from2 === "function") {

package/dist/esm/memory-client.js

@@ -383,7 +383,7 @@ export class MemoryClient {
         return unexpectedResponse(operation);
     }
     async invoke(operation, input) {
-        const response = await this.room.invoke({
+        const response = await this.room.invokeContent({
             toolkit: "memory",
             tool: operation,
             input,