@meshagent/meshagent 0.27.0 → 0.28.0

package/dist/browser/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/browser/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/browser/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/browser/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/browser/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/browser/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/browser/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/browser/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/browser/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/dist/esm/agent-client.d.ts

@@ -1,44 +1,31 @@
 import { RoomClient } from "./room-client";
-import { Response } from "./response";
-export declare class AgentDescription {
-    readonly name: string;
-    readonly title: string;
-    readonly description: string;
-    readonly outputSchema?: Record<string, any>;
-    readonly inputSchema?: Record<string, any>;
-    readonly labels: string[];
-    readonly supportsTools: boolean;
-    constructor({ name, title, description, outputSchema, inputSchema, labels, supportsTools, }: {
-        name: string;
-        title: string;
-        description: string;
-        outputSchema?: Record<string, any>;
-        inputSchema?: Record<string, any>;
-        labels?: string[];
-        supportsTools: boolean;
-    });
-    toJson(): Record<string, any>;
-    static fromJson(a: Record<string, any>): AgentDescription;
-}
+import { Content } from "./response";
+import { ToolContentSpec } from "./tool-content-type";
 export declare class ToolDescription {
     title: string;
     name: string;
     description: string;
-    inputSchema: Record<string, any>;
+    inputSpec?: ToolContentSpec;
+    outputSpec?: ToolContentSpec;
     defs?: Record<string, any>;
     thumbnailUrl?: string;
     pricing?: string;
     supportsContext?: boolean;
-    constructor({ title, name, description, inputSchema, thumbnailUrl, defs, pricing, supportsContext }: {
+    constructor({ title, name, description, inputSchema, inputSpec, outputSpec, outputSchema, thumbnailUrl, defs, pricing, supportsContext }: {
         title: string;
         name: string;
         description: string;
-        inputSchema: Record<string, any>;
+        inputSchema?: Record<string, any>;
+        inputSpec?: ToolContentSpec;
+        outputSpec?: ToolContentSpec;
+        outputSchema?: Record<string, any>;
         thumbnailUrl?: string;
         defs?: Record<string, any>;
         pricing?: string;
         supportsContext?: boolean;
     });
+    get inputSchema(): Record<string, any> | undefined;
+    get outputSchema(): Record<string, any> | undefined;
 }
 export declare class ToolkitDescription {
     readonly title: string;
@@ -87,5 +74,5 @@ export declare class AgentsClient {
         toolkit: string;
         tool: string;
         arguments: Record<string, any>;
-    }): Promise<Response>;
+    }): Promise<Content>;
 }

package/dist/esm/agent-client.js

@@ -1,51 +1,54 @@
-export class AgentDescription {
-    constructor({ name, title, description, outputSchema, inputSchema, labels, supportsTools, }) {
-        this.name = name;
-        this.title = title;
-        this.description = description;
-        this.outputSchema = outputSchema;
-        this.inputSchema = inputSchema;
-        this.labels = Array.isArray(labels) ? labels : [];
-        this.supportsTools = supportsTools ?? false;
-    }
-    toJson() {
-        return {
-            name: this.name,
-            title: this.title,
-            description: this.description,
-            input_schema: this.inputSchema,
-            output_schema: this.outputSchema,
-            labels: this.labels,
-            supports_tools: this.supportsTools,
-        };
-    }
-    static fromJson(a) {
-        let labels = [];
-        if (Array.isArray(a["labels"])) {
-            labels = a["labels"].filter((item) => typeof item === "string");
-        }
-        return new AgentDescription({
-            name: a["name"],
-            title: a["title"] ?? "",
-            description: a["description"] ?? "",
-            inputSchema: a["input_schema"] ?? undefined,
-            outputSchema: a["output_schema"] ?? undefined,
-            supportsTools: a["supports_tools"] === true,
-            labels,
-        });
-    }
-}
+import { ToolContentSpec } from "./tool-content-type";
 export class ToolDescription {
-    constructor({ title, name, description, inputSchema, thumbnailUrl, defs, pricing, supportsContext }) {
+    constructor({ title, name, description, inputSchema, inputSpec, outputSpec, outputSchema, thumbnailUrl, defs, pricing, supportsContext }) {
         this.title = title;
         this.name = name;
         this.description = description;
-        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;
         this.defs = defs;
         this.pricing = pricing;
         this.supportsContext = supportsContext ?? false;
     }
+    get inputSchema() {
+        return this.inputSpec?.schema;
+    }
+    get outputSchema() {
+        return this.outputSpec?.schema;
+    }
 }
 export class ToolkitDescription {
     constructor({ title, name, description, tools, thumbnailUrl, participantId }) {
@@ -73,9 +76,12 @@ export class ToolkitDescription {
                 name: tool.name,
                 title: tool.title,
                 description: tool.description,
-                input_schema: tool.inputSchema,
+                input_spec: tool.inputSpec?.toJson(),
+                output_spec: tool.outputSpec?.toJson(),
                 thumbnail_url: tool.thumbnailUrl,
                 defs: tool.defs,
+                pricing: tool.pricing,
+                supports_context: tool.supportsContext,
             })),
         };
     }
@@ -94,10 +100,13 @@ export class ToolkitDescription {
                     name: tool["name"],
                     description: tool["description"],
                     inputSchema: tool["input_schema"],
+                    inputSpec: ToolContentSpec.fromJson(tool["input_spec"]),
+                    outputSchema: tool["output_schema"],
+                    outputSpec: ToolContentSpec.fromJson(tool["output_spec"]),
                     thumbnailUrl: tool["thumbnail_url"],
                     defs: tool["defs"],
                     pricing: tool["pricing"],
-                    supportsContext: tool["supportsContext"],
+                    supportsContext: tool["supports_context"] ?? tool["supportsContext"],
                 }));
             }
         }
@@ -110,10 +119,13 @@ export class ToolkitDescription {
                     name: toolName,
                     description: tool["description"],
                     inputSchema: tool["input_schema"],
+                    inputSpec: ToolContentSpec.fromJson(tool["input_spec"]),
+                    outputSchema: tool["output_schema"],
+                    outputSpec: ToolContentSpec.fromJson(tool["output_spec"]),
                     thumbnailUrl: tool["thumbnail_url"],
                     defs: tool["defs"],
                     pricing: tool["pricing"],
-                    supportsContext: tool["supportsContext"],
+                    supportsContext: tool["supports_context"] ?? tool["supportsContext"],
                 }));
             }
         }
@@ -178,6 +190,14 @@ export class AgentsClient {
         return toolkits;
     }
     async invokeTool(params) {
-        return await this.client.sendRequest("agent.invoke_tool", params);
+        const request = {
+            toolkit: params.toolkit,
+            tool: params.tool,
+            arguments: {
+                type: "json",
+                json: params.arguments,
+            },
+        };
+        return await this.client.sendRequest("agent.invoke_tool", request);
     }
 }