@meshagent/meshagent 0.44.10 → 0.44.12

package/dist/esm/requirement.d.ts

@@ -1,6 +1,10 @@
+import { Schema } from "apache-arrow";
 export declare class RoomException extends Error {
     constructor(message: string);
 }
+export declare class ForbiddenException extends RoomException {
+    constructor(message: string);
+}
 export declare abstract class Requirement {
     readonly name: string;
     constructor({ name }: {
@@ -25,3 +29,20 @@ export declare class RequiredSchema extends Requirement {
     });
     toJson(): Record<string, any>;
 }
+export declare class RequiredTable extends Requirement {
+    readonly schema: Schema;
+    readonly namespace?: string[];
+    readonly scalarIndexes?: string[];
+    readonly fullTextSearchIndexes?: string[];
+    readonly vectorIndexes?: string[];
+    constructor({ name, schema, namespace, scalarIndexes, fullTextSearchIndexes, vectorIndexes, }: {
+        name: string;
+        schema: Schema;
+        namespace?: string[];
+        scalarIndexes?: string[];
+        fullTextSearchIndexes?: string[];
+        vectorIndexes?: string[];
+    });
+    static fromJson(r: Record<string, any>): RequiredTable;
+    toJson(): Record<string, any>;
+}

package/dist/esm/requirement.js

@@ -1,9 +1,54 @@
+import { Table, tableFromIPC, tableToIPC } from "apache-arrow";
 export class RoomException extends Error {
     constructor(message) {
         super(message);
         this.name = "RoomException";
     }
 }
+export class ForbiddenException extends RoomException {
+    constructor(message) {
+        super(message);
+        this.name = "ForbiddenException";
+    }
+}
+const globalScope = globalThis;
+function bytesToBase64(bytes) {
+    if (globalScope.Buffer) {
+        return globalScope.Buffer.from(bytes).toString("base64");
+    }
+    if (!globalScope.btoa) {
+        throw new Error("base64 encoding is not available in this runtime");
+    }
+    let binary = "";
+    for (const byte of bytes) {
+        binary += String.fromCharCode(byte);
+    }
+    return globalScope.btoa(binary);
+}
+function base64ToBytes(base64) {
+    if (globalScope.Buffer) {
+        return Uint8Array.from(globalScope.Buffer.from(base64, "base64"));
+    }
+    if (!globalScope.atob) {
+        throw new Error("base64 decoding is not available in this runtime");
+    }
+    const binary = globalScope.atob(base64);
+    const bytes = new Uint8Array(binary.length);
+    for (let index = 0; index < binary.length; index += 1) {
+        bytes[index] = binary.charCodeAt(index);
+    }
+    return bytes;
+}
+function schemaToIPC(schema) {
+    return tableToIPC(new Table(schema, []), "stream");
+}
+function schemaFromIPCBytes(data) {
+    const table = tableFromIPC(data);
+    if (table instanceof Promise) {
+        throw new RoomException("unexpected async Arrow IPC result");
+    }
+    return table.schema;
+}
 export class Requirement {
     constructor({ name }) {
         this.name = name;
@@ -16,6 +61,9 @@ export class Requirement {
                 participantName: r["participant_name"],
             });
         }
+        if ("table" in r) {
+            return RequiredTable.fromJson(r);
+        }
         if ("schema" in r) {
             return new RequiredSchema({ name: r["schema"] });
         }
@@ -46,3 +94,39 @@ export class RequiredSchema extends Requirement {
         };
     }
 }
