@meshagent/meshagent 0.3.1 → 0.4.1

package/dist/browser/helpers.d.ts

@@ -10,17 +10,23 @@ export declare function deploySchema({ room, schema, name, overwrite }: {
     overwrite?: boolean;
 }): Promise<void>;
 export declare function meshagentBaseUrl(baseUrl?: string): string;
-export declare function websocketRoomUrl({ roomName, baseUrl }: {
+export declare function websocketRoomUrl({ roomName, apiUrl }: {
     roomName: string;
-    baseUrl?: string;
+    apiUrl?: string;
 }): string;
-export declare function participantToken({ participantName, roomName, role }: {
+export declare function participantToken({ participantName, roomName, role, projectId, apiKeyId, }: {
     participantName: string;
     roomName: string;
     role?: string;
+    projectId: string;
+    apiKeyId: string;
 }): ParticipantToken;
-export declare function websocketProtocol({ participantName, roomName, role }: {
+export declare function websocketProtocol({ participantName, roomName, role, projectId, apiKeyId, secret, apiUrl }: {
     participantName: string;
     roomName: string;
     role?: string;
+    projectId: string;
+    apiKeyId: string;
+    secret: string;
+    apiUrl?: string;
 }): Promise<WebSocketClientProtocol>;

package/dist/browser/helpers.js

@@ -25,41 +25,20 @@ function meshagentBaseUrl(baseUrl) {
     if (baseUrl) {
         return baseUrl;
     }
-    return process.env.MESHAGENT_API_URL || 'https://api.meshagent.com';
+    return 'https://api.meshagent.com';
 }
-function websocketRoomUrl({ roomName, baseUrl }) {
-    if (!baseUrl) {
-        const envApiUrl = process.env.MESHAGENT_API_URL;
-        if (!envApiUrl) {
-            baseUrl = 'wss://api.meshagent.com';
-        }
-        else {
-            if (envApiUrl.startsWith('https:')) {
-                baseUrl = 'wss:' + envApiUrl.substring('https:'.length);
-            }
-            else if (envApiUrl.startsWith('http:')) {
-                baseUrl = 'ws:' + envApiUrl.substring('http:'.length);
-            }
-            else {
-                baseUrl = envApiUrl;
-            }
-        }
+function websocketRoomUrl({ roomName, apiUrl }) {
+    const baseUrl = apiUrl || 'wss://api.meshagent.com';
+    let url = baseUrl;
+    if (baseUrl.startsWith('https:')) {
+        url = 'wss:' + baseUrl.substring('https:'.length);
     }
-    return `${baseUrl}/rooms/${roomName}`;
-}
-function participantToken({ participantName, roomName, role }) {
-    const projectId = process.env.MESHAGENT_PROJECT_ID;
-    const apiKeyId = process.env.MESHAGENT_KEY_ID;
-    const secret = process.env.MESHAGENT_SECRET;
-    if (!projectId) {
-        throw new Error('MESHAGENT_PROJECT_ID must be set. You can find this in the Meshagent Studio under API keys.');
-    }
-    if (!apiKeyId) {
-        throw new Error('MESHAGENT_KEY_ID must be set. You can find this in the Meshagent Studio under API keys.');
-    }
-    if (!secret) {
-        throw new Error('MESHAGENT_SECRET must be set. You can find this in the Meshagent Studio under API keys.');
+    else if (baseUrl.startsWith('http:')) {
+        url = 'ws:' + baseUrl.substring('http:'.length);
     }
+    return `${url}/rooms/${roomName}`;
+}
+function participantToken({ participantName, roomName, role, projectId, apiKeyId, }) {
     const token = new participant_token_1.ParticipantToken({ name: participantName, projectId, apiKeyId });
     token.addRoomGrant(roomName);
     if (role) {
@@ -67,13 +46,9 @@ function participantToken({ participantName, roomName, role }) {
     }
     return token;
 }
-async function websocketProtocol({ participantName, roomName, role }) {
-    const url = websocketRoomUrl({ roomName });
-    const token = participantToken({ participantName, roomName, role });
-    const secret = process.env.MESHAGENT_SECRET;
-    if (!secret) {
-        throw new Error('MESHAGENT_SECRET must be set in the environment.');
-    }
+async function websocketProtocol({ participantName, roomName, role, projectId, apiKeyId, secret, apiUrl }) {
+    const url = websocketRoomUrl({ roomName, apiUrl });
+    const token = participantToken({ participantName, roomName, role, projectId, apiKeyId });
     const jwt = await token.toJwt({ token: secret });
     return new protocol_1.WebSocketClientProtocol({ url, token: jwt });
 }

package/dist/browser/index.d.ts

@@ -22,3 +22,4 @@ export * from './storage-client';
 export * from './stream-controller';
 export * from './sync-client';
 export * from './helpers';
+export * from './utils';

package/dist/browser/index.js

@@ -38,3 +38,4 @@ __exportStar(require("./storage-client"), exports);
 __exportStar(require("./stream-controller"), exports);
 __exportStar(require("./sync-client"), exports);
 __exportStar(require("./helpers"), exports);
+__exportStar(require("./utils"), exports);

package/dist/browser/participant-token.d.ts

@@ -25,12 +25,12 @@ export declare class ParticipantToken {
     addRoleGrant(role: string): void;
     addRoomGrant(roomName: string): void;
     toJson(): Record<string, any>;
-    toJwt({ token }?: {
-        token?: string;
+    toJwt({ token }: {
+        token: string;
     }): Promise<string>;
     static fromJson(json: Record<string, any>): ParticipantToken;
-    static fromJwt(jwtStr: string, options?: {
-        token?: string;
+    static fromJwt(jwtStr: string, options: {
+        token: string;
         verify?: boolean;
     }): Promise<ParticipantToken>;
 }

package/dist/browser/participant-token.js

@@ -51,9 +51,8 @@ class ParticipantToken {
             grants: this.grants.map((g) => g.toJson()),
         };
     }
-    async toJwt({ token } = {}) {
-        const secret = token || process.env.MESHAGENT_SECRET;
-        const secretKey = new TextEncoder().encode(secret);
+    async toJwt({ token }) {
+        const secretKey = new TextEncoder().encode(token);
         const payload = {
             ...this.toJson(),
             ...this.extra,
@@ -75,13 +74,9 @@ class ParticipantToken {
         });
     }
     static async fromJwt(jwtStr, options) {
-        const { token, verify = true } = options || {};
+        const { token, verify = true } = options;
         if (verify) {
-            const secret = token || process.env.MESHAGENT_SECRET;
-            if (!secret) {
-                throw new Error("No secret provided to verify JWT. Provide `token` or set MESHAGENT_SECRET");
-            }
-            const secretKey = new TextEncoder().encode(secret);
+            const secretKey = new TextEncoder().encode(token);
             const { payload } = await (0, jose_1.jwtVerify)(jwtStr, secretKey, {
                 algorithms: ["HS256"],
             });

package/dist/browser/protocol.d.ts

@@ -75,7 +75,11 @@ export declare class Protocol {
     getNextMessageId(): number;
     send(type: string, data: Uint8Array, id?: number): Promise<void>;
     sendJson(object: any): Promise<void>;
-    start(onMessage?: null): void;
+    start({ onMessage, onDone, onError }?: {
+        onMessage?: MessageHandler;
+        onDone?: () => void;
+        onError?: (error: any) => void;
+    }): void;
     dispose(): void;
     onDataReceived(dataPacket: Uint8Array): void;
 }

package/dist/browser/protocol.js

@@ -168,6 +168,11 @@ class Protocol {
     }
     async handleMessage(messageId, type, data) {
         const handler = this.handlers[type] ?? this.handlers["*"];
+        if (!handler) {
+            const d = data ? (0, utils_1.unpackMessage)(data) : null;
+            console.warn(`No handler for message type ${type}; data: ${d}`);
+            return;
+        }
         await handler(this, messageId, type, data);
     }
     getNextMessageId() {
@@ -181,11 +186,11 @@ class Protocol {
     async sendJson(object) {
         return await this.send("application/json", utils_1.encoder.encode(JSON.stringify(object)));
     }
-    start(onMessage = null) {
+    start({ onMessage, onDone, onError } = {}) {
         if (onMessage != null) {
             this.addHandler("*", onMessage);
         }
-        this.channel.start(this.onDataReceived.bind(this), {});
+        this.channel.start(this.onDataReceived.bind(this), { onDone, onError });
         this._iterator?.return(null);
         (async () => {
             this._iterator = this._send.stream();

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

@@ -30,7 +30,10 @@ export declare class RoomClient {
     });
     get localParticipant(): LocalParticipant | null;
     get ready(): Promise<boolean>;
-    start(): Promise<void>;
+    start({ onDone, onError }?: {
+        onDone?: () => void;
+        onError?: (error: Error) => void;
+    }): Promise<void>;
     dispose(): void;
     sendRequest(type: string, request: RequestHeader, data?: Uint8Array): Promise<Response>;
     private _handleResponse;

package/dist/browser/room-client.js

@@ -37,8 +37,8 @@ class RoomClient {
     get ready() {
         return this._ready.fut;
     }
-    async start() {
-        this.sync.start();
+    async start({ onDone, onError } = {}) {
+        this.sync.start({ onDone, onError });
         await this.ready;
     }
     dispose() {

package/dist/browser/sync-client.d.ts

@@ -21,9 +21,13 @@ export declare class SyncClient extends EventEmitter<SyncClientEvent> {
     constructor({ room }: {
         room: RoomClient;
     });
-    start(): void;
+    start({ onDone, onError }?: {
+        onDone?: () => void;
+        onError?: (error: Error) => void;
+    }): void;
     dispose(): void;
     private _handleSync;
+    private _handleStatus;
     create(path: string, json?: Record<string, any>): Promise<void>;
     open(path: string, { create }?: {
         create?: boolean;

package/dist/browser/sync-client.js

@@ -24,9 +24,10 @@ class SyncClient extends event_emitter_1.EventEmitter {
         this._connectedDocuments = {};
         this.client = room;
         this.client.protocol.addHandler("room.sync", this._handleSync.bind(this));
+        this.client.protocol.addHandler("room.status", this._handleStatus.bind(this));
     }
-    start() {
-        this.client.protocol.start();
+    start({ onDone, onError } = {}) {
+        this.client.protocol.start({ onDone, onError });
         (async () => {
             for await (const message of this._changesToSync.stream) {
                 await this.client.sendRequest("room.sync", { path: message.path }, utils_1.encoder.encode(message.base64));
@@ -60,6 +61,11 @@ class SyncClient extends event_emitter_1.EventEmitter {
             throw new room_server_client_1.RoomServerException(`received change for a document that is not connected: ${path}`);
         }
     }
+    async _handleStatus(protocol, messageId, data, bytes) {
+        const headerStr = (0, utils_1.splitMessageHeader)(bytes || new Uint8Array());
+        const header = JSON.parse(headerStr);
+        this.emit("status", header.status);
+    }
     async create(path, json) {
         await this.client.sendRequest("room.create", { path, json });
     }
@@ -99,6 +105,11 @@ class SyncClient extends event_emitter_1.EventEmitter {
         }
     }
     async close(path) {
+        const pending = this._connectingDocuments[path];
+        if (pending) {
+            await pending;
+            await new Promise(resolve => setTimeout(resolve, 50));
+        }
         const rc = this._connectedDocuments[path];
         if (!rc) {
             throw new room_server_client_1.RoomServerException(`Not connected to ${path}`);

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

@@ -0,0 +1,88 @@
+import { RoomClient } from "./room-client";
+import { Response } from "./response";
+import { Requirement } from "./requirement";
+export declare class AgentDescription {
+    readonly name: string;
+    readonly title: string;
+    readonly description: string;
+    readonly outputSchema?: Record<string, any>;
+    readonly inputSchema?: Record<string, any>;
+    readonly requires: Requirement[];
+    readonly labels: string[];
+    readonly supportsTools: boolean;
+    constructor({ name, title, description, outputSchema, inputSchema, requires, labels, supportsTools, }: {
+        name: string;
+        title: string;
+        description: string;
+        outputSchema?: Record<string, any>;
+        inputSchema?: Record<string, any>;
+        requires: Requirement[];
+        labels: string[];
+        supportsTools: boolean;
+    });
+    static fromJson(a: Record<string, any>): AgentDescription;
+}
+export declare class ToolDescription {
+    title: string;
+    name: string;
+    description: string;
+    inputSchema: Record<string, any>;
+    defs?: Record<string, any>;
+    thumbnailUrl?: string;
+    constructor({ title, name, description, inputSchema, thumbnailUrl, defs }: {
+        title: string;
+        name: string;
+        description: string;
+        inputSchema: Record<string, any>;
+        thumbnailUrl?: string;
+        defs?: Record<string, any>;
+    });
+}
+export declare class ToolkitDescription {
+    readonly title: string;
+    readonly name: string;
+    readonly description: string;
+    readonly tools: ToolDescription[];
+    readonly thumbnailUrl?: string;
+    private _byName;
+    constructor({ title, name, description, tools, thumbnailUrl }: {
+        title: string;
+        name: string;
+        description: string;
+        tools: ToolDescription[];
+        thumbnailUrl?: string;
+    });
+    getTool(name: string): ToolDescription | undefined;
+    static fromJson(json: Record<string, any>, opts?: {
+        name?: string;
+    }): ToolkitDescription;
+}
+export declare class ToolkitConfiguration {
+    name: string;
+    use?: string[] | undefined;
+    constructor(name: string, use?: string[] | undefined);
+    toJson(): Record<string, any>;
+}
+export declare class AgentsClient {
+    private client;
+    constructor({ room }: {
+        room: RoomClient;
+    });
+    call(params: {
+        name: string;
+        url: string;
+        arguments: Record<string, any>;
+    }): Promise<void>;
+    ask(params: {
+        agentName: string;
+        toolkits?: ToolkitConfiguration[];
+        arguments: Record<string, any>;
+    }): Promise<Record<string, any>>;
+    listToolkits(): Promise<ToolkitDescription[]>;
+    listAgents(): Promise<AgentDescription[]>;
+    invokeTool(params: {
+        toolkit: string;
+        tool: string;
+        arguments: Record<string, any>;
+    }): Promise<Response>;
+}

package/dist/esm/agent-client.js

@@ -0,0 +1,166 @@
+import { RequiredToolkit, RequiredSchema } from "./requirement";
+export class AgentDescription {
+    constructor({ name, title, description, outputSchema, inputSchema, requires, labels, supportsTools, }) {
+        this.name = name;
+        this.title = title;
+        this.description = description;
+        this.outputSchema = outputSchema;
+        this.inputSchema = inputSchema;
+        this.requires = requires;
+        this.labels = labels;
+        this.supportsTools = supportsTools;
+    }
+    static fromJson(a) {
+        let requires = [];
+        if (Array.isArray(a["requires"])) {
+            requires = a["requires"].map((e) => {
+                if (e["toolkit"] != null) {
+                    return RequiredToolkit.fromJson(e);
+                }
+                if (e["schema"] != null) {
+                    return RequiredSchema.fromJson(e);
+                }
+                throw new Error("Invalid requirement object");
+            });
+        }
+        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,
+            requires,
+            supportsTools: a["supports_tools"] === true,
+            labels,
+        });
+    }
+}
+export class ToolDescription {
+    constructor({ title, name, description, inputSchema, thumbnailUrl, defs }) {
+        this.title = title;
+        this.name = name;
+        this.description = description;
+        this.inputSchema = inputSchema;
+        this.thumbnailUrl = thumbnailUrl;
+        this.defs = defs;
+    }
+}
+export class ToolkitDescription {
+    constructor({ title, name, description, tools, thumbnailUrl }) {
+        this.title = title;
+        this.name = name;
+        this.description = description;
+        this.tools = tools;
+        this.thumbnailUrl = thumbnailUrl;
+        this._byName = new Map(this.tools.map((tool) => [tool.name, tool]));
+    }
+    getTool(name) {
+        return this._byName.get(name);
+    }
+    static fromJson(json, opts) {
+        const { name } = opts ?? {};
+        const title = json["title"] ?? "";
+        const finalName = name ?? json["name"] ?? "";
+        const description = json["description"] ?? "";
+        const thumbnailUrl = json["thumbnail_url"] ?? undefined;
+        const toolsList = [];
+        if (Array.isArray(json["tools"])) {
+            for (const tool of json["tools"]) {
+                toolsList.push(new ToolDescription({
+                    title: tool["title"],
+                    name: tool["name"],
+                    description: tool["description"],
+                    inputSchema: tool["input_schema"],
+                    thumbnailUrl: tool["thumbnail_url"],
+                    defs: tool["defs"],
+                }));
+            }
+        }
+        else if (typeof json["tools"] === "object" && json["tools"] !== null) {
+            const toolsMap = json["tools"];
+            for (const toolName of Object.keys(toolsMap)) {
+                const tool = toolsMap[toolName];
+                toolsList.push(new ToolDescription({
+                    title: tool["title"],
+                    name: toolName,
+                    description: tool["description"],
+                    inputSchema: tool["input_schema"],
+                    thumbnailUrl: tool["thumbnail_url"],
+                    defs: tool["defs"],
+                }));
+            }
+        }
+        return new ToolkitDescription({
+            title,
+            name: finalName,
+            description,
+            thumbnailUrl,
+            tools: toolsList,
+        });
+    }
+}
+export class ToolkitConfiguration {
+    constructor(name, use) {
+        this.name = name;
+        this.use = use;
+    }
+    toJson() {
+        if (!this.use) {
+            return {
+                [this.name]: {},
+            };
+        }
+        else {
+            return {
+                [this.name]: {
+                    use: this.use.reduce((acc, tool) => {
+                        acc[tool] = {};
+                        return acc;
+                    }, {}),
+                },
+            };
+        }
+    }
+}
+export class AgentsClient {
+    constructor({ room }) {
+        this.client = room;
+    }
+    async call(params) {
+        await this.client.sendRequest("agent.call", params);
+    }
+    async ask(params) {
+        const { agentName, toolkits = [], arguments: args } = params;
+        const usedToolkits = {};
+        for (const t of toolkits) {
+            Object.assign(usedToolkits, t.toJson());
+        }
+        const result = (await this.client.sendRequest("agent.ask", {
+            agent: agentName,
+            arguments: args,
+            toolkits: usedToolkits,
+        }));
+        return result.json["answer"];
+    }
+    async listToolkits() {
+        const result = (await this.client.sendRequest("agent.list_toolkits", {}));
+        const tools = result.json["tools"];
+        const toolkits = [];
+        for (const name of Object.keys(tools)) {
+            const data = tools[name];
+            toolkits.push(ToolkitDescription.fromJson(data, { name }));
+        }
+        return toolkits;
+    }
+    async listAgents() {
+        const result = (await this.client.sendRequest("agent.list_agents", {}));
+        return (result.json["agents"] || []).map(AgentDescription.fromJson);
+    }
+    async invokeTool(params) {
+        return await this.client.sendRequest("agent.invoke_tool", params);
+    }
+}

package/dist/esm/agent.d.ts

@@ -0,0 +1,103 @@
+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 AgentCallContext {
+    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;
+}
+export declare abstract class Tool {
+    readonly name: string;
+    readonly description: string;
+    readonly title: string;
+    readonly inputSchema: Record<string, any>;
+    readonly thumbnailUrl?: string;
+    constructor({ name, description, title, inputSchema, thumbnailUrl }: {
+        name: string;
+        description: string;
+        title: string;
+        inputSchema: Record<string, any>;
+        thumbnailUrl?: string;
+    });
+    abstract execute(arguments_: Record<string, any>): Promise<Response>;
+}
+export declare abstract class Toolkit {
+    readonly tools: Tool[];
+    readonly rules: string[];
+    constructor({ tools, rules }: {
+        tools: Tool[];
+        rules?: string[];
+    });
+    getTool(name: string): Tool;
+    getTools(): Record<string, any>;
+    execute(name: string, args: Record<string, any>): Promise<Response>;
+}
+export declare abstract class RemoteToolkit extends Toolkit {
+    protected readonly client: RoomClient;
+    protected readonly name: string;
+    protected readonly title: string;
+    protected readonly description: string;
+    private _registrationId?;
+    constructor({ name, title, description, room, tools, rules }: {
+        name: string;
+        title: string;
+        description: string;
+        room: RoomClient;
+        tools: Tool[];
+        rules?: string[];
+    });
+    start({ public_: isPublic }?: {
+        public_?: boolean;
+    }): Promise<void>;
+    stop(): Promise<void>;
+    private _register;
+    private _unregister;
+    private _toolCall;
+}
+export declare abstract class RemoteTaskRunner {
+    protected readonly client: RoomClient;
+    protected readonly name: string;
+    protected readonly description: string;
+    protected readonly inputSchema?: Record<string, any>;
+    protected readonly outputSchema?: Record<string, any>;
+    protected readonly supportsTools: boolean;
+    protected readonly required: RequiredToolkit[];
+    private _registrationId?;
+    constructor({ name, description, client, inputSchema, outputSchema, supportsTools, required, }: {
+        name: string;
+        description: string;
+        client: RoomClient;
+        inputSchema?: Record<string, any>;
+        outputSchema?: Record<string, any>;
+        supportsTools?: boolean;
+        required?: RequiredToolkit[];
+    });
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    protected _register(): Promise<void>;
+    protected _unregister(): Promise<void>;
+    abstract ask(context: AgentCallContext, arguments_: Record<string, any>): Promise<Record<string, any>>;
+    private _ask;
+}