@meshagent/meshagent 0.40.2 → 0.41.1

package/dist/node/agent.d.ts

@@ -8,8 +8,7 @@ export declare abstract class Tool {
     readonly title: string;
     readonly inputSpec?: ToolContentSpec;
     readonly outputSpec?: ToolContentSpec;
-    readonly thumbnailUrl?: string;
-    constructor({ name, description, title, inputSchema, inputSpec, outputSpec, outputSchema, thumbnailUrl }: {
+    constructor({ name, description, title, inputSchema, inputSpec, outputSpec, outputSchema }: {
         name: string;
         description: string;
         title: string;
@@ -17,7 +16,6 @@ export declare abstract class Tool {
         inputSpec?: ToolContentSpec;
         outputSpec?: ToolContentSpec;
         outputSchema?: Record<string, any>;
-        thumbnailUrl?: string;
     });
     get inputSchema(): Record<string, any> | undefined;
     get outputSchema(): Record<string, any> | undefined;
@@ -27,14 +25,12 @@ export declare class Toolkit {
     readonly name: string;
     readonly title: string;
     readonly description: string;
-    readonly thumbnailUrl?: string;
     readonly tools: Tool[];
     readonly rules: string[];
-    constructor({ name, title, description, thumbnailUrl, tools, rules }: {
+    constructor({ name, title, description, tools, rules }: {
         name: string;
         title?: string;
         description?: string;
-        thumbnailUrl?: string;
         tools: Tool[];
         rules?: string[];
     });

package/dist/node/agent.js

@@ -8,7 +8,7 @@ const tool_content_type_1 = require("./tool-content-type");
 const utils_1 = require("./utils");
 const room_event_1 = require("./room-event");
 class Tool {
-    constructor({ name, description, title, inputSchema, inputSpec, outputSpec, outputSchema, thumbnailUrl }) {
+    constructor({ name, description, title, inputSchema, inputSpec, outputSpec, outputSchema }) {
         this.name = name;
         this.description = description;
         this.title = title;
@@ -46,7 +46,6 @@ class Tool {
                 schema: outputSchema,
             });
         }
-        this.thumbnailUrl = thumbnailUrl;
     }
     get inputSchema() {
         return this.inputSpec?.schema;
@@ -57,11 +56,10 @@ class Tool {
 }
 exports.Tool = Tool;
 class Toolkit {
-    constructor({ name, title = name, description = "", thumbnailUrl, tools, rules = [] }) {
+    constructor({ name, title = name, description = "", tools, rules = [] }) {
         this.name = name;
         this.title = title;
         this.description = description;
-        this.thumbnailUrl = thumbnailUrl;
         this.tools = tools;
         this.rules = rules;
     }
@@ -80,7 +78,6 @@ class Toolkit {
                 title: tool.title,
                 input_spec: tool.inputSpec?.toJson(),
                 output_spec: tool.outputSpec?.toJson(),
-                thumbnail_url: tool.thumbnailUrl,
             };
         }
         return json;
@@ -150,7 +147,6 @@ class _RemoteToolkitWrapper {
             description: this.toolkit.description,
             tools: this.toolkit.getTools(),
             public: public_,
-            thumbnail_url: this.toolkit.thumbnailUrl,
         });
         const json = response.json;
         this._registrationId = json["id"];

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;
@@ -240,6 +272,7 @@ export interface FeedSubscription {
     room: string;
     roomId?: string | null;
     path: string;
+    filenameDatetimeFormat?: string | null;
     createdAt: Date;
     annotations: Record<string, string>;
 }
@@ -344,6 +377,7 @@ export declare class Meshagent {
     private parseRoomShare;
     private parseRoomSession;
     private parseRoom;
+    private parseRoute;
     private parseFeed;
     private parseFeedSubscription;
     private parseLLMLogger;
@@ -541,12 +575,14 @@ export declare class Meshagent {
         feedId: string;
         room: string;
         path: string;
+        filenameDatetimeFormat?: string | null;
         annotations?: Record<string, string>;
     }): Promise<FeedSubscription>;
     updateFeedSubscription(params: {
         projectId: string;
         feedId: string;
         subscriptionId: string;
+        filenameDatetimeFormat?: string | null;
         annotations?: Record<string, string>;
     }): Promise<void>;
     getFeedSubscription(projectId: string, feedId: string, subscriptionId: string): Promise<FeedSubscription>;
@@ -752,6 +788,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");
@@ -277,11 +299,16 @@ class Meshagent {
         if (!data || typeof data !== "object") {
             throw new requirement_1.RoomException("Invalid feed subscription payload");
         }
-        const { id, feed_id: feedIdRaw, feedId, project_id: projectIdRaw, projectId, room, room_id: roomIdRaw, roomId, path, created_at: createdAtRaw, createdAt, annotations, } = data;
+        const { id, feed_id: feedIdRaw, feedId, project_id: projectIdRaw, projectId, room, room_id: roomIdRaw, roomId, path, filename_datetime_format: filenameDatetimeFormatRaw, filenameDatetimeFormat, created_at: createdAtRaw, createdAt, annotations, } = data;
         const feedIdValue = typeof feedId === "string" ? feedId : feedIdRaw;
         const projectIdValue = typeof projectId === "string" ? projectId : projectIdRaw;
         const createdAtValue = typeof createdAt === "string" ? createdAt : createdAtRaw;
         const roomIdValue = typeof roomId === "string" ? roomId : roomIdRaw;
+        const filenameDatetimeFormatValue = typeof filenameDatetimeFormat === "string"
+            ? filenameDatetimeFormat
+            : typeof filenameDatetimeFormatRaw === "string"
+                ? filenameDatetimeFormatRaw
+                : undefined;
         if (typeof id !== "string" ||
             typeof feedIdValue !== "string" ||
             typeof projectIdValue !== "string" ||
@@ -297,6 +324,7 @@ class Meshagent {
             room,
             roomId: typeof roomIdValue === "string" ? roomIdValue : undefined,
             path,
+            filenameDatetimeFormat: filenameDatetimeFormatValue,
             createdAt: new Date(createdAtValue),
             annotations: annotations && typeof annotations === "object" ? annotations : {},
         };
@@ -1140,19 +1168,27 @@ class Meshagent {
         });
     }
     async createFeedSubscription(params) {
-        const { projectId, feedId, room, path, annotations = {} } = params;
+        const { projectId, feedId, room, path, filenameDatetimeFormat, annotations = {} } = params;
         const data = await this.request(`/accounts/projects/${projectId}/feeds/${feedId}/subscriptions`, {
             method: "POST",
-            json: { room, path, annotations },
+            json: {
+                room,
+                path,
+                ...(filenameDatetimeFormat !== undefined ? { filename_datetime_format: filenameDatetimeFormat } : {}),
+                annotations,
+            },
             action: "create feed subscription",
         });
         return this.parseFeedSubscription(data.subscription);
     }
     async updateFeedSubscription(params) {
-        const { projectId, feedId, subscriptionId, annotations = {} } = params;
+        const { projectId, feedId, subscriptionId, filenameDatetimeFormat, annotations = {} } = params;
         await this.request(`/accounts/projects/${projectId}/feeds/${feedId}/subscriptions/${subscriptionId}`, {
             method: "PUT",
-            json: { annotations },
+            json: {
+                ...(filenameDatetimeFormat !== undefined ? { filename_datetime_format: filenameDatetimeFormat } : {}),
+                annotations,
+            },
             action: "update feed subscription",
             responseType: "void",
         });
@@ -1726,6 +1762,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.1",
     "description": "Meshagent Client",
     "homepage": "https://github.com/meshagent/meshagent-ts",
     "scripts": {