@meshagent/meshagent 0.36.3 → 0.37.1

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

@@ -12,7 +12,7 @@ import { ContainersClient } from "./containers-client";
 import { MemoryClient } from "./memory-client";
 import { ServicesClient } from "./services-client";
 import { RoomEvent } from "./room-event";
-import { Content } from "./response";
+import { type Content } from "./response";
 interface RequestHeader {
     [key: string]: any;
 }

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

@@ -1,4 +1,4 @@
-import { ServiceSpec } from "./meshagent-client";
+import type { ServiceSpec } from "./meshagent-client";
 import { RoomClient } from "./room-client";
 export interface ServiceRuntimeState {
     serviceId: string;

package/dist/browser/version.d.ts

@@ -0,0 +1 @@
+export declare const __version__ = "0.36.3";

package/dist/browser/version.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.__version__ = void 0;
+exports.__version__ = "0.36.3";

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

@@ -1,5 +1,5 @@
 import { RoomClient } from "./room-client";
-import { Content } from "./response";
+import type { Content } from "./response";
 import { ToolContentSpec } from "./tool-content-type";
 export declare class ToolDescription {
     title: string;
@@ -10,8 +10,7 @@ export declare class ToolDescription {
     defs?: Record<string, any>;
     thumbnailUrl?: string;
     pricing?: string;
-    supportsContext?: boolean;
-    constructor({ title, name, description, inputSchema, inputSpec, outputSpec, outputSchema, thumbnailUrl, defs, pricing, supportsContext }: {
+    constructor({ title, name, description, inputSchema, inputSpec, outputSpec, outputSchema, thumbnailUrl, defs, pricing }: {
         title: string;
         name: string;
         description: string;
@@ -22,7 +21,6 @@ export declare class ToolDescription {
         thumbnailUrl?: string;
         defs?: Record<string, any>;
         pricing?: string;
-        supportsContext?: boolean;
     });
     get inputSchema(): Record<string, any> | undefined;
     get outputSchema(): Record<string, any> | undefined;
@@ -49,12 +47,6 @@ export declare class ToolkitDescription {
         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 }: {

package/dist/esm/agent-client.js

@@ -1,6 +1,6 @@
 import { ToolContentSpec } from "./tool-content-type";
 export class ToolDescription {
-    constructor({ title, name, description, inputSchema, inputSpec, outputSpec, outputSchema, thumbnailUrl, defs, pricing, supportsContext }) {
+    constructor({ title, name, description, inputSchema, inputSpec, outputSpec, outputSchema, thumbnailUrl, defs, pricing }) {
         this.title = title;
         this.name = name;
         this.description = description;
@@ -41,7 +41,6 @@ export class ToolDescription {
         this.thumbnailUrl = thumbnailUrl;
         this.defs = defs;
         this.pricing = pricing;
-        this.supportsContext = supportsContext ?? false;
     }
     get inputSchema() {
         return this.inputSpec?.schema;
@@ -81,7 +80,6 @@ export class ToolkitDescription {
                 thumbnail_url: tool.thumbnailUrl,
                 defs: tool.defs,
                 pricing: tool.pricing,
-                supports_context: tool.supportsContext,
             })),
         };
     }
@@ -106,7 +104,6 @@ export class ToolkitDescription {
                     thumbnailUrl: tool["thumbnail_url"],
                     defs: tool["defs"],
                     pricing: tool["pricing"],
-                    supportsContext: tool["supports_context"] ?? tool["supportsContext"],
                 }));
             }
         }
@@ -125,7 +122,6 @@ export class ToolkitDescription {
                     thumbnailUrl: tool["thumbnail_url"],
                     defs: tool["defs"],
                     pricing: tool["pricing"],
-                    supportsContext: tool["supports_context"] ?? tool["supportsContext"],
                 }));
             }
         }
@@ -139,29 +135,6 @@ export class ToolkitDescription {
         });
     }
 }
-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;

package/dist/esm/agent.d.ts

@@ -1,6 +1,6 @@
 import { RoomClient } from "./room-client";
 import { RequiredToolkit } from "./requirement";
