@meshagent/meshagent 0.47.0 → 0.48.0

package/CHANGELOG.md

@@ -1,3 +1,15 @@
+## [0.48.0]
+- Reworked the TS/JS agent chat stack to preserve ordered threaded messages and support injected-message threads across chat clients and process handling.
+- Added chat feed widgets and virtual scrolling to the React/Tailwind UI, improving large-thread performance.
+- Aligned `meshagent-agents-ts` with the Dart agents implementation and refreshed the shared chat/message contracts.
+- Removed the LiveKit dependency from the React package and updated shared package dependencies for the new chat stack.
+
+## [0.47.1]
+- Changed room mount discovery to return typed room/container consumers without exposing internal source paths, and added typed container mount specs to listed containers.
+- Added duplex messaging stream subscriptions and replay-state alignment in the TypeScript chat clients, bringing the NodeJS SDK in line with the new streaming model.
+- Reworked messaging and room client flow control so dispatch ordering, close behavior, and presence updates stay consistent under streaming loads.
+- Expanded stream and presence test coverage for the new messaging behavior.
+
 ## [0.47.0]
 - Improved TypeScript messaging clients so room delivery order and startup/presence behavior stay consistent.
 - Moved managed-agent client routing onto the Rust tunnel path and hardened agent chat-client event handling.

package/dist/browser/agent.js

@@ -530,10 +530,10 @@ class _RemoteToolkitWrapper {
             return false;
         }
     }
