@meshagent/meshagent 0.42.2 → 0.43.0

package/CHANGELOG.md

@@ -1,4 +1,11 @@
+## [0.43.0]
+- Split LiveKit helpers into `@meshagent/meshagent-livekit-ts` and added `@meshagent/meshagent-node-ts` for room websocket proxying and room-connect helpers.
+- Updated `meshagent-ts` exports for ESM-aware resolution, moved LiveKit out of the core package, and added `RoomClient.withIAP()` and `WebSocketClientProtocol.withIAP()` for the new room-connect flow.
+- Room websocket auth now uses bearer headers on Node and `meshagent-room.` subprotocol tokens in the browser, and the agents/thread APIs now carry backend metadata and attachment-aware prompts.
+- React/auth/dev/tailwind packages now publish CJS main entries alongside ESM builds, and the new LiveKit package depends on `livekit-client@^2.15.5`.
+
 ## [0.42.2]
+- Moved TypeScript LiveKit helpers into the new `@meshagent/meshagent-livekit` package so the core TypeScript SDK no longer depends on `livekit-client`.
 - Added `ContainerExitStatus`, `RoomContainerStats`, and published build image metadata to the TypeScript container client models.
 - Added `waitForExitStatus` while keeping `waitForExit` as the exit-code convenience wrapper.
 - Container list parsing now preserves image IDs, runtime stats, and exit-status metadata from API responses.

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