-import { Content } from "./response";
+import { type Content } from "./response";
 import { ToolContentSpec } from "./tool-content-type";
 export declare abstract class Tool {
     readonly name: string;
@@ -23,10 +23,18 @@ export declare abstract class Tool {
     get outputSchema(): Record<string, any> | undefined;
     abstract execute(arguments_: Record<string, any>): Promise<Content>;
 }
-export declare abstract class Toolkit {
+export declare class Toolkit {
+    readonly name: string;
+    readonly title: string;
+    readonly description: string;
+    readonly thumbnailUrl?: string;
     readonly tools: Tool[];
     readonly rules: string[];
-    constructor({ tools, rules }: {
+    constructor({ name, title, description, thumbnailUrl, tools, rules }: {
+        name: string;
+        title?: string;
+        description?: string;
+        thumbnailUrl?: string;
         tools: Tool[];
         rules?: string[];
     });
@@ -34,28 +42,20 @@ export declare abstract class Toolkit {
     getTools(): Record<string, any>;
     execute(name: string, args: Record<string, any>): Promise<Content>;
 }
-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[];
+export declare class HostedToolkit {
+    readonly toolkit: Toolkit;
+    private readonly _stopHostedToolkit;
+    constructor({ toolkit, stopHostedToolkit }: {
+        toolkit: Toolkit;
+        stopHostedToolkit: () => Promise<void>;
     });
-    start({ public_: isPublic }?: {
-        public_?: boolean;
-    }): Promise<void>;
     stop(): Promise<void>;
-    private _register;
-    private _unregister;
-    private _toolCall;
 }
+export declare function startHostedToolkit({ room, toolkit, public_: isPublic }: {
+    room: RoomClient;
+    toolkit: Toolkit;
+    public_?: boolean;
+}): Promise<HostedToolkit>;
 export declare abstract class RemoteTaskRunner {
     protected readonly client: RoomClient;
     protected readonly name: string;

package/dist/esm/agent.js

@@ -50,7 +50,11 @@ export class Tool {
     }
 }
 export class Toolkit {
-    constructor({ tools, rules = [] }) {
+    constructor({ name, title = name, description = "", thumbnailUrl, tools, rules = [] }) {
+        this.name = name;
+        this.title = title;
+        this.description = description;
+        this.thumbnailUrl = thumbnailUrl;
         this.tools = tools;
         this.rules = rules;
     }
@@ -78,30 +82,37 @@ export class Toolkit {
         return this.getTool(name).execute(args);
     }
 }
-export class RemoteToolkit extends Toolkit {
-    constructor({ name, title, description, room, tools, rules = [] }) {
-        super({ tools, rules });
+export class HostedToolkit {
+    constructor({ toolkit, stopHostedToolkit }) {
+        this.toolkit = toolkit;
+        this._stopHostedToolkit = stopHostedToolkit;
+    }
+    async stop() {
+        await this._stopHostedToolkit();
+    }
+}
+class _RemoteToolkitWrapper {
+    constructor({ toolkit, room }) {
+        this.toolkit = toolkit;
         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(`room.tool_call.${this.name}`, handler);
+        this.client.protocol.addHandler(`room.tool_call.${this.toolkit.name}`, handler);
         await this._register(isPublic);
     }
     async stop() {
         await this._unregister();
-        this.client.protocol.removeHandler(`room.tool_call.${this.name}`);
+        this.client.protocol.removeHandler(`room.tool_call.${this.toolkit.name}`);
     }
     async _register(public_) {
         const response = await this.client.sendRequest("room.register_toolkit", {
-            name: this.name,
-            title: this.title,
-            description: this.description,
-            tools: this.getTools(),
+            name: this.toolkit.name,
+            title: this.toolkit.title,
+            description: this.toolkit.description,
+            tools: this.toolkit.getTools(),
             public: public_,
+            thumbnail_url: this.toolkit.thumbnailUrl,
         });
         const json = response.json;
         this._registrationId = json["id"];
@@ -138,7 +149,7 @@ export class RemoteToolkit extends Toolkit {
             else {
                 args = rawArguments ?? {};
             }
-            const response = await this.execute(toolName, args);
+            const response = await this.toolkit.execute(toolName, args);
             await this.client.protocol.send("room.tool_call_response", response.pack(), messageId);
         }
         catch (e) {
@@ -147,6 +158,14 @@ export class RemoteToolkit extends Toolkit {
         }
     }
 }
+export async function startHostedToolkit({ room, toolkit, public_: isPublic = false }) {
+    const wrapper = new _RemoteToolkitWrapper({ toolkit, room });
+    await wrapper.start({ public_: isPublic });
+    return new HostedToolkit({
+        toolkit,
+        stopHostedToolkit: () => wrapper.stop(),
+    });
+}
 export class RemoteTaskRunner {
     constructor({ name, description, client, inputSchema, outputSchema, supportsTools = false, required = [], }) {
         this.client = client;

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

@@ -1,5 +1,5 @@
-import { ContainerMountSpec } from "./meshagent-client";
-import { Content } from "./response";
+import type { ContainerMountSpec } from "./meshagent-client";
+import { type Content } from "./response";
 import { RoomClient } from "./room-client";
 export interface DockerSecret {
     username: string;
@@ -138,29 +138,17 @@ export declare class ContainersClient {
         writableRootFs?: boolean;
         private?: boolean;
     }): Promise<string>;
-    startBuild(params: {
-        tag: string;
-        mounts: ContainerMountSpec[];
-        contextPath: string;
-        dockerfilePath?: string;
-        private?: boolean;
-        credentials?: DockerSecret[];
-        contextArchivePath?: string;
-        contextArchiveRef?: string;
-        contextArchiveMountPath?: string;
-        contextArchiveArch?: string;
-    }): Promise<string>;
     build(params: {
         tag: string;
-        mounts: ContainerMountSpec[];
+        mountPath: string;
         contextPath: string;
+        chunks: AsyncIterable<Uint8Array>;
         dockerfilePath?: string;
+        optimizeImage?: boolean;
         private?: boolean;
         credentials?: DockerSecret[];
-        contextArchivePath?: string;
-        contextArchiveRef?: string;
-        contextArchiveMountPath?: string;
-        contextArchiveArch?: string;
+        builderName?: string;
+        size?: number;
     }): Promise<string>;
     listBuilds(): Promise<BuildJob[]>;
     cancelBuild(params: {

package/dist/esm/containers-client.js

@@ -131,19 +131,28 @@ function parseBuildJob(data, operation) {
         exitCode: readOptionalIntegerField(data, "exit_code", operation),
     };
 }
-function buildRequestPayload(params) {
-    return {
-        tag: params.tag,
-        mounts: toMountList(params.mounts),
-        context_path: params.contextPath,
-        dockerfile_path: params.dockerfilePath ?? null,
-        private: params.private ?? false,
-        credentials: toCredentials(params.credentials ?? []),
-        context_archive_path: params.contextArchivePath ?? null,
-        context_archive_ref: params.contextArchiveRef ?? null,
-        context_archive_mount_path: params.contextArchiveMountPath ?? null,
-        context_archive_arch: params.contextArchiveArch ?? null,
-    };
+async function* buildInputStream(params) {
+    yield new BinaryContent({
+        data: new Uint8Array(0),
+        headers: {
+            kind: "start",
+            tag: params.tag,
+            mount_path: params.mountPath,
+            context_path: params.contextPath,
+            dockerfile_path: params.dockerfilePath ?? null,
+            optimize_image: params.optimizeImage ?? true,
+            private: params.private ?? false,
+            credentials: toCredentials(params.credentials ?? []),
+            builder_name: params.builderName ?? null,
+            size: params.size ?? null,
+        },
+    });
+    for await (const chunk of params.chunks) {
+        yield new BinaryContent({
+            data: new Uint8Array(chunk),
+            headers: { kind: "data" },
+        });
+    }
 }
 export class ExecSession {
     constructor(params) {
@@ -383,15 +392,12 @@ export class ContainersClient {
         }
         return readStringField(output.json, "container_id", "run");
     }
-    async startBuild(params) {
-        const output = await this.invoke("start_build", buildRequestPayload(params));
-        if (!(output instanceof JsonContent) || !isRecord(output.json)) {
-            throw this.unexpectedResponseError("start_build");
-        }
-        return readStringField(output.json, "build_id", "start_build");
-    }
     async build(params) {
-        const output = await this.invoke("build", buildRequestPayload(params));
+        const output = await this.room.invokeWithStreamInput({
+            toolkit: "containers",
+            tool: "build",
+            input: buildInputStream(params),
+        });
         if (!(output instanceof JsonContent) || !isRecord(output.json)) {
             throw this.unexpectedResponseError("build");
         }

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

@@ -11,6 +11,8 @@ export declare abstract class DataType {
         elementType: DataType;
     }): VectorDataType;
     static text(): TextDataType;
+    static json(): JsonDataType;
+    static uuid(): UuidDataType;
     static binary(): BinaryDataType;
 }
 export declare class BoolDataType extends DataType {
@@ -48,6 +50,16 @@ export declare class TextDataType extends DataType {
     static fromJson(data: any): TextDataType;
     toJson(): Record<string, unknown>;
 }
+export declare class JsonDataType extends DataType {
+    constructor();
+    static fromJson(data: any): JsonDataType;
+    toJson(): Record<string, unknown>;
+}
+export declare class UuidDataType extends DataType {
+    constructor();
+    static fromJson(data: any): UuidDataType;
+    toJson(): Record<string, unknown>;
+}
 export declare class BinaryDataType extends DataType {
     constructor();
     static fromJson(data: any): BinaryDataType;

package/dist/esm/data-types.js

@@ -23,6 +23,12 @@ export class DataType {
     static text() {
         return new TextDataType();
     }
+    static json() {
+        return new JsonDataType();
+    }
+    static uuid() {
+        return new UuidDataType();
+    }
     static binary() {
         return new BinaryDataType();
     }
@@ -126,6 +132,36 @@ export class TextDataType extends DataType {
     }
 }
 _dataTypes["text"] = TextDataType;
+export class JsonDataType extends DataType {
+    constructor() {
+        super();
+    }
+    static fromJson(data) {
+        if (data.type !== "json") {
+            throw new Error(`Expected type 'json', got '${data.type}'`);
+        }
+        return new JsonDataType();
+    }
+    toJson() {
+        return { type: "json" };
+    }
+}
+_dataTypes["json"] = JsonDataType;
+export class UuidDataType extends DataType {
+    constructor() {
+        super();
+    }
+    static fromJson(data) {
+        if (data.type !== "uuid") {
+            throw new Error(`Expected type 'uuid', got '${data.type}'`);
+        }
+        return new UuidDataType();
+    }
+    toJson() {
+        return { type: "uuid" };
+    }
+}
+_dataTypes["uuid"] = UuidDataType;
 export class BinaryDataType extends DataType {
     constructor() {
         super();