@meshagent/meshagent 0.5.18 → 0.6.0

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

@@ -1,5 +1,6 @@
 import { RoomClient } from "./room-client";
-import { Response } from "./response";
+import { Response, JsonResponse } from "./response";
+import { RemoteParticipant } from "./participant";
 import { Requirement } from "./requirement";
 export declare class AgentDescription {
     readonly name: string;
@@ -16,10 +17,11 @@ export declare class AgentDescription {
         description: string;
         outputSchema?: Record<string, any>;
         inputSchema?: Record<string, any>;
-        requires: Requirement[];
-        labels: string[];
+        requires?: Requirement[];
+        labels?: string[];
         supportsTools: boolean;
     });
+    toJson(): Record<string, any>;
     static fromJson(a: Record<string, any>): AgentDescription;
 }
 export declare class ToolDescription {
@@ -29,13 +31,17 @@ export declare class ToolDescription {
     inputSchema: Record<string, any>;
     defs?: Record<string, any>;
     thumbnailUrl?: string;
-    constructor({ title, name, description, inputSchema, thumbnailUrl, defs }: {
+    pricing?: string;
+    supportsContext?: boolean;
+    constructor({ title, name, description, inputSchema, thumbnailUrl, defs, pricing, supportsContext }: {
         title: string;
         name: string;
         description: string;
         inputSchema: Record<string, any>;
         thumbnailUrl?: string;
         defs?: Record<string, any>;
+        pricing?: string;
+        supportsContext?: boolean;
     });
 }
 export declare class ToolkitDescription {
@@ -53,6 +59,7 @@ export declare class ToolkitDescription {
         thumbnailUrl?: string;
     });
     getTool(name: string): ToolDescription | undefined;
+    toJson(): Record<string, any>;
     static fromJson(json: Record<string, any>, opts?: {
         name?: string;
     }): ToolkitDescription;
@@ -74,10 +81,11 @@ export declare class AgentsClient {
         arguments: Record<string, any>;
     }): Promise<void>;
     ask(params: {
-        agentName: string;
-        toolkits?: ToolkitConfiguration[];
+        agent: string;
         arguments: Record<string, any>;
-    }): Promise<Record<string, any>>;
+        onBehalfOf?: RemoteParticipant;
+        requires?: Requirement[];
+    }): Promise<JsonResponse>;
     listToolkits(): Promise<ToolkitDescription[]>;
     listAgents(): Promise<AgentDescription[]>;
     invokeTool(params: {

package/dist/esm/agent-client.js

@@ -1,3 +1,4 @@
+import { JsonResponse } from "./response";
 import { RequiredToolkit, RequiredSchema } from "./requirement";
 export class AgentDescription {
     constructor({ name, title, description, outputSchema, inputSchema, requires, labels, supportsTools, }) {
@@ -6,9 +7,21 @@ export class AgentDescription {
         this.description = description;
         this.outputSchema = outputSchema;
         this.inputSchema = inputSchema;
-        this.requires = requires;
-        this.labels = labels;
-        this.supportsTools = supportsTools;
+        this.requires = Array.isArray(requires) ? requires : [];
+        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,
+            requires: this.requires.map((requirement) => requirement.toJson()),
+        };
     }
     static fromJson(a) {
         let requires = [];
@@ -40,13 +53,15 @@ export class AgentDescription {
     }
 }
 export class ToolDescription {
-    constructor({ title, name, description, inputSchema, thumbnailUrl, defs }) {
+    constructor({ title, name, description, inputSchema, thumbnailUrl, defs, pricing, supportsContext }) {
         this.title = title;
         this.name = name;
         this.description = description;
         this.inputSchema = inputSchema;
         this.thumbnailUrl = thumbnailUrl;
         this.defs = defs;
+        this.pricing = pricing;
+        this.supportsContext = supportsContext ?? false;
     }
 }
 export class ToolkitDescription {
@@ -61,6 +76,22 @@ export class ToolkitDescription {
     getTool(name) {
         return this._byName.get(name);
     }
+    toJson() {
+        return {
+            name: this.name,
+            description: this.description,
+            title: this.title,
+            thumbnail_url: this.thumbnailUrl,
+            tools: this.tools.map((tool) => ({
+                name: tool.name,
+                title: tool.title,
+                description: tool.description,
+                input_schema: tool.inputSchema,
+                thumbnail_url: tool.thumbnailUrl,
+                defs: tool.defs,
+            })),
+        };
+    }
     static fromJson(json, opts) {
         const { name } = opts ?? {};
         const title = json["title"] ?? "";
@@ -77,6 +108,8 @@ export class ToolkitDescription {
                     inputSchema: tool["input_schema"],
                     thumbnailUrl: tool["thumbnail_url"],
                     defs: tool["defs"],
+                    pricing: tool["pricing"],
+                    supportsContext: tool["supportsContext"],
                 }));
             }
         }
@@ -91,6 +124,8 @@ export class ToolkitDescription {
                     inputSchema: tool["input_schema"],
                     thumbnailUrl: tool["thumbnail_url"],
                     defs: tool["defs"],
+                    pricing: tool["pricing"],
+                    supportsContext: tool["supportsContext"],
                 }));
             }
         }
