@meshagent/meshagent 0.29.2 → 0.30.0

package/CHANGELOG.md

@@ -1,3 +1,15 @@
+## [0.30.0]
+- Breaking: tool invocation now uses toolkit-based `room.invoke`/`room.*` events with streaming tool-call chunks, and `RemoteToolkit` registration follows the new room-scoped protocol.
+- Added a Containers client with image listing/pulling, container lifecycle operations, and exec/log streaming.
+- Storage client replaced handle-based writes with streaming upload/download, download URLs, and size metadata.
+- Database and Sync clients now stream inserts/queries/search and sync updates with typed value handling; messaging/queues/developer clients updated to toolkit invocation.
+
+## [0.29.4]
+- Stability
+
+## [0.29.3]
+- Stability
+
 ## [0.29.2]
 - Stability
 

package/dist/browser/agent-client.js

@@ -173,38 +173,13 @@ class AgentsClient {
         this.client = room;
     }
     async call(params) {
-        await this.client.sendRequest("agent.call", params);
+        await this.client.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.client.sendRequest("agent.list_toolkits", request));
-        const tools = result.json["tools"];
-        const toolkits = [];
-        for (const name of Object.keys(tools)) {
-            const data = tools[name];
-            toolkits.push(ToolkitDescription.fromJson(data, { name }));
-        }
-        return toolkits;
+        return await this.client.listToolkits(params);
     }
     async invokeTool(params) {
-        const request = {
-            toolkit: params.toolkit,
-            tool: params.tool,
-            arguments: {
-                type: "json",
-                json: params.arguments,
-            },
-        };
-        return await this.client.sendRequest("agent.invoke_tool", request);
+        return await this.client.invoke(params);
     }
 }
 exports.AgentsClient = AgentsClient;

package/dist/browser/agent.js