+export class RequiredTable extends Requirement {
+    constructor({ name, schema, namespace, scalarIndexes, fullTextSearchIndexes, vectorIndexes, }) {
+        super({ name });
+        this.schema = schema;
+        this.namespace = namespace;
+        this.scalarIndexes = scalarIndexes;
+        this.fullTextSearchIndexes = fullTextSearchIndexes;
+        this.vectorIndexes = vectorIndexes;
+    }
+    static fromJson(r) {
+        if (typeof r["table"] !== "string") {
+            throw new RoomException("required table name must be a string");
+        }
+        if (typeof r["schema"] !== "string") {
+            throw new RoomException("required table schema must be a base64 Arrow IPC schema");
+        }
+        return new RequiredTable({
+            name: r["table"],
+            schema: schemaFromIPCBytes(base64ToBytes(r["schema"])),
+            namespace: Array.isArray(r["namespace"]) ? r["namespace"].map(String) : undefined,
+            scalarIndexes: Array.isArray(r["scalar_indexes"]) ? r["scalar_indexes"].map(String) : undefined,
+            fullTextSearchIndexes: Array.isArray(r["full_text_search_indexes"]) ? r["full_text_search_indexes"].map(String) : undefined,
+            vectorIndexes: Array.isArray(r["vector_indexes"]) ? r["vector_indexes"].map(String) : undefined,
+        });
+    }
+    toJson() {
+        return {
+            table: this.name,
+            schema: bytesToBase64(schemaToIPC(this.schema)),
+            namespace: this.namespace,
+            scalar_indexes: this.scalarIndexes,
+            full_text_search_indexes: this.fullTextSearchIndexes,
+            vector_indexes: this.vectorIndexes,
+        };
+    }
+}

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

@@ -18,6 +18,7 @@ import { ContainersClient } from "./containers-client.js";
 interface RequestHeader {
     [key: string]: unknown;
 }