@@ -1,7 +1,7 @@
-import { RoomClient } from "./room-client";
-import type { Content } from "./response";
-import { ToolInput, type ToolCallOutput } from "./agent";
-import { ToolContentSpec } from "./tool-content-type";
+import { RoomClient } from "./room-client.js";
+import type { Content } from "./response.js";
+import { ToolInput, type ToolCallOutput } from "./agent.js";
+import { ToolContentSpec } from "./tool-content-type.js";
 export declare class ToolDescription {
     title: string;
     name: string;

package/dist/browser/agent-client.js

@@ -1,15 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AgentsClient = exports.ToolkitDescription = exports.ToolDescription = void 0;
-const agent_1 = require("./agent");
-const tool_content_type_1 = require("./tool-content-type");
+const agent_js_1 = require("./agent.js");
+const tool_content_type_js_1 = require("./tool-content-type.js");
 class ToolDescription {
     constructor({ title, name, description, inputSchema, inputSpec, outputSpec, outputSchema, defs }) {
         this.title = title;
         this.name = name;
         this.description = description;
         if (inputSpec !== undefined && inputSchema !== undefined) {
-            this.inputSpec = new tool_content_type_1.ToolContentSpec({
+            this.inputSpec = new tool_content_type_js_1.ToolContentSpec({
                 types: [...inputSpec.types],
                 stream: inputSpec.stream,
                 schema: inputSchema,
@@ -19,14 +19,14 @@ class ToolDescription {
             this.inputSpec = inputSpec;
         }
         else if (inputSchema !== undefined) {
-            this.inputSpec = new tool_content_type_1.ToolContentSpec({
+            this.inputSpec = new tool_content_type_js_1.ToolContentSpec({
                 types: ["json"],
                 stream: false,
                 schema: inputSchema,
             });
         }
         if (outputSpec !== undefined && outputSchema !== undefined) {
-            this.outputSpec = new tool_content_type_1.ToolContentSpec({
+            this.outputSpec = new tool_content_type_js_1.ToolContentSpec({
                 types: [...outputSpec.types],
                 stream: outputSpec.stream,
                 schema: outputSchema,
@@ -36,7 +36,7 @@ class ToolDescription {
             this.outputSpec = outputSpec;
         }
         else if (outputSchema !== undefined) {
-            this.outputSpec = new tool_content_type_1.ToolContentSpec({
+            this.outputSpec = new tool_content_type_js_1.ToolContentSpec({
                 types: ["json"],
                 stream: false,
                 schema: outputSchema,
@@ -96,9 +96,9 @@ class ToolkitDescription {
                     name: tool["name"],
                     description: tool["description"],
                     inputSchema: tool["input_schema"],
-                    inputSpec: tool_content_type_1.ToolContentSpec.fromJson(tool["input_spec"]),
+                    inputSpec: tool_content_type_js_1.ToolContentSpec.fromJson(tool["input_spec"]),
                     outputSchema: tool["output_schema"],
-                    outputSpec: tool_content_type_1.ToolContentSpec.fromJson(tool["output_spec"]),
+                    outputSpec: tool_content_type_js_1.ToolContentSpec.fromJson(tool["output_spec"]),
                     defs: tool["defs"],
                 }));
             }
@@ -112,9 +112,9 @@ class ToolkitDescription {
                     name: toolName,
                     description: tool["description"],
                     inputSchema: tool["input_schema"],
-                    inputSpec: tool_content_type_1.ToolContentSpec.fromJson(tool["input_spec"]),
+                    inputSpec: tool_content_type_js_1.ToolContentSpec.fromJson(tool["input_spec"]),
                     outputSchema: tool["output_schema"],
-                    outputSpec: tool_content_type_1.ToolContentSpec.fromJson(tool["output_spec"]),
+                    outputSpec: tool_content_type_js_1.ToolContentSpec.fromJson(tool["output_spec"]),
                     defs: tool["defs"],
                 }));
             }
@@ -149,7 +149,7 @@ class AgentsClient {
                 onBehalfOfId: params.onBehalfOfId,
             });
         }
-        if (params.input instanceof agent_1.ToolContentInput) {
+        if (params.input instanceof agent_js_1.ToolContentInput) {
             const output = await this.client.invokeToolCall({
                 toolkit: params.toolkit,
                 tool: params.tool,
@@ -158,10 +158,10 @@ class AgentsClient {
                 onBehalfOfId: params.onBehalfOfId,
             });
             return output.kind === "content"
-                ? new agent_1.ToolContentOutput(output.content)
-                : new agent_1.ToolStreamOutput(output.stream, { inputClosed: output.inputClosed });
+                ? new agent_js_1.ToolContentOutput(output.content)
+                : new agent_js_1.ToolStreamOutput(output.stream, { inputClosed: output.inputClosed });
         }
-        if (params.input instanceof agent_1.ToolStreamInput) {
+        if (params.input instanceof agent_js_1.ToolStreamInput) {
             const output = await this.client.invokeToolCall({
                 toolkit: params.toolkit,
                 tool: params.tool,
@@ -171,8 +171,8 @@ class AgentsClient {
                 onBehalfOfId: params.onBehalfOfId,
             });
             return output.kind === "content"
-                ? new agent_1.ToolContentOutput(output.content)
-                : new agent_1.ToolStreamOutput(output.stream, { inputClosed: output.inputClosed });
+                ? new agent_js_1.ToolContentOutput(output.content)
+                : new agent_js_1.ToolStreamOutput(output.stream, { inputClosed: output.inputClosed });
         }
         throw new Error("invokeTool input must be ToolContentInput or ToolStreamInput");
     }

package/dist/browser/agent.d.ts

@@ -1,9 +1,9 @@
-import { RoomClient } from "./room-client";
-import { RequiredToolkit } from "./requirement";
-import { type Content } from "./response";
-import { RoomServerException } from "./room-server-client";
-import { ToolContentSpec } from "./tool-content-type";
-import { Participant } from "./participant";
+import { RoomClient } from "./room-client.js";
+import { RequiredToolkit } from "./requirement.js";
+import { type Content } from "./response.js";
+import { RoomServerException } from "./room-server-client.js";
+import { ToolContentSpec } from "./tool-content-type.js";
+import { Participant } from "./participant.js";
 export type ValidationMode = "full" | "contentTypes" | "none";
 export declare class InvalidToolDataException extends RoomServerException {
     constructor(message: string);

package/dist/browser/agent.js

@@ -2,14 +2,14 @@
 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 {
+const response_js_1 = require("./response.js");
+const room_server_client_js_1 = require("./room-server-client.js");
+const tool_content_type_js_1 = require("./tool-content-type.js");
+const utils_js_1 = require("./utils.js");
+const room_event_js_1 = require("./room-event.js");
+const participant_js_1 = require("./participant.js");
+const stream_controller_js_1 = require("./stream-controller.js");
+class InvalidToolDataException extends room_server_client_js_1.RoomServerException {
     constructor(message) {
         super(message);
         this.name = "InvalidToolDataException";
@@ -90,10 +90,10 @@ exports.ContentTool = ContentTool;
 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 tool_content_type_js_1.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 tool_content_type_js_1.ToolContentSpec({ types: [...params.outputSpec.types], stream: params.outputSpec.stream, schema: params.outputSchema })
             : params.outputSpec;
         super({
             name: params.name,
@@ -101,10 +101,10 @@ 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 tool_content_type_js_1.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 tool_content_type_js_1.ToolContentSpec({ types: ["json"], stream: false, schema: params.outputSchema })
                 : undefined),
             outputSchema: params.outputSchema,
             defs: params.defs,
@@ -116,38 +116,38 @@ function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function contentType(content) {
-    if (content instanceof response_1.BinaryContent)
+    if (content instanceof response_js_1.BinaryContent)
         return "binary";
-    if (content instanceof response_1.JsonContent)
+    if (content instanceof response_js_1.JsonContent)
         return "json";
-    if (content instanceof response_1.TextContent)
+    if (content instanceof response_js_1.TextContent)
         return "text";
-    if (content instanceof response_1.FileContent)
+    if (content instanceof response_js_1.FileContent)
         return "file";
-    if (content instanceof response_1.LinkContent)
+    if (content instanceof response_js_1.LinkContent)
         return "link";
-    if (content instanceof response_1.EmptyContent)
+    if (content instanceof response_js_1.EmptyContent)
         return "empty";
     return undefined;
 }
 function schemaValue(content) {
-    if (content instanceof response_1.BinaryContent)
+    if (content instanceof response_js_1.BinaryContent)
         return content.headers;
-    if (content instanceof response_1.JsonContent)
+    if (content instanceof response_js_1.JsonContent)
         return content.json;
-    if (content instanceof response_1.TextContent)
+    if (content instanceof response_js_1.TextContent)
         return content.text;
-    if (content instanceof response_1.EmptyContent)
+    if (content instanceof response_js_1.EmptyContent)
         return null;
-    if (content instanceof response_1.LinkContent)
+    if (content instanceof response_js_1.LinkContent)
         return { name: content.name, url: content.url };
-    if (content instanceof response_1.FileContent)
+    if (content instanceof response_js_1.FileContent)
         return { name: content.name, mime_type: content.mimeType, size: content.data.length };
-    if (content instanceof response_1.ControlContent)
+    if (content instanceof response_js_1.ControlContent)
         return { method: content.method };
-    if (content instanceof response_1.ErrorContent)
+    if (content instanceof response_js_1.ErrorContent)
         return content.code === undefined ? { text: content.text } : { text: content.text, code: content.code };
-    const [header] = (0, utils_1.unpackMessage)(content.pack());
+    const [header] = (0, utils_js_1.unpackMessage)(content.pack());
     return header;
 }
 function schemaWithDefs(schema, defs) {
@@ -268,7 +268,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 response_js_1.JsonContent({ json: second })));
             if (output instanceof ToolContentOutput) {
                 return output.content;
             }
@@ -297,9 +297,9 @@ class Toolkit {
         throw new Error(`tool ${name} has unsupported type`);
     }
     decodeFunctionToolArguments(toolName, input) {
-        if (input instanceof response_1.EmptyContent)
+        if (input instanceof response_js_1.EmptyContent)
             return {};
-        if (input instanceof response_1.JsonContent) {
+        if (input instanceof response_js_1.JsonContent) {
             if (!isRecord(input.json)) {
                 throw new Error(`tool ${toolName} requires JSON object input`);
             }
@@ -318,18 +318,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 tool_content_type_js_1.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 tool_content_type_js_1.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 tool_content_type_js_1.ToolContentSpec({ types: ["json"], stream: false, schema: tool.outputSchema });
     }
     validateStreamMode({ tool, direction, spec, stream }) {
         if (!this.shouldValidateContentTypes || spec === undefined)
@@ -399,7 +399,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 room_server_client_js_1.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 +425,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 room_server_client_js_1.RoomServerException("hosted toolkit stopped"));
         try {
             await this._unregister();
         }
@@ -484,13 +484,13 @@ class _RemoteToolkitWrapper {
         });
     }
     _onRoomEvent(event) {
-        if (!this._started || !(event instanceof room_event_1.RoomStatusEvent)) {
+        if (!this._started || !(event instanceof room_event_js_1.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 room_server_client_js_1.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 +509,16 @@ class _RemoteToolkitWrapper {
             if (remote.id === participantId)
                 return remote;
         }
-        return new participant_1.RemoteParticipant(this.client, participantId, "user");
+        return new participant_js_1.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 (0, response_js_1.unpackContent)((0, utils_js_1.packMessage)(rawArguments, payload.length > 0 ? payload : undefined));
         }
-        return new response_1.JsonContent({ json: rawArguments });
+        return new response_js_1.JsonContent({ json: rawArguments });
     }
     async _sendToolCallResponse(messageId, chunk) {
         try {
@@ -531,9 +531,9 @@ class _RemoteToolkitWrapper {
         }
     }
     async _sendToolCallResponseChunk(messageId, toolCallId, chunk) {
-        const [header, payload] = (0, utils_1.unpackMessage)(chunk.pack());
+        const [header, payload] = (0, utils_js_1.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", (0, utils_js_1.packMessage)({ tool_call_id: toolCallId, chunk: header }, payload.length > 0 ? payload : undefined), { id: messageId });
             return true;
         }
         catch (error) {
@@ -553,7 +553,7 @@ class _RemoteToolkitWrapper {
         };
     }
     _enqueueRequestStreamChunk(stream, chunk, tool) {
-        if (chunk instanceof response_1.ControlContent) {
+        if (chunk instanceof response_js_1.ControlContent) {
             if (chunk.method === "open")
                 return;
             if (chunk.method === "close") {
@@ -582,7 +582,7 @@ class _RemoteToolkitWrapper {
         let toolCallId = toolCallIdFallback;
         let openedResponseStream = false;
         try {
-            const [message, payload] = (0, utils_1.unpackMessage)(data);
+            const [message, payload] = (0, utils_js_1.unpackMessage)(data);
             const toolName = message["name"];
             if (typeof toolName !== "string" || toolName.length === 0) {
                 throw new Error("tool call requires a tool name");
@@ -591,19 +591,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 response_js_1.ControlContent && inputChunk.method === "open";
+            if (inputChunk instanceof response_js_1.ControlContent && !requestStream) {
+                await this._sendToolCallResponse(messageId, new response_js_1.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 stream_controller_js_1.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 response_js_1.ControlContent({ method: "open" }), tool);
                 const buffered = this._pendingRequestChunks.get(toolCallId) ?? [];
                 this._pendingRequestChunks.delete(toolCallId);
                 for (const chunk of buffered) {
@@ -630,29 +630,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 response_js_1.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 response_js_1.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 response_js_1.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 response_js_1.ErrorContent({ text: String(error) }));
             }
-            await this._sendToolCallResponseChunk(messageId, toolCallId, new response_1.ControlContent({
+            await this._sendToolCallResponseChunk(messageId, toolCallId, new response_js_1.ControlContent({
                 method: "close",
-                statusCode: error instanceof InvalidToolDataException ? response_1.ControlCloseStatus.INVALID_DATA : undefined,
+                statusCode: error instanceof InvalidToolDataException ? response_js_1.ControlCloseStatus.INVALID_DATA : undefined,
                 message: error instanceof InvalidToolDataException ? error.message : undefined,
             }));
         }
@@ -665,14 +665,14 @@ class _RemoteToolkitWrapper {
             return;
         }
         try {
-            const [message, payload] = (0, utils_1.unpackMessage)(data);
+            const [message, payload] = (0, utils_js_1.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 = (0, response_js_1.unpackContent)((0, utils_js_1.packMessage)(chunkHeader, payload.length > 0 ? payload : undefined));
             const stream = this._requestStreams.get(toolCallId);
             if (stream === undefined) {
                 const buffered = this._pendingRequestChunks.get(toolCallId) ?? [];

package/dist/browser/api_keys.js

@@ -1,4 +1,7 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.base36Encode = base36Encode;
 exports.base36Decode = base36Decode;
@@ -8,7 +11,8 @@ exports.base64CompressUuid = base64CompressUuid;
 exports.base64DecompressUuid = base64DecompressUuid;
 exports.parseApiKey = parseApiKey;
 exports.encodeApiKey = encodeApiKey;
-const base_64_1 = require("base-64");
+const base_64_1 = __importDefault(require("base-64"));
+const { encode: base64Encode, decode: base64Decode } = base_64_1.default;
 const BASE36_ALPHABET = "0123456789abcdefghijklmnopqrstuvwxyz";
 const BASE36 = 36n;
 const UUID_HEX_REGEX = /^[0-9a-f]{32}$/;
@@ -95,7 +99,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 +111,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) {

package/dist/browser/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;