@meshagent/meshagent 0.3.1 → 0.4.1

package/dist/esm/agent.js

@@ -0,0 +1,218 @@
+import { ErrorResponse } from "./response";
+import { packMessage, 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 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;
+    }
+}
+export class Tool {
+    constructor({ name, description, title, inputSchema, thumbnailUrl }) {
+        this.name = name;
+        this.description = description;
+        this.title = title;
+        this.inputSchema = inputSchema;
+        this.thumbnailUrl = thumbnailUrl;
+    }
+}
+export 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);
+    }
+}
+export 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 [message, _] = unpackMessage(data);
+            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 ErrorResponse({ text: String(e) });
+            await this.client.protocol.send("agent.tool_call_response", err.pack(), messageId);
+        }
+    }
+}
+export 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 [message, _] = unpackMessage(data);
+            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 = packMessage({ task_id, answer });
+            await protocol.send("agent.ask_response", encoded);
+        }
+        catch (e) {
+            const rawError = {
+                task_id: "",
+                error: String(e),
+            };
+            await protocol.send("agent.ask_response", packMessage(rawError));
+        }
+    }
+}

package/dist/esm/client.d.ts

@@ -0,0 +1,90 @@
+interface ElementData {
+    tagName: string;
+    attributes: Record<string, any>;
+    children: Array<XmlElement | XmlText>;
+}
+interface TextData {
+    delta: any;
+}
+export declare class XmlElement {
+    private _data;
+    private _parent;
+    private _doc;
+    constructor(parent: XmlElement | null, { tagName, attributes }: {
+        tagName: string;
+        attributes: Record<string, any>;
+    }, doc: ClientXmlDocument);
+    getNodeByID(id: string): XmlElement | XmlText | null;
+    get id(): string | undefined;
+    get doc(): ClientXmlDocument;
+    get data(): ElementData;
+    get tagName(): string;
+    get parent(): XmlElement | null;
+    getAttribute(name: string): any;
+    setAttribute(name: string, value: any): void;
+    removeAttribute(name: string): void;
+    createChildElement(tagName: string, attributes: Record<string, any>): XmlElement | XmlText | null;
+    createChildElementAt(index: number, tagName: string, attributes: Record<string, any>): XmlElement | XmlText | null;
+    createChildElementAfter(element: XmlElement | XmlText, tagName: string, attributes: Record<string, any>): XmlElement | XmlText | null;
+    protected _defaultChildren(tagName: string): any[];
+    delete(): void;
+    getChildren(): Array<XmlElement | XmlText>;
+}
+export declare class XmlText {
+    private _data;
+    parent: XmlElement;
+    doc: ClientXmlDocument;
+    constructor(parent: XmlElement, data: TextData, doc: ClientXmlDocument);
+    get delta(): any;
+    insert(index: number, text: string, attributes?: Record<string, any>): void;
+    format(from: number, length: number, attributes: Record<string, any>): void;
+    delete(index: number, length: number): void;
+    get id(): string | undefined;
+}
+type SendChangesFn = (message: any) => void;
+interface InsertElementData {
+    element?: {
+        name: string;
+        attributes: Record<string, any>;
+        children: any[];
+    };
+    text?: {
+        delta: any;
+    };
+}
+interface ReceiveChangesMessage {
+    target: string;
+    root: boolean;
+    elements: Array<{
+        retain?: number;
+        insert?: InsertElementData[];
+        delete?: number;
+    }>;
+    text: Array<{
+        insert?: string;
+        delete?: number;
+        attributes?: Record<string, any>;
+        retain?: number;
+    }>;
+    attributes: {
+        set: Array<{
+            name: string;
+            value: any;
+        }>;
+        delete: string[];
+    };
+}
+export declare class ClientXmlDocument {
+    private _root;
+    private _id;
+    sendChanges: SendChangesFn;
+    constructor({ id, sendChanges, }: {
+        id: string;
+        sendChanges: SendChangesFn;
+    });
+    get id(): string;
+    get root(): XmlElement;
+    _createNode(parent: XmlElement, data: InsertElementData): XmlElement | XmlText;
+    receiveChanges(message: ReceiveChangesMessage): void;
+}
+export {};