@meshagent/meshagent 0.37.2 → 0.38.1

package/dist/esm/agent.js

@@ -1,6 +1,8 @@
 import { ErrorContent } from "./response";
+import { RoomServerException } from "./room-server-client";
 import { ToolContentSpec } from "./tool-content-type";
 import { unpackMessage } from "./utils";
+import { RoomStatusEvent } from "./room-event";
 export class Tool {
     constructor({ name, description, title, inputSchema, inputSpec, outputSpec, outputSchema, thumbnailUrl }) {
         this.name = name;
@@ -93,17 +95,46 @@ export class HostedToolkit {
 }
 class _RemoteToolkitWrapper {
     constructor({ toolkit, room }) {
+        this._toolCallHandler = this._toolCall.bind(this);
+        this._roomEventHandler = this._onRoomEvent.bind(this);
+        this._started = false;
+        this._public = false;
+        this._registerTask = null;
         this.toolkit = toolkit;
         this.client = room;
     }
     async start({ public_: isPublic = false } = {}) {
-        const handler = this._toolCall.bind(this);
-        this.client.protocol.addHandler(`room.tool_call.${this.toolkit.name}`, handler);
-        await this._register(isPublic);
+        if (this._started) {
+            throw new RoomServerException(`toolkit '${this.toolkit.name}' is already started`);
+        }
+        this._public = isPublic;
+        this.client.protocol.addHandler(`room.tool_call.${this.toolkit.name}`, this._toolCallHandler);
+        this.client.on("disconnected", this._roomEventHandler);
+        this.client.on("reconnected", this._roomEventHandler);
+        try {
+            await this._register(isPublic);
+            this._started = true;
+        }
+        catch (error) {
+            this.client.off("disconnected", this._roomEventHandler);
+            this.client.off("reconnected", this._roomEventHandler);
+            this.client.protocol.removeHandler(`room.tool_call.${this.toolkit.name}`, this._toolCallHandler);
+            throw error;
+        }
     }
     async stop() {
-        await this._unregister();
-        this.client.protocol.removeHandler(`room.tool_call.${this.toolkit.name}`);
+        if (!this._started) {
+            return;
+        }
+        this._started = false;
+        this.client.off("disconnected", this._roomEventHandler);
+        this.client.off("reconnected", this._roomEventHandler);
+        try {
+            await this._unregister();
+        }
+        finally {
+            this.client.protocol.removeHandler(`room.tool_call.${this.toolkit.name}`, this._toolCallHandler);
+        }
     }
     async _register(public_) {
         const response = await this.client.sendRequest("room.register_toolkit", {
@@ -118,13 +149,43 @@ class _RemoteToolkitWrapper {
         this._registrationId = json["id"];
     }
     async _unregister() {
-        if (!this._registrationId)
+        const registrationId = this._registrationId;
+        this._registrationId = undefined;
+        if (registrationId == null || this.client.isClosed) {
             return;
+        }
         await this.client.sendRequest("room.unregister_toolkit", {
-            id: this._registrationId,
+            id: registrationId,
         });
     }
+    _scheduleRegisterIfNeeded() {
+        if (!this._started || this._registrationId != null || this._registerTask != null || this.client.isClosed) {
+            return;
+        }
+        this._registerTask = this._register(this._public)
+            .catch((error) => {
+            console.warn(`unable to reregister hosted toolkit ${this.toolkit.name}`, error);
+        })
+            .finally(() => {
+            this._registerTask = null;
+        });
+    }
+    _onRoomEvent(event) {
+        if (!this._started || !(event instanceof RoomStatusEvent)) {
+            return;
+        }
+        if (event.status === "disconnected") {
+            this._registrationId = undefined;
+            return;
+        }
+        if (event.status === "reconnected") {
+            this._scheduleRegisterIfNeeded();
+        }
+    }
     async _toolCall(protocol, messageId, type, data) {
+        if (!this.client.isActiveProtocol(protocol)) {
+            return;
+        }
         try {
             const [message, _] = unpackMessage(data);
             const toolName = message["name"];
@@ -150,11 +211,11 @@ class _RemoteToolkitWrapper {
                 args = rawArguments ?? {};
             }
             const response = await this.toolkit.execute(toolName, args);
-            await this.client.protocol.send("room.tool_call_response", response.pack(), messageId);
+            await this.client.protocol.send("room.tool_call_response", response.pack(), { id: messageId });
         }
         catch (e) {
             const err = new ErrorContent({ text: String(e) });
-            await this.client.protocol.send("room.tool_call_response", err.pack(), messageId);
+            await this.client.protocol.send("room.tool_call_response", err.pack(), { id: messageId });
         }
     }
 }
@@ -179,6 +240,9 @@ export class RemoteTaskRunner {
     async start() {
     }
     async stop() {
-        this.client.protocol.removeHandler("agent.ask");
+        const handler = this.client.protocol.getHandler("agent.ask");
+        if (handler != null) {
+            this.client.protocol.removeHandler("agent.ask", handler);
+        }
     }
 }

package/dist/esm/developer-client.js

@@ -14,6 +14,9 @@ export class DeveloperClient extends EventEmitter {
         this.emit("log", event);
     }
     async _handleDeveloperLog(protocol, messageId, type, bytes) {
+        if (!this.client.isActiveProtocol(protocol)) {
+            return;
+        }
         const [rawJson, _] = unpackMessage(bytes || new Uint8Array());
         this._emitDeveloperLog(rawJson["type"], rawJson["data"]);
     }

package/dist/esm/helpers.d.ts

@@ -1,7 +1,7 @@
 import { MeshSchema } from './schema';
 import { RoomClient } from './room-client';
 import { ParticipantToken } from './participant-token';
-import { WebSocketClientProtocol } from './protocol';
+import { ProtocolFactory } from './protocol';
 export declare function validateSchemaName(name: string): void;
 export declare function deploySchema({ room, schema, name, overwrite }: {
     room: RoomClient;
@@ -31,4 +31,4 @@ export declare function websocketProtocol({ participantName, roomName, role, pro
     secret?: string;
     apiUrl?: string;
     apiKey?: string;
-}): Promise<WebSocketClientProtocol>;
+}): Promise<ProtocolFactory>;

package/dist/esm/helpers.js

@@ -56,5 +56,5 @@ export async function websocketProtocol({ participantName, roomName, role, proje
     const url = websocketRoomUrl({ roomName, apiUrl });
     const token = participantToken({ participantName, roomName, role, projectId, apiKeyId, apiKey });
     const jwt = await token.toJwt({ token: secret, apiKey });
-    return new WebSocketClientProtocol({ url, token: jwt });
+    return WebSocketClientProtocol.createFactory({ url, token: jwt });
 }

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

@@ -202,6 +202,14 @@ export interface Mailbox {
     roomId?: string;
     queue: string;
 }
+export interface ProjectRepository {
+    id: string;
+    projectId: string;
+    name: string;
+    description: string;
+    annotations: Record<string, string>;
+    createdAt: Date;
+}
 export interface Balance {
     balance: number;
     autoRechargeThreshold?: number | null;
@@ -278,6 +286,7 @@ export declare class Meshagent {
     private parseRoomShare;
     private parseRoomSession;
     private parseRoom;
+    private parseProjectRepository;
     private parseProjectRoomGrant;
     private parseProjectRoomGrantCount;
     private parseProjectUserGrantCount;
@@ -393,6 +402,22 @@ export declare class Meshagent {
     }): Promise<void>;
     listMailboxes(projectId: string): Promise<Mailbox[]>;
     deleteMailbox(projectId: string, address: string): Promise<void>;
+    createRepository(params: {
+        projectId: string;
+        name: string;
+        description?: string;
+        annotations?: Record<string, string>;
+    }): Promise<ProjectRepository>;
+    updateRepository(params: {
+        projectId: string;
+        repositoryId: string;
+        name: string;
+        description?: string;
+        annotations?: Record<string, string>;
+    }): Promise<ProjectRepository>;
+    getRepository(projectId: string, repositoryId: string): Promise<ProjectRepository>;
+    listRepositories(projectId: string): Promise<ProjectRepository[]>;
+    deleteRepository(projectId: string, repositoryId: string): Promise<void>;
     createService(projectId: string, service: ServiceSpec): Promise<string>;
     createRoomService(projectId: string, roomName: string, service: ServiceSpec): Promise<string>;
     updateRoomService(projectId: string, roomName: string, serviceId: string, service: ServiceSpec): Promise<void>;

package/dist/esm/meshagent-client.js

@@ -223,6 +223,33 @@ export class Meshagent {
             annotations: annotations && typeof annotations === "object" ? annotations : {},
         };
     }
+    parseProjectRepository(data) {
+        if (!data || typeof data !== "object") {
+            throw new RoomException("Invalid repository payload");
+        }
+        const { id, project_id: projectIdRaw, projectId, name, description, annotations, created_at: createdAtRaw, createdAt, } = data;
+        const projectIdValue = typeof projectId === "string"
+            ? projectId
+            : typeof projectIdRaw === "string"
+                ? projectIdRaw
+                : undefined;
+        const createdAtValue = typeof createdAt === "string"
+            ? createdAt
+            : typeof createdAtRaw === "string"
+                ? createdAtRaw
+                : undefined;
+        if (typeof id !== "string" || typeof projectIdValue !== "string" || typeof name !== "string" || typeof createdAtValue !== "string") {
+            throw new RoomException("Invalid repository payload: missing required fields");
+        }
+        return {
+            id,
+            projectId: projectIdValue,
+            name,
+            description: typeof description === "string" ? description : "",
+            annotations: annotations && typeof annotations === "object" ? annotations : {},
+            createdAt: new Date(createdAtValue),
+        };
+    }
     parseProjectRoomGrant(data) {
         if (!data || typeof data !== "object") {
             throw new RoomException("Invalid room grant payload");
@@ -889,6 +916,44 @@ export class Meshagent {
             responseType: "void",
         });
     }
+    async createRepository(params) {
+        const { projectId, name, description = "", annotations = {} } = params;
+        const data = await this.request(`/accounts/projects/${projectId}/repositories`, {
+            method: "POST",
+            json: { name, description, annotations },
+            action: "create repository",
+        });
+        return this.parseProjectRepository(data);
+    }
+    async updateRepository(params) {
+        const { projectId, repositoryId, name, description = "", annotations = {} } = params;
+        const data = await this.request(`/accounts/projects/${projectId}/repositories/${repositoryId}`, {
+            method: "PUT",
+            json: { name, description, annotations },
+            action: "update repository",
+        });
+        return this.parseProjectRepository(data);
+    }
+    async getRepository(projectId, repositoryId) {
+        const data = await this.request(`/accounts/projects/${projectId}/repositories/${repositoryId}`, {
+            action: "fetch repository",
+        });
+        return this.parseProjectRepository(data);
+    }
+    async listRepositories(projectId) {
+        const data = await this.request(`/accounts/projects/${projectId}/repositories`, {
+            action: "list repositories",
+        });
+        const repositories = Array.isArray(data?.repositories) ? data.repositories : [];
+        return repositories.map((item) => this.parseProjectRepository(item));
+    }
+    async deleteRepository(projectId, repositoryId) {
+        await this.request(`/accounts/projects/${projectId}/repositories/${repositoryId}`, {
+            method: "DELETE",
+            action: "delete repository",
+            responseType: "void",
+        });
+    }
     async createService(projectId, service) {
         const data = await this.request(`/accounts/projects/${projectId}/services`, {
             method: "POST",

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

@@ -1,6 +1,6 @@
 import { EventEmitter } from "./event-emitter";
-import { RoomClient } from "./room-client";
 import { Participant, RemoteParticipant } from "./participant";
+import { RoomClient } from "./room-client";
 import { RoomMessageEvent } from "./room-event";
 type MessagePayload = Record<string, unknown>;
 export declare class MessagingClient extends EventEmitter<RoomMessageEvent> {
@@ -11,44 +11,57 @@ export declare class MessagingClient extends EventEmitter<RoomMessageEvent> {
     private _messageQueued;
     private _sendTask;
     private _messageQueueClosed;
-    private _enabled;
+    private _desiredEnabled;
+    private _online;
+    private _enableInFlight;
     constructor({ room }: {
         room: RoomClient;
     });
+    get isEnabled(): boolean;
+    get online(): boolean;
+    get remoteParticipants(): RemoteParticipant[];
     private _messageInput;
-    private _syntheticMessageEvent;
+    private _invoke;
+    private _invokeNowait;
+    start(): void;
+    stop(): Promise<void>;
+    private _nextQueuedMessage;
+    private _wakeMessageQueue;
+    private _queueMessage;
+    private _setOnline;
+    private _waitUntilOnline;
+    private _enableCurrentConnectionNowait;
+    private _clearCurrentConnectionState;
+    _onRoomDisconnect({ reason: _reason }: {
+        reason: string | null;
+    }): void;
+    _onRoomReconnect(): void;
     private _removeParticipant;
     private _markParticipantOffline;
     private _resolveMessageRecipient;
-    private _queueMessage;
-    private _rejectQueuedMessages;
-    private _isParticipantNotFound;
-    private _nextQueuedMessage;
+    private _dropQueuedMessage;
+    private _drainQueuedMessages;
     private _sendMessages;
-    start(): Promise<void>;
-    stop(): Promise<void>;
-    sendMessage({ to, type, message, attachment, ignoreOffline }: {
+    sendMessage({ to, type, message, attachment, ignoreOffline, }: {
         to: Participant;
         type: string;
         message: MessagePayload;
         attachment?: Uint8Array;
         ignoreOffline?: boolean;
     }): Promise<void>;
-    sendMessageNowait({ to, type, message, attachment }: {
+    sendMessageNowait({ to, type, message, attachment, }: {
         to: Participant;
         type: string;
         message: MessagePayload;
         attachment?: Uint8Array;
     }): void;
-    enable(): Promise<void>;
-    disable(): Promise<void>;
-    broadcastMessage({ type, message, attachment }: {
+    enable(): void;
+    disable(): void;
+    broadcastMessage({ type, message, attachment, }: {
         type: string;
         message: MessagePayload;
         attachment?: Uint8Array;
     }): Promise<void>;
-    get remoteParticipants(): RemoteParticipant[];
-    get isEnabled(): boolean;
     getParticipants(): RemoteParticipant[];
     getParticipant(id: string): RemoteParticipant | null;
     getParticipantByName(name: string): RemoteParticipant | null;