@meshagent/meshagent 0.29.2 → 0.30.0

package/dist/node/room-client.js

@@ -13,6 +13,7 @@ const queues_client_1 = require("./queues-client");
 const database_client_1 = require("./database-client");
 const agent_client_1 = require("./agent-client");
 const secrets_client_1 = require("./secrets-client");
+const containers_client_1 = require("./containers-client");
 const room_server_client_1 = require("./room-server-client");
 const response_1 = require("./response");
 class RoomClient {
@@ -21,10 +22,12 @@ class RoomClient {
         this._ready = new completer_1.Completer();
         this._localParticipant = null;
         this._eventsController = new stream_controller_1.StreamController();
+        this._toolCallStreams = new Map();
         this.protocol = protocol;
         protocol.addHandler("room_ready", this._handleRoomReady.bind(this));
         protocol.addHandler("connected", this._handleParticipant.bind(this));
         protocol.addHandler("__response__", this._handleResponse.bind(this));
+        protocol.addHandler("room.tool_call_response_chunk", this._handleToolCallResponseChunk.bind(this));
         this.sync = new sync_client_1.SyncClient({ room: this });
         this.storage = new storage_client_1.StorageClient({ room: this });
         this.developer = new developer_client_1.DeveloperClient({ room: this });
@@ -33,6 +36,7 @@ class RoomClient {
         this.database = new database_client_1.DatabaseClient({ room: this });
         this.agents = new agent_client_1.AgentsClient({ room: this });
         this.secrets = new secrets_client_1.SecretsClient({ room: this });
+        this.containers = new containers_client_1.ContainersClient({ room: this });
     }
     get localParticipant() {
         return this._localParticipant;
@@ -51,6 +55,10 @@ class RoomClient {
             this._pendingRequests.delete(prKey);
         }
         this.sync.dispose();
+        for (const stream of this._toolCallStreams.values()) {
+            stream.close();
+        }
+        this._toolCallStreams.clear();
         this.protocol.dispose();
         this._localParticipant = null;
     }
@@ -62,6 +70,202 @@ class RoomClient {
         await this.protocol.send(type, message, requestId);
         return await pr.fut;
     }
+    async call(params) {
+        await this.sendRequest("room.call", params);
+    }
+    async listToolkits(params) {
+        const request = {};
+        if (params?.participantId != null) {
+            request["participant_id"] = params.participantId;
+        }
+        if (params?.participantName != null) {
+            request["participant_name"] = params.participantName;
+        }
+        if (params?.timeout !== undefined) {
+            request["timeout"] = params.timeout;
+        }
+        const result = await this.sendRequest("room.list_toolkits", request);
+        if (!(result instanceof response_1.JsonContent)) {
+            throw new room_server_client_1.RoomServerException("unexpected return type from room.list_toolkits");
+        }
+        const tools = result.json["tools"];
+        if (typeof tools !== "object" || tools === null || Array.isArray(tools)) {
+            throw new room_server_client_1.RoomServerException("unexpected return type from room.list_toolkits");
+        }
+        const toolkits = [];
+        for (const [name, data] of Object.entries(tools)) {
+            if (typeof data !== "object" || data === null || Array.isArray(data)) {
+                throw new room_server_client_1.RoomServerException("unexpected toolkit description from room.list_toolkits");
+            }
+            toolkits.push(agent_client_1.ToolkitDescription.fromJson(data, { name }));
+        }
+        return toolkits;
+    }
+    async invoke(params) {
+        const input = params.input ?? params.arguments ?? new response_1.EmptyContent();
+        const request = {
+            toolkit: params.toolkit,
+            tool: params.tool,
+        };
+        let requestData;
+        if (input instanceof response_1.BinaryContent ||
+            input instanceof response_1.EmptyContent ||
+            input instanceof response_1.ErrorContent ||
+            input instanceof response_1.FileContent ||
+            input instanceof response_1.JsonContent ||
+            input instanceof response_1.LinkContent ||
+            input instanceof response_1.TextContent) {
+            const packed = input.pack();
+            request["arguments"] = JSON.parse((0, utils_1.splitMessageHeader)(packed));
+            const payload = (0, utils_1.splitMessagePayload)(packed);
+            if (payload.length > 0) {
+                requestData = payload;
+            }
+        }
+        else if (typeof input === "object" && input !== null && !Array.isArray(input)) {
+            request["arguments"] = {
+                type: "json",
+                json: input,
+            };
+        }
+        else {
+            throw new room_server_client_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;
+        }
+        if (params.callerContext != null) {
+            request["caller_context"] = params.callerContext;
+        }
+        return await this.sendRequest("room.invoke_tool", request, requestData);
+    }
+    async invokeWithStreamInput(params) {
+        const toolCallId = `${Date.now()}-${this.protocol.getNextMessageId()}-${Math.random().toString(16).slice(2)}`;
+        const request = {
+            toolkit: params.toolkit,
+            tool: params.tool,
+            tool_call_id: toolCallId,
+            arguments: { type: "control", method: "open" },
+        };
+        if (params.participantId != null) {
+            request["participant_id"] = params.participantId;
+        }
+        if (params.onBehalfOfId != null) {
+            request["on_behalf_of_id"] = params.onBehalfOfId;
+        }
+        if (params.callerContext != null) {
+            request["caller_context"] = params.callerContext;
+        }
+        const requestTask = this._streamInvokeToolRequestChunks(toolCallId, params.input);
+        try {
+            const response = await this.sendRequest("room.invoke_tool", request);
+            await requestTask;
+            if (response instanceof response_1.ControlContent && response.method === "open") {
+                throw new room_server_client_1.RoomServerException(`unexpected return type from ${params.toolkit}.${params.tool}`);
+            }
+            return response;
+        }
+        catch (error) {
+            await Promise.resolve(requestTask).catch(() => undefined);
+            throw error;
+        }
+    }
+    async invokeStream(params) {
+        const toolCallId = `${Date.now()}-${this.protocol.getNextMessageId()}-${Math.random().toString(16).slice(2)}`;
+        const controller = new stream_controller_1.StreamController();
+        const responseIterator = controller.stream[Symbol.asyncIterator]();
+        this._toolCallStreams.set(toolCallId, controller);
+        const request = {
+            toolkit: params.toolkit,
+            tool: params.tool,
+            tool_call_id: toolCallId,
+            arguments: { type: "control", method: "open" },
+        };
+        if (params.participantId != null) {
+            request["participant_id"] = params.participantId;
+        }
+        if (params.onBehalfOfId != null) {
+            request["on_behalf_of_id"] = params.onBehalfOfId;
+        }
+        if (params.callerContext != null) {
+            request["caller_context"] = params.callerContext;
+        }
+        const requestTask = this._streamInvokeToolRequestChunks(toolCallId, params.input);
+        void requestTask.catch((error) => {
+            const stream = this._toolCallStreams.get(toolCallId);
+            if (!stream) {
+                return;
+            }
+            stream.add(new response_1.ErrorContent({ text: `request stream failed: ${String(error)}` }));
+            stream.close();
+            this._toolCallStreams.delete(toolCallId);
+        });
+        const response = await this.sendRequest("room.invoke_tool", request);
+        if (!(response instanceof response_1.ControlContent) || response.method !== "open") {
+            this._toolCallStreams.delete(toolCallId);
+            controller.close();
+            throw new room_server_client_1.RoomServerException(`unexpected return type from ${params.toolkit}.${params.tool}`);
+        }
+        return {
+            [Symbol.asyncIterator]() {
+                return responseIterator;
+            },
+        };
+    }
+    async _sendToolCallRequestChunk(toolCallId, chunk) {
+        const packed = chunk.pack();
+        const request = {
+            tool_call_id: toolCallId,
+            chunk: JSON.parse((0, utils_1.splitMessageHeader)(packed)),
+        };
+        const payload = (0, utils_1.splitMessagePayload)(packed);
+        await this.sendRequest("room.tool_call_request_chunk", 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);
+            }
+        }
+        finally {
+            await this._sendToolCallRequestChunk(toolCallId, new response_1.ControlContent({ method: "close" }));
+        }
+    }
+    _decodeToolCallContent(params) {
+        const chunk = params.header["chunk"];
+        if (typeof chunk === "object" && chunk !== null && !Array.isArray(chunk)) {
+            const chunkMap = chunk;
+            if (typeof chunkMap["type"] === "string") {
+                return (0, response_1.unpackContent)((0, utils_1.packMessage)(chunkMap, params.payload.length > 0 ? params.payload : undefined));
+            }
+            return new response_1.JsonContent({ json: chunkMap });
+        }
+        return new response_1.JsonContent({ json: { chunk } });
+    }
+    async _handleToolCallResponseChunk(protocol, messageId, type, data) {
+        if (!data) {
+            return;
+        }
+        const [header, payload] = (0, utils_1.unpackMessage)(data);
+        const toolCallId = header["tool_call_id"];
+        if (typeof toolCallId !== "string" || toolCallId.length === 0) {
+            return;
+        }
+        const stream = this._toolCallStreams.get(toolCallId);
+        if (!stream) {
+            return;
+        }
+        const content = this._decodeToolCallContent({ header, payload });
+        stream.add(content);
+        if (content instanceof response_1.ControlContent && content.method === "close") {
+            stream.close();
+            this._toolCallStreams.delete(toolCallId);
+        }
+    }
     async _handleResponse(protocol, messageId, type, data) {
         if (!data) {
             console.error("No data in response");

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

@@ -11,6 +11,7 @@ export declare class SecretsClient {
     constructor({ room }: {
         room: RoomClient;
     });
+    private unexpectedResponse;
     setSecret({ secretId, data, mimeType, name, delegatedTo, forIdentity, }: {
         secretId: string;
         data: Uint8Array;

package/dist/node/secrets-client.js

@@ -6,43 +6,50 @@ class SecretsClient {
     constructor({ room }) {
         this.client = room;
     }
+    unexpectedResponse(operation) {
+        return new Error(`unexpected return type from secrets.${operation}`);
+    }
     async setSecret({ secretId, data, mimeType, name, delegatedTo, forIdentity, }) {
-        const req = {
-            secret_id: secretId,
-        };
-        if (mimeType)
-            req.type = mimeType;
-        if (name)
-            req.name = name;
-        if (delegatedTo)
-            req.delegated_to = delegatedTo;
-        if (forIdentity)
-            req.for_identity = forIdentity;
-        const response = await this.client.sendRequest("secrets.set_secret", req, data);
+        const response = await this.client.invoke({
+            toolkit: "secrets",
+            tool: "set_secret",
+            input: new response_1.BinaryContent({
+                data,
+                headers: {
+                    secret_id: secretId,
+                    type: mimeType ?? null,
+                    name: name ?? null,
+                    delegated_to: delegatedTo ?? null,
+                    for_identity: forIdentity ?? null,
+                    has_data: true,
+                },
+            }),
+        });
         if (response instanceof response_1.EmptyContent || response instanceof response_1.JsonContent) {
             return;
         }
-        throw new Error("Invalid response received, expected EmptyContent or JsonContent");
+        throw this.unexpectedResponse("set_secret");
     }
     async getSecret({ secretId, delegatedTo, }) {
         const req = {
             secret_id: secretId,
+            type: null,
+            name: null,
+            delegated_to: delegatedTo ?? null,
         };
-        if (delegatedTo)
-            req.delegated_to = delegatedTo;
-        const response = await this.client.sendRequest("secrets.get_secret", req);
+        const response = await this.client.invoke({ toolkit: "secrets", tool: "get_secret", input: req });
         if (response instanceof response_1.EmptyContent) {
             return null;
         }
         if (response instanceof response_1.FileContent) {
             return response;
         }
-        throw new Error("Invalid response received, expected FileContent or EmptyContent");
+        throw this.unexpectedResponse("get_secret");
     }
     async listSecrets() {
-        const response = await this.client.sendRequest("secrets.list_secrets", {});
+        const response = await this.client.invoke({ toolkit: "secrets", tool: "list_secrets", input: {} });
         if (!(response instanceof response_1.JsonContent)) {
-            throw new Error("Invalid response received, expected JsonContent");
+            throw this.unexpectedResponse("list_secrets");
         }
         const secrets = Array.isArray(response.json?.secrets) ? response.json.secrets : [];
         return secrets.map((item) => ({
@@ -55,27 +62,25 @@ class SecretsClient {
     async deleteSecret({ secretId, delegatedTo, }) {
         const req = {
             id: secretId,
+            delegated_to: delegatedTo ?? null,
         };
-        if (delegatedTo)
-            req.delegated_to = delegatedTo;
-        const response = await this.client.sendRequest("secrets.delete_secret", req);
+        const response = await this.client.invoke({ toolkit: "secrets", tool: "delete_secret", input: req });
         if (response instanceof response_1.EmptyContent || response instanceof response_1.JsonContent) {
             return;
         }
-        throw new Error("Invalid response received, expected EmptyContent or JsonContent");
+        throw this.unexpectedResponse("delete_secret");
     }
     async deleteRequestedSecret({ url, type, delegatedTo, }) {
         const req = {
             url,
             type,
+            delegated_to: delegatedTo ?? null,
         };
-        if (delegatedTo)
-            req.delegated_to = delegatedTo;
-        const response = await this.client.sendRequest("secrets.delete_requested_secret", req);
+        const response = await this.client.invoke({ toolkit: "secrets", tool: "delete_requested_secret", input: req });
         if (response instanceof response_1.EmptyContent || response instanceof response_1.JsonContent) {
             return;
         }
-        throw new Error("Invalid response received, expected EmptyContent or JsonContent");
+        throw this.unexpectedResponse("delete_requested_secret");
     }
 }
 exports.SecretsClient = SecretsClient;

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

@@ -1,6 +1,6 @@
 import { RoomClient } from "./room-client";
 import { RoomEvent } from "./room-event";
-import { FileContent } from "./response";
+import { BinaryContent, FileContent } from "./response";
 import { EventEmitter } from "./event-emitter";
 export declare class FileHandle {
     id: number;
@@ -11,9 +11,11 @@ export declare class FileHandle {
 declare class StorageEntry {
     name: string;
     isFolder: boolean;
-    constructor({ name, isFolder }: {
+    size: number | null;
+    constructor({ name, isFolder, size }: {
         name: string;
         isFolder: boolean;
+        size?: number | null;
     });
     nameWithoutExtension(): string;
 }
@@ -24,15 +26,28 @@ export declare class StorageClient extends EventEmitter<RoomEvent> {
     });
     private _handleFileUpdated;
     private _handleFileDeleted;
+    private _unexpectedResponseError;
+    private _invoke;
     list(path: string): Promise<StorageEntry[]>;
     delete(path: string): Promise<void>;
-    open(path: string, { overwrite }: {
-        overwrite: boolean;
-    }): Promise<FileHandle>;
     exists(path: string): Promise<boolean>;
-    write(handle: FileHandle, bytes: Uint8Array): Promise<void>;
-    close(handle: FileHandle): Promise<void>;
+    private _defaultUploadName;
+    upload(path: string, bytes: Uint8Array, { overwrite, name, mimeType, }?: {
+        overwrite?: boolean;
+        name?: string | null;
+        mimeType?: string | null;
+    }): Promise<void>;
+    uploadStream(path: string, chunks: AsyncIterable<Uint8Array>, { overwrite, chunkSize, size, name, mimeType, }?: {
+        overwrite?: boolean;
+        chunkSize?: number;
+        size?: number | null;
+        name?: string | null;
+        mimeType?: string | null;
+    }): Promise<void>;
     download(path: string): Promise<FileContent>;
+    downloadStream(path: string, { chunkSize, }?: {
+        chunkSize?: number;
+    }): Promise<AsyncIterable<BinaryContent>>;
     downloadUrl(path: string): Promise<string>;
 }
 export {};