@meshagent/meshagent 0.40.2 → 0.41.0

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

@@ -207,6 +207,38 @@ export interface ServiceSpec {
     container?: ContainerSpec | null;
     external?: ExternalServiceSpec | null;
 }
+export interface RouteMetadata {
+    name: string;
+    annotations?: Record<string, string>;
+}
+export interface RouteBackendTarget {
+    name: string;
+}
+export interface RouteBackend {
+    room?: RouteBackendTarget | null;
+    agent?: RouteBackendTarget | null;
+}
+export interface RoutePathSpec {
+    path?: string;
+    pathType?: "prefix" | "exact";
+    targetPort: string | number;
+}
+export interface RouteSpec {
+    version: "v1";
+    kind: "Route";
+    metadata: RouteMetadata;
+    domain: string;
+    backend: RouteBackend;
+    paths?: RoutePathSpec[];
+}
+export interface Route {
+    domain: string;
+    spec: RouteSpec;
+}
+export interface RoutesPage {
+    routes: Route[];
+    total: number;
+}
 export interface Mailbox {
     address: string;
     room: string;
@@ -344,6 +376,7 @@ export declare class Meshagent {
     private parseRoomShare;
     private parseRoomSession;
     private parseRoom;
+    private parseRoute;
     private parseFeed;
     private parseFeedSubscription;
     private parseLLMLogger;
@@ -752,6 +785,61 @@ export declare class Meshagent {
         offset?: number;
         orderBy?: string;
     }): Promise<RoomInfo[]>;
+    createRoute(params: {
+        projectId: string;
+        spec: RouteSpec;
+    }): Promise<void>;
+    updateRoute(params: {
+        projectId: string;
+        domain: string;
+        spec: RouteSpec;
+    }): Promise<void>;
+    getRoute(params: {
+        projectId: string;
+        domain: string;
+    }): Promise<Route>;
+    listRoutesPage(projectId: string, options?: {
+        count?: number;
+        offset?: number;
+        filter?: string;
+    }): Promise<RoutesPage>;
+    listRoutes(projectId: string, options?: {
+        count?: number;
+        offset?: number;
+        filter?: string;
+    }): Promise<Route[]>;
+    listRoomRoutesPage(params: {
+        projectId: string;
+        roomName: string;
+        count?: number;
+        offset?: number;
+        filter?: string;
+    }): Promise<RoutesPage>;
+    listRoomRoutes(params: {
+        projectId: string;
+        roomName: string;
+        count?: number;
+        offset?: number;
+        filter?: string;
+    }): Promise<Route[]>;
+    listAgentRoutesPage(params: {
+        projectId: string;
+        agentName: string;
+        count?: number;
+        offset?: number;
+        filter?: string;
+    }): Promise<RoutesPage>;
+    listAgentRoutes(params: {
+        projectId: string;
+        agentName: string;
+        count?: number;
+        offset?: number;
+        filter?: string;
+    }): Promise<Route[]>;
+    deleteRoute(params: {
+        projectId: string;
+        domain: string;
+    }): Promise<void>;
     listRoomGrants(projectId: string, options?: {
         limit?: number;
         offset?: number;

package/dist/node/meshagent-client.js

@@ -231,6 +231,28 @@ class Meshagent {
             annotations: annotations && typeof annotations === "object" ? annotations : {},
         };
     }
+    parseRoute(data) {
+        if (!data || typeof data !== "object") {
+            throw new requirement_1.RoomException("Invalid route payload: expected object");
+        }
+        if (data.spec && typeof data.spec === "object") {
+            return { domain: String(data.domain ?? data.spec.domain), spec: data.spec };
+        }
+        if (typeof data.domain === "string" && typeof data.room_name === "string") {
+            return {
+                domain: data.domain,
+                spec: {
+                    version: "v1",
+                    kind: "Route",
+                    metadata: { name: data.domain, annotations: data.annotations ?? {} },
+                    domain: data.domain,
+                    backend: { room: { name: data.room_name } },
+                    paths: [{ path: "/", pathType: "prefix", targetPort: data.port }],
+                },
+            };
+        }
+        throw new requirement_1.RoomException("Invalid route payload: missing spec");
+    }
     parseFeed(data) {
         if (!data || typeof data !== "object") {
             throw new requirement_1.RoomException("Invalid feed payload");
@@ -1726,6 +1748,76 @@ class Meshagent {
         const rooms = Array.isArray(data?.rooms) ? data.rooms : [];
         return rooms.map((item) => this.parseRoom(item));
     }
+    async createRoute(params) {
+        await this.request(`/accounts/projects/${params.projectId}/routes`, {
+            method: "POST",
+            json: { spec: params.spec },
+            action: "create route",
+            responseType: "void",
+        });
+    }
+    async updateRoute(params) {
+        const domain = this.encodePathComponent(params.domain);
+        await this.request(`/accounts/projects/${params.projectId}/routes/${domain}`, {
+            method: "PUT",
+            json: { spec: params.spec },
+            action: "update route",
+            responseType: "void",
+        });
+    }
+    async getRoute(params) {
+        const domain = this.encodePathComponent(params.domain);
+        const data = await this.request(`/accounts/projects/${params.projectId}/routes/${domain}`, {
+            action: "get route",
+        });
+        return this.parseRoute(data.route);
+    }
+    async listRoutesPage(projectId, options = {}) {
+        const { count = 100, offset = 0, filter } = options;
+        const data = await this.request(`/accounts/projects/${projectId}/routes`, {
+            query: { count, offset, filter },
+            action: "list routes",
+        });
+        const routes = Array.isArray(data.routes) ? data.routes.map((item) => this.parseRoute(item)) : [];
+        return { routes, total: Number(data.total ?? routes.length) };
+    }
+    async listRoutes(projectId, options = {}) {
+        return (await this.listRoutesPage(projectId, options)).routes;
+    }
+    async listRoomRoutesPage(params) {
+        const { projectId, roomName, count = 100, offset = 0, filter } = params;
+        const room = this.encodePathComponent(roomName);
+        const data = await this.request(`/accounts/projects/${projectId}/rooms/${room}/routes`, {
+            query: { count, offset, filter },
+            action: "list room routes",
+        });
+        const routes = Array.isArray(data.routes) ? data.routes.map((item) => this.parseRoute(item)) : [];
+        return { routes, total: Number(data.total ?? routes.length) };
+    }
+    async listRoomRoutes(params) {
+        return (await this.listRoomRoutesPage(params)).routes;
+    }
+    async listAgentRoutesPage(params) {
+        const { projectId, agentName, count = 100, offset = 0, filter } = params;
+        const agent = this.encodePathComponent(agentName);
+        const data = await this.request(`/accounts/projects/${projectId}/agents/${agent}/routes`, {
+            query: { count, offset, filter },
+            action: "list agent routes",
+        });
+        const routes = Array.isArray(data.routes) ? data.routes.map((item) => this.parseRoute(item)) : [];
+        return { routes, total: Number(data.total ?? routes.length) };
+    }
+    async listAgentRoutes(params) {
+        return (await this.listAgentRoutesPage(params)).routes;
+    }
+    async deleteRoute(params) {
+        const domain = this.encodePathComponent(params.domain);
+        await this.request(`/accounts/projects/${params.projectId}/routes/${domain}`, {
+            method: "DELETE",
+            action: "delete route",
+            responseType: "void",
+        });
+    }
     async listRoomGrants(projectId, options = {}) {
         const { limit = 50, offset = 0, orderBy = "room_name" } = options;
         const data = await this.request(`/accounts/projects/${projectId}/room-grants`, {

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

@@ -176,13 +176,12 @@ export declare class RoomClient {
         label: string;
         expectResponse?: boolean;
     }): number | null;
-    invokeNowait({ toolkit, tool, input, participantId, onBehalfOfId, callerContext, }: {
+    invokeNowait({ toolkit, tool, input, participantId, onBehalfOfId, }: {
         toolkit: string;
         tool: string;
         input?: Content;
         participantId?: string;
         onBehalfOfId?: string;
-        callerContext?: Record<string, unknown>;
     }): void;
     _sendLocalAttributesNowait(attributes: Record<string, unknown>): void;
     _resendLocalAttributesNowait(): void;
@@ -204,7 +203,6 @@ export declare class RoomClient {
         input?: Record<string, unknown> | Content;
         participantId?: string;
         onBehalfOfId?: string;
-        callerContext?: Record<string, unknown>;
     }): Promise<Content>;
     invokeWithStreamInput(params: {
         toolkit: string;
@@ -212,7 +210,6 @@ export declare class RoomClient {
         input: AsyncIterable<Content>;
         participantId?: string;
         onBehalfOfId?: string;
-        callerContext?: Record<string, unknown>;
     }): Promise<Content>;
     invokeStream(params: {
         toolkit: string;
@@ -220,7 +217,6 @@ export declare class RoomClient {
         input: AsyncIterable<Content>;
         participantId?: string;
         onBehalfOfId?: string;
-        callerContext?: Record<string, unknown>;
     }): Promise<AsyncIterable<Content>>;
     private _sendToolCallRequestChunk;
     private _streamInvokeToolRequestChunks;

package/dist/node/room-client.js

@@ -1108,7 +1108,7 @@ class RoomClient {
             expectResponse,
         });
     }
-    invokeNowait({ toolkit, tool, input, participantId, onBehalfOfId, callerContext, }) {
+    invokeNowait({ toolkit, tool, input, participantId, onBehalfOfId, }) {
         const resolvedInput = input ?? new response_1.EmptyContent();
         const packedInput = (0, utils_1.unpackMessage)(resolvedInput.pack());
         const request = {
@@ -1116,7 +1116,6 @@ class RoomClient {
             tool,
             participant_id: participantId,
             on_behalf_of_id: onBehalfOfId,
-            caller_context: callerContext,
             tool_call_id: `${Date.now()}-${Math.random().toString(16).slice(2)}`,
             arguments: packedInput[0],
         };
@@ -1228,9 +1227,6 @@ class RoomClient {
         if (params.onBehalfOfId != null) {
             request["on_behalf_of_id"] = params.onBehalfOfId;
         }
-        if (params.callerContext != null) {
-            request["caller_context"] = params.callerContext;
-        }
         return await this.sendRequest("room.invoke_tool", request, requestData);
     }
     async invokeWithStreamInput(params) {
@@ -1247,9 +1243,6 @@ class RoomClient {
         if (params.onBehalfOfId != null) {
             request["on_behalf_of_id"] = params.onBehalfOfId;
         }
-        if (params.callerContext != null) {
-            request["caller_context"] = params.callerContext;
-        }
         const requestTask = this._streamInvokeToolRequestChunks(toolCallId, params.input);
         try {
             const response = await this.sendRequest("room.invoke_tool", request);
@@ -1281,9 +1274,6 @@ class RoomClient {
         if (params.onBehalfOfId != null) {
             request["on_behalf_of_id"] = params.onBehalfOfId;
         }
-        if (params.callerContext != null) {
-            request["caller_context"] = params.callerContext;
-        }
         const requestTask = this._streamInvokeToolRequestChunks(toolCallId, params.input);
         void requestTask.catch((error) => {
             const stream = this._toolCallStreams.get(toolCallId);

package/dist/node/storage-client.js

@@ -136,12 +136,11 @@ class StorageClient extends event_emitter_1.EventEmitter {
             updatedAt: _parseStorageTimestamp(value["updated_at"], operation),
         });
     }
-    async _invoke(operation, input, callerContext) {
+    async _invoke(operation, input) {
         return await this.client.invoke({
             toolkit: "storage",
             tool: operation,
             input,
-            callerContext,
         });
     }
     async list(path) {

package/package.json

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