@meshagent/meshagent 0.27.0 → 0.28.0

package/dist/esm/agent.d.ts

@@ -1,47 +1,27 @@
 import { RoomClient } from "./room-client";
 import { RequiredToolkit } from "./requirement";
-import { Response } from "./response";
-export declare class AgentChatContext {
-    messages: Array<Record<string, any>>;
-    readonly systemRole: string;
-    constructor({ messages, systemRole }: {
-        messages?: Array<Record<string, any>>;
-        systemRole?: string;
-    });
-    appendRules(rules: string[]): void;
-    appendUserMessage(message: string): void;
-    appendUserImage(url: string): void;
-    copy(): AgentChatContext;
-    toJson(): Record<string, any>;
-    static fromJson(json: Record<string, any>): AgentChatContext;
-}
-export declare class TaskContext {
-    private readonly _jwt;
-    private readonly _chat;
-    private readonly _apiUrl;
-    constructor({ chat, jwt, api_url }: {
-        chat: AgentChatContext;
-        jwt: string;
-        api_url: string;
-    });
-    get chat(): AgentChatContext;
-    get jwt(): string;
-    get api_url(): string;
-}
+import { Content } from "./response";
+import { ToolContentSpec } from "./tool-content-type";
 export declare abstract class Tool {
     readonly name: string;
     readonly description: string;
     readonly title: string;
-    readonly inputSchema: Record<string, any>;
+    readonly inputSpec?: ToolContentSpec;
+    readonly outputSpec?: ToolContentSpec;
     readonly thumbnailUrl?: string;
-    constructor({ name, description, title, inputSchema, thumbnailUrl }: {
+    constructor({ name, description, title, inputSchema, inputSpec, outputSpec, outputSchema, thumbnailUrl }: {
         name: string;
         description: string;
         title: string;
-        inputSchema: Record<string, any>;
+        inputSchema?: Record<string, any>;
+        inputSpec?: ToolContentSpec;
+        outputSpec?: ToolContentSpec;
+        outputSchema?: Record<string, any>;
         thumbnailUrl?: string;
     });
-    abstract execute(arguments_: Record<string, any>): Promise<Response>;
+    get inputSchema(): Record<string, any> | undefined;
+    get outputSchema(): Record<string, any> | undefined;
+    abstract execute(arguments_: Record<string, any>): Promise<Content>;
 }
 export declare abstract class Toolkit {
     readonly tools: Tool[];
@@ -52,7 +32,7 @@ export declare abstract class Toolkit {
     });
     getTool(name: string): Tool;
     getTools(): Record<string, any>;
-    execute(name: string, args: Record<string, any>): Promise<Response>;
+    execute(name: string, args: Record<string, any>): Promise<Content>;
 }
 export declare abstract class RemoteToolkit extends Toolkit {
     protected readonly client: RoomClient;
@@ -96,5 +76,5 @@ export declare abstract class RemoteTaskRunner {
     });
     start(): Promise<void>;
     stop(): Promise<void>;
-    abstract ask(context: TaskContext, arguments_: Record<string, any>): Promise<Record<string, any>>;
+    abstract ask(arguments_: Record<string, any>): Promise<Record<string, any>>;
 }

package/dist/esm/agent.js

@@ -1,80 +1,53 @@
-import { ErrorResponse } from "./response";
+import { ErrorContent } from "./response";
+import { ToolContentSpec } from "./tool-content-type";
 import { unpackMessage } from "./utils";
