@meshagent/meshagent 0.29.4 → 0.30.1

package/dist/esm/room-client.js

@@ -1,5 +1,5 @@
 import { Completer } from "./completer";
-import { packMessage, unpackMessage } from "./utils";
+import { packMessage, splitMessageHeader, splitMessagePayload, unpackMessage } from "./utils";
 import { LocalParticipant } from "./participant";
 import { StreamController } from "./stream-controller";
 import { SyncClient } from "./sync-client";
@@ -8,20 +8,23 @@ import { StorageClient } from "./storage-client";
 import { MessagingClient } from "./messaging-client";
 import { QueuesClient } from "./queues-client";
 import { DatabaseClient } from "./database-client";
-import { AgentsClient } from "./agent-client";
+import { AgentsClient, ToolkitDescription } from "./agent-client";
 import { SecretsClient } from "./secrets-client";
+import { ContainersClient } from "./containers-client";
 import { RoomServerException } from "./room-server-client";
-import { ErrorContent, unpackContent } from "./response";
+import { BinaryContent, ControlContent, EmptyContent, ErrorContent, FileContent, JsonContent, LinkContent, TextContent, unpackContent } from "./response";
 export class RoomClient {
     constructor({ protocol }) {
         this._pendingRequests = new Map();
         this._ready = new Completer();
         this._localParticipant = null;
         this._eventsController = new 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 SyncClient({ room: this });
         this.storage = new StorageClient({ room: this });
         this.developer = new DeveloperClient({ room: this });
@@ -30,6 +33,7 @@ export class RoomClient {
         this.database = new DatabaseClient({ room: this });
         this.agents = new AgentsClient({ room: this });
         this.secrets = new SecretsClient({ room: this });
+        this.containers = new ContainersClient({ room: this });
     }
     get localParticipant() {
         return this._localParticipant;
@@ -48,6 +52,10 @@ export 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;
     }
@@ -59,6 +67,202 @@ export 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 JsonContent)) {
+            throw new RoomServerException("unexpected return type from room.list_toolkits");
+        }
+        const tools = result.json["tools"];
+        if (typeof tools !== "object" || tools === null || Array.isArray(tools)) {
+            throw new 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 RoomServerException("unexpected toolkit description from room.list_toolkits");
+            }
+            toolkits.push(ToolkitDescription.fromJson(data, { name }));
+        }
+        return toolkits;
+    }
+    async invoke(params) {
+        const input = params.input ?? params.arguments ?? new EmptyContent();
+        const request = {
+            toolkit: params.toolkit,
+            tool: params.tool,
+        };
+        let requestData;
+        if (input instanceof BinaryContent ||
+            input instanceof EmptyContent ||
+            input instanceof ErrorContent ||
+            input instanceof FileContent ||
+            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;
+            }
+        }
+        else if (typeof input === "object" && input !== null && !Array.isArray(input)) {
+            request["arguments"] = {
+                type: "json",
+                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;
+        }
+        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 ControlContent && response.method === "open") {
+                throw new 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 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 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 ControlContent) || response.method !== "open") {
+            this._toolCallStreams.delete(toolCallId);
+            controller.close();
+            throw new 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(splitMessageHeader(packed)),
+        };
+        const payload = 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 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 unpackContent(packMessage(chunkMap, params.payload.length > 0 ? params.payload : undefined));
+            }
+            return new JsonContent({ json: chunkMap });
+        }
+        return new JsonContent({ json: { chunk } });
+    }
+    async _handleToolCallResponseChunk(protocol, messageId, type, data) {
+        if (!data) {
+            return;
+        }
+        const [header, payload] = 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 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/esm/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/esm/secrets-client.js

@@ -1,45 +1,52 @@
-import { EmptyContent, FileContent, JsonContent } from "./response";
+import { BinaryContent, EmptyContent, FileContent, JsonContent } from "./response";
 export 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 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 EmptyContent || response instanceof 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 EmptyContent) {
             return null;
         }
         if (response instanceof 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 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) => ({
@@ -52,26 +59,24 @@ export 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 EmptyContent || response instanceof 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 EmptyContent || response instanceof JsonContent) {
             return;
         }
-        throw new Error("Invalid response received, expected EmptyContent or JsonContent");
+        throw this.unexpectedResponse("delete_requested_secret");
     }
 }

package/dist/esm/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 {};