@meshagent/meshagent 0.29.4 → 0.30.1

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

@@ -6,8 +6,8 @@ export declare class DeveloperClient extends EventEmitter<RoomLogEvent> {
     constructor({ room }: {
         room: RoomClient;
     });
+    private _emitDeveloperLog;
     private _handleDeveloperLog;
     log(type: string, data: Record<string, any>): Promise<void>;
-    enable(): Promise<void>;
-    disable(): Promise<void>;
+    logs(): AsyncIterable<RoomLogEvent>;
 }

package/dist/esm/developer-client.js

@@ -1,5 +1,6 @@
 import { EventEmitter } from "./event-emitter";
-import { packMessage, unpackMessage } from "./utils";
+import { BinaryContent, ControlContent, ErrorContent } from "./response";
+import { unpackMessage } from "./utils";
 import { RoomLogEvent } from "./room-event";
 export class DeveloperClient extends EventEmitter {
     constructor({ room }) {
@@ -7,25 +8,69 @@ export class DeveloperClient extends EventEmitter {
         this.client = room;
         this.client.protocol.addHandler("developer.log", this._handleDeveloperLog.bind(this));
     }
-    async _handleDeveloperLog(protocol, messageId, type, bytes) {
-        const [rawJson, _] = unpackMessage(bytes || new Uint8Array());
-        const event = new RoomLogEvent({
-            type: rawJson["type"],
-            data: rawJson["data"],
-        });
+    _emitDeveloperLog(type, data) {
+        const event = new RoomLogEvent({ type, data });
         this.client.emit(event);
         this.emit("log", event);
     }
-    async log(type, data) {
-        const message = packMessage({ type, data }, undefined);
-        await this.client.protocol.send("developer.log", message);
+    async _handleDeveloperLog(protocol, messageId, type, bytes) {
+        const [rawJson, _] = unpackMessage(bytes || new Uint8Array());
+        this._emitDeveloperLog(rawJson["type"], rawJson["data"]);
     }
-    async enable() {
-        const message = packMessage({}, undefined);
-        await this.client.protocol.send("developer.watch", message);
+    async log(type, data) {
+        await this.client.invoke({
+            toolkit: "developer",
+            tool: "log",
+            input: { type, data },
+        });
     }
-    async disable() {
-        const message = packMessage({}, undefined);
-        await this.client.protocol.send("developer.unwatch", message);
+    async *logs() {
+        let resolveClosed;
+        const closed = new Promise((resolve) => {
+            resolveClosed = resolve;
+        });
+        const input = (async function* () {
+            await closed;
+        })();
+        const stream = await this.client.invokeStream({
+            toolkit: "developer",
+            tool: "logs",
+            input,
+        });
+        try {
+            for await (const chunk of stream) {
+                if (chunk instanceof ErrorContent) {
+                    throw new Error(chunk.text);
+                }
+                if (chunk instanceof ControlContent) {
+                    if (chunk.method === "close") {
+                        return;
+                    }
+                    throw new Error("unexpected return type from developer.logs");
+                }
+                if (!(chunk instanceof BinaryContent)) {
+                    throw new Error("unexpected return type from developer.logs");
+                }
+                const logType = chunk.headers["type"];
+                if (typeof logType !== "string" || logType.length === 0) {
+                    throw new Error("developer.logs returned a chunk without a valid type");
+                }
+                const decoded = chunk.data.length === 0
+                    ? {}
+                    : JSON.parse(new TextDecoder().decode(chunk.data));
+                if (typeof decoded !== "object" || decoded === null || Array.isArray(decoded)) {
+                    throw new Error("developer.logs returned invalid JSON data");
+                }
+                const event = new RoomLogEvent({ type: logType, data: decoded });
+                this.client.emit(event);
+                this.emit("log", event);
+                yield event;
+            }
+        }
+        finally {
+            if (resolveClosed) {
+                resolveClosed();
+            }
+        }
     }
 }

package/dist/esm/helpers.js

@@ -9,10 +9,11 @@ export function validateSchemaName(name) {
 }
 export async function deploySchema({ room, schema, name, overwrite = true }) {
     validateSchemaName(name);
-    const handle = await room.storage.open(`.schemas/${name}.json`, { overwrite });
     const data = Buffer.from(JSON.stringify(schema.toJson()), 'utf-8');
-    await room.storage.write(handle, data);
-    await room.storage.close(handle);
+    async function* singleChunk() {
+        yield data;
+    }
+    await room.storage.uploadStream(`.schemas/${name}.json`, singleChunk(), { overwrite, size: data.length });
 }
 export function meshagentBaseUrl(baseUrl) {
     if (baseUrl) {

package/dist/esm/index.d.ts

@@ -3,6 +3,7 @@ export * from './agent-client';
 export * from './event-emitter';
 export * from './client';
 export * from './completer';
+export * from './containers-client';
 export * from './data-types';
 export * from './database-client';
 export * from './developer-client';

package/dist/esm/index.js

@@ -3,6 +3,7 @@ export * from './agent-client';
 export * from './event-emitter';
 export * from './client';
 export * from './completer';
+export * from './containers-client';
 export * from './data-types';
 export * from './database-client';
 export * from './developer-client';

package/dist/esm/lk-client.js

@@ -1,3 +1,5 @@
+import { JsonContent } from './response';
+import { RoomServerException } from './room-server-client';
 export class LivekitConnectionInfo {
     constructor({ url, token }) {
         this.url = url;
@@ -9,11 +11,18 @@ export class LivekitClient {
         this.room = room;
     }
     async getConnectionInfo({ breakoutRoom }) {
-        const response = (await this.room.sendRequest('livekit.connect', { breakout_room: breakoutRoom }));
-        if (!response || !response.json) {
-            throw new Error('Failed to get connection info');
+        const response = await this.room.invoke({
+            toolkit: 'livekit',
+            tool: 'connect',
+            input: { breakout_room: breakoutRoom ?? null },
+        });
+        if (!(response instanceof JsonContent)) {
+            throw new RoomServerException('unexpected return type from livekit.connect');
         }
         const { url, token } = response.json;
+        if (typeof url !== 'string' || typeof token !== 'string') {
+            throw new RoomServerException('unexpected return type from livekit.connect');
+        }
         return new LivekitConnectionInfo({ url, token });
     }
 }

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

@@ -62,9 +62,14 @@ export interface ProjectStorageMountSpec {
     subpath?: string | null;
     read_only?: boolean;
 }
+export interface EmptyDirMountSpec {
+    path: string;
+    read_only?: boolean;
+}
 export interface ContainerMountSpec {
     room?: RoomStorageMountSpec[];
     project?: ProjectStorageMountSpec[];
+    empty_dirs?: EmptyDirMountSpec[];
 }
 export interface ServiceApiKeySpec {
     role: "admin";

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

@@ -20,6 +20,7 @@ export declare class MessagingClient extends EventEmitter<RoomMessageEvent> {
     constructor({ room }: {
         room: RoomClient;
     });
+    private _messageInput;
     createStream({ to, header }: {
         to: Participant;
         header: Record<string, any>;

package/dist/esm/messaging-client.js

@@ -5,6 +5,20 @@ import { RoomMessage, RoomMessageEvent } from "./room-event";
 import { splitMessageHeader, splitMessagePayload } from "./utils";
 import { StreamController } from "./stream-controller";
 import { Completer } from "./completer";
+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);
+}
 export class MessageStreamChunk {
     constructor({ header, data }) {
         this.header = header;
@@ -20,6 +34,19 @@ export class MessagingClient extends EventEmitter {
         this.client = room;
         this.client.protocol.addHandler("messaging.send", this._handleMessageSend.bind(this));
     }
+    _messageInput(params) {
+        const input = {
+            type: params.type,
+            message_json: JSON.stringify(params.message),
+        };
+        if (params.attachment !== undefined) {
+            input["attachment_base64"] = bytesToBase64(params.attachment);
+        }
+        if (params.toParticipantId !== undefined) {
+            input["to_participant_id"] = params.toParticipantId;
+        }
+        return input;
+    }
     async createStream({ to, header }) {
         const streamId = uuidV4();
         const completer = new Completer();
@@ -32,21 +59,38 @@ export class MessagingClient extends EventEmitter {
         return completer.fut;
     }
     async sendMessage({ to, type, message, attachment }) {
-        await this.client.sendRequest("messaging.send", {
-            to_participant_id: to.id,
-            type,
-            message,
-        }, attachment);
+        await this.client.invoke({
+            toolkit: "messaging",
+            tool: "send",
+            input: this._messageInput({
+                toParticipantId: to.id,
+                type,
+                message,
+                attachment,
+            }),
+        });
     }
     async enable(onStreamAccept) {
-        await this.client.sendRequest("messaging.enable", {});
+        await this.client.invoke({
+            toolkit: "messaging",
+            tool: "enable",
+            input: {},
+        });
         this._onStreamAcceptCallback = onStreamAccept;
     }
     async disable() {
-        await this.client.sendRequest("messaging.disable", {});
+        await this.client.invoke({
+            toolkit: "messaging",
+            tool: "disable",
+            input: {},
+        });
     }
     async broadcastMessage({ type, message, attachment }) {
-        await this.client.sendRequest("messaging.broadcast", { type, message }, attachment);
+        await this.client.invoke({
+            toolkit: "messaging",
+            tool: "broadcast",
+            input: this._messageInput({ type, message, attachment }),
+        });
     }
     get remoteParticipants() {
         return Object.values(this._participants);

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

@@ -12,6 +12,8 @@ export declare class QueuesClient {
     constructor({ room }: {
         room: RoomClient;
     });
+    private _unexpectedResponseError;
+    private _invoke;
     list(): Promise<Queue[]>;
     open(name: string): Promise<void>;
     drain(name: string): Promise<void>;

package/dist/esm/queues-client.js

@@ -1,4 +1,5 @@
-import { EmptyContent } from "./response";
+import { EmptyContent, JsonContent } from "./response";
+import { RoomServerException } from "./room-server-client";
 export class Queue {
     constructor({ name, size }) {
         this.name = name;
@@ -9,25 +10,50 @@ export class QueuesClient {
     constructor({ room }) {
         this.client = room;
     }
+    _unexpectedResponseError(operation) {
+        return new RoomServerException(`unexpected return type from queues.${operation}`);
+    }
+    async _invoke(operation, arguments_) {
+        return await this.client.invoke({
+            toolkit: "queues",
+            tool: operation,
+            arguments: arguments_,
+        });
+    }
     async list() {
-        const response = (await this.client.sendRequest("queues.list", {}));
+        const response = await this._invoke("list", {});
+        if (!(response instanceof JsonContent)) {
+            throw this._unexpectedResponseError("list");
+        }
         const queues = response.json["queues"];
         return queues.map((q) => new Queue({ name: q["name"], size: q["size"] }));
     }
     async open(name) {
-        await this.client.sendRequest("queues.open", { name });
+        const response = await this._invoke("open", { name });
+        if (!(response instanceof EmptyContent)) {
+            throw this._unexpectedResponseError("open");
+        }
     }
     async drain(name) {
-        await this.client.sendRequest("queues.drain", { name });
+        const response = await this._invoke("drain", { name });
+        if (!(response instanceof EmptyContent)) {
+            throw this._unexpectedResponseError("drain");
+        }
     }
     async close(name) {
-        await this.client.sendRequest("queues.close", { name });
+        const response = await this._invoke("close", { name });
+        if (!(response instanceof EmptyContent)) {
+            throw this._unexpectedResponseError("close");
+        }
     }
     async send(name, message, { create = true }) {
-        await this.client.sendRequest("queues.send", { name, create, message });
+        const response = await this._invoke("send", { name, create, message });
+        if (!(response instanceof EmptyContent)) {
+            throw this._unexpectedResponseError("send");
+        }
     }
     async receive(name, { create = true, wait = true }) {
-        const response = await this.client.sendRequest("queues.receive", {
+        const response = await this._invoke("receive", {
             name,
             create,
             wait,
@@ -35,8 +61,9 @@ export class QueuesClient {
         if (response instanceof EmptyContent) {
             return null;
         }
-        else {
+        if (response instanceof JsonContent) {
             return response.json;
         }
+        throw this._unexpectedResponseError("receive");
     }
 }

package/dist/esm/response.d.ts

@@ -1,6 +1,17 @@
 export interface Content {
     pack(): Uint8Array;
 }
+export declare class BinaryContent implements Content {
+    data: Uint8Array;
+    headers: Record<string, any>;
+    constructor({ data, headers }: {
+        data: Uint8Array;
+        headers?: Record<string, any>;
+    });
+    static unpack(header: Record<string, any>, payload: Uint8Array): BinaryContent;
+    pack(): Uint8Array;
+    toString(): string;
+}
 export declare class LinkContent implements Content {
     url: string;
     name: string;
@@ -59,4 +70,21 @@ export declare class EmptyContent implements Content {
     pack(): Uint8Array;
     toString(): string;
 }
+export declare enum ControlCloseStatus {
+    NORMAL = 1000,
+    INVALID_DATA = 1007
+}
+export declare class ControlContent implements Content {
+    method: "open" | "close";
+    statusCode?: number;
+    message?: string;
+    constructor({ method, statusCode, message, }: {
+        method: "open" | "close";
+        statusCode?: number;
+        message?: string;
+    });
+    static unpack(header: Record<string, any>, _payload: Uint8Array): ControlContent;
+    pack(): Uint8Array;
+    toString(): string;
+}
 export declare function unpackContent(data: Uint8Array): Content;

package/dist/esm/response.js

@@ -1,4 +1,25 @@
 import { packMessage, splitMessageHeader, splitMessagePayload } from "./utils";
+export class BinaryContent {
+    constructor({ data, headers = {} }) {
+        this.data = data;
+        this.headers = headers;
+    }
+    static unpack(header, payload) {
+        return new BinaryContent({
+            data: payload,
+            headers: typeof header["headers"] === "object" && header["headers"] != null ? header["headers"] : {},
+        });
+    }
+    pack() {
+        return packMessage({
+            type: "binary",
+            headers: this.headers,
+        }, this.data);
+    }
+    toString() {
+        return `BinaryContent: headers=${JSON.stringify(this.headers)} length=${this.data.length}`;
+    }
+}
 export class LinkContent {
     constructor({ url, name }) {
         this.url = url;
@@ -127,7 +148,59 @@ export class EmptyContent {
         return `EmptyContent`;
     }
 }
+export var ControlCloseStatus;
+(function (ControlCloseStatus) {
+    ControlCloseStatus[ControlCloseStatus["NORMAL"] = 1000] = "NORMAL";
+    ControlCloseStatus[ControlCloseStatus["INVALID_DATA"] = 1007] = "INVALID_DATA";
+})(ControlCloseStatus || (ControlCloseStatus = {}));
+export class ControlContent {
+    constructor({ method, statusCode, message, }) {
+        this.method = method;
+        this.statusCode = method === "close" ? statusCode ?? ControlCloseStatus.NORMAL : statusCode;
+        this.message = message;
+    }
+    static unpack(header, _payload) {
+        const method = header["method"];
+        if (method !== "open" && method !== "close") {
+            throw new Error(`Invalid control method: ${method}`);
+        }
+        const rawStatusCode = header["status_code"];
+        let statusCode;
+        if (typeof rawStatusCode === "number" && Number.isInteger(rawStatusCode)) {
+            statusCode = rawStatusCode;
+        }
+        else if (typeof rawStatusCode === "string") {
+            const parsed = Number.parseInt(rawStatusCode, 10);
+            if (!Number.isNaN(parsed)) {
+                statusCode = parsed;
+            }
+        }
+        return new ControlContent({
+            method,
+            statusCode,
+            message: typeof header["message"] === "string" ? header["message"] : undefined,
+        });
+    }
+    pack() {
+        const header = {
+            type: "control",
+            method: this.method,
+        };
+        if (this.method === "close") {
+            header["status_code"] = this.statusCode ?? ControlCloseStatus.NORMAL;
+            if (this.message !== undefined) {
+                header["message"] = this.message;
+            }
+        }
+        return packMessage(header);
+    }
+    toString() {
+        return `ControlContent: ${this.method}`;
+    }
+}
 const _contentTypes = {
+    binary: BinaryContent.unpack,
+    control: ControlContent.unpack,
     empty: EmptyContent.unpack,
     error: ErrorContent.unpack,
     file: FileContent.unpack,

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

@@ -6,8 +6,9 @@ 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 { RoomEvent } from "./room-event";
 import { Content } from "./response";
 interface RequestHeader {
@@ -23,10 +24,12 @@ export declare class RoomClient {
     readonly database: DatabaseClient;
     readonly agents: AgentsClient;
     readonly secrets: SecretsClient;
+    readonly containers: ContainersClient;
     private _pendingRequests;
     private _ready;
     private _localParticipant;
     private _eventsController;
+    private _toolCallStreams;
     constructor({ protocol }: {
         protocol: Protocol;
     });
@@ -38,6 +41,45 @@ export declare class RoomClient {
     }): Promise<void>;
     dispose(): void;
     sendRequest(type: string, request: RequestHeader, data?: Uint8Array): Promise<Content>;
+    call(params: {
+        name: string;
+        url: string;
+        arguments: Record<string, any>;
+    }): Promise<void>;
+    listToolkits(params?: {
+        participantId?: string;
+        participantName?: string;
+        timeout?: number;
+    }): Promise<ToolkitDescription[]>;
+    invoke(params: {
+        toolkit: string;
+        tool: string;
+        arguments?: Record<string, any>;
+        input?: Record<string, any> | Content;
+        participantId?: string;
+        onBehalfOfId?: string;
+        callerContext?: Record<string, any>;
+    }): Promise<Content>;
+    invokeWithStreamInput(params: {
+        toolkit: string;
+        tool: string;
+        input: AsyncIterable<Content>;
+        participantId?: string;
+        onBehalfOfId?: string;
+        callerContext?: Record<string, any>;
+    }): Promise<Content>;
+    invokeStream(params: {
+        toolkit: string;
+        tool: string;
+        input: AsyncIterable<Content>;
+        participantId?: string;
+        onBehalfOfId?: string;
+        callerContext?: Record<string, any>;
+    }): Promise<AsyncIterable<Content>>;
+    private _sendToolCallRequestChunk;
+    private _streamInvokeToolRequestChunks;
+    private _decodeToolCallContent;
+    private _handleToolCallResponseChunk;
     private _handleResponse;
     private _handleRoomReady;
     private _onParticipantInit;