@meshagent/meshagent 0.0.11 → 0.0.13

package/dist/browser/utils.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RefCount = exports.decoder = exports.encoder = void 0;
+exports.splitMessagePayload = splitMessagePayload;
+exports.splitMessageHeader = splitMessageHeader;
+exports.packMessage = packMessage;
+exports.mergeUint8Arrays = mergeUint8Arrays;
+exports.blobToArrayBuffer = blobToArrayBuffer;
+const text_encoding_1 = require("@kayahr/text-encoding");
+const encoder = new text_encoding_1.TextEncoder();
+exports.encoder = encoder;
+const decoder = new text_encoding_1.TextDecoder();
+exports.decoder = decoder;
+function splitMessagePayload(packet) {
+    const dataView = new DataView(packet.buffer, packet.byteOffset, packet.byteLength);
+    const headerSize = dataView.getUint32(4, false) + dataView.getUint32(0, false) * Math.pow(2, 32);
+    return packet.subarray(8 + headerSize, packet.length);
+}
+function splitMessageHeader(packet) {
+    const dataView = new DataView(packet.buffer, packet.byteOffset, packet.byteLength);
+    const headerSize = dataView.getUint32(4, false) + dataView.getUint32(0, false) * Math.pow(2, 32);
+    const payload = packet.subarray(8, 8 + headerSize);
+    return decoder.decode(payload);
+}
+function packMessage(request, data) {
+    const jsonMessage = encoder.encode(JSON.stringify(request));
+    const size = jsonMessage.length;
+    const header = new Uint8Array(4 * 2);
+    const dataView = new DataView(header.buffer);
+    dataView.setUint32(0, (size & 0x000fffff00000000) / Math.pow(2, 32), false);
+    dataView.setUint32(4, size & 0xffffffff, false);
+    return mergeUint8Arrays(header, jsonMessage, data ?? new Uint8Array(0));
+}
+function mergeUint8Arrays(...arrays) {
+    const totalSize = arrays.reduce((acc, e) => acc + e.length, 0);
+    const merged = new Uint8Array(totalSize);
+    arrays.forEach((array, i, arrays) => {
+        const offset = arrays
+            .slice(0, i)
+            .reduce((acc, e) => acc + e.length, 0);
+        merged.set(array, offset);
+    });
+    return merged;
+}
+function blobToArrayBuffer(blob) {
+    return new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onload = () => resolve(reader.result);
+        reader.onerror = () => reject(reader.error);
+        reader.readAsArrayBuffer(blob);
+    });
+}
+class RefCount {
+    constructor(ref) {
+        this.ref = ref;
+        this.count = 1;
+    }
+}
+exports.RefCount = RefCount;

package/dist/node/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/node/agent-client.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentsClient = exports.ToolkitConfiguration = exports.ToolkitDescription = exports.ToolDescription = exports.AgentDescription = void 0;
+const requirement_1 = require("./requirement");
+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 requirement_1.RequiredToolkit.fromJson(e);
+                }
+                if (e["schema"] != null) {
+                    return requirement_1.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,
+        });
+    }
+}
+exports.AgentDescription = AgentDescription;
+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;
+    }
+}
+exports.ToolDescription = ToolDescription;
+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,
+        });
+    }
+}
+exports.ToolkitDescription = ToolkitDescription;
+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;
+                    }, {}),
+                },
+            };
+        }
+    }
+}
+exports.ToolkitConfiguration = ToolkitConfiguration;
+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);
+    }
+}
+exports.AgentsClient = AgentsClient;

package/dist/node/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;
+}

package/dist/node/agent.js

