@meshagent/meshagent 0.27.0 → 0.28.0

package/dist/node/index.js

@@ -42,4 +42,5 @@ __exportStar(require("./stream-controller"), exports);
 __exportStar(require("./sync-client"), exports);
 __exportStar(require("./api_keys"), exports);
 __exportStar(require("./helpers"), exports);
+__exportStar(require("./tool-content-type"), exports);
 __exportStar(require("./utils"), exports);

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

@@ -30,6 +30,7 @@ export interface RoomInfo {
     id: string;
     name: string;
     metadata: Record<string, unknown>;
+    annotations: Record<string, string>;
 }
 export interface ProjectRoomGrant {
     room: RoomInfo;
@@ -79,6 +80,7 @@ export interface ServiceMetadata {
 }
 export interface ContainerSpec {
     command?: string | null;
+    working_dir?: string | null;
     image: string;
     environment?: EnvironmentVariable[] | null;
     secrets?: string[];
@@ -137,6 +139,7 @@ export interface ServiceSpec {
 export interface Mailbox {
     address: string;
     room: string;
+    roomId?: string;
     queue: string;
 }
 export interface Balance {
@@ -322,10 +325,14 @@ export declare class Meshagent {
         name: string;
         ifNotExists?: boolean;
         metadata?: Record<string, unknown>;
+        annotations?: Record<string, string>;
         permissions?: Record<string, ApiScope>;
     }): Promise<RoomInfo>;
     getRoom(projectId: string, name: string): Promise<RoomInfo>;
-    updateRoom(projectId: string, roomId: string, name: string): Promise<void>;
+    updateRoom(projectId: string, roomId: string, name: string, options?: {
+        metadata?: Record<string, unknown>;
+        annotations?: Record<string, string>;
+    }): Promise<void>;
     deleteRoom(projectId: string, roomId: string): Promise<void>;
     connectRoom(projectId: string, room: string): Promise<RoomConnectionInfo>;
     createRoomGrant(params: {

package/dist/node/meshagent-client.js

@@ -176,7 +176,7 @@ class Meshagent {
         if (!data || typeof data !== "object") {
             throw new requirement_1.RoomException("Invalid room payload");
         }
-        const { id, name, metadata } = data;
+        const { id, name, metadata, annotations } = data;
         if (typeof id !== "string" || typeof name !== "string") {
             throw new requirement_1.RoomException("Invalid room payload: missing id or name");
         }
@@ -184,6 +184,7 @@ class Meshagent {
             id,
             name,
             metadata: metadata && typeof metadata === "object" ? metadata : {},
+            annotations: annotations && typeof annotations === "object" ? annotations : {},
         };
     }
     parseProjectRoomGrant(data) {
@@ -710,11 +711,14 @@ class Meshagent {
             if (!item || typeof item !== "object") {
                 throw new requirement_1.RoomException("Invalid mailbox payload");
             }
-            const { address, room, queue } = item;
+            const { address, room, room_id, queue } = item;
             if (typeof address !== "string" || typeof room !== "string" || typeof queue !== "string") {
                 throw new requirement_1.RoomException("Invalid mailbox payload: missing fields");
             }
-            return { address, room, queue };
+            if (room_id !== undefined && typeof room_id !== "string") {
+                throw new requirement_1.RoomException("Invalid mailbox payload: invalid room_id");
+            }
+            return { address, room, roomId: room_id, queue };
         });
     }
     async deleteMailbox(projectId, address) {
@@ -839,11 +843,12 @@ class Meshagent {
         return secrets.map((item) => this.parseSecret(item));
     }
     async createRoom(params) {
-        const { projectId, name, ifNotExists = false, metadata, permissions } = params;
+        const { projectId, name, ifNotExists = false, metadata, annotations, permissions } = params;
         const payload = {
             name,
             if_not_exists: Boolean(ifNotExists),
             metadata,
+            annotations,
         };
         if (permissions) {
             const serialized = {};
@@ -865,10 +870,17 @@ class Meshagent {
         });
         return this.parseRoom(data);
     }
-    async updateRoom(projectId, roomId, name) {
+    async updateRoom(projectId, roomId, name, options = {}) {
+        const payload = { name };
+        if (options.metadata !== undefined) {
+            payload["metadata"] = options.metadata;
+        }
+        if (options.annotations !== undefined) {
+            payload["annotations"] = options.annotations;
+        }
         await this.request(`/accounts/projects/${projectId}/rooms/${roomId}`, {
             method: "PUT",
-            json: { name },
+            json: payload,
             action: "update room",
             responseType: "void",
         });

package/dist/node/queues-client.js

@@ -36,7 +36,7 @@ class QueuesClient {
             create,
             wait,
         });
-        if (response instanceof response_1.EmptyResponse) {
+        if (response instanceof response_1.EmptyContent) {
             return null;
         }
         else {

package/dist/node/response.d.ts

@@ -1,18 +1,18 @@
-export interface Response {
+export interface Content {
     pack(): Uint8Array;
 }
-export declare class LinkResponse implements Response {
+export declare class LinkContent implements Content {
     url: string;
     name: string;
     constructor({ url, name }: {
         url: string;
         name: string;
     });
-    static unpack(header: Record<string, any>, payload: Uint8Array): LinkResponse;
+    static unpack(header: Record<string, any>, _payload: Uint8Array): LinkContent;
     pack(): Uint8Array;
     toString(): string;
 }
-export declare class FileResponse implements Response {
+export declare class FileContent implements Content {
     data: Uint8Array;
     name: string;
     mimeType: string;
@@ -21,40 +21,40 @@ export declare class FileResponse implements Response {
         name: string;
         mimeType: string;
     });
-    static unpack(header: Record<string, any>, payload: Uint8Array): FileResponse;
+    static unpack(header: Record<string, any>, payload: Uint8Array): FileContent;
     pack(): Uint8Array;
     toString(): string;
 }
-export declare class TextResponse implements Response {
+export declare class TextContent implements Content {
     text: string;
     constructor({ text }: {
         text: string;
     });
-    static unpack(header: Record<string, any>, payload: Uint8Array): TextResponse;
+    static unpack(header: Record<string, any>, _payload: Uint8Array): TextContent;
     pack(): Uint8Array;
     toString(): string;
 }
-export declare class JsonResponse implements Response {
+export declare class JsonContent implements Content {
     json: Record<string, any>;
     constructor({ json }: {
         json: Record<string, any>;
     });
-    static unpack(header: Record<string, any>, payload: Uint8Array): JsonResponse;
+    static unpack(header: Record<string, any>, _payload: Uint8Array): JsonContent;
     pack(): Uint8Array;
     toString(): string;
 }
-export declare class ErrorResponse implements Response {
+export declare class ErrorContent implements Content {
     text: string;
     constructor({ text }: {
         text: string;
     });
-    static unpack(header: Record<string, any>, payload: Uint8Array): ErrorResponse;
+    static unpack(header: Record<string, any>, _payload: Uint8Array): ErrorContent;
     pack(): Uint8Array;
     toString(): string;
 }
-export declare class EmptyResponse implements Response {
-    static unpack(header: Record<string, any>, payload: Uint8Array): EmptyResponse;
+export declare class EmptyContent implements Content {
+    static unpack(_header: Record<string, any>, _payload: Uint8Array): EmptyContent;
     pack(): Uint8Array;
     toString(): string;
 }
-export declare function unpackResponse(data: Uint8Array): Response;
+export declare function unpackContent(data: Uint8Array): Content;

package/dist/node/response.js

@@ -1,15 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EmptyResponse = exports.ErrorResponse = exports.JsonResponse = exports.TextResponse = exports.FileResponse = exports.LinkResponse = void 0;
-exports.unpackResponse = unpackResponse;
+exports.EmptyContent = exports.ErrorContent = exports.JsonContent = exports.TextContent = exports.FileContent = exports.LinkContent = void 0;
+exports.unpackContent = unpackContent;
 const utils_1 = require("./utils");
-class LinkResponse {
+class LinkContent {
     constructor({ url, name }) {
         this.url = url;
         this.name = name;
     }
-    static unpack(header, payload) {
-        return new LinkResponse({
+    static unpack(header, _payload) {
+        return new LinkContent({
             url: header["url"],
             name: header["name"],
         });
@@ -22,18 +22,18 @@ class LinkResponse {
         });
     }
     toString() {
-        return `LinkResponse (${this.name}): ${this.url}`;
+        return `LinkContent (${this.name}): ${this.url}`;
     }
 }
-exports.LinkResponse = LinkResponse;
-class FileResponse {
+exports.LinkContent = LinkContent;
+class FileContent {
     constructor({ data, name, mimeType }) {
         this.data = data;
         this.name = name;
         this.mimeType = mimeType;
     }
     static unpack(header, payload) {
-        return new FileResponse({
+        return new FileContent({
             data: payload,
             name: header["name"],
             mimeType: header["mime_type"],
@@ -47,16 +47,16 @@ class FileResponse {
         }, this.data);
     }
     toString() {
-        return `FileResponse (${this.name}): ${this.mimeType}`;
+        return `FileContent (${this.name}): ${this.mimeType}`;
     }
 }
-exports.FileResponse = FileResponse;
-class TextResponse {
+exports.FileContent = FileContent;
+class TextContent {
     constructor({ text }) {
         this.text = text;
     }
-    static unpack(header, payload) {
-        return new TextResponse({
+    static unpack(header, _payload) {
+        return new TextContent({
             text: header["text"],
         });
     }
@@ -67,16 +67,16 @@ class TextResponse {
         });
     }
     toString() {
-        return `TextResponse: ${this.text}`;
+        return `TextContent: ${this.text}`;
     }
 }
-exports.TextResponse = TextResponse;
-class JsonResponse {
+exports.TextContent = TextContent;
+class JsonContent {
     constructor({ json }) {
         this.json = json;
     }
-    static unpack(header, payload) {
-        return new JsonResponse({ json: header["json"] });
+    static unpack(header, _payload) {
+        return new JsonContent({ json: header["json"] });
     }
     pack() {
         return (0, utils_1.packMessage)({
@@ -85,16 +85,16 @@ class JsonResponse {
         });
     }
     toString() {
-        return `JsonResponse: ${JSON.stringify(this.json)}`;
+        return `JsonContent: ${JSON.stringify(this.json)}`;
     }
 }
-exports.JsonResponse = JsonResponse;
-class ErrorResponse {
+exports.JsonContent = JsonContent;
+class ErrorContent {
     constructor({ text }) {
         this.text = text;
     }
-    static unpack(header, payload) {
-        return new ErrorResponse({ text: header["text"] });
+    static unpack(header, _payload) {
+        return new ErrorContent({ text: header["text"] });
     }
     pack() {
         return (0, utils_1.packMessage)({
@@ -103,36 +103,36 @@ class ErrorResponse {
         });
     }
     toString() {
-        return `ErrorResponse: ${this.text}`;
+        return `ErrorContent: ${this.text}`;
     }
 }
-exports.ErrorResponse = ErrorResponse;
-class EmptyResponse {
-    static unpack(header, payload) {
-        return new EmptyResponse();
+exports.ErrorContent = ErrorContent;
+class EmptyContent {
+    static unpack(_header, _payload) {
+        return new EmptyContent();
     }
     pack() {
         return (0, utils_1.packMessage)({ type: "empty" });
     }
     toString() {
-        return `EmptyResponse`;
+        return `EmptyContent`;
     }
 }
-exports.EmptyResponse = EmptyResponse;
-const _responseTypes = {
-    empty: EmptyResponse.unpack,
-    error: ErrorResponse.unpack,
-    file: FileResponse.unpack,
-    json: JsonResponse.unpack,
-    link: LinkResponse.unpack,
-    text: TextResponse.unpack,
+exports.EmptyContent = EmptyContent;
+const _contentTypes = {
+    empty: EmptyContent.unpack,
+    error: ErrorContent.unpack,
+    file: FileContent.unpack,
+    json: JsonContent.unpack,
+    link: LinkContent.unpack,
+    text: TextContent.unpack,
 };
-function unpackResponse(data) {
+function unpackContent(data) {
     const header = JSON.parse((0, utils_1.splitMessageHeader)(data));
     const payload = (0, utils_1.splitMessagePayload)(data);
     const typeKey = header["type"];
-    if (!_responseTypes[typeKey]) {
-        throw new Error(`Unknown response type: ${typeKey}`);
+    if (!_contentTypes[typeKey]) {
+        throw new Error(`Unknown content type: ${typeKey}`);
     }
-    return _responseTypes[typeKey](header, payload);
+    return _contentTypes[typeKey](header, payload);
 }

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

@@ -9,7 +9,7 @@ import { DatabaseClient } from "./database-client";
 import { AgentsClient } from "./agent-client";
 import { SecretsClient } from "./secrets-client";
 import { RoomEvent } from "./room-event";
-import { Response } from "./response";
+import { Content } from "./response";
 interface RequestHeader {
     [key: string]: any;
 }
@@ -37,7 +37,7 @@ export declare class RoomClient {
         onError?: (error: Error) => void;
     }): Promise<void>;
     dispose(): void;
-    sendRequest(type: string, request: RequestHeader, data?: Uint8Array): Promise<Response>;
+    sendRequest(type: string, request: RequestHeader, data?: Uint8Array): Promise<Content>;
     private _handleResponse;
     private _handleRoomReady;
     private _onParticipantInit;

package/dist/node/room-client.js

@@ -66,7 +66,7 @@ class RoomClient {
             console.error("No data in response");
             return;
         }
-        const response = (0, response_1.unpackResponse)(data);
+        const response = (0, response_1.unpackContent)(data);
         console.log("GOT RESPONSE", response);
         if (!response) {
             console.error("No response");
@@ -75,7 +75,7 @@ class RoomClient {
         if (this._pendingRequests.has(messageId)) {
             const pr = this._pendingRequests.get(messageId);
             this._pendingRequests.delete(messageId);
-            if (response instanceof response_1.ErrorResponse) {
+            if (response instanceof response_1.ErrorContent) {
                 pr.reject(new Error(response.text));
             }
             else {

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

@@ -1,5 +1,5 @@
 import { RoomClient } from "./room-client";
-import { FileResponse } from "./response";
+import { FileContent } from "./response";
 export interface SecretInfo {
     id: string;
     name: string;
@@ -22,7 +22,7 @@ export declare class SecretsClient {
     getSecret({ secretId, delegatedTo, }: {
         secretId: string;
         delegatedTo?: string;
-    }): Promise<FileResponse | null>;
+    }): Promise<FileContent | null>;
     listSecrets(): Promise<SecretInfo[]>;
     deleteSecret({ secretId, delegatedTo, }: {
         secretId: string;

package/dist/node/secrets-client.js

@@ -19,10 +19,10 @@ class SecretsClient {
         if (forIdentity)
             req.for_identity = forIdentity;
         const response = await this.client.sendRequest("secrets.set_secret", req, data);
-        if (response instanceof response_1.EmptyResponse || response instanceof response_1.JsonResponse) {
+        if (response instanceof response_1.EmptyContent || response instanceof response_1.JsonContent) {
             return;
         }
-        throw new Error("Invalid response received, expected EmptyResponse or JsonResponse");
+        throw new Error("Invalid response received, expected EmptyContent or JsonContent");
     }
     async getSecret({ secretId, delegatedTo, }) {
         const req = {
@@ -31,18 +31,18 @@ class SecretsClient {
         if (delegatedTo)
             req.delegated_to = delegatedTo;
         const response = await this.client.sendRequest("secrets.get_secret", req);
-        if (response instanceof response_1.EmptyResponse) {
+        if (response instanceof response_1.EmptyContent) {
             return null;
         }
-        if (response instanceof response_1.FileResponse) {
+        if (response instanceof response_1.FileContent) {
             return response;
         }
-        throw new Error("Invalid response received, expected FileResponse or EmptyResponse");
+        throw new Error("Invalid response received, expected FileContent or EmptyContent");
     }
     async listSecrets() {
         const response = await this.client.sendRequest("secrets.list_secrets", {});
-        if (!(response instanceof response_1.JsonResponse)) {
-            throw new Error("Invalid response received, expected JsonResponse");
+        if (!(response instanceof response_1.JsonContent)) {
+            throw new Error("Invalid response received, expected JsonContent");
         }
         const secrets = Array.isArray(response.json?.secrets) ? response.json.secrets : [];
         return secrets.map((item) => ({
@@ -59,10 +59,10 @@ class SecretsClient {
         if (delegatedTo)
             req.delegated_to = delegatedTo;
         const response = await this.client.sendRequest("secrets.delete_secret", req);
-        if (response instanceof response_1.EmptyResponse || response instanceof response_1.JsonResponse) {
+        if (response instanceof response_1.EmptyContent || response instanceof response_1.JsonContent) {
             return;
         }
-        throw new Error("Invalid response received, expected EmptyResponse or JsonResponse");
+        throw new Error("Invalid response received, expected EmptyContent or JsonContent");
     }
     async deleteRequestedSecret({ url, type, delegatedTo, }) {
         const req = {
@@ -72,10 +72,10 @@ class SecretsClient {
         if (delegatedTo)
             req.delegated_to = delegatedTo;
         const response = await this.client.sendRequest("secrets.delete_requested_secret", req);
-        if (response instanceof response_1.EmptyResponse || response instanceof response_1.JsonResponse) {
+        if (response instanceof response_1.EmptyContent || response instanceof response_1.JsonContent) {
             return;
         }
-        throw new Error("Invalid response received, expected EmptyResponse or JsonResponse");
+        throw new Error("Invalid response received, expected EmptyContent or JsonContent");
     }
 }
 exports.SecretsClient = SecretsClient;

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

@@ -1,6 +1,6 @@
 import { RoomClient } from "./room-client";
 import { RoomEvent } from "./room-event";
-import { FileResponse } from "./response";
+import { FileContent } from "./response";
 import { EventEmitter } from "./event-emitter";
 export declare class FileHandle {
     id: number;
@@ -32,7 +32,7 @@ export declare class StorageClient extends EventEmitter<RoomEvent> {
     exists(path: string): Promise<boolean>;
     write(handle: FileHandle, bytes: Uint8Array): Promise<void>;
     close(handle: FileHandle): Promise<void>;
-    download(path: string): Promise<FileResponse>;
+    download(path: string): Promise<FileContent>;
     downloadUrl(path: string): Promise<string>;
 }
 export {};

package/dist/node/tool-content-type.d.ts

@@ -0,0 +1,13 @@
+export type ToolContentType = "json" | "text" | "file" | "link" | "empty";
+export declare class ToolContentSpec {
+    readonly types: ToolContentType[];
+    readonly stream: boolean;
+    readonly schema?: Record<string, unknown>;
+    constructor({ types, stream, schema, }: {
+        types: ToolContentType[];
+        stream?: boolean;
+        schema?: Record<string, unknown>;
+    });
+    toJson(): Record<string, unknown>;
+    static fromJson(value: unknown): ToolContentSpec | undefined;
+}

package/dist/node/tool-content-type.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolContentSpec = void 0;
+const SUPPORTED_TOOL_CONTENT_TYPES = new Set([
+    "json",
+    "text",
+    "file",
+    "link",
+    "empty",
+]);
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+class ToolContentSpec {
+    constructor({ types, stream = false, schema, }) {
+        if (!Array.isArray(types) || types.length === 0) {
+            throw new Error("ToolContentSpec.types must contain at least one supported type");
+        }
+        for (const type of types) {
+            if (!SUPPORTED_TOOL_CONTENT_TYPES.has(type)) {
+                throw new Error(`Unsupported tool content type: ${String(type)}`);
+            }
+        }
+        this.types = [...types];
+        this.stream = stream;
+        this.schema = schema;
+    }
+    toJson() {
+        const value = {
+            types: [...this.types],
+            stream: this.stream,
+        };
+        if (this.schema !== undefined) {
+            value["schema"] = this.schema;
+        }
+        return value;
+    }
+    static fromJson(value) {
+        if (value === null || value === undefined) {
+            return undefined;
+        }
+        if (!isRecord(value)) {
+            throw new Error("ToolContentSpec must be a JSON object");
+        }
+        const rawTypes = value["types"];
+        if (!Array.isArray(rawTypes) || rawTypes.length === 0) {
+            throw new Error("ToolContentSpec.types must be a non-empty array");
+        }
+        const types = rawTypes.map((item) => {
+            if (typeof item !== "string") {
+                throw new Error("ToolContentSpec.types values must be strings");
+            }
+            if (!SUPPORTED_TOOL_CONTENT_TYPES.has(item)) {
+                throw new Error(`Unsupported tool content type: ${item}`);
+            }
+            return item;
+        });
+        const rawStream = value["stream"];
+        const stream = typeof rawStream === "boolean" ? rawStream : false;
+        const rawSchema = value["schema"];
+        if (rawSchema !== undefined && !isRecord(rawSchema)) {
+            throw new Error("ToolContentSpec.schema must be an object when provided");
+        }
+        const schema = rawSchema;
+        return new ToolContentSpec({ types, stream, schema });
+    }
+}
+exports.ToolContentSpec = ToolContentSpec;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@meshagent/meshagent",
-    "version": "0.27.0",
+    "version": "0.28.0",
     "description": "Meshagent Client",
     "homepage": "https://github.com/meshagent/meshagent-ts",
     "scripts": {