@@ -134,17 +169,20 @@ export class AgentsClient {
         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,
+        const { agent, arguments: args, onBehalfOf, requires } = params;
+        const payload = {
+            agent,
             arguments: args,
-            toolkits: usedToolkits,
-        }));
-        return result.json["answer"];
+        };
+        if (onBehalfOf) {
+            payload["on_behalf_of_id"] = onBehalfOf.id;
+        }
+        if (requires && requires.length > 0) {
+            payload["requires"] = requires.map((req) => req.toJson());
+        }
+        const result = (await this.client.sendRequest("agent.ask", payload));
+        const answer = (result.json["answer"] ?? {});
+        return new JsonResponse({ json: answer });
     }
     async listToolkits() {
         const result = (await this.client.sendRequest("agent.list_toolkits", {}));

package/dist/esm/api_keys.d.ts

@@ -0,0 +1,13 @@
+export declare function base36Encode(value: bigint | number): string;
+export declare function base36Decode(numberStr: string): bigint;
+export declare function compressUuid(guidString: string): string;
+export declare function decompressUuid(compressedUuid: string): string;
+export declare function base64CompressUuid(id: string): string;
+export declare function base64DecompressUuid(id: string): string;
+export interface ApiKey {
+    id: string;
+    projectId: string;
+    secret: string;
+}
+export declare function parseApiKey(key: string): ApiKey;
+export declare function encodeApiKey(key: ApiKey): string;

package/dist/esm/api_keys.js

@@ -0,0 +1,175 @@
+import { encode as base64Encode, decode as base64Decode } from "base-64";
+const BASE36_ALPHABET = "0123456789abcdefghijklmnopqrstuvwxyz";
+const BASE36 = 36n;
+const UUID_HEX_REGEX = /^[0-9a-f]{32}$/;
+function toBigInt(value) {
+    if (typeof value === "bigint") {
+        return value;
+    }
+    if (typeof value === "number") {
+        if (!Number.isInteger(value)) {
+            throw new TypeError("number must be an integer");
+        }
+        return BigInt(value);
+    }
+    throw new TypeError("number must be an integer");
+}
+export function base36Encode(value) {
+    const number = toBigInt(value);
+    if (number < 0n) {
+        throw new RangeError("number must be non-negative");
+    }
+    if (number === 0n) {
+        return "0";
+    }
+    let current = number;
+    let base36 = "";
+    while (current > 0n) {
+        const remainder = Number(current % BASE36);
+        base36 = BASE36_ALPHABET[remainder] + base36;
+        current /= BASE36;
+    }
+    return base36;
+}
+export function base36Decode(numberStr) {
+    const sanitized = numberStr.trim().toLowerCase();
+    if (sanitized === "") {
+        return 0n;
+    }
+    let result = 0n;
+    for (const char of sanitized) {
+        const value = BASE36_ALPHABET.indexOf(char);
+        if (value === -1) {
+            throw new RangeError(`Invalid character '${char}' for base36 encoding`);
+        }
+        result = result * BASE36 + BigInt(value);
+    }
+    return result;
+}
+function normalizeUuidHex(id) {
+    const trimmed = id.trim().toLowerCase().replace(/-/g, "");
+    if (!UUID_HEX_REGEX.test(trimmed)) {
+        throw new Error("invalid uuid format");
+    }
+    return trimmed;
+}
+function formatUuidFromHex(hex) {
+    return (`${hex.substring(0, 8)}-` +
+        `${hex.substring(8, 12)}-` +
+        `${hex.substring(12, 16)}-` +
+        `${hex.substring(16, 20)}-` +
+        `${hex.substring(20)}`);
+}
+function hexToBytes(hex) {
+    if (hex.length % 2 !== 0) {
+        throw new Error("invalid hex string length");
+    }
+    const bytes = new Uint8Array(hex.length / 2);
+    for (let i = 0; i < hex.length; i += 2) {
+        bytes[i / 2] = parseInt(hex.substring(i, i + 2), 16);
+    }
+    return bytes;
+}
+function bytesToHex(bytes) {
+    return Array.from(bytes, byte => byte.toString(16).padStart(2, "0")).join("");
+}
+const globalScope = globalThis;
+function bytesToBase64(bytes) {
+    if (globalScope.Buffer) {
+        return globalScope.Buffer.from(bytes).toString("base64");
+    }
+    let binary = "";
+    for (const byte of bytes) {
+        binary += String.fromCharCode(byte);
+    }
+    if (globalScope.btoa) {
+        return globalScope.btoa(binary);
+    }
+    return base64Encode(binary);
+}
+function base64ToBytes(base64) {
+    if (globalScope.Buffer) {
+        const buffer = globalScope.Buffer.from(base64, "base64");
+        return Uint8Array.from(buffer);
+    }
+    let binary;
+    if (globalScope.atob) {
+        binary = globalScope.atob(base64);
+    }
+    else {
+        binary = base64Decode(base64);
+    }
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i += 1) {
+        bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes;
+}
+export function compressUuid(guidString) {
+    const hex = normalizeUuidHex(guidString);
+    const guidInt = BigInt(`0x${hex}`);
+    return base36Encode(guidInt);
+}
+export function decompressUuid(compressedUuid) {
+    const guidInt = base36Decode(compressedUuid);
+    const hex = guidInt.toString(16).padStart(32, "0");
+    return formatUuidFromHex(hex);
+}
+export function base64CompressUuid(id) {
+    const hex = normalizeUuidHex(id);
+    const bytes = hexToBytes(hex);
+    const base64 = bytesToBase64(bytes)
+        .replace(/\+/g, "-")
+        .replace(/\//g, "_");
+    return base64.replace(/-/g, ".").replace(/=+$/g, "");
+}
+export function base64DecompressUuid(id) {
+    let base64 = id.replace(/\./g, "-");
+    const paddingNeeded = base64.length % 4;
+    if (paddingNeeded !== 0) {
+        base64 += "=".repeat(4 - paddingNeeded);
+    }
+    base64 = base64.replace(/-/g, "+").replace(/_/g, "/");
+    const bytes = base64ToBytes(base64);
+    if (bytes.length !== 16) {
+        throw new Error("invalid uuid length");
+    }
+    return formatUuidFromHex(bytesToHex(bytes));
+}
+function splitApiKey(key) {
+    const rest = key.slice(3);
+    const firstSeparator = rest.indexOf("-");
+    if (firstSeparator === -1) {
+        throw new Error("invalid api key");
+    }
+    const secondSeparator = rest.indexOf("-", firstSeparator + 1);
+    if (secondSeparator === -1) {
+        throw new Error("invalid api key");
+    }
+    const idPart = rest.slice(0, firstSeparator);
+    const projectPart = rest.slice(firstSeparator + 1, secondSeparator);
+    const secret = rest.slice(secondSeparator + 1);
+    if (!idPart || !projectPart || secret === undefined) {
+        throw new Error("invalid api key");
+    }
+    return { idPart, projectPart, secret };
+}
+export function parseApiKey(key) {
+    if (!key.startsWith("ma-")) {
+        throw new Error("invalid api key");
+    }
+    const { idPart, projectPart, secret } = splitApiKey(key);
+    return {
+        id: base64DecompressUuid(idPart),
+        projectId: base64DecompressUuid(projectPart),
+        secret,
+    };
+}
+export function encodeApiKey(key) {
+    return ("ma-" +
+        base64CompressUuid(key.id) +
+        "-" +
+        base64CompressUuid(key.projectId) +
+        "-" +
+        key.secret);
+}

package/dist/esm/data-types.d.ts

@@ -11,6 +11,7 @@ export declare abstract class DataType {
         elementType: DataType;
     }): VectorDataType;
     static text(): TextDataType;
+    static binary(): BinaryDataType;
 }
 export declare class IntDataType extends DataType {
     constructor();
@@ -42,3 +43,8 @@ export declare class TextDataType extends DataType {
     static fromJson(data: any): TextDataType;
     toJson(): Record<string, unknown>;
 }
+export declare class BinaryDataType extends DataType {
+    constructor();
+    static fromJson(data: any): BinaryDataType;
+    toJson(): Record<string, unknown>;
+}

package/dist/esm/data-types.js

@@ -23,6 +23,9 @@ export class DataType {
     static text() {
         return new TextDataType();
     }
+    static binary() {
+        return new BinaryDataType();
+    }
 }
 export class IntDataType extends DataType {
     constructor() {
@@ -108,3 +111,18 @@ export class TextDataType extends DataType {
     }
 }
 _dataTypes["text"] = TextDataType;
+export class BinaryDataType extends DataType {
+    constructor() {
+        super();
+    }
+    static fromJson(data) {
+        if (data.type !== "binary") {
+            throw new Error(`Expected type 'binary', got '${data.type}'`);
+        }
+        return new BinaryDataType();
+    }
+    toJson() {
+        return { type: "binary" };
+    }
+}
+_dataTypes["binary"] = BinaryDataType;