@@ -0,0 +1,229 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RemoteTaskRunner = exports.RemoteToolkit = exports.Toolkit = exports.Tool = exports.AgentCallContext = exports.AgentChatContext = void 0;
+const response_1 = require("./response");
+const utils_1 = require("./utils");
+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",
+        });
+    }
+}
+exports.AgentChatContext = AgentChatContext;
+class AgentCallContext {
+    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;
+    }
+}
+exports.AgentCallContext = AgentCallContext;
+class Tool {
+    constructor({ name, description, title, inputSchema, thumbnailUrl }) {
+        this.name = name;
+        this.description = description;
+        this.title = title;
+        this.inputSchema = inputSchema;
+        this.thumbnailUrl = thumbnailUrl;
+    }
+}
+exports.Tool = Tool;
+class Toolkit {
+    constructor({ tools, rules = [] }) {
+        this.tools = tools;
+        this.rules = rules;
+    }
+    getTool(name) {
+        const tool = this.tools.find((t) => t.name === name);
+        if (!tool) {
+            throw new Error(`Tool was not found ${name}`);
+        }
+        return tool;
+    }
+    getTools() {
+        const json = {};
+        for (const tool of this.tools) {
+            json[tool.name] = {
+                description: tool.description,
+                title: tool.title,
+                input_schema: tool.inputSchema,
+                thumbnail_url: tool.thumbnailUrl,
+            };
+        }
+        return json;
+    }
+    async execute(name, args) {
+        return this.getTool(name).execute(args);
+    }
+}
+exports.Toolkit = Toolkit;
+class RemoteToolkit extends Toolkit {
+    constructor({ name, title, description, room, tools, rules = [] }) {
+        super({ tools, rules });
+        this.client = room;
+        this.name = name;
+        this.title = title;
+        this.description = description;
+    }
+    async start({ public_: isPublic = false } = {}) {
+        const handler = this._toolCall.bind(this);
+        this.client.protocol.addHandler(`agent.tool_call.${this.name}`, handler);
+        await this._register(isPublic);
+    }
+    async stop() {
+        await this._unregister();
+        this.client.protocol.removeHandler(`agent.tool_call.${this.name}`);
+    }
+    async _register(public_) {
+        const response = await this.client.sendRequest("agent.register_toolkit", {
+            name: this.name,
+            title: this.title,
+            description: this.description,
+            tools: this.getTools(),
+            public: public_,
+        });
+        const json = response.json;
+        this._registrationId = json["id"];
+    }
+    async _unregister() {
+        if (!this._registrationId)
+            return;
+        await this.client.sendRequest("agent.unregister_toolkit", {
+            id: this._registrationId,
+        });
+    }
+    async _toolCall(protocol, messageId, type, data) {
+        try {
+            const raw = utils_1.decoder.decode(data);
+            const message = JSON.parse(raw);
+            const toolName = message["name"];
+            const args = message["arguments"];
+            const response = await this.execute(toolName, args);
+            await this.client.protocol.send("agent.tool_call_response", response.pack(), messageId);
+        }
+        catch (e) {
+            const err = new response_1.ErrorResponse({ text: String(e) });
+            await this.client.protocol.send("agent.tool_call_response", err.pack(), messageId);
+        }
+    }
+}
+exports.RemoteToolkit = RemoteToolkit;
+class RemoteTaskRunner {
+    constructor({ name, description, client, inputSchema, outputSchema, supportsTools = false, required = [], }) {
+        this.client = client;
+        this.name = name;
+        this.description = description;
+        this.inputSchema = inputSchema;
+        this.outputSchema = outputSchema;
+        this.supportsTools = supportsTools;
+        this.required = required;
+    }
+    async start() {
+        const handler = this._ask.bind(this);
+        this.client.protocol.addHandler("agent.ask", handler);
+        await this._register();
+    }
+    async stop() {
+        await this._unregister();
+        this.client.protocol.removeHandler("agent.ask");
+    }
+    async _register() {
+        const res = await this.client.sendRequest("agent.register_agent", {
+            name: this.name,
+            description: this.description,
+            input_schema: this.inputSchema,
+            output_schema: this.outputSchema,
+            supports_tools: this.supportsTools,
+            requires: this.required.map((r) => ({
+                toolkit: r.name,
+                tools: r.tools,
+            })),
+        });
+        this._registrationId = res.json["id"];
+    }
+    async _unregister() {
+        if (!this._registrationId)
+            return;
+        await this.client.sendRequest("agent.unregister_agent", { id: this._registrationId });
+    }
+    async _ask(protocol, messageId, msgType, data) {
+        console.info("_ask handler invoked with data", data);
+        try {
+            const raw = utils_1.decoder.decode(data);
+            const message = JSON.parse(raw);
+            console.info("got message", message);
+            const jwt = message["jwt"];
+            const args = message["arguments"];
+            const task_id = message["task_id"];
+            const context_json = message["context"];
+            const api_url = message["api_url"];
+            const chat = AgentChatContext.fromJson(context_json);
+            const callContext = new AgentCallContext({ chat, jwt, api_url });
+            const answer = await this.ask(callContext, args);
+            const encoded = utils_1.encoder.encode(JSON.stringify({ task_id, answer }));
+            await protocol.send("agent.ask_response", encoded);
+        }
+        catch (e) {
+            const rawError = JSON.stringify({
+                task_id: "",
+                error: String(e),
+            });
+            await protocol.send("agent.ask_response", utils_1.encoder.encode(rawError));
+        }
+    }
+}
+exports.RemoteTaskRunner = RemoteTaskRunner;