@meshagent/meshagent 0.42.0 → 0.43.0

package/dist/esm/agent.js

@@ -1,71 +1,58 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RemoteTaskRunner = exports.HostedToolkit = exports.Toolkit = exports.Tool = exports.ContentTool = exports.FunctionTool = exports.BaseTool = exports.ToolStreamOutput = exports.ToolContentOutput = exports.ToolCallOutput = exports.ToolStreamInput = exports.ToolContentInput = exports.ToolInput = exports.RoomToolContext = exports.ToolContext = exports.InvalidToolDataException = void 0;
-exports.startHostedToolkit = startHostedToolkit;
-const response_1 = require("./response");
-const room_server_client_1 = require("./room-server-client");
-const tool_content_type_1 = require("./tool-content-type");
-const utils_1 = require("./utils");
-const room_event_1 = require("./room-event");
-const participant_1 = require("./participant");
-const stream_controller_1 = require("./stream-controller");
-class InvalidToolDataException extends room_server_client_1.RoomServerException {
+import { BinaryContent, ControlCloseStatus, ControlContent, EmptyContent, ErrorContent, FileContent, JsonContent, LinkContent, TextContent, unpackContent, } from "./response.js";
+import { RoomServerException } from "./room-server-client.js";
+import { ToolContentSpec } from "./tool-content-type.js";
+import { packMessage, unpackMessage } from "./utils.js";
+import { RoomStatusEvent } from "./room-event.js";
+import { RemoteParticipant } from "./participant.js";
+import { StreamController } from "./stream-controller.js";
+export class InvalidToolDataException extends RoomServerException {
     constructor(message) {
         super(message);
         this.name = "InvalidToolDataException";
     }
 }
-exports.InvalidToolDataException = InvalidToolDataException;
-class ToolContext {
+export class ToolContext {
     constructor({ caller, onBehalfOf } = {}) {
         this.caller = caller;
         this.onBehalfOf = onBehalfOf;
     }
 }
-exports.ToolContext = ToolContext;
-class RoomToolContext extends ToolContext {
+export class RoomToolContext extends ToolContext {
     constructor({ room, caller, onBehalfOf }) {
         super({ caller, onBehalfOf });
         this.room = room;
     }
 }
-exports.RoomToolContext = RoomToolContext;
-class ToolInput {
+export class ToolInput {
 }
-exports.ToolInput = ToolInput;
-class ToolContentInput extends ToolInput {
+export class ToolContentInput extends ToolInput {
     constructor(content) {
         super();
         this.content = content;
     }
 }
-exports.ToolContentInput = ToolContentInput;
-class ToolStreamInput extends ToolInput {
+export class ToolStreamInput extends ToolInput {
     constructor(stream) {
         super();
         this.stream = stream;
     }
 }
-exports.ToolStreamInput = ToolStreamInput;
-class ToolCallOutput {
+export class ToolCallOutput {
 }
-exports.ToolCallOutput = ToolCallOutput;
-class ToolContentOutput extends ToolCallOutput {
+export class ToolContentOutput extends ToolCallOutput {
     constructor(content) {
         super();
         this.content = content;
     }
 }
-exports.ToolContentOutput = ToolContentOutput;
-class ToolStreamOutput extends ToolCallOutput {
+export class ToolStreamOutput extends ToolCallOutput {
     constructor(stream, { inputClosed } = {}) {
         super();
         this.stream = stream;
         this.inputClosed = inputClosed;
     }
 }
-exports.ToolStreamOutput = ToolStreamOutput;
-class BaseTool {
+export class BaseTool {
     constructor({ name, description, title, inputSchema, inputSpec, outputSpec, outputSchema, defs }) {
         this.name = name;
         this.description = description;
@@ -77,23 +64,20 @@ class BaseTool {
         this.defs = defs;
     }
 }
-exports.BaseTool = BaseTool;
-class FunctionTool extends BaseTool {
+export class FunctionTool extends BaseTool {
     async *executeStream(context, arguments_) {
         yield await this.execute(context, arguments_);
     }
 }
-exports.FunctionTool = FunctionTool;
-class ContentTool extends BaseTool {
+export class ContentTool extends BaseTool {
 }
-exports.ContentTool = ContentTool;
-class Tool extends BaseTool {
+export class Tool extends BaseTool {
     constructor(params) {
         const inputSpec = params.inputSpec !== undefined && params.inputSchema !== undefined
-            ? new tool_content_type_1.ToolContentSpec({ types: [...params.inputSpec.types], stream: params.inputSpec.stream, schema: params.inputSchema })
+            ? new ToolContentSpec({ types: [...params.inputSpec.types], stream: params.inputSpec.stream, schema: params.inputSchema })
             : params.inputSpec;
         const outputSpec = params.outputSpec !== undefined && params.outputSchema !== undefined
-            ? new tool_content_type_1.ToolContentSpec({ types: [...params.outputSpec.types], stream: params.outputSpec.stream, schema: params.outputSchema })
+            ? new ToolContentSpec({ types: [...params.outputSpec.types], stream: params.outputSpec.stream, schema: params.outputSchema })
             : params.outputSpec;
         super({
             name: params.name,
@@ -101,53 +85,52 @@ class Tool extends BaseTool {
             title: params.title,
             inputSchema: params.inputSchema,
             inputSpec: inputSpec ?? (params.inputSchema !== undefined
-                ? new tool_content_type_1.ToolContentSpec({ types: ["json"], stream: false, schema: params.inputSchema })
+                ? new ToolContentSpec({ types: ["json"], stream: false, schema: params.inputSchema })
                 : undefined),
             outputSpec: outputSpec ?? (params.outputSchema !== undefined
-                ? new tool_content_type_1.ToolContentSpec({ types: ["json"], stream: false, schema: params.outputSchema })
+                ? new ToolContentSpec({ types: ["json"], stream: false, schema: params.outputSchema })
                 : undefined),
             outputSchema: params.outputSchema,
             defs: params.defs,
         });
     }
 }
-exports.Tool = Tool;
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function contentType(content) {
-    if (content instanceof response_1.BinaryContent)
+    if (content instanceof BinaryContent)
         return "binary";
-    if (content instanceof response_1.JsonContent)
+    if (content instanceof JsonContent)
         return "json";
-    if (content instanceof response_1.TextContent)
+    if (content instanceof TextContent)
         return "text";
-    if (content instanceof response_1.FileContent)
+    if (content instanceof FileContent)
         return "file";
-    if (content instanceof response_1.LinkContent)
+    if (content instanceof LinkContent)
         return "link";
-    if (content instanceof response_1.EmptyContent)
+    if (content instanceof EmptyContent)
         return "empty";
     return undefined;
 }
 function schemaValue(content) {
-    if (content instanceof response_1.BinaryContent)
+    if (content instanceof BinaryContent)
         return content.headers;
-    if (content instanceof response_1.JsonContent)
+    if (content instanceof JsonContent)
         return content.json;
-    if (content instanceof response_1.TextContent)
+    if (content instanceof TextContent)
         return content.text;
-    if (content instanceof response_1.EmptyContent)
+    if (content instanceof EmptyContent)
         return null;
-    if (content instanceof response_1.LinkContent)
+    if (content instanceof LinkContent)
         return { name: content.name, url: content.url };
-    if (content instanceof response_1.FileContent)
+    if (content instanceof FileContent)
         return { name: content.name, mime_type: content.mimeType, size: content.data.length };
-    if (content instanceof response_1.ControlContent)
+    if (content instanceof ControlContent)
         return { method: content.method };
-    if (content instanceof response_1.ErrorContent)
+    if (content instanceof ErrorContent)
         return content.code === undefined ? { text: content.text } : { text: content.text, code: content.code };
-    const [header] = (0, utils_1.unpackMessage)(content.pack());
+    const [header] = unpackMessage(content.pack());
     return header;
 }
 function schemaWithDefs(schema, defs) {
@@ -237,7 +220,7 @@ function validateJsonSchemaValue(schema, value, root = schema) {
     }
     return undefined;
 }
-class Toolkit {
+export class Toolkit {
     constructor({ name, title = name, description = "", tools, rules = [], validationMode = "full" }) {
         this.name = name;
         this.title = title;
@@ -268,7 +251,7 @@ class Toolkit {
     }
     async execute(first, second, third) {
         if (typeof first === "string") {
-            const output = await this.executeTool(new ToolContext(), first, new ToolContentInput(new response_1.JsonContent({ json: second })));
+            const output = await this.executeTool(new ToolContext(), first, new ToolContentInput(new JsonContent({ json: second })));
             if (output instanceof ToolContentOutput) {
                 return output.content;
             }
@@ -297,9 +280,9 @@ class Toolkit {
         throw new Error(`tool ${name} has unsupported type`);
     }
     decodeFunctionToolArguments(toolName, input) {
-        if (input instanceof response_1.EmptyContent)
+        if (input instanceof EmptyContent)
             return {};
-        if (input instanceof response_1.JsonContent) {
+        if (input instanceof JsonContent) {
             if (!isRecord(input.json)) {
                 throw new Error(`tool ${toolName} requires JSON object input`);
             }
@@ -318,18 +301,18 @@ class Toolkit {
             return tool.inputSpec;
         if (tool.inputSpec !== undefined)
             return tool.inputSpec;
-        return new tool_content_type_1.ToolContentSpec({ types: ["json"], stream: false, schema: tool.inputSchema ?? { type: "object", additionalProperties: true } });
+        return new ToolContentSpec({ types: ["json"], stream: false, schema: tool.inputSchema ?? { type: "object", additionalProperties: true } });
     }
     resolveOutputSpec(tool) {
         if (tool.outputSpec !== undefined) {
             if (tool.outputSchema !== undefined && tool.outputSpec.schema === undefined && tool.outputSpec.types.includes("json")) {
-                return new tool_content_type_1.ToolContentSpec({ types: [...tool.outputSpec.types], stream: tool.outputSpec.stream, schema: tool.outputSchema });
+                return new ToolContentSpec({ types: [...tool.outputSpec.types], stream: tool.outputSpec.stream, schema: tool.outputSchema });
             }
             return tool.outputSpec;
         }
         if (tool.outputSchema === undefined)
             return undefined;
-        return new tool_content_type_1.ToolContentSpec({ types: ["json"], stream: false, schema: tool.outputSchema });
+        return new ToolContentSpec({ types: ["json"], stream: false, schema: tool.outputSchema });
     }
     validateStreamMode({ tool, direction, spec, stream }) {
         if (!this.shouldValidateContentTypes || spec === undefined)
@@ -372,8 +355,7 @@ class Toolkit {
         this.validateSchema({ tool, direction: "output", content, schema: spec?.schema });
     }
 }
-exports.Toolkit = Toolkit;
-class HostedToolkit {
+export class HostedToolkit {
     constructor({ toolkit, stopHostedToolkit }) {
         this.toolkit = toolkit;
         this._stopHostedToolkit = stopHostedToolkit;
@@ -382,7 +364,6 @@ class HostedToolkit {
         await this._stopHostedToolkit();
     }
 }
-exports.HostedToolkit = HostedToolkit;
 class _RemoteToolkitWrapper {
     constructor({ toolkit, room }) {
         this._toolCallHandler = this._toolCall.bind(this);
@@ -399,7 +380,7 @@ class _RemoteToolkitWrapper {
     }
     async start({ public_: isPublic = false } = {}) {
         if (this._started) {
-            throw new room_server_client_1.RoomServerException(`toolkit ${this.toolkit.name} is already started`);
+            throw new RoomServerException(`toolkit ${this.toolkit.name} is already started`);
         }
         this._public = isPublic;
         this.client.protocol.addHandler(`room.tool_call.${this.toolkit.name}`, this._toolCallHandler);
@@ -425,7 +406,7 @@ class _RemoteToolkitWrapper {
         this._started = false;
         this.client.off("disconnected", this._roomEventHandler);
         this.client.off("reconnected", this._roomEventHandler);
-        this._failActiveRequestStreams(new room_server_client_1.RoomServerException("hosted toolkit stopped"));
+        this._failActiveRequestStreams(new RoomServerException("hosted toolkit stopped"));
         try {
             await this._unregister();
         }
@@ -484,13 +465,13 @@ class _RemoteToolkitWrapper {
         });
     }
     _onRoomEvent(event) {
-        if (!this._started || !(event instanceof room_event_1.RoomStatusEvent)) {
+        if (!this._started || !(event instanceof RoomStatusEvent)) {
             return;
         }
         if (event.status === "disconnected") {
             this._registrationId = undefined;
             const message = event.message?.trim();
-            this._failActiveRequestStreams(new room_server_client_1.RoomServerException(message == null || message.length === 0
+            this._failActiveRequestStreams(new RoomServerException(message == null || message.length === 0
                 ? "room connection lost before streamed tool call request completed"
                 : `room connection lost before streamed tool call request completed: ${message}`));
             return;
@@ -509,16 +490,16 @@ class _RemoteToolkitWrapper {
             if (remote.id === participantId)
                 return remote;
         }
-        return new participant_1.RemoteParticipant(this.client, participantId, "user");
+        return new RemoteParticipant(this.client, participantId, "user");
     }
     _contentFromToolCallArguments(rawArguments, payload) {
         if (!isRecord(rawArguments)) {
             throw new Error("arguments must be a content header object");
         }
         if (typeof rawArguments.type === "string") {
-            return (0, response_1.unpackContent)((0, utils_1.packMessage)(rawArguments, payload.length > 0 ? payload : undefined));
+            return unpackContent(packMessage(rawArguments, payload.length > 0 ? payload : undefined));
         }
-        return new response_1.JsonContent({ json: rawArguments });
+        return new JsonContent({ json: rawArguments });
     }
     async _sendToolCallResponse(messageId, chunk) {
         try {
@@ -531,9 +512,9 @@ class _RemoteToolkitWrapper {
         }
     }
     async _sendToolCallResponseChunk(messageId, toolCallId, chunk) {
-        const [header, payload] = (0, utils_1.unpackMessage)(chunk.pack());
+        const [header, payload] = unpackMessage(chunk.pack());
         try {
-            await this.client.protocol.send("room.tool_call_response_chunk", (0, utils_1.packMessage)({ tool_call_id: toolCallId, chunk: header }, payload.length > 0 ? payload : undefined), { id: messageId });
+            await this.client.protocol.send("room.tool_call_response_chunk", packMessage({ tool_call_id: toolCallId, chunk: header }, payload.length > 0 ? payload : undefined), { id: messageId });
             return true;
         }
         catch (error) {
@@ -553,7 +534,7 @@ class _RemoteToolkitWrapper {
         };
     }
     _enqueueRequestStreamChunk(stream, chunk, tool) {
-        if (chunk instanceof response_1.ControlContent) {
+        if (chunk instanceof ControlContent) {
             if (chunk.method === "open")
                 return;
             if (chunk.method === "close") {
@@ -582,7 +563,7 @@ class _RemoteToolkitWrapper {
         let toolCallId = toolCallIdFallback;
         let openedResponseStream = false;
         try {
-            const [message, payload] = (0, utils_1.unpackMessage)(data);
+            const [message, payload] = unpackMessage(data);
             const toolName = message["name"];
             if (typeof toolName !== "string" || toolName.length === 0) {
                 throw new Error("tool call requires a tool name");
@@ -591,19 +572,19 @@ class _RemoteToolkitWrapper {
                 ? message["tool_call_id"]
                 : toolCallIdFallback;
             const inputChunk = this._contentFromToolCallArguments(message["arguments"], payload);
-            const requestStream = inputChunk instanceof response_1.ControlContent && inputChunk.method === "open";
-            if (inputChunk instanceof response_1.ControlContent && !requestStream) {
-                await this._sendToolCallResponse(messageId, new response_1.ErrorContent({ text: "request stream must start with an open control chunk" }));
+            const requestStream = inputChunk instanceof ControlContent && inputChunk.method === "open";
+            if (inputChunk instanceof ControlContent && !requestStream) {
+                await this._sendToolCallResponse(messageId, new ErrorContent({ text: "request stream must start with an open control chunk" }));
                 return;
             }
             const tool = this.toolkit.getTool(toolName);
             this.toolkit.validateStreamMode({ tool, direction: "input", spec: this.toolkit.resolveInputSpec(tool), stream: requestStream });
             let resolvedInput;
             if (requestStream) {
-                const controller = new stream_controller_1.StreamController();
+                const controller = new StreamController();
                 this._requestStreams.set(toolCallId, controller);
                 this._requestStreamTools.set(toolCallId, tool);
-                this._enqueueRequestStreamChunk(controller, new response_1.ControlContent({ method: "open" }), tool);
+                this._enqueueRequestStreamChunk(controller, new ControlContent({ method: "open" }), tool);
                 const buffered = this._pendingRequestChunks.get(toolCallId) ?? [];
                 this._pendingRequestChunks.delete(toolCallId);
                 for (const chunk of buffered) {
@@ -630,29 +611,29 @@ class _RemoteToolkitWrapper {
             if (output instanceof ToolStreamOutput) {
                 this.toolkit.validateStreamMode({ tool, direction: "output", spec: this.toolkit.resolveOutputSpec(tool), stream: true });
                 openedResponseStream = true;
-                if (!await this._sendToolCallResponse(messageId, new response_1.ControlContent({ method: "open" })))
+                if (!await this._sendToolCallResponse(messageId, new ControlContent({ method: "open" })))
                     return;
                 for await (const chunk of output.stream) {
                     this.toolkit.validateOutputContent(tool, chunk);
                     if (!await this._sendToolCallResponseChunk(messageId, toolCallId, chunk))
                         return;
                 }
-                await this._sendToolCallResponseChunk(messageId, toolCallId, new response_1.ControlContent({ method: "close" }));
+                await this._sendToolCallResponseChunk(messageId, toolCallId, new ControlContent({ method: "close" }));
                 return;
             }
             throw new Error(`tool ${toolName} returned unsupported output`);
         }
         catch (error) {
             if (!openedResponseStream) {
-                await this._sendToolCallResponse(messageId, new response_1.ErrorContent({ text: String(error) }));
+                await this._sendToolCallResponse(messageId, new ErrorContent({ text: String(error) }));
                 return;
             }
             if (!(error instanceof InvalidToolDataException)) {
-                await this._sendToolCallResponseChunk(messageId, toolCallId, new response_1.ErrorContent({ text: String(error) }));
+                await this._sendToolCallResponseChunk(messageId, toolCallId, new ErrorContent({ text: String(error) }));
             }
-            await this._sendToolCallResponseChunk(messageId, toolCallId, new response_1.ControlContent({
+            await this._sendToolCallResponseChunk(messageId, toolCallId, new ControlContent({
                 method: "close",
-                statusCode: error instanceof InvalidToolDataException ? response_1.ControlCloseStatus.INVALID_DATA : undefined,
+                statusCode: error instanceof InvalidToolDataException ? ControlCloseStatus.INVALID_DATA : undefined,
                 message: error instanceof InvalidToolDataException ? error.message : undefined,
             }));
         }
@@ -665,14 +646,14 @@ class _RemoteToolkitWrapper {
             return;
         }
         try {
-            const [message, payload] = (0, utils_1.unpackMessage)(data);
+            const [message, payload] = unpackMessage(data);
             const toolCallId = message["tool_call_id"];
             if (typeof toolCallId !== "string" || toolCallId.length === 0)
                 return;
             const chunkHeader = message["chunk"];
             if (!isRecord(chunkHeader))
                 return;
-            const chunk = (0, response_1.unpackContent)((0, utils_1.packMessage)(chunkHeader, payload.length > 0 ? payload : undefined));
+            const chunk = unpackContent(packMessage(chunkHeader, payload.length > 0 ? payload : undefined));
             const stream = this._requestStreams.get(toolCallId);
             if (stream === undefined) {
                 const buffered = this._pendingRequestChunks.get(toolCallId) ?? [];
@@ -687,7 +668,7 @@ class _RemoteToolkitWrapper {
         }
     }
 }
-async function startHostedToolkit({ room, toolkit, public_: isPublic = false }) {
+export async function startHostedToolkit({ room, toolkit, public_: isPublic = false }) {
     const wrapper = new _RemoteToolkitWrapper({ toolkit, room });
     await wrapper.start({ public_: isPublic });
     return new HostedToolkit({
@@ -695,7 +676,7 @@ async function startHostedToolkit({ room, toolkit, public_: isPublic = false })
         stopHostedToolkit: () => wrapper.stop(),
     });
 }
-class RemoteTaskRunner {
+export class RemoteTaskRunner {
     constructor({ name, description, client, inputSchema, outputSchema, supportsTools = false, required = [], }) {
         this.client = client;
         this.name = name;
@@ -714,4 +695,3 @@ class RemoteTaskRunner {
         }
     }
 }
-exports.RemoteTaskRunner = RemoteTaskRunner;

package/dist/esm/api_keys.js

@@ -1,14 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.base36Encode = base36Encode;
-exports.base36Decode = base36Decode;
-exports.compressUuid = compressUuid;
-exports.decompressUuid = decompressUuid;
-exports.base64CompressUuid = base64CompressUuid;
-exports.base64DecompressUuid = base64DecompressUuid;
-exports.parseApiKey = parseApiKey;
-exports.encodeApiKey = encodeApiKey;
-const base_64_1 = require("base-64");
+import base64 from "base-64";
+const { encode: base64Encode, decode: base64Decode } = base64;
 const BASE36_ALPHABET = "0123456789abcdefghijklmnopqrstuvwxyz";
 const BASE36 = 36n;
 const UUID_HEX_REGEX = /^[0-9a-f]{32}$/;
@@ -24,7 +15,7 @@ function toBigInt(value) {
     }
     throw new TypeError("number must be an integer");
 }
-function base36Encode(value) {
+export function base36Encode(value) {
     const number = toBigInt(value);
     if (number < 0n) {
         throw new RangeError("number must be non-negative");
@@ -41,7 +32,7 @@ function base36Encode(value) {
     }
     return base36;
 }
-function base36Decode(numberStr) {
+export function base36Decode(numberStr) {
     const sanitized = numberStr.trim().toLowerCase();
     if (sanitized === "") {
         return 0n;
@@ -95,7 +86,7 @@ function bytesToBase64(bytes) {
     if (globalScope.btoa) {
         return globalScope.btoa(binary);
     }
-    return (0, base_64_1.encode)(binary);
+    return base64Encode(binary);
 }
 function base64ToBytes(base64) {
     if (globalScope.Buffer) {
@@ -107,7 +98,7 @@ function base64ToBytes(base64) {
         binary = globalScope.atob(base64);
     }
     else {
-        binary = (0, base_64_1.decode)(base64);
+        binary = base64Decode(base64);
     }
     const bytes = new Uint8Array(binary.length);
     for (let i = 0; i < binary.length; i += 1) {
@@ -115,17 +106,17 @@ function base64ToBytes(base64) {
     }
     return bytes;
 }
-function compressUuid(guidString) {
+export function compressUuid(guidString) {
     const hex = normalizeUuidHex(guidString);
     const guidInt = BigInt(`0x${hex}`);
     return base36Encode(guidInt);
 }
-function decompressUuid(compressedUuid) {
+export function decompressUuid(compressedUuid) {
     const guidInt = base36Decode(compressedUuid);
     const hex = guidInt.toString(16).padStart(32, "0");
     return formatUuidFromHex(hex);
 }
-function base64CompressUuid(id) {
+export function base64CompressUuid(id) {
     const hex = normalizeUuidHex(id);
     const bytes = hexToBytes(hex);
     const base64 = bytesToBase64(bytes)
@@ -133,7 +124,7 @@ function base64CompressUuid(id) {
         .replace(/\//g, "_");
     return base64.replace(/-/g, ".").replace(/=+$/g, "");
 }
-function base64DecompressUuid(id) {
+export function base64DecompressUuid(id) {
     let base64 = id.replace(/\./g, "-");
     const paddingNeeded = base64.length % 4;
     if (paddingNeeded !== 0) {
@@ -164,7 +155,7 @@ function splitApiKey(key) {
     }
     return { idPart, projectPart, secret };
 }
-function parseApiKey(key) {
+export function parseApiKey(key) {
     if (!key.startsWith("ma-")) {
         throw new Error("invalid api key");
     }
@@ -175,7 +166,7 @@ function parseApiKey(key) {
         secret,
     };
 }
-function encodeApiKey(key) {
+export function encodeApiKey(key) {
     return ("ma-" +
         base64CompressUuid(key.id) +
         "-" +

package/dist/esm/client.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ClientXmlDocument = exports.XmlText = exports.XmlElement = void 0;
-const uuid_1 = require("uuid");
-class XmlElement {
+import { v4 as uuid } from "uuid";
+export class XmlElement {
     constructor(parent, { tagName, attributes }, doc) {
         this._data = {
             tagName,
@@ -69,7 +66,7 @@ class XmlElement {
         });
     }
     createChildElement(tagName, attributes) {
-        const newId = (0, uuid_1.v4)();
+        const newId = uuid();
         const elementData = {
             name: tagName,
             attributes: {
@@ -96,7 +93,7 @@ class XmlElement {
         return this.getNodeByID(newId);
     }
     createChildElementAt(index, tagName, attributes) {
-        const newId = (0, uuid_1.v4)();
+        const newId = uuid();
         const elementData = {
             name: tagName,
             attributes: {
@@ -134,7 +131,7 @@ class XmlElement {
                 throw new Error("Text does not belong to this node");
             }
         }
-        const newId = (0, uuid_1.v4)();
+        const newId = uuid();
         const elementData = {
             name: tagName,
             attributes: {
@@ -188,8 +185,7 @@ class XmlElement {
         return this._data.children;
     }
 }
-exports.XmlElement = XmlElement;
-class XmlText {
+export class XmlText {
     constructor(parent, data, doc) {
         this._data = data;
         this.parent = parent;
@@ -246,8 +242,7 @@ class XmlText {
         return this.parent?.id;
     }
 }
-exports.XmlText = XmlText;
-class ClientXmlDocument {
+export class ClientXmlDocument {
     constructor({ id, sendChanges, }) {
         this._root = new XmlElement(null, { tagName: "root", attributes: {} }, this);
         this.sendChanges = sendChanges;
@@ -446,4 +441,3 @@ class ClientXmlDocument {
         }
     }
 }
-exports.ClientXmlDocument = ClientXmlDocument;

package/dist/esm/completer.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Completer = void 0;
-class Completer {
+export class Completer {
     constructor() {
         this.completed = false;
         this.fut = new Promise((resolve, reject) => {
@@ -22,4 +19,3 @@ class Completer {
         this.reject(reason);
     }
 }
-exports.Completer = Completer;

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

@@ -1,6 +1,6 @@
-import type { ContainerMountSpec } from "./meshagent-client";
-import { type Content } from "./response";
-import { RoomClient } from "./room-client";
+import type { ContainerMountSpec } from "./meshagent-client.js";
+import { type Content } from "./response.js";
+import { RoomClient } from "./room-client.js";
 export interface DockerSecret {
     username: string;
     password: string;
@@ -56,15 +56,30 @@ export interface RoomContainerPort {
     containerPort: number;
     hostPort: number;
 }
+export interface RoomContainerStats {
+    cpuUsageNanoCores?: number;
+    memoryUsageBytes?: number;
+    memoryWorkingSetBytes?: number;
+    timestampNs?: number;
+}
 export interface RoomContainer {
     id: string;
     image: string;
+    imageId?: string;
     name?: string;
     ports: RoomContainerPort[];
     startedBy: ContainerParticipantInfo;
     state: string;
     private: boolean;
     serviceId?: string;
+    stats?: RoomContainerStats;
+    exitStatus?: ContainerExitStatus;
+}
+export interface ContainerExitStatus {
+    exitCode: number;
+    reason?: string;
+    message?: string;
+    oomKilled?: boolean;
 }
 export interface LogProgress {
     layer?: string | null;
@@ -211,6 +226,9 @@ export declare class ContainersClient {
         containerId: string;
         force?: boolean;
     }): Promise<void>;
+    waitForExitStatus(params: {
+        containerId: string;
+    }): Promise<ContainerExitStatus>;
     waitForExit(params: {
         containerId: string;
     }): Promise<number>;