+export type InvokeInput = Record<string, unknown> | Content;
 export declare class RoomProtocolProxy {
     private readonly _room;
     private readonly _handlers;
@@ -67,6 +68,7 @@ export declare class RoomClient {
     private readonly _eventEmitter;
     private readonly _pendingRequests;
     private readonly _toolCallStreams;
+    private readonly _toolCallPreOpenErrors;
     private readonly _ignoredResponseLabels;
     private readonly _ready;
     private readonly _roomClosed;
@@ -202,11 +204,20 @@ export declare class RoomClient {
         participantName?: string;
         timeout?: number;
     }): Promise<ToolkitDescription[]>;
+    private _normalizeInvokeInput;
     invoke(params: {
         toolkit: string;
         tool: string;
         arguments?: Record<string, unknown>;
-        input?: Record<string, unknown> | Content;
+        input?: InvokeInput;
+        participantId?: string;
+        onBehalfOfId?: string;
+    }): AsyncIterable<Content>;
+    invokeContent(params: {
+        toolkit: string;
+        tool: string;
+        arguments?: Record<string, unknown>;
+        input?: InvokeInput;
         participantId?: string;
         onBehalfOfId?: string;
     }): Promise<Content>;

package/dist/esm/room-client.js

@@ -7,7 +7,7 @@ import { MemoryClient } from "./memory-client.js";
 import { LocalParticipant } from "./participant.js";
 import { ProtocolCloseException, ProtocolCloseKind, ProtocolHandshakeException, ProtocolReconnectUnsupportedException, WebSocketClientProtocol, } from "./protocol.js";
 import { QueuesClient } from "./queues-client.js";
-import { BinaryContent, ControlContent, EmptyContent, ErrorContent, FileContent, JsonContent, LinkContent, TextContent, unpackContent } from "./response.js";
+import { BinaryContent, ControlCloseStatus, ControlContent, EmptyContent, ErrorContent, FileContent, JsonContent, LinkContent, TextContent, unpackContent } from "./response.js";
 import { RoomStatusEvent } from "./room-event.js";
 import { RoomServerException } from "./room-server-client.js";
 import { SecretsClient } from "./secrets-client.js";
@@ -212,6 +212,7 @@ export class RoomClient {
         this._eventEmitter = new EventEmitter();
         this._pendingRequests = new Map();
         this._toolCallStreams = new Map();
+        this._toolCallPreOpenErrors = new Map();
         this._ignoredResponseLabels = new Map();
         this._ready = new Completer();
         this._roomClosed = new Completer();
@@ -1195,13 +1196,10 @@ export class RoomClient {
         }
         return toolkits;
     }
-    async invoke(params) {
-        const input = params.input ?? params.arguments ?? new EmptyContent();
-        const request = {
-            toolkit: params.toolkit,
-            tool: params.tool,
-        };
-        let requestData;
+    _normalizeInvokeInput(input) {
+        if (input === undefined) {
+            return new EmptyContent();
+        }
         if (input instanceof BinaryContent ||
             input instanceof EmptyContent ||
             input instanceof ErrorContent ||
@@ -1209,35 +1207,53 @@ export class RoomClient {
             input instanceof JsonContent ||
             input instanceof LinkContent ||
             input instanceof TextContent) {
-            const packed = input.pack();
-            request["arguments"] = JSON.parse(splitMessageHeader(packed));
-            const payload = 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 JsonContent({ json: input });
         }
-        else {
-            throw new 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 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 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 StreamController();
         const responseIterator = controller.stream[Symbol.asyncIterator]();
+        const preOpenError = new Completer();
         this._toolCallStreams.set(toolCallId, controller);
+        this._toolCallPreOpenErrors.set(toolCallId, preOpenError);
         const request = {
             toolkit: params.toolkit,
             tool: params.tool,
@@ -1265,7 +1281,11 @@ export 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 ControlContent && response.method === "open") {
                 if (requestTask != null) {
                     void requestTask.catch((error) => {
@@ -1273,7 +1293,7 @@ export class RoomClient {
                         if (stream == null) {
                             return;
                         }
-                        stream.add(new ErrorContent({ text: `request stream failed: ${String(error)}` }));
+                        stream.addError(error);
                         stream.close();
                         this._toolCallStreams.delete(toolCallId);
                     });
@@ -1297,6 +1317,7 @@ export class RoomClient {
         }
         catch (error) {
             await Promise.resolve(requestTask).catch(() => undefined);
+            this._toolCallPreOpenErrors.delete(toolCallId);
             this._toolCallStreams.delete(toolCallId);
             controller.close();
             throw error;
@@ -1334,7 +1355,9 @@ export class RoomClient {
         const toolCallId = `${Date.now()}-${Math.random().toString(16).slice(2)}`;
         const controller = new StreamController();
         const responseIterator = controller.stream[Symbol.asyncIterator]();
+        const preOpenError = new Completer();
         this._toolCallStreams.set(toolCallId, controller);
+        this._toolCallPreOpenErrors.set(toolCallId, preOpenError);
         const request = {
             toolkit: params.toolkit,
             tool: params.tool,
@@ -1353,11 +1376,24 @@ export class RoomClient {
             if (stream == null) {
                 return;
             }
-            stream.add(new 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 ControlContent) || response.method !== "open") {
             this._toolCallStreams.delete(toolCallId);
             controller.close();
@@ -1414,10 +1450,34 @@ export class RoomClient {
             return;
         }
         const content = this._decodeToolCallContent({ header, payload });
+        const preOpenError = this._toolCallPreOpenErrors.get(toolCallId);
+        if (preOpenError != null && content instanceof ErrorContent) {
+            const error = new 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 ControlContent &&
+            content.method === "close" &&
+            content.statusCode !== undefined &&
+            content.statusCode !== ControlCloseStatus.NORMAL) {
+            const error = new 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 ControlContent && content.method === "close") {
             stream.close();
             this._toolCallStreams.delete(toolCallId);
+            this._toolCallPreOpenErrors.delete(toolCallId);
         }
     }
     async _handleResponse(protocol, messageId, _type, data) {

package/dist/esm/secrets-client.js

@@ -18,7 +18,7 @@ export class SecretsClient {
         return new 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/esm/services-client.js

@@ -50,7 +50,7 @@ export 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: {},
@@ -74,7 +74,7 @@ export class ServicesClient {
         };
     }
     async restart(params) {
-        const response = await this.room.invoke({
+        const response = await this.room.invokeContent({
             toolkit: "services",
             tool: "restart",
             input: {

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

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

package/dist/esm/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/esm/stream-controller.js

@@ -16,21 +16,26 @@ export 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() {
@@ -52,10 +57,25 @@ export 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 });
             }
         }
     }
@@ -67,7 +87,7 @@ export 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/esm/sync-client.js

@@ -161,7 +161,7 @@ export class SyncClient extends EventEmitter {
         return new 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/node/agent-client.js

@@ -141,7 +141,7 @@ 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/node/containers-client.js

@@ -403,7 +403,7 @@ class ContainersClient {
         return new room_server_client_js_1.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/node/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);