-    async _sendToolCallResponseChunk(messageId, toolCallId, chunk) {
+    _sendToolCallResponseChunk(messageId, toolCallId, chunk) {
         const [header, payload] = (0, utils_js_1.unpackMessage)(chunk.pack());
         try {
-            await this.client.protocol.send("room.tool_call_response_chunk", (0, utils_js_1.packMessage)({ tool_call_id: toolCallId, chunk: header }, payload.length > 0 ? payload : undefined), { id: messageId });
+            this.client.protocol.sendNowait("room.tool_call_response_chunk", (0, utils_js_1.packMessage)({ tool_call_id: toolCallId, chunk: header }, payload.length > 0 ? payload : undefined), { id: messageId });
             return true;
         }
         catch (error) {
@@ -634,10 +634,10 @@ class _RemoteToolkitWrapper {
                     return;
                 for await (const chunk of output.stream) {
                     this.toolkit.validateOutputContent(tool, chunk);
-                    if (!await this._sendToolCallResponseChunk(messageId, toolCallId, chunk))
+                    if (!this._sendToolCallResponseChunk(messageId, toolCallId, chunk))
                         return;
                 }
-                await this._sendToolCallResponseChunk(messageId, toolCallId, new response_js_1.ControlContent({ method: "close" }));
+                this._sendToolCallResponseChunk(messageId, toolCallId, new response_js_1.ControlContent({ method: "close" }));
                 return;
             }
             throw new Error(`tool ${toolName} returned unsupported output`);
@@ -648,9 +648,9 @@ class _RemoteToolkitWrapper {
                 return;
             }
             if (!(error instanceof InvalidToolDataException)) {
-                await this._sendToolCallResponseChunk(messageId, toolCallId, new response_js_1.ErrorContent({ text: String(error) }));
+                this._sendToolCallResponseChunk(messageId, toolCallId, new response_js_1.ErrorContent({ text: String(error) }));
             }
-            await this._sendToolCallResponseChunk(messageId, toolCallId, new response_js_1.ControlContent({
+            this._sendToolCallResponseChunk(messageId, toolCallId, new response_js_1.ControlContent({
                 method: "close",
                 statusCode: error instanceof InvalidToolDataException ? response_js_1.ControlCloseStatus.INVALID_DATA : undefined,
                 message: error instanceof InvalidToolDataException ? error.message : undefined,

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

@@ -72,6 +72,7 @@ export interface RoomContainer {
     state: string;
     private: boolean;
     serviceId?: string;
+    mounts?: ContainerMountSpec;
     stats?: RoomContainerStats;
     exitStatus?: ContainerExitStatus;
 }

package/dist/browser/containers-client.js

@@ -9,6 +9,38 @@ const stream_controller_js_1 = require("./stream-controller.js");
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function parseContainerMountSpec(value) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    if (!isRecord(value)) {
+        throw new room_server_client_js_1.RoomServerException("unexpected return type from containers.list");
+    }
+    const readMounts = (field, validate) => {
+        const raw = value[field];
+        if (raw === undefined || raw === null) {
+            return undefined;
+        }
+        if (!Array.isArray(raw) || !raw.every((mount) => isRecord(mount) && validate(mount))) {
+            throw new room_server_client_js_1.RoomServerException("unexpected return type from containers.list");
+        }
+        return raw;
+    };
+    const optionalMountFieldsAreValid = (mount) => (mount["subpath"] === undefined || mount["subpath"] === null || typeof mount["subpath"] === "string")
+        && (mount["read_only"] === undefined || typeof mount["read_only"] === "boolean");
+    return {
+        room: readMounts("room", (mount) => typeof mount["path"] === "string" && optionalMountFieldsAreValid(mount)),
+        volumes: readMounts("volumes", (mount) => typeof mount["name"] === "string"
+            && typeof mount["path"] === "string"
+            && optionalMountFieldsAreValid(mount)),
+        empty_dirs: readMounts("empty_dirs", (mount) => typeof mount["path"] === "string"
+            && (mount["read_only"] === undefined || typeof mount["read_only"] === "boolean")),
+        configs: readMounts("configs", (mount) => mount["path"] === undefined || mount["path"] === null || typeof mount["path"] === "string"),
+        files: readMounts("files", (mount) => typeof mount["path"] === "string"
+            && (mount["read_only"] === undefined || typeof mount["read_only"] === "boolean")
+            && (mount["text"] === undefined || mount["text"] === null || typeof mount["text"] === "string")),
+    };
+}
 function toStringMapList(values) {
     return Object.entries(values).map(([key, value]) => ({ key, value }));
 }
@@ -904,6 +936,7 @@ class ContainersClient {
             const imageIdRaw = entry["image_id"];
             const portsRaw = entry["ports"];
             const serviceIdRaw = entry["service_id"];
+            const mountsRaw = entry["mounts"];
             const statsRaw = entry["stats"];
             const exitStatusRaw = entry["exit_status"];
             if (!Array.isArray(portsRaw) ||
@@ -964,6 +997,7 @@ class ContainersClient {
                 state,
                 private: privateFlag,
                 serviceId: typeof serviceIdRaw === "string" ? serviceIdRaw : undefined,
+                mounts: parseContainerMountSpec(mountsRaw),
                 stats,
                 exitStatus,
             });

package/dist/browser/entrypoint.d.ts

@@ -16,6 +16,7 @@ export var ServerXmlDocument: {
             ignoreRemoteMapChanges: UndoManagerOptions;
             captureTimeout: UndoManagerOptions;
             afterTransactionHandler: (transaction: any) => void;
+            destroy(): void;
             addToScope(ytypes: Array<any | {
                 gc: DocOpts;
                 gcFilter: DocOpts;

package/dist/browser/entrypoint.js

@@ -3994,10 +3994,9 @@ var UndoManager = class extends ObservableV2 {
         this.emit("stack-item-updated", changeEvent);
       }
     };
+    this.destroy = this.destroy.bind(this);
     this.doc.on("afterTransaction", this.afterTransactionHandler);
-    this.doc.on("destroy", () => {
-      this.destroy();
-    });
+    this.doc.on("destroy", this.destroy);
   }
   /**
    * Extend the scope.
@@ -4114,6 +4113,7 @@ var UndoManager = class extends ObservableV2 {
   destroy() {
     this.trackedOrigins.delete(this);
     this.doc.off("afterTransaction", this.afterTransactionHandler);
+    this.doc.off("destroy", this.destroy);
     super.destroy();
   }
 };

package/dist/browser/index.d.ts

@@ -10,6 +10,7 @@ export * from './document.js';
 export * from './meshagent-client.js';
 export * from './messaging-client.js';
 export * from './memory-client.js';
+export * from './mounts-client.js';
 export * from './oauth-scopes.js';
 export * from './participant-token.js';
 export * from './participant.js';

package/dist/browser/index.js

@@ -26,6 +26,7 @@ __exportStar(require("./document.js"), exports);
 __exportStar(require("./meshagent-client.js"), exports);
 __exportStar(require("./messaging-client.js"), exports);
 __exportStar(require("./memory-client.js"), exports);
+__exportStar(require("./mounts-client.js"), exports);
 __exportStar(require("./oauth-scopes.js"), exports);
 __exportStar(require("./participant-token.js"), exports);
 __exportStar(require("./participant.js"), exports);

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

@@ -1,9 +1,10 @@
 import { ApiScope } from "./participant-token.js";
 export type ProjectRole = "member" | "admin" | "developer" | "room_creator" | "room_inventory" | "room_manager" | "session_inventory" | "agent_creator" | "agent_inventory" | "agent_manager" | "repository_creator" | "repository_inventory" | "repository_manager" | "feed_creator" | "feed_inventory" | "feed_manager" | "oauth_client_creator" | "oauth_client_inventory" | "oauth_client_manager" | "api_key_creator" | "api_key_inventory" | "api_key_manager" | "service_creator" | "service_inventory" | "service_manager" | "service_account_creator" | "service_account_inventory" | "service_account_manager" | "participant_token_creator" | "mailbox_creator" | "mailbox_inventory" | "mailbox_manager" | "route_creator" | "route_inventory" | "route_manager" | "scheduled_task_creator" | "scheduled_task_inventory" | "scheduled_task_manager" | "feed_subscription_creator" | "feed_subscription_inventory" | "feed_subscription_manager" | "llm_logger_creator" | "llm_logger_inventory" | "llm_logger_manager" | "llm_proxy_user" | "usage_reporter" | "billing_manager" | "group_manager";
 export type ResourceRole = "viewer" | "operator" | "developer" | "admin";
+export type RoomRole = "site_user" | ResourceRole;
 export type FeedRole = "reader" | "subscriber" | "publisher" | "manager";
 export type SecretRole = "use_proxy";
-export type AccessRole = ProjectRole | ResourceRole | FeedRole | SecretRole | "list";
+export type AccessRole = ProjectRole | RoomRole | FeedRole | SecretRole | "list";
 export type AccessSubjectType = "user" | "group" | "agent" | "service_account" | "userset";
 export type AccessResourceType = "project" | "room" | "agent" | "group" | "repository" | "feed" | "secret";
 export interface AccessSubject {
@@ -234,6 +235,12 @@ export interface RoomStorageMountSpec {
     subpath?: string | null;
     read_only?: boolean;
 }
+export interface VolumeStorageMountSpec {
+    name: string;
+    path: string;
+    subpath?: string | null;
+    read_only?: boolean;
+}
 export interface EmptyDirMountSpec {
     path: string;
     read_only?: boolean;
@@ -248,6 +255,7 @@ export interface FileMountSpec {
 }
 export interface ContainerMountSpec {
     room?: RoomStorageMountSpec[];
+    volumes?: VolumeStorageMountSpec[];
     empty_dirs?: EmptyDirMountSpec[];
     configs?: ConfigMountSpec[];
     files?: FileMountSpec[];

package/dist/browser/meshagent-client.js

@@ -659,6 +659,7 @@ class Meshagent {
         const parsedSubject = this.parseAccessSubject(data.subject);
         const parsedDirectRoles = Array.isArray(data.direct_roles)
             ? data.direct_roles.filter((item) => item === "member" ||
+                item === "site_user" ||
                 item === "viewer" ||
                 item === "operator" ||
                 item === "developer" ||

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

@@ -1,8 +1,72 @@
 import { EventEmitter } from "./event-emitter.js";
 import { Participant, RemoteParticipant } from "./participant.js";
+import { Content } from "./response.js";
 import { RoomClient } from "./room-client.js";
-import { RoomMessageEvent } from "./room-event.js";
+import { RoomMessage, RoomMessageEvent } from "./room-event.js";
 type MessagePayload = Record<string, unknown>;
+export type MessagingStreamEvent = {
+    kind: "message";
+    message: RoomMessage;
+} | {
+    kind: "client_disconnected";
+    streamId: string;
+    participantId: string;
+} | {
+    kind: "closed";
+    streamId: string;
+    reason: string;
+    message?: string;
+};
+declare class MessagingStreamInput {
+    private readonly items;
+    private signal;
+    private active;
+    private closed;
+    private error;
+    enqueue(content: Content, { wait }?: {
+        wait?: boolean;
+    }): Promise<void>;
+    close(error?: unknown): void;
+    fail(error: unknown): void;
+    stream(): AsyncIterable<Content>;
+}
+export declare class MessagingStream implements AsyncIterable<MessagingStreamEvent> {
+    readonly streamId: string;
+    readonly remoteParticipantId: string;
+    private readonly input;
+    private readonly output;
+    private readonly inputDone;
+    private readonly onClosed;
+    private readonly events;
+    private eventSignal;
+    private state;
+    constructor({ streamId, remoteParticipantId, input, output, inputClosed, onClosed, }: {
+        streamId: string;
+        remoteParticipantId: string;
+        input: MessagingStreamInput;
+        output: AsyncIterator<Content>;
+        inputClosed?: Promise<void>;
+        onClosed: () => void;
+    });
+    get closed(): boolean;
+    private push;
+    private finish;
+    private consumeOutput;
+    private content;
+    sendMessageNowait(params: {
+        type: string;
+        message: MessagePayload;
+        attachment?: Uint8Array;
+    }): void;
+    sendMessage(params: {
+        type: string;
+        message: MessagePayload;
+        attachment?: Uint8Array;
+    }): Promise<void>;
+    close(): Promise<void>;
+    clientDisconnected(participantId: string): void;
+    [Symbol.asyncIterator](): AsyncIterator<MessagingStreamEvent>;
+}
 export declare class MessagingClient extends EventEmitter<RoomMessageEvent> {
     private readonly client;
     private readonly _messageHandler;
@@ -11,6 +75,7 @@ export declare class MessagingClient extends EventEmitter<RoomMessageEvent> {
     private _messageQueued;
     private _sendTask;
     private readonly _sendOperations;
+    private readonly _streams;
     private _messageQueueClosed;
     private _desiredEnabled;
     private _online;
@@ -64,6 +129,12 @@ export declare class MessagingClient extends EventEmitter<RoomMessageEvent> {
         message: MessagePayload;
         attachment?: Uint8Array;
     }): Promise<void>;
+    stream({ to, type, message, attachment, }: {
+        to: Participant;
+        type: string;
+        message: MessagePayload;
+        attachment?: Uint8Array;
+    }): Promise<MessagingStream>;
     getParticipants(): RemoteParticipant[];
     getParticipant(id: string): RemoteParticipant | null;
     getParticipantByName(name: string): RemoteParticipant | null;

package/dist/browser/messaging-client.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MessagingClient = void 0;
+exports.MessagingClient = exports.MessagingStream = void 0;
 const completer_js_1 = require("./completer.js");
 const event_emitter_js_1 = require("./event-emitter.js");
 const participant_js_1 = require("./participant.js");
@@ -22,6 +22,256 @@ function bytesToBase64(bytes) {
     }
     return globalScope.btoa(binary);
 }
+function base64ToBytes(value) {
+    if (globalScope.Buffer != null) {
+        return new Uint8Array(globalScope.Buffer.from(value, "base64"));
+    }
+    const atob = globalThis.atob;
+    if (atob == null) {
+        throw new Error("base64 decoding is not available in this runtime");
+    }
+    const binary = atob(value);
+    return Uint8Array.from(binary, (character) => character.charCodeAt(0));
+}
+class MessagingStreamInput {
+    constructor() {
+        this.items = [];
+        this.signal = null;
+        this.active = null;
+        this.closed = false;
+        this.error = null;
+    }
+    enqueue(content, { wait = false } = {}) {
+        if (this.closed) {
+            return Promise.reject(this.error ?? new room_server_client_js_1.RoomServerException("the messaging stream is closed"));
+        }
+        const sent = wait ? new completer_js_1.Completer() : undefined;
+        this.items.push({ content, sent });
+        this.signal?.resolve();
+        this.signal = null;
+        return sent?.fut ?? Promise.resolve();
+    }
+    close(error = new room_server_client_js_1.RoomServerException("the messaging stream is closed")) {
+        if (this.closed) {
+            return;
+        }
+        this.closed = true;
+        this.error = error;
+        this.active?.sent?.reject(error);
+        this.active = null;
+        for (const item of this.items.splice(0)) {
+            item.sent?.reject(error);
+        }
+        this.signal?.resolve();
+        this.signal = null;
+    }
+    fail(error) {
+        this.close(error);
+    }
+    async *stream() {
+        try {
+            while (true) {
+                while (this.items.length === 0 && !this.closed) {
+                    this.signal ?? (this.signal = new completer_js_1.Completer());
+                    await this.signal.fut;
+                }
+                const item = this.items.shift();
+                if (item == null) {
+                    return;
+                }
+                this.active = item;
+                yield item.content;
+                item.sent?.resolve();
+                this.active = null;
+            }
+        }
+        finally {
+            if (this.active != null && this.closed) {
+                this.active.sent?.reject(this.error ?? new room_server_client_js_1.RoomServerException("the messaging stream is closed"));
+                this.active = null;
+            }
+        }
+    }
+}
+class MessagingStream {
+    constructor({ streamId, remoteParticipantId, input, output, inputClosed, onClosed, }) {
+        this.events = [];
+        this.eventSignal = null;
+        this.state = "accepted";
+        this.streamId = streamId;
+        this.remoteParticipantId = remoteParticipantId;
+        this.input = input;
+        this.output = output;
+        this.inputDone = Promise.resolve(inputClosed).catch((error) => {
+            this.input.fail(error);
+            this.push({
+                kind: "closed",
+                streamId: this.streamId,
+                reason: "error",
+                message: error instanceof Error ? error.message : String(error),
+            });
+            void this.output.return?.();
+            this.finish();
+        });
+        this.onClosed = onClosed;
+        void this.consumeOutput();
+    }
+    get closed() {
+        return this.state === "terminal";
+    }
+    push(event) {
+        if (this.state !== "accepted") {
+            return;
+        }
+        this.events.push(event);
+        this.eventSignal?.resolve();
+        this.eventSignal = null;
+    }
+    finish() {
+        if (this.state === "terminal") {
+            return;
+        }
+        this.state = "terminal";
+        this.input.close();
+        this.eventSignal?.resolve();
+        this.eventSignal = null;
+        void this.inputDone.finally(this.onClosed);
+    }
+    async consumeOutput() {
+        try {
+            while (true) {
+                const next = await this.output.next();
+                if (next.done) {
+                    return;
+                }
+                if (next.value instanceof response_js_1.ControlContent && next.value.method === "close") {
+                    this.push({
+                        kind: "client_disconnected",
+                        streamId: this.streamId,
+                        participantId: this.remoteParticipantId,
+                    });
+                    return;
+                }
+                if (!(next.value instanceof response_js_1.JsonContent)) {
+                    throw new room_server_client_js_1.RoomServerException("unexpected chunk from messaging.stream");
+                }
+                const value = next.value.json;
+                const kind = value["kind"];
+                if (kind === "message") {
+                    const type = value["type"];
+                    const message = value["message"];
+                    if (typeof type !== "string" || typeof message !== "object" || message == null || Array.isArray(message)) {
+                        throw new room_server_client_js_1.RoomServerException("invalid message chunk from messaging.stream");
+                    }
+                    const encodedAttachment = value["attachment_base64"];
+                    this.push({
+                        kind: "message",
+                        message: new room_event_js_1.RoomMessage({
+                            fromParticipantId: this.remoteParticipantId,
+                            type,
+                            message: message,
+                            attachment: typeof encodedAttachment === "string" && encodedAttachment !== ""
+                                ? base64ToBytes(encodedAttachment)
+                                : undefined,
+                        }),
+                    });
+                }
+                else if (kind === "client_disconnected" && typeof value["participant_id"] === "string") {
+                    this.push({
+                        kind,
+                        streamId: this.streamId,
+                        participantId: value["participant_id"],
+                    });
+                    return;
+                }
+                else if (kind === "closed") {
+                    this.push({
+                        kind,
+                        streamId: this.streamId,
+                        reason: typeof value["reason"] === "string" ? value["reason"] : "closed",
+                        message: typeof value["message"] === "string" ? value["message"] : undefined,
+                    });
+                    return;
+                }
+                else {
+                    throw new room_server_client_js_1.RoomServerException("unexpected chunk from messaging.stream");
+                }
+            }
+        }
+        catch (error) {
+            this.input.fail(error);
+            this.push({
+                kind: "closed",
+                streamId: this.streamId,
+                reason: "error",
+                message: error instanceof Error ? error.message : String(error),
+            });
+        }
+        finally {
+            this.finish();
+        }
+    }
+    content({ type, message, attachment, }) {
+        return new response_js_1.JsonContent({
+            json: {
+                type,
+                message_json: JSON.stringify(message),
+                ...(attachment == null ? {} : { attachment_base64: bytesToBase64(attachment) }),
+            },
+        });
+    }
+    sendMessageNowait(params) {
+        if (this.state !== "accepted") {
+            throw new room_server_client_js_1.RoomServerException("the messaging stream is closed");
+        }
+        void this.input.enqueue(this.content(params));
+    }
+    async sendMessage(params) {
+        if (this.state !== "accepted") {
+            throw new room_server_client_js_1.RoomServerException("the messaging stream is closed");
+        }
+        await this.input.enqueue(this.content(params), { wait: true });
+    }
+    async close() {
+        if (this.state === "terminal") {
+            await this.inputDone;
+            return;
+        }
+        this.input.close();
+        try {
+            await this.inputDone;
+        }
+        finally {
+            await this.output.return?.();
+            this.finish();
+        }
+    }
+    clientDisconnected(participantId) {
+        if (this.state === "terminal") {
+            return;
+        }
+        this.push({
+            kind: "client_disconnected",
+            streamId: this.streamId,
+            participantId,
+        });
+        this.finish();
+    }
+    async *[Symbol.asyncIterator]() {
+        while (true) {
+            while (this.events.length === 0 && this.state !== "terminal") {
+                this.eventSignal ?? (this.eventSignal = new completer_js_1.Completer());
+                await this.eventSignal.fut;
+            }
+            const event = this.events.shift();
+            if (event == null) {
+                return;
+            }
+            yield event;
+        }
+    }
+}
+exports.MessagingStream = MessagingStream;
 class MessagingClient extends event_emitter_js_1.EventEmitter {
     constructor({ room }) {
         super();
@@ -31,6 +281,7 @@ class MessagingClient extends event_emitter_js_1.EventEmitter {
         this._messageQueued = null;
         this._sendTask = null;
         this._sendOperations = new Set();
+        this._streams = new Set();
         this._messageQueueClosed = false;
         this._desiredEnabled = false;
         this._online = false;
@@ -96,6 +347,7 @@ class MessagingClient extends event_emitter_js_1.EventEmitter {
             await sendTask;
         }
         await Promise.all(this._sendOperations);
+        await Promise.all([...this._streams].map(async (stream) => stream.close()));
         this._desiredEnabled = false;
         this._clearCurrentConnectionState();
     }
@@ -159,6 +411,9 @@ class MessagingClient extends event_emitter_js_1.EventEmitter {
         }
     }
     _onRoomDisconnect({ reason: _reason }) {
+        for (const stream of [...this._streams]) {
+            stream.clientDisconnected(this.client.localParticipant?.id ?? stream.remoteParticipantId);
+        }
         this._clearCurrentConnectionState();
     }
     _onRoomReconnect() {
@@ -351,6 +606,49 @@ class MessagingClient extends event_emitter_js_1.EventEmitter {
             throw error;
         }
     }
+    async stream({ to, type, message, attachment, }) {
+        const input = new MessagingStreamInput();
+        void input.enqueue(new response_js_1.JsonContent({
+            json: {
+                to_participant_id: to.id,
+                type,
+                message_json: JSON.stringify(message),
+                ...(attachment == null ? {} : { attachment_base64: bytesToBase64(attachment) }),
+            },
+        }));
+        const outputResult = await this.client.invokeToolCall({
+            toolkit: "messaging",
+            tool: "stream",
+            input: input.stream(),
+            streamInput: true,
+        });
+        if (outputResult.kind !== "stream") {
+            input.close();
+            throw new room_server_client_js_1.RoomServerException("unexpected return type from messaging.stream");
+        }
+        const outputIterable = outputResult.stream;
+        const output = outputIterable[Symbol.asyncIterator]();
+        const accepted = await output.next();
+        if (accepted.done
+            || !(accepted.value instanceof response_js_1.JsonContent)
+            || accepted.value.json["kind"] !== "accepted"
+            || typeof accepted.value.json["stream_id"] !== "string") {
+            input.close();
+            await output.return?.();
+            throw new room_server_client_js_1.RoomServerException("messaging.stream did not acknowledge acceptance");
+        }
+        let stream;
+        stream = new MessagingStream({
+            streamId: accepted.value.json["stream_id"],
+            remoteParticipantId: to.id,
+            input,
+            output,
+            inputClosed: outputResult.inputClosed,
+            onClosed: () => this._streams.delete(stream),
+        });
+        this._streams.add(stream);
+        return stream;
+    }
     getParticipants() {
         return this.remoteParticipants;
     }
@@ -444,6 +742,9 @@ class MessagingClient extends event_emitter_js_1.EventEmitter {
         this._wakeMessageQueue();
         this._drainQueuedMessages({ error });
         this._desiredEnabled = false;
+        for (const stream of [...this._streams]) {
+            stream.clientDisconnected(this.client.localParticipant?.id ?? stream.remoteParticipantId);
+        }
         this._clearCurrentConnectionState();
         this.client.protocol.removeHandler("messaging.send", this._messageHandler);
         super.dispose();

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

@@ -0,0 +1,21 @@
+import type { RoomClient } from "./room-client.js";
+export interface MountedVolumeConsumer {
+    kind: "room" | "container";
+    containerId?: string;
+}
+export interface MountedVolume {
+    id: string;
+    name: string;
+    required: boolean;
+    description: string;
+    metadata: Record<string, unknown>;
+    annotations: Record<string, string>;
+    storageClass: "standard" | "juice" | "zerofs";
+    maxSizeMb?: number;
+    consumers: MountedVolumeConsumer[];
+}
+export declare class MountsClient {
+    private readonly room;
+    constructor(room: RoomClient);
+    list(): Promise<MountedVolume[]>;
+}