@@ -93,15 +93,15 @@ class RemoteToolkit extends Toolkit {
     }
     async start({ public_: isPublic = false } = {}) {
         const handler = this._toolCall.bind(this);
-        this.client.protocol.addHandler(`agent.tool_call.${this.name}`, handler);
+        this.client.protocol.addHandler(`room.tool_call.${this.name}`, handler);
         await this._register(isPublic);
     }
     async stop() {
         await this._unregister();
-        this.client.protocol.removeHandler(`agent.tool_call.${this.name}`);
+        this.client.protocol.removeHandler(`room.tool_call.${this.name}`);
     }
     async _register(public_) {
-        const response = await this.client.sendRequest("agent.register_toolkit", {
+        const response = await this.client.sendRequest("room.register_toolkit", {
             name: this.name,
             title: this.title,
             description: this.description,
@@ -114,7 +114,7 @@ class RemoteToolkit extends Toolkit {
     async _unregister() {
         if (!this._registrationId)
             return;
-        await this.client.sendRequest("agent.unregister_toolkit", {
+        await this.client.sendRequest("room.unregister_toolkit", {
             id: this._registrationId,
         });
     }
@@ -144,11 +144,11 @@ class RemoteToolkit extends Toolkit {
                 args = rawArguments ?? {};
             }
             const response = await this.execute(toolName, args);
-            await this.client.protocol.send("agent.tool_call_response", response.pack(), messageId);
+            await this.client.protocol.send("room.tool_call_response", response.pack(), messageId);
         }
         catch (e) {
             const err = new response_1.ErrorContent({ text: String(e) });
-            await this.client.protocol.send("agent.tool_call_response", err.pack(), messageId);
+            await this.client.protocol.send("room.tool_call_response", err.pack(), messageId);
         }
     }
 }

package/dist/browser/containers-client.d.ts

@@ -0,0 +1,125 @@
+import { ContainerMountSpec } from "./meshagent-client";
+import { Content } from "./response";
+import { RoomClient } from "./room-client";
+export interface DockerSecret {
+    username: string;
+    password: string;
+    registry: string;
+    email?: string;
+}
+export interface ContainerImage {
+    id: string;
+    tags: string[];
+    size?: number;
+    labels: Record<string, unknown>;
+}
+export interface ContainerParticipantInfo {
+    id: string;
+    name: string;
+}
+export interface RoomContainer {
+    id: string;
+    image: string;
+    name?: string;
+    startedBy: ContainerParticipantInfo;
+    state: string;
+    private: boolean;
+    serviceId?: string;
+}
+export interface ContainerLogsSession {
+    stream: AsyncIterable<string>;
+    result: Promise<void>;
+    cancel(): Promise<void>;
+}
+export declare class ExecSession {
+    readonly command: string;
+    readonly result: Promise<number>;
+    readonly previousOutput: Uint8Array[];
+    readonly output: AsyncIterable<Uint8Array>;
+    private readonly requestId;
+    private readonly containerId;
+    private readonly tty?;
+    private readonly resultCompleter;
+    private readonly outputController;
+    private readonly queuedInput;
+    private inputClosed;
+    private closed;
+    private inputWaiter;
+    private lastResizeWidth?;
+    private lastResizeHeight?;
+    constructor(params: {
+        requestId: string;
+        command: string;
+        containerId: string;
+        tty?: boolean;
+    });
+    inputStream(): AsyncIterable<Content>;
+    write(data: Uint8Array): Promise<void>;
+    resize(params: {
+        width: number;
+        height: number;
+    }): Promise<void>;
+    stop(): Promise<void>;
+    kill(): Promise<void>;
+    close(status: number): void;
+    closeError(error: unknown): void;
+    addOutput(data: Uint8Array): void;
+    get isClosed(): boolean;
+    private queueInput;
+    private closeInputStream;
+}
+export declare class ContainersClient {
+    private readonly room;
+    constructor({ room }: {
+        room: RoomClient;
+    });
+    private unexpectedResponseError;
+    private invoke;
+    listImages(): Promise<ContainerImage[]>;
+    pullImage(params: {
+        tag: string;
+        credentials?: DockerSecret[];
+    }): Promise<void>;
+    run(params: {
+        image: string;
+        command?: string;
+        workingDir?: string;
+        env?: Record<string, string>;
+        mountPath?: string;
+        mountSubpath?: string;
+        role?: string;
+        participantName?: string;
+        ports?: Record<number, number> | Record<string, number>;
+        credentials?: DockerSecret[];
+        name?: string;
+        mounts?: ContainerMountSpec;
+        writableRootFs?: boolean;
+        private?: boolean;
+    }): Promise<string>;
+    runService(params: {
+        serviceId: string;
+        env?: Record<string, string>;
+    }): Promise<string>;
+    exec(params: {
+        containerId: string;
+        command: string;
+        tty?: boolean;
+    }): ExecSession;
+    stop(params: {
+        containerId: string;
+        force?: boolean;
+    }): Promise<void>;
+    waitForExit(params: {
+        containerId: string;
+    }): Promise<number>;
+    deleteContainer(params: {
+        containerId: string;
+    }): Promise<void>;
+    logs(params: {
+        containerId: string;
+        follow?: boolean;
+    }): ContainerLogsSession;
+    list(params?: {
+        all?: boolean;
+    }): Promise<RoomContainer[]>;
+}

package/dist/browser/containers-client.js

@@ -0,0 +1,458 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContainersClient = exports.ExecSession = void 0;
+const uuid_1 = require("uuid");
+const completer_1 = require("./completer");
+const response_1 = require("./response");
+const room_server_client_1 = require("./room-server-client");
+const stream_controller_1 = require("./stream-controller");
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function toStringMapList(values) {
+    return Object.entries(values).map(([key, value]) => ({ key, value }));
+}
+function toPortPairs(values) {
+    return Object.entries(values).map(([containerPort, hostPort]) => ({
+        container_port: Number(containerPort),
+        host_port: hostPort,
+    }));
+}
+function toCredentials(values) {
+    return values.map((entry) => ({
+        registry: entry.registry,
+        username: entry.username,
+        password: entry.password,
+    }));
+}
+function readStringField(data, field, operation) {
+    const value = data[field];
+    if (typeof value !== "string") {
+        throw new room_server_client_1.RoomServerException(`unexpected return type from containers.${operation}`);
+    }
+    return value;
+}
+function decodeJsonStatus(data) {
+    const text = new TextDecoder().decode(data);
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        throw new room_server_client_1.RoomServerException("containers.exec returned an invalid status payload");
+    }
+    if (!isRecord(parsed)) {
+        throw new room_server_client_1.RoomServerException("containers.exec returned an invalid status payload");
+    }
+    const status = parsed["status"];
+    if (typeof status !== "number" || !Number.isInteger(status)) {
+        throw new room_server_client_1.RoomServerException("containers.exec returned an invalid status payload");
+    }
+    return status;
+}
+class ExecSession {
+    constructor(params) {
+        this.previousOutput = [];
+        this.resultCompleter = new completer_1.Completer();
+        this.outputController = new stream_controller_1.StreamController();
+        this.queuedInput = [];
+        this.inputClosed = false;
+        this.closed = false;
+        this.inputWaiter = null;
+        this.requestId = params.requestId;
+        this.command = params.command;
+        this.containerId = params.containerId;
+        this.tty = params.tty;
+        this.result = this.resultCompleter.fut;
+        this.output = this.outputController.stream;
+    }
+    async *inputStream() {
+        yield new response_1.BinaryContent({
+            data: new Uint8Array(0),
+            headers: {
+                kind: "start",
+                request_id: this.requestId,
+                container_id: this.containerId,
+                command: this.command,
+                tty: this.tty,
+            },
+        });
+        while (true) {
+            while (this.queuedInput.length > 0) {
+                const chunk = this.queuedInput.shift();
+                if (chunk) {
+                    yield chunk;
+                }
+            }
+            if (this.inputClosed) {
+                return;
+            }
+            this.inputWaiter = new completer_1.Completer();
+            await this.inputWaiter.fut;
+            this.inputWaiter = null;
+        }
+    }
+    async write(data) {
+        this.queueInput({ channel: 1, data });
+    }
+    async resize(params) {
+        if (this.lastResizeWidth === params.width && this.lastResizeHeight === params.height) {
+            return;
+        }
+        this.lastResizeWidth = params.width;
+        this.lastResizeHeight = params.height;
+        this.queueInput({ channel: 4, width: params.width, height: params.height });
+    }
+    async stop() {
+        this.closeInputStream();
+    }
+    async kill() {
+        if (this.inputClosed) {
+            return;
+        }
+        this.queueInput({ channel: 5 });
+    }
+    close(status) {
+        if (!this.resultCompleter.completed) {
+            this.resultCompleter.complete(status);
+        }
+        this.closed = true;
+        this.closeInputStream();
+        this.outputController.close();
+    }
+    closeError(error) {
+        if (!this.resultCompleter.completed) {
+            this.resultCompleter.completeError(error);
+        }
+        this.closed = true;
+        this.closeInputStream();
+        this.outputController.close();
+    }
+    addOutput(data) {
+        this.previousOutput.push(data);
+        this.outputController.add(data);
+    }
+    get isClosed() {
+        return this.closed;
+    }
+    queueInput(params) {
+        if (this.inputClosed) {
+            throw new room_server_client_1.RoomServerException("container exec session is already closed");
+        }
+        this.queuedInput.push(new response_1.BinaryContent({
+            data: params.data ?? new Uint8Array(0),
+            headers: {
+                kind: "input",
+                channel: params.channel,
+                width: params.width,
+                height: params.height,
+            },
+        }));
+        this.inputWaiter?.complete();
+    }
+    closeInputStream() {
+        if (this.inputClosed) {
+            return;
+        }
+        this.inputClosed = true;
+        this.inputWaiter?.complete();
+    }
+}
+exports.ExecSession = ExecSession;
+class ContainersClient {
+    constructor({ room }) {
+        this.room = room;
+    }
+    unexpectedResponseError(operation) {
+        return new room_server_client_1.RoomServerException(`unexpected return type from containers.${operation}`);
+    }
+    async invoke(operation, input) {
+        return await this.room.invoke({
+            toolkit: "containers",
+            tool: operation,
+            input,
+        });
+    }
+    async listImages() {
+        const output = await this.invoke("list_images", {});
+        if (!(output instanceof response_1.JsonContent)) {
+            throw this.unexpectedResponseError("list_images");
+        }
+        const imagesRaw = output.json["images"];
+        if (!Array.isArray(imagesRaw)) {
+            throw this.unexpectedResponseError("list_images");
+        }
+        const images = [];
+        for (const entry of imagesRaw) {
+            if (!isRecord(entry)) {
+                throw this.unexpectedResponseError("list_images");
+            }
+            const id = entry["id"];
+            const tags = entry["tags"];
+            const labelsRaw = entry["labels"];
+            if (typeof id !== "string" || !Array.isArray(tags)) {
+                throw this.unexpectedResponseError("list_images");
+            }
+            const normalizedTags = tags.filter((tag) => typeof tag === "string");
+            const size = entry["size"];
+            images.push({
+                id,
+                tags: normalizedTags,
+                size: typeof size === "number" ? size : undefined,
+                labels: isRecord(labelsRaw) ? labelsRaw : {},
+            });
+        }
+        return images;
+    }
+    async pullImage(params) {
+        await this.invoke("pull_image", {
+            tag: params.tag,
+            credentials: toCredentials(params.credentials ?? []),
+        });
+    }
+    async run(params) {
+        const output = await this.invoke("run", {
+            image: params.image,
+            command: params.command,
+            working_dir: params.workingDir,
+            env: toStringMapList(params.env ?? {}),
+            mount_path: params.mountPath,
+            mount_subpath: params.mountSubpath,
+            role: params.role,
+            participant_name: params.participantName,
+            ports: toPortPairs(params.ports ?? {}),
+            credentials: toCredentials(params.credentials ?? []),
+            name: params.name,
+            mounts: params.mounts,
+            writable_root_fs: params.writableRootFs,
+            private: params.private,
+        });
+        if (!(output instanceof response_1.JsonContent) || !isRecord(output.json)) {
+            throw this.unexpectedResponseError("run");
+        }
+        return readStringField(output.json, "container_id", "run");
+    }
+    async runService(params) {
+        const output = await this.invoke("run_service", {
+            service_id: params.serviceId,
+            env: toStringMapList(params.env ?? {}),
+        });
+        if (!(output instanceof response_1.JsonContent) || !isRecord(output.json)) {
+            throw this.unexpectedResponseError("run_service");
+        }
+        return readStringField(output.json, "container_id", "run_service");
+    }
+    exec(params) {
+        const requestId = (0, uuid_1.v4)();
+        const session = new ExecSession({
+            requestId,
+            command: params.command,
+            containerId: params.containerId,
+            tty: params.tty,
+        });
+        this.room
+            .invokeStream({
+            toolkit: "containers",
+            tool: "exec",
+            input: session.inputStream(),
+        })
+            .then(async (stream) => {
+            for await (const chunk of stream) {
+                if (chunk instanceof response_1.ErrorContent) {
+                    throw new room_server_client_1.RoomServerException(chunk.text, chunk.code);
+                }
+                if (!(chunk instanceof response_1.BinaryContent)) {
+                    throw this.unexpectedResponseError("exec");
+                }
+                const channel = chunk.headers["channel"];
+                if (typeof channel !== "number") {
+                    throw new room_server_client_1.RoomServerException("containers.exec returned a chunk without a valid channel");
+                }
+                if (channel === 1) {
+                    session.addOutput(chunk.data);
+                    continue;
+                }
+                if (channel === 3) {
+                    session.close(decodeJsonStatus(chunk.data));
+                    return;
+                }
+            }
+            throw new room_server_client_1.RoomServerException("containers.exec stream closed before a status was returned");
+        })
+            .catch((error) => {
+            session.closeError(error);
+        });
+        return session;
+    }
+    async stop(params) {
+        await this.invoke("stop_container", {
+            container_id: params.containerId,
+            force: params.force ?? true,
+        });
+    }
+    async waitForExit(params) {
+        const output = await this.invoke("wait_for_exit", {
+            container_id: params.containerId,
+        });
+        if (!(output instanceof response_1.JsonContent) || !isRecord(output.json)) {
+            throw this.unexpectedResponseError("wait_for_exit");
+        }
+        const exitCode = output.json["exit_code"];
+        if (typeof exitCode !== "number" || !Number.isInteger(exitCode)) {
+            throw this.unexpectedResponseError("wait_for_exit");
+        }
+        return exitCode;
+    }
+    async deleteContainer(params) {
+        await this.invoke("delete_container", {
+            container_id: params.containerId,
+        });
+    }
+    logs(params) {
+        const requestId = (0, uuid_1.v4)();
+        const closeInput = new completer_1.Completer();
+        const streamController = new stream_controller_1.StreamController();
+        const result = new completer_1.Completer();
+        let inputClosed = false;
+        const closeInputStream = () => {
+            if (inputClosed) {
+                return;
+            }
+            inputClosed = true;
+            if (!closeInput.completed) {
+                closeInput.complete();
+            }
+        };
+        const inputStream = async function* () {
+            yield new response_1.BinaryContent({
+                data: new Uint8Array(0),
+                headers: {
+                    kind: "start",
+                    request_id: requestId,
+                    container_id: params.containerId,
+                    follow: params.follow ?? false,
+                },
+            });
+            await closeInput.fut;
+        };
+        this.room
+            .invokeStream({
+            toolkit: "containers",
+            tool: "logs",
+            input: inputStream(),
+        })
+            .then(async (stream) => {
+            const decoder = new TextDecoder();
+            for await (const chunk of stream) {
+                if (chunk instanceof response_1.ErrorContent) {
+                    throw new room_server_client_1.RoomServerException(chunk.text, chunk.code);
+                }
+                if (chunk instanceof response_1.ControlContent) {
+                    continue;
+                }
+                if (!(chunk instanceof response_1.BinaryContent)) {
+                    throw this.unexpectedResponseError("logs");
+                }
+                const channel = chunk.headers["channel"];
+                if (typeof channel !== "number") {
+                    throw new room_server_client_1.RoomServerException("containers.logs returned a chunk without a valid channel");
+                }
+                if (channel !== 1) {
+                    continue;
+                }
+                streamController.add(decoder.decode(chunk.data));
+            }
+            closeInputStream();
+            streamController.close();
+            result.complete();
+        })
+            .catch((error) => {
+            closeInputStream();
+            streamController.close();
+            if (!result.completed) {
+                result.completeError(error);
+            }
+        });
+        const outputStream = {
+            [Symbol.asyncIterator]() {
+                const it = streamController.stream[Symbol.asyncIterator]();
+                return {
+                    async next() {
+                        return await it.next();
+                    },
+                    async return(value) {
+                        closeInputStream();
+                        return await it.return?.(value) ?? { done: true, value };
+                    },
+                    async throw(e) {
+                        closeInputStream();
+                        if (it.throw) {
+                            return await it.throw(e);
+                        }
+                        throw e;
+                    },
+                };
+            },
+        };
+        return {
+            stream: outputStream,
+            result: result.fut,
+            cancel: async () => {
+                closeInputStream();
+                await result.fut.catch(() => undefined);
+            },
+        };
+    }
+    async list(params) {
+        const output = await this.invoke("list_containers", {
+            all: params?.all,
+        });
+        if (!(output instanceof response_1.JsonContent) || !isRecord(output.json)) {
+            throw this.unexpectedResponseError("list");
+        }
+        const containersRaw = output.json["containers"];
+        if (!Array.isArray(containersRaw)) {
+            throw this.unexpectedResponseError("list");
+        }
+        const items = [];
+        for (const entry of containersRaw) {
+            if (!isRecord(entry)) {
+                throw this.unexpectedResponseError("list");
+            }
+            const startedByRaw = entry["started_by"];
+            if (!isRecord(startedByRaw)) {
+                throw this.unexpectedResponseError("list");
+            }
+            const id = entry["id"];
+            const image = entry["image"];
+            const state = entry["state"];
+            const privateFlag = entry["private"];
+            const startedById = startedByRaw["id"];
+            const startedByName = startedByRaw["name"];
+            if (typeof id !== "string" ||
+                typeof image !== "string" ||
+                typeof state !== "string" ||
+                typeof privateFlag !== "boolean" ||
+                typeof startedById !== "string" ||
+                typeof startedByName !== "string") {
+                throw this.unexpectedResponseError("list");
+            }
+            const nameRaw = entry["name"];
+            const serviceIdRaw = entry["service_id"];
+            items.push({
+                id,
+                image,
+                name: typeof nameRaw === "string" ? nameRaw : undefined,
+                startedBy: {
+                    id: startedById,
+                    name: startedByName,
+                },
+                state,
+                private: privateFlag,
+                serviceId: typeof serviceIdRaw === "string" ? serviceIdRaw : undefined,
+            });
+        }
+        return items;
+    }
+}
+exports.ContainersClient = ContainersClient;