-export class AgentChatContext {
-    constructor({ messages, systemRole = "system" }) {
-        this.messages = messages ? [...messages] : [];
-        this.systemRole = systemRole;
-    }
-    appendRules(rules) {
-        let systemMessage = this.messages.find((m) => m["role"] === this.systemRole);
-        if (!systemMessage) {
-            systemMessage = { role: this.systemRole, content: "" };
-            this.messages.push(systemMessage);
-        }
-        const plan = `
-        Rules:
-            -${rules.join("\n-")}
-        `;
-        systemMessage["content"] += plan;
-    }
-    appendUserMessage(message) {
-        this.messages.push({ role: "user", content: message });
-    }
-    appendUserImage(url) {
-        this.messages.push({
-            role: "user",
-            content: [
-                {
-                    type: "image_url",
-                    image_url: { url: url, detail: "auto" },
-                },
-            ],
-        });
-    }
-    copy() {
-        const cloned = JSON.parse(JSON.stringify(this.messages));
-        return new AgentChatContext({
-            messages: cloned,
-            systemRole: this.systemRole,
-        });
-    }
-    toJson() {
-        return {
-            messages: this.messages,
-            system_role: this.systemRole,
-        };
-    }
-    static fromJson(json) {
-        return new AgentChatContext({
-            messages: json["messages"],
-            systemRole: json["system_role"] || "system",
-        });
-    }
-}
-export class TaskContext {
-    constructor({ chat, jwt, api_url }) {
-        this._jwt = jwt;
-        this._chat = chat;
-        this._apiUrl = api_url;
-    }
-    get chat() {
-        return this._chat;
-    }
-    get jwt() {
-        return this._jwt;
-    }
-    get api_url() {
-        return this._apiUrl;
-    }
-}
 export class Tool {
-    constructor({ name, description, title, inputSchema, thumbnailUrl }) {
+    constructor({ name, description, title, inputSchema, inputSpec, outputSpec, outputSchema, thumbnailUrl }) {
         this.name = name;
         this.description = description;
         this.title = title;
-        this.inputSchema = inputSchema;
+        if (inputSpec !== undefined && inputSchema !== undefined) {
+            this.inputSpec = new ToolContentSpec({
+                types: [...inputSpec.types],
+                stream: inputSpec.stream,
+                schema: inputSchema,
+            });
+        }
+        else if (inputSpec !== undefined) {
+            this.inputSpec = inputSpec;
+        }
+        else if (inputSchema !== undefined) {
+            this.inputSpec = new ToolContentSpec({
+                types: ["json"],
+                stream: false,
+                schema: inputSchema,
+            });
+        }
+        if (outputSpec !== undefined && outputSchema !== undefined) {
+            this.outputSpec = new ToolContentSpec({
+                types: [...outputSpec.types],
+                stream: outputSpec.stream,
+                schema: outputSchema,
+            });
+        }
+        else if (outputSpec !== undefined) {
+            this.outputSpec = outputSpec;
+        }
+        else if (outputSchema !== undefined) {
+            this.outputSpec = new ToolContentSpec({
+                types: ["json"],
+                stream: false,
+                schema: outputSchema,
+            });
+        }
         this.thumbnailUrl = thumbnailUrl;
     }
+    get inputSchema() {
+        return this.inputSpec?.schema;
+    }
+    get outputSchema() {
+        return this.outputSpec?.schema;
+    }
 }
 export class Toolkit {
     constructor({ tools, rules = [] }) {
@@ -94,7 +67,8 @@ export class Toolkit {
             json[tool.name] = {
                 description: tool.description,
                 title: tool.title,
-                input_schema: tool.inputSchema,
+                input_spec: tool.inputSpec?.toJson(),
+                output_spec: tool.outputSpec?.toJson(),
                 thumbnail_url: tool.thumbnailUrl,
             };
         }
@@ -143,12 +117,32 @@ export class RemoteToolkit extends Toolkit {
         try {
             const [message, _] = unpackMessage(data);
             const toolName = message["name"];
-            const args = message["arguments"];
+            const rawArguments = message["arguments"];
+            let args;
+            if (rawArguments &&
+                typeof rawArguments === "object" &&
+                !Array.isArray(rawArguments) &&
+                "type" in rawArguments) {
+                const content = rawArguments;
+                const contentType = content["type"];
+                if (contentType === "json") {
+                    args = content["json"] ?? {};
+                }
+                else if (contentType === "empty") {
+                    args = {};
+                }
+                else {
+                    throw new Error(`tool '${toolName}' requires JSON object input, received content type '${String(contentType)}'`);
+                }
+            }
+            else {
+                args = rawArguments ?? {};
+            }
             const response = await this.execute(toolName, args);
             await this.client.protocol.send("agent.tool_call_response", response.pack(), messageId);
         }
         catch (e) {
-            const err = new ErrorResponse({ text: String(e) });
+            const err = new ErrorContent({ text: String(e) });
             await this.client.protocol.send("agent.tool_call_response", err.pack(), messageId);
         }
     }

package/dist/esm/database-client.js

@@ -1,4 +1,4 @@
-import { JsonResponse } from "./response";
+import { JsonContent } from "./response";
 export class DatabaseClient {
     constructor({ room }) {
         this.room = room;
@@ -66,7 +66,7 @@ export class DatabaseClient {
             params,
         };
         const response = await this.room.sendRequest("database.sql", payload);
-        if (response instanceof JsonResponse) {
+        if (response instanceof JsonContent) {
             if (response?.json?.results) {
                 return response.json.results;
             }
@@ -97,7 +97,7 @@ export class DatabaseClient {
             payload.vector = vector;
         }
         const response = await this.room.sendRequest("database.search", payload);
-        if (response instanceof JsonResponse) {
+        if (response instanceof JsonContent) {
             if (response?.json?.results) {
                 return response.json.results;
             }

package/dist/esm/index.d.ts

@@ -26,4 +26,5 @@ export * from './stream-controller';
 export * from './sync-client';
 export * from './api_keys';
 export * from './helpers';
+export * from './tool-content-type';
 export * from './utils';

package/dist/esm/index.js

@@ -26,4 +26,5 @@ export * from './stream-controller';
 export * from './sync-client';
 export * from './api_keys';
 export * from './helpers';
+export * from './tool-content-type';
 export * from './utils';

package/dist/esm/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/esm/meshagent-client.js

@@ -173,7 +173,7 @@ export class Meshagent {
         if (!data || typeof data !== "object") {
             throw new RoomException("Invalid room payload");
         }
-        const { id, name, metadata } = data;
+        const { id, name, metadata, annotations } = data;
         if (typeof id !== "string" || typeof name !== "string") {
             throw new RoomException("Invalid room payload: missing id or name");
         }
@@ -181,6 +181,7 @@ export class Meshagent {
             id,
             name,
             metadata: metadata && typeof metadata === "object" ? metadata : {},
+            annotations: annotations && typeof annotations === "object" ? annotations : {},
         };
     }
     parseProjectRoomGrant(data) {
@@ -707,11 +708,14 @@ export class Meshagent {
             if (!item || typeof item !== "object") {
                 throw new 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 RoomException("Invalid mailbox payload: missing fields");
             }
-            return { address, room, queue };
+            if (room_id !== undefined && typeof room_id !== "string") {
+                throw new RoomException("Invalid mailbox payload: invalid room_id");
+            }
+            return { address, room, roomId: room_id, queue };
         });
     }
     async deleteMailbox(projectId, address) {
@@ -836,11 +840,12 @@ export 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 = {};
@@ -862,10 +867,17 @@ export 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/esm/queues-client.js

@@ -1,4 +1,4 @@
-import { EmptyResponse } from "./response";
+import { EmptyContent } from "./response";
 export class Queue {
     constructor({ name, size }) {
         this.name = name;
@@ -32,7 +32,7 @@ export class QueuesClient {
             create,
             wait,
         });
-        if (response instanceof EmptyResponse) {
+        if (response instanceof EmptyContent) {
             return null;
         }
         else {

package/dist/esm/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/esm/response.js

@@ -1,11 +1,11 @@
 import { packMessage, splitMessageHeader, splitMessagePayload } from "./utils";
-export class LinkResponse {
+export 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"],
         });
@@ -18,17 +18,17 @@ export class LinkResponse {
         });
     }
     toString() {
-        return `LinkResponse (${this.name}): ${this.url}`;
+        return `LinkContent (${this.name}): ${this.url}`;
     }
 }
-export class FileResponse {
+export 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"],
@@ -42,15 +42,15 @@ export class FileResponse {
         }, this.data);
     }
     toString() {
-        return `FileResponse (${this.name}): ${this.mimeType}`;
+        return `FileContent (${this.name}): ${this.mimeType}`;
     }
 }
-export class TextResponse {
+export class TextContent {
     constructor({ text }) {
         this.text = text;
     }
-    static unpack(header, payload) {
-        return new TextResponse({
+    static unpack(header, _payload) {
+        return new TextContent({
             text: header["text"],
         });
     }
@@ -61,15 +61,15 @@ export class TextResponse {
         });
     }
     toString() {
-        return `TextResponse: ${this.text}`;
+        return `TextContent: ${this.text}`;
     }
 }
-export class JsonResponse {
+export 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 packMessage({
@@ -78,15 +78,15 @@ export class JsonResponse {
         });
     }
     toString() {
-        return `JsonResponse: ${JSON.stringify(this.json)}`;
+        return `JsonContent: ${JSON.stringify(this.json)}`;
     }
 }
-export class ErrorResponse {
+export 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 packMessage({
@@ -95,34 +95,34 @@ export class ErrorResponse {
         });
     }
     toString() {
-        return `ErrorResponse: ${this.text}`;
+        return `ErrorContent: ${this.text}`;
     }
 }
-export class EmptyResponse {
-    static unpack(header, payload) {
-        return new EmptyResponse();
+export class EmptyContent {
+    static unpack(_header, _payload) {
+        return new EmptyContent();
     }
     pack() {
         return packMessage({ type: "empty" });
     }
     toString() {
-        return `EmptyResponse`;
+        return `EmptyContent`;
     }
 }
-const _responseTypes = {
-    empty: EmptyResponse.unpack,
-    error: ErrorResponse.unpack,
-    file: FileResponse.unpack,
-    json: JsonResponse.unpack,
-    link: LinkResponse.unpack,
-    text: TextResponse.unpack,
+const _contentTypes = {
+    empty: EmptyContent.unpack,
+    error: ErrorContent.unpack,
+    file: FileContent.unpack,
+    json: JsonContent.unpack,
+    link: LinkContent.unpack,
+    text: TextContent.unpack,
 };
-export function unpackResponse(data) {
+export function unpackContent(data) {
     const header = JSON.parse(splitMessageHeader(data));
     const payload = 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/esm/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/esm/room-client.js

@@ -10,7 +10,7 @@ import { QueuesClient } from "./queues-client";
 import { DatabaseClient } from "./database-client";
 import { AgentsClient } from "./agent-client";
 import { SecretsClient } from "./secrets-client";
-import { ErrorResponse, unpackResponse } from "./response";
+import { ErrorContent, unpackContent } from "./response";
 export class RoomClient {
     constructor({ protocol }) {
         this._pendingRequests = new Map();
@@ -63,7 +63,7 @@ export class RoomClient {
             console.error("No data in response");
             return;
         }
-        const response = unpackResponse(data);
+        const response = unpackContent(data);
         console.log("GOT RESPONSE", response);
         if (!response) {
             console.error("No response");
@@ -72,7 +72,7 @@ export class RoomClient {
         if (this._pendingRequests.has(messageId)) {
             const pr = this._pendingRequests.get(messageId);
             this._pendingRequests.delete(messageId);
-            if (response instanceof ErrorResponse) {
+            if (response instanceof ErrorContent) {
                 pr.reject(new Error(response.text));
             }
             else {