@meshagent/meshagent 0.44.10 → 0.44.12

package/dist/node/meshagent-client.js

@@ -1,10 +1,260 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Meshagent = void 0;
+exports.Meshagent = exports.ManagedAgentGrant = exports.ServiceTemplateSpec = exports.RoomSession = void 0;
+exports.normalizeServiceSpec = normalizeServiceSpec;
 const helpers_js_1 = require("./helpers.js");
 const requirement_js_1 = require("./requirement.js");
 const participant_token_js_1 = require("./participant-token.js");
 const utils_js_1 = require("./utils.js");
+class RoomSession {
+    constructor({ id, roomId, roomName, createdAt, isActive, participants, kind = "room", agentId, agentName, }) {
+        this.id = id;
+        this.roomId = roomId;
+        this.roomName = roomName;
+        this.createdAt = createdAt;
+        this.isActive = isActive;
+        this.participants = participants;
+        this.kind = kind;
+        this.agentId = agentId;
+        this.agentName = agentName;
+    }
+    toJson() {
+        return {
+            id: this.id,
+            room_id: this.roomId ?? null,
+            room_name: this.roomName,
+            started_at: this.createdAt.toISOString(),
+            is_active: this.isActive,
+            kind: this.kind,
+            ...(this.agentId != null ? { agent_id: this.agentId } : {}),
+            ...(this.agentName != null ? { agent_name: this.agentName } : {}),
+        };
+    }
+}
+exports.RoomSession = RoomSession;
+function cloneJsonValue(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => cloneJsonValue(item));
+    }
+    if (value != null && typeof value === "object") {
+        const result = {};
+        for (const [key, item] of Object.entries(value)) {
+            result[key] = cloneJsonValue(item);
+        }
+        return result;
+    }
+    return value;
+}
+function formatTemplateString(value, values) {
+    return value.replace(/\{([A-Za-z_][A-Za-z0-9_]*)\}/g, (token, key) => values[key] ?? token);
+}
+function formatJsonValue(value, values) {
+    if (typeof value === "string") {
+        return formatTemplateString(value, values);
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => formatJsonValue(item, values));
+    }
+    if (value != null && typeof value === "object") {
+        const result = {};
+        for (const [key, item] of Object.entries(value)) {
+            result[key] = formatJsonValue(item, values);
+        }
+        return result;
+    }
+    return value;
+}
+function objectOrUndefined(value) {
+    return value != null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function objectArray(value) {
+    return Array.isArray(value)
+        ? value.filter((item) => objectOrUndefined(item) !== undefined)
+        : undefined;
+}
+function stringValue(value) {
+    return typeof value === "string" ? value : undefined;
+}
+function booleanValue(value) {
+    return typeof value === "boolean" ? value : undefined;
+}
+function normalizeRoomMount(value) {
+    return {
+        path: stringValue(value.path) ?? "",
+        ...(stringValue(value.subpath) !== undefined ? { subpath: stringValue(value.subpath) } : {}),
+        ...(booleanValue(value.read_only) !== undefined ? { read_only: booleanValue(value.read_only) } : {}),
+    };
+}
+function normalizeProjectMount(value) {
+    return {
+        path: stringValue(value.path) ?? "",
+        ...(stringValue(value.subpath) !== undefined ? { subpath: stringValue(value.subpath) } : {}),
+        read_only: booleanValue(value.read_only) ?? true,
+    };
+}
+function normalizeImageMount(value) {
+    return {
+        path: stringValue(value.path) ?? "",
+        ...(stringValue(value.subpath) !== undefined ? { subpath: stringValue(value.subpath) } : {}),
+        read_only: booleanValue(value.read_only) ?? true,
+        image: stringValue(value.image) ?? "",
+    };
+}
+function normalizeFileMount(value) {
+    return {
+        path: stringValue(value.path) ?? "",
+        ...(stringValue(value.subpath) !== undefined ? { subpath: stringValue(value.subpath) } : {}),
+        read_only: booleanValue(value.read_only) ?? true,
+        text: stringValue(value.text) ?? "",
+    };
+}
+function normalizeEmptyDirMount(value) {
+    return {
+        path: stringValue(value.path) ?? "",
+        read_only: booleanValue(value.read_only) ?? false,
+    };
+}
+function normalizeConfigMount(value) {
+    return {
+        path: stringValue(value.path) ?? "/var/run/meshagent",
+    };
+}
+function normalizeContainerMountSpec(value) {
+    const source = objectOrUndefined(value) ?? {};
+    const room = objectArray(source.room)?.map(normalizeRoomMount);
+    const project = objectArray(source.project)?.map(normalizeProjectMount);
+    const images = objectArray(source.images)?.map(normalizeImageMount);
+    const files = objectArray(source.files)?.map(normalizeFileMount);
+    const emptyDirs = objectArray(source.empty_dirs)?.map(normalizeEmptyDirMount);
+    const configs = objectArray(source.configs)?.map(normalizeConfigMount);
+    return {
+        ...(room !== undefined ? { room } : {}),
+        ...(project !== undefined ? { project } : {}),
+        ...(images !== undefined ? { images } : {}),
+        ...(files !== undefined ? { files } : {}),
+        ...(emptyDirs !== undefined ? { empty_dirs: emptyDirs } : {}),
+        ...(configs !== undefined ? { configs } : {}),
+    };
+}
+function normalizeAgentSpec(agent, values) {
+    const formatted = formatJsonValue(agent, values);
+    const spec = cloneJsonValue(formatted);
+    if (spec.email != null && spec.email.public == null) {
+        spec.email = { ...spec.email, public: false };
+    }
+    if (spec.channels?.email) {
+        spec.channels = {
+            ...spec.channels,
+            email: spec.channels.email.map((channel) => ({
+                ...channel,
+                private: channel.private ?? false,
+            })),
+        };
+    }
+    if (spec.channels?.messaging) {
+        spec.channels = {
+            ...spec.channels,
+            messaging: spec.channels.messaging.map((channel) => ({
+                ...channel,
+                protocol: channel.protocol ?? "meshagent.agent-message.v1",
+            })),
+        };
+    }
+    return spec;
+}
+function normalizeServiceSpec(service) {
+    const normalized = cloneJsonValue(service);
+    if (normalized.container?.storage != null) {
+        normalized.container = {
+            ...normalized.container,
+            storage: normalizeContainerMountSpec(normalized.container.storage),
+        };
+    }
+    return normalized;
+}
+class ServiceTemplateSpec {
+    constructor({ version = "v1", kind = "ServiceTemplate", variables, metadata, ports = [], container, external, agents = [], }) {
+        this.version = version;
+        this.kind = kind;
+        this.variables = variables;
+        this.metadata = metadata;
+        this.ports = ports;
+        this.container = container;
+        this.external = external;
+        this.agents = agents;
+    }
+    static fromJson(json) {
+        const metadata = objectOrUndefined(json.metadata);
+        if (metadata === undefined || typeof metadata.name !== "string") {
+            throw new requirement_js_1.RoomException("Invalid service template payload: missing metadata.name");
+        }
+        return new ServiceTemplateSpec({
+            version: stringValue(json.version) ?? "v1",
+            kind: stringValue(json.kind) ?? "ServiceTemplate",
+            variables: objectArray(json.variables),
+            metadata: cloneJsonValue(metadata),
+            ports: (objectArray(json.ports) ?? []),
+            container: objectOrUndefined(json.container),
+            external: objectOrUndefined(json.external),
+            agents: objectArray(json.agents) ?? [],
+        });
+    }
+    toJson() {
+        return {
+            version: this.version,
+            kind: this.kind,
+            ...(this.variables != null ? { variables: cloneJsonValue(this.variables) } : {}),
+            metadata: cloneJsonValue(this.metadata),
+            ...(this.ports.length > 0 ? { ports: cloneJsonValue(this.ports) } : {}),
+            ...(this.container != null ? { container: cloneJsonValue(this.container) } : {}),
+            ...(this.external != null ? { external: cloneJsonValue(this.external) } : {}),
+            ...(this.agents.length > 0 ? { agents: cloneJsonValue(this.agents) } : {}),
+        };
+    }
+    toServiceSpec({ values = {} } = {}) {
+        const service = {
+            version: "v1",
+            kind: "Service",
+            metadata: cloneJsonValue(this.metadata),
+            agents: this.agents.map((agent) => normalizeAgentSpec(agent, values)),
+            ports: cloneJsonValue(this.ports),
+        };
+        if (this.container != null) {
+            const formattedContainer = formatJsonValue(this.container, values);
+            const image = stringValue(formattedContainer.image);
+            if (image === undefined || image.length === 0) {
+                throw new requirement_js_1.RoomException("ServiceTemplateSpec.image is required to build a ServiceSpec");
+            }
+            service.container = {
+                ...(booleanValue(formattedContainer.private) !== undefined ? { private: booleanValue(formattedContainer.private) } : {}),
+                ...(stringValue(formattedContainer.command) !== undefined ? { command: stringValue(formattedContainer.command) } : {}),
+                ...(stringValue(formattedContainer.working_dir) !== undefined ? { working_dir: stringValue(formattedContainer.working_dir) } : {}),
+                image,
+                ...(Array.isArray(formattedContainer.environment)
+                    ? { environment: formattedContainer.environment }
+                    : {}),
+                ...(objectOrUndefined(formattedContainer.storage) !== undefined
+                    ? { storage: normalizeContainerMountSpec(formattedContainer.storage) }
+                    : {}),
+                ...(booleanValue(formattedContainer.on_demand) !== undefined ? { on_demand: booleanValue(formattedContainer.on_demand) } : {}),
+                ...(booleanValue(formattedContainer.writable_root_fs) !== undefined
+                    ? { writable_root_fs: booleanValue(formattedContainer.writable_root_fs) }
+                    : {}),
+            };
+        }
+        if (this.external != null) {
+            const formattedExternal = formatJsonValue(this.external, values);
+            const url = stringValue(formattedExternal.url);
+            if (url !== undefined) {
+                service.external = { url };
+            }
+        }
+        return normalizeServiceSpec(service);
+    }
+}
+exports.ServiceTemplateSpec = ServiceTemplateSpec;
 function pruneUndefinedValues(value) {
     if (Array.isArray(value)) {
         const prunedItems = value
@@ -27,6 +277,27 @@ function pruneUndefinedValues(value) {
     }
     return value;
 }
+function pruneNullishValues(value) {
+    if (Array.isArray(value)) {
+        return value
+            .map((item) => pruneNullishValues(item))
+            .filter((item) => item !== undefined);
+    }
+    if (value === null || value === undefined) {
+        return undefined;
+    }
+    if (typeof value === "object") {
+        const result = {};
+        for (const [key, entryValue] of Object.entries(value)) {
+            const normalized = pruneNullishValues(entryValue);
+            if (normalized !== undefined) {
+                result[key] = normalized;
+            }
+        }
+        return result;
+    }
+    return value;
+}
 function serializeServiceSpec(service) {
     const agents = service.agents?.map((agent) => ({
         ...agent,
@@ -50,6 +321,18 @@ function serializeCreateServiceSpec(service) {
     delete payload.id;
     return payload;
 }
+class ManagedAgentGrant {
+    constructor({ admin = false } = {}) {
+        this.admin = admin;
+    }
+    static fromJson(json) {
+        return new ManagedAgentGrant({ admin: json["admin"] === true });
+    }
+    toJson() {
+        return { admin: this.admin };
+    }
+}
+exports.ManagedAgentGrant = ManagedAgentGrant;
 const globalScope = globalThis;
 function bytesToBase64(bytes) {
     if (globalScope.Buffer) {
@@ -152,7 +435,11 @@ class Meshagent {
             catch {
                 message = "<unable to read body>";
             }
-            throw new requirement_js_1.RoomException(`Failed to ${action}. Status code: ${response.status}, body: ${message}`);
+            const errorMessage = `Failed to ${action}. Status code: ${response.status}, body: ${message}`;
+            if (response.status === 403) {
+                throw new requirement_js_1.ForbiddenException(errorMessage);
+            }
+            throw new requirement_js_1.RoomException(errorMessage);
         }
         switch (responseType) {
             case "json":
@@ -191,7 +478,7 @@ class Meshagent {
         if (!data || typeof data !== "object") {
             throw new requirement_js_1.RoomException("Invalid room session payload");
         }
-        const { id, room_id: roomIdRaw, roomId, room_name: roomNameRaw, roomName, created_at: createdRaw, createdAt, is_active: isActiveRaw, isActive, participants } = data;
+        const { id, room_id: roomIdRaw, roomId, room_name: roomNameRaw, roomName, created_at: createdRaw, createdAt, is_active: isActiveRaw, isActive, participants, kind, agent_id: agentIdRaw, agentId, agent_name: agentNameRaw, agentName, } = data;
         if (typeof id !== "string") {
             throw new requirement_js_1.RoomException("Invalid room session payload: missing id");
         }
@@ -207,13 +494,32 @@ class Meshagent {
         if (typeof isActiveValue !== "boolean") {
             throw new requirement_js_1.RoomException("Invalid room session payload: missing is_active");
         }
-        return {
+        return new RoomSession({
             id,
             roomId: typeof roomId === "string" ? roomId : typeof roomIdRaw === "string" ? roomIdRaw : undefined,
             roomName: roomNameValue,
             createdAt: new Date(created),
             isActive: isActiveValue,
             participants: participants && typeof participants === "object" ? participants : undefined,
+            kind: typeof kind === "string" ? kind : "room",
+            agentId: typeof agentId === "string" ? agentId : typeof agentIdRaw === "string" ? agentIdRaw : undefined,
+            agentName: typeof agentName === "string" ? agentName : typeof agentNameRaw === "string" ? agentNameRaw : undefined,
+        });
+    }
+    parseManagedAgent(data) {
+        if (!data || typeof data !== "object") {
+            throw new requirement_js_1.RoomException("Invalid managed agent payload");
+        }
+        const { id, name, configuration } = data;
+        if (typeof id !== "string" || typeof name !== "string") {
+            throw new requirement_js_1.RoomException("Invalid managed agent payload: missing id or name");
+        }
+        return {
+            id,
+            name,
+            configuration: configuration && typeof configuration === "object" && !Array.isArray(configuration)
+                ? configuration
+                : {},
         };
     }
     parseRoom(data) {
@@ -779,7 +1085,7 @@ class Meshagent {
         });
     }
     async addUserToProject(projectId, userId, options = {}) {
-        const { isAdmin, isDeveloper, canCreateRooms } = options;
+        const { isAdmin, isDeveloper, canCreateRooms, inviteRedirectUrl } = options;
         return await this.request(`/accounts/projects/${projectId}/users`, {
             method: "POST",
             json: {
@@ -790,6 +1096,28 @@ class Meshagent {
                 ...(canCreateRooms !== undefined
                     ? { can_create_rooms: canCreateRooms }
                     : {}),
+                ...(inviteRedirectUrl !== undefined
+                    ? { invite_redirect_url: inviteRedirectUrl }
+                    : {}),
+            },
+            action: "add user to project",
+        });
+    }
+    async addUserToProjectByEmail(projectId, email, options = {}) {
+        const { isAdmin, isDeveloper, canCreateRooms, inviteRedirectUrl } = options;
+        return await this.request(`/accounts/projects/${projectId}/users`, {
+            method: "POST",
+            json: {
+                project_id: projectId,
+                email,
+                ...(isAdmin !== undefined ? { is_admin: isAdmin } : {}),
+                ...(isDeveloper !== undefined ? { is_developer: isDeveloper } : {}),
+                ...(canCreateRooms !== undefined
+                    ? { can_create_rooms: canCreateRooms }
+                    : {}),
+                ...(inviteRedirectUrl !== undefined
+                    ? { invite_redirect_url: inviteRedirectUrl }
+                    : {}),
             },
             action: "add user to project",
         });
@@ -847,6 +1175,22 @@ class Meshagent {
             action: "get project by key",
         });
     }
+    async createAgent(params) {
+        const { projectId, configuration, ifNotExists = false, permissions } = params;
+        const permissionsJson = permissions == null
+            ? undefined
+            : Object.fromEntries(Object.entries(permissions).map(([userId, grant]) => [userId, grant.toJson()]));
+        const data = await this.request(`/accounts/projects/${this.encodePathComponent(projectId)}/agents`, {
+            method: "POST",
+            json: {
+                configuration: pruneNullishValues(configuration),
+                if_not_exists: ifNotExists,
+                ...(permissionsJson !== undefined ? { permissions: permissionsJson } : {}),
+            },
+            action: "create agent",
+        });
+        return this.parseManagedAgent(data);
+    }
     async createApiKey(projectId, name, description) {
         return await this.request(`/accounts/projects/${projectId}/api-keys`, {
             method: "POST",
@@ -1338,14 +1682,14 @@ class Meshagent {
         const data = await this.request(`/accounts/projects/${projectId}/rooms/${roomName}/services/${serviceId}`, {
             action: "fetch room service",
         });
-        return data;
+        return normalizeServiceSpec(data);
     }
     async listRoomServices(projectId, roomName) {
         const data = await this.request(`/accounts/projects/${projectId}/rooms/${roomName}/services`, {
             action: "list room services",
         });
         const services = Array.isArray(data?.services) ? data.services : [];
-        return services;
+        return services.map((service) => normalizeServiceSpec(service));
     }
     async deleteRoomService(projectId, roomName, serviceId) {
         await this.request(`/accounts/projects/${projectId}/rooms/${roomName}/services/${serviceId}`, {
@@ -1369,14 +1713,14 @@ class Meshagent {
         const data = await this.request(`/accounts/projects/${projectId}/services/${serviceId}`, {
             action: "fetch service",
         });
-        return data;
+        return normalizeServiceSpec(data);
     }
     async listServices(projectId) {
         const data = await this.request(`/accounts/projects/${projectId}/services`, {
             action: "list services",
         });
         const services = Array.isArray(data?.services) ? data.services : [];
-        return services;
+        return services.map((service) => normalizeServiceSpec(service));
     }
     async deleteService(projectId, serviceId) {
         await this.request(`/accounts/projects/${projectId}/services/${serviceId}`, {
@@ -1715,13 +2059,16 @@ class Meshagent {
         });
     }
     async createRoomGrantByEmail(params) {
-        const { projectId, roomId, email, permissions } = params;
+        const { projectId, roomId, email, permissions, inviteRedirectUrl } = params;
         await this.request(`/accounts/projects/${projectId}/room-grants`, {
             method: "POST",
             json: {
                 room_id: roomId,
                 email,
                 permissions: permissions.toJSON(),
+                ...(inviteRedirectUrl !== undefined
+                    ? { invite_redirect_url: inviteRedirectUrl }
+                    : {}),
             },
             action: "create room grant",
             responseType: "void",

package/dist/node/messaging-client.js

@@ -60,7 +60,7 @@ class MessagingClient extends event_emitter_js_1.EventEmitter {
         return input;
     }
     async _invoke({ operation, input, }) {
-        await this.client.invoke({
+        await this.client.invokeContent({
             toolkit: "messaging",
             tool: operation,
             input: new response_js_1.JsonContent({ json: input }),

package/dist/node/queues-client.js

@@ -18,7 +18,7 @@ class QueuesClient {
         return new room_server_client_js_1.RoomServerException(`unexpected return type from queues.${operation}`);
     }
     async _invoke(operation, arguments_) {
-        return await this.client.invoke({
+        return await this.client.invokeContent({
             toolkit: "queues",
             tool: operation,
             arguments: arguments_,

package/dist/node/requirement.d.ts

@@ -1,6 +1,10 @@
+import { Schema } from "apache-arrow";
 export declare class RoomException extends Error {
     constructor(message: string);
 }
+export declare class ForbiddenException extends RoomException {
+    constructor(message: string);
+}
 export declare abstract class Requirement {
     readonly name: string;
     constructor({ name }: {
@@ -25,3 +29,20 @@ export declare class RequiredSchema extends Requirement {
     });
     toJson(): Record<string, any>;
 }
+export declare class RequiredTable extends Requirement {
+    readonly schema: Schema;
+    readonly namespace?: string[];
+    readonly scalarIndexes?: string[];
+    readonly fullTextSearchIndexes?: string[];
+    readonly vectorIndexes?: string[];
+    constructor({ name, schema, namespace, scalarIndexes, fullTextSearchIndexes, vectorIndexes, }: {
+        name: string;
+        schema: Schema;
+        namespace?: string[];
+        scalarIndexes?: string[];
+        fullTextSearchIndexes?: string[];
+        vectorIndexes?: string[];
+    });
+    static fromJson(r: Record<string, any>): RequiredTable;
+    toJson(): Record<string, any>;
+}

package/dist/node/requirement.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RequiredSchema = exports.RequiredToolkit = exports.Requirement = exports.RoomException = void 0;
+exports.RequiredTable = exports.RequiredSchema = exports.RequiredToolkit = exports.Requirement = exports.ForbiddenException = exports.RoomException = void 0;
+const apache_arrow_1 = require("apache-arrow");
 class RoomException extends Error {
     constructor(message) {
         super(message);
@@ -8,6 +9,51 @@ class RoomException extends Error {
     }
 }
 exports.RoomException = RoomException;
+class ForbiddenException extends RoomException {
+    constructor(message) {
+        super(message);
+        this.name = "ForbiddenException";
+    }
+}
+exports.ForbiddenException = ForbiddenException;
+const globalScope = globalThis;
+function bytesToBase64(bytes) {
+    if (globalScope.Buffer) {
+        return globalScope.Buffer.from(bytes).toString("base64");
+    }
+    if (!globalScope.btoa) {
+        throw new Error("base64 encoding is not available in this runtime");
+    }
+    let binary = "";
+    for (const byte of bytes) {
+        binary += String.fromCharCode(byte);
+    }
+    return globalScope.btoa(binary);
+}
+function base64ToBytes(base64) {
+    if (globalScope.Buffer) {
+        return Uint8Array.from(globalScope.Buffer.from(base64, "base64"));
+    }
+    if (!globalScope.atob) {
+        throw new Error("base64 decoding is not available in this runtime");
+    }
+    const binary = globalScope.atob(base64);
+    const bytes = new Uint8Array(binary.length);
+    for (let index = 0; index < binary.length; index += 1) {
+        bytes[index] = binary.charCodeAt(index);
+    }
+    return bytes;
+}
+function schemaToIPC(schema) {
+    return (0, apache_arrow_1.tableToIPC)(new apache_arrow_1.Table(schema, []), "stream");
+}
+function schemaFromIPCBytes(data) {
+    const table = (0, apache_arrow_1.tableFromIPC)(data);
+    if (table instanceof Promise) {
+        throw new RoomException("unexpected async Arrow IPC result");
+    }
+    return table.schema;
+}
 class Requirement {
     constructor({ name }) {
         this.name = name;
@@ -20,6 +66,9 @@ class Requirement {
                 participantName: r["participant_name"],
             });
         }
+        if ("table" in r) {
+            return RequiredTable.fromJson(r);
+        }
         if ("schema" in r) {
             return new RequiredSchema({ name: r["schema"] });
         }
@@ -53,3 +102,40 @@ class RequiredSchema extends Requirement {
     }
 }
 exports.RequiredSchema = RequiredSchema;
+class RequiredTable extends Requirement {
+    constructor({ name, schema, namespace, scalarIndexes, fullTextSearchIndexes, vectorIndexes, }) {
+        super({ name });
+        this.schema = schema;
+        this.namespace = namespace;
+        this.scalarIndexes = scalarIndexes;
+        this.fullTextSearchIndexes = fullTextSearchIndexes;
+        this.vectorIndexes = vectorIndexes;
+    }
+    static fromJson(r) {
+        if (typeof r["table"] !== "string") {
+            throw new RoomException("required table name must be a string");
+        }
+        if (typeof r["schema"] !== "string") {
+            throw new RoomException("required table schema must be a base64 Arrow IPC schema");
+        }
+        return new RequiredTable({
+            name: r["table"],
+            schema: schemaFromIPCBytes(base64ToBytes(r["schema"])),
+            namespace: Array.isArray(r["namespace"]) ? r["namespace"].map(String) : undefined,
+            scalarIndexes: Array.isArray(r["scalar_indexes"]) ? r["scalar_indexes"].map(String) : undefined,
+            fullTextSearchIndexes: Array.isArray(r["full_text_search_indexes"]) ? r["full_text_search_indexes"].map(String) : undefined,
+            vectorIndexes: Array.isArray(r["vector_indexes"]) ? r["vector_indexes"].map(String) : undefined,
+        });
+    }
+    toJson() {
+        return {
+            table: this.name,
+            schema: bytesToBase64(schemaToIPC(this.schema)),
+            namespace: this.namespace,
+            scalar_indexes: this.scalarIndexes,
+            full_text_search_indexes: this.fullTextSearchIndexes,
+            vector_indexes: this.vectorIndexes,
+        };
+    }
+}
+exports.RequiredTable = RequiredTable;

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

@@ -18,6 +18,7 @@ import { ContainersClient } from "./containers-client.js";
 interface RequestHeader {
     [key: string]: unknown;
 }
+export type InvokeInput = Record<string, unknown> | Content;
 export declare class RoomProtocolProxy {
     private readonly _room;
     private readonly _handlers;
@@ -67,6 +68,7 @@ export declare class RoomClient {
     private readonly _eventEmitter;
     private readonly _pendingRequests;
     private readonly _toolCallStreams;
+    private readonly _toolCallPreOpenErrors;
     private readonly _ignoredResponseLabels;
     private readonly _ready;
     private readonly _roomClosed;
@@ -202,11 +204,20 @@ export declare class RoomClient {
         participantName?: string;
         timeout?: number;
     }): Promise<ToolkitDescription[]>;
+    private _normalizeInvokeInput;
     invoke(params: {
         toolkit: string;
         tool: string;
         arguments?: Record<string, unknown>;
-        input?: Record<string, unknown> | Content;
+        input?: InvokeInput;
+        participantId?: string;
+        onBehalfOfId?: string;
+    }): AsyncIterable<Content>;
+    invokeContent(params: {
+        toolkit: string;
+        tool: string;
+        arguments?: Record<string, unknown>;
+        input?: InvokeInput;
         participantId?: string;
         onBehalfOfId?: string;
     }): Promise<Content>;