@meshagent/meshagent 0.44.11 → 0.44.12

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

@@ -11,13 +11,28 @@ export interface RoomConnectionInfo {
     projectId: string;
     roomUrl: string;
 }
-export interface RoomSession {
-    id: string;
-    roomId?: string | null;
-    roomName: string;
-    createdAt: Date;
-    isActive: boolean;
-    participants?: Record<string, number>;
+export declare class RoomSession {
+    readonly id: string;
+    readonly roomId?: string | null;
+    readonly roomName: string;
+    readonly createdAt: Date;
+    readonly isActive: boolean;
+    readonly participants?: Record<string, number> | null;
+    readonly kind: string;
+    readonly agentId?: string | null;
+    readonly agentName?: string | null;
+    constructor({ id, roomId, roomName, createdAt, isActive, participants, kind, agentId, agentName, }: {
+        id: string;
+        roomId?: string | null;
+        roomName: string;
+        createdAt: Date;
+        isActive: boolean;
+        participants?: Record<string, number> | null;
+        kind?: string;
+        agentId?: string | null;
+        agentName?: string | null;
+    });
+    toJson(): Record<string, unknown>;
 }
 export interface RoomInfo {
     id: string;
@@ -63,6 +78,18 @@ export interface ProjectStorageMountSpec {
     subpath?: string | null;
     read_only?: boolean;
 }
+export interface ImageStorageMountSpec {
+    path: string;
+    subpath?: string | null;
+    read_only?: boolean;
+    image: string;
+}
+export interface FileStorageMountSpec {
+    path: string;
+    subpath?: string | null;
+    read_only?: boolean;
+    text: string;
+}
 export interface EmptyDirMountSpec {
     path: string;
     read_only?: boolean;
@@ -73,6 +100,8 @@ export interface ConfigMountSpec {
 export interface ContainerMountSpec {
     room?: RoomStorageMountSpec[];
     project?: ProjectStorageMountSpec[];
+    images?: ImageStorageMountSpec[];
+    files?: FileStorageMountSpec[];
     empty_dirs?: EmptyDirMountSpec[];
     configs?: ConfigMountSpec[];
 }
@@ -212,6 +241,65 @@ export interface ServiceSpec {
     container?: ContainerSpec | null;
     external?: ExternalServiceSpec | null;
 }
+export interface TemplateEnvironmentVariable {
+    name: string;
+    value?: string | null;
+    token?: Record<string, unknown> | null;
+}
+export interface ServiceTemplateContainerMountSpec {
+    room?: RoomStorageMountSpec[] | null;
+    project?: ProjectStorageMountSpec[] | null;
+    images?: ImageStorageMountSpec[] | null;
+    files?: FileStorageMountSpec[] | null;
+    empty_dirs?: EmptyDirMountSpec[] | null;
+    configs?: ConfigMountSpec[] | null;
+}
+export interface ContainerTemplateSpec {
+    private?: boolean | null;
+    command?: string | null;
+    working_dir?: string | null;
+    image?: string | null;
+    environment?: TemplateEnvironmentVariable[] | null;
+    storage?: ServiceTemplateContainerMountSpec | null;
+    on_demand?: boolean | null;
+    writable_root_fs?: boolean | null;
+}
+export interface ExternalServiceTemplateSpec {
+    url: string;
+}
+export interface ServiceTemplateVariable {
+    name: string;
+    label?: string | null;
+    description?: string | null;
+    default?: string | null;
+    required?: boolean | null;
+}
+export declare function normalizeServiceSpec(service: ServiceSpec | Record<string, unknown>): ServiceSpec;
+export declare class ServiceTemplateSpec {
+    readonly version: string;
+    readonly kind: string;
+    readonly variables?: ServiceTemplateVariable[] | null;
+    readonly metadata: ServiceMetadata;
+    readonly ports: PortSpec[];
+    readonly container?: ContainerTemplateSpec | null;
+    readonly external?: ExternalServiceTemplateSpec | null;
+    readonly agents: Record<string, unknown>[];
+    constructor({ version, kind, variables, metadata, ports, container, external, agents, }: {
+        version?: string;
+        kind?: string;
+        variables?: ServiceTemplateVariable[] | null;
+        metadata: ServiceMetadata;
+        ports?: PortSpec[];
+        container?: ContainerTemplateSpec | null;
+        external?: ExternalServiceTemplateSpec | null;
+        agents?: Record<string, unknown>[];
+    });
+    static fromJson(json: Record<string, unknown>): ServiceTemplateSpec;
+    toJson(): Record<string, unknown>;
+    toServiceSpec({ values }?: {
+        values?: Record<string, string>;
+    }): ServiceSpec;
+}
 export interface RouteMetadata {
     name: string;
     annotations?: Record<string, string>;
@@ -370,6 +458,19 @@ export interface ExternalOAuthClientRegistration {
     clientId: string;
     clientSecret?: string | null;
 }
+export interface ManagedAgent {
+    id: string;
+    name: string;
+    configuration: Record<string, unknown>;
+}
+export declare class ManagedAgentGrant {
+    readonly admin: boolean;
+    constructor({ admin }?: {
+        admin?: boolean;
+    });
+    static fromJson(json: Record<string, unknown>): ManagedAgentGrant;
+    toJson(): Record<string, unknown>;
+}
 type JsonRequest = Record<string, unknown> | Array<unknown> | string | number | boolean | null;
 export declare class Meshagent {
     private readonly baseUrl;
@@ -382,6 +483,7 @@ export declare class Meshagent {
     private request;
     private parseRoomShare;
     private parseRoomSession;
+    private parseManagedAgent;
     private parseRoom;
     private parseRoute;
     private parseFeed;
@@ -425,6 +527,13 @@ export declare class Meshagent {
         isAdmin?: boolean;
         isDeveloper?: boolean;
         canCreateRooms?: boolean;
+        inviteRedirectUrl?: string;
+    }): Promise<Record<string, unknown>>;
+    addUserToProjectByEmail(projectId: string, email: string, options?: {
+        isAdmin?: boolean;
+        isDeveloper?: boolean;
+        canCreateRooms?: boolean;
+        inviteRedirectUrl?: string;
     }): Promise<Record<string, unknown>>;
     removeUserFromProject(projectId: string, userId: string): Promise<Record<string, unknown>>;
     updateProjectSettings(projectId: string, settings: Record<string, unknown>): Promise<Record<string, unknown>>;
@@ -439,6 +548,12 @@ export declare class Meshagent {
     listProjects(): Promise<Record<string, unknown>>;
     getProject(projectId: string): Promise<Record<string, unknown>>;
     getProjectByKey(projectKey: string): Promise<Record<string, unknown>>;
+    createAgent(params: {
+        projectId: string;
+        configuration: Record<string, unknown>;
+        ifNotExists?: boolean;
+        permissions?: Record<string, ManagedAgentGrant> | null;
+    }): Promise<ManagedAgent>;
     createApiKey(projectId: string, name: string, description: string): Promise<Record<string, unknown>>;
     deleteApiKey(projectId: string, id: string): Promise<void>;
     listApiKeys(projectId: string): Promise<Record<string, unknown>>;
@@ -780,6 +895,7 @@ export declare class Meshagent {
         roomId: string;
         email: string;
         permissions: ApiScope;
+        inviteRedirectUrl?: string;
     }): Promise<void>;
     updateRoomGrant(params: {
         projectId: string;

package/dist/esm/meshagent-client.js

@@ -1,7 +1,254 @@
 import { meshagentBaseUrl } from "./helpers.js";
-import { RoomException } from "./requirement.js";
+import { ForbiddenException, RoomException } from "./requirement.js";
 import { ApiScope } from "./participant-token.js";
 import { decoder, encoder } from "./utils.js";
+export 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 } : {}),
+        };
+    }
+}
+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;
+}
+export function normalizeServiceSpec(service) {
+    const normalized = cloneJsonValue(service);
+    if (normalized.container?.storage != null) {
+        normalized.container = {
+            ...normalized.container,
+            storage: normalizeContainerMountSpec(normalized.container.storage),
+        };
+    }
+    return normalized;
+}
+export 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 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 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);
+    }
+}
 function pruneUndefinedValues(value) {
     if (Array.isArray(value)) {
         const prunedItems = value
@@ -24,6 +271,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,
@@ -47,6 +315,17 @@ function serializeCreateServiceSpec(service) {
     delete payload.id;
     return payload;
 }
+export class ManagedAgentGrant {
+    constructor({ admin = false } = {}) {
+        this.admin = admin;
+    }
+    static fromJson(json) {
+        return new ManagedAgentGrant({ admin: json["admin"] === true });
+    }
+    toJson() {
+        return { admin: this.admin };
+    }
+}
 const globalScope = globalThis;
 function bytesToBase64(bytes) {
     if (globalScope.Buffer) {
@@ -149,7 +428,11 @@ export class Meshagent {
             catch {
                 message = "<unable to read body>";
             }
-            throw new 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 ForbiddenException(errorMessage);
+            }
+            throw new RoomException(errorMessage);
         }
         switch (responseType) {
             case "json":
@@ -188,7 +471,7 @@ export class Meshagent {
         if (!data || typeof data !== "object") {
             throw new 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 RoomException("Invalid room session payload: missing id");
         }
@@ -204,13 +487,32 @@ export class Meshagent {
         if (typeof isActiveValue !== "boolean") {
             throw new 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 RoomException("Invalid managed agent payload");
+        }
+        const { id, name, configuration } = data;
+        if (typeof id !== "string" || typeof name !== "string") {
+            throw new RoomException("Invalid managed agent payload: missing id or name");
+        }
+        return {
+            id,
+            name,
+            configuration: configuration && typeof configuration === "object" && !Array.isArray(configuration)
+                ? configuration
+                : {},
         };
     }
     parseRoom(data) {
@@ -776,7 +1078,7 @@ export 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: {
@@ -787,6 +1089,28 @@ export 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",
         });
@@ -844,6 +1168,22 @@ export 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",
@@ -1335,14 +1675,14 @@ export 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}`, {
@@ -1366,14 +1706,14 @@ export 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}`, {
@@ -1712,13 +2052,16 @@ export 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/esm/messaging-client.js

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

package/dist/esm/queues-client.js

@@ -14,7 +14,7 @@ export class QueuesClient {
         return new 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_,