@meshagent/meshagent 0.36.2 → 0.37.0

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/room-event.d.ts

@@ -52,6 +52,18 @@ export declare class FileUpdatedEvent extends RoomEvent {
     get name(): string;
     get description(): string;
 }
+export declare class FileMovedEvent extends RoomEvent {
+    sourcePath: string;
+    destinationPath: string;
+    participantId: string;
+    constructor({ sourcePath, destinationPath, participantId, }: {
+        sourcePath: string;
+        destinationPath: string;
+        participantId: string;
+    });
+    get name(): string;
+    get description(): string;
+}
 export declare class RoomLogEvent extends RoomEvent {
     type: string;
     data: Record<string, any>;

package/dist/browser/room-event.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RoomLogEvent = exports.FileUpdatedEvent = exports.FileDeletedEvent = exports.FileCreatedEvent = exports.RoomMessageEvent = exports.RoomMessage = exports.RoomEvent = void 0;
+exports.RoomLogEvent = exports.FileMovedEvent = exports.FileUpdatedEvent = exports.FileDeletedEvent = exports.FileCreatedEvent = exports.RoomMessageEvent = exports.RoomMessage = exports.RoomEvent = void 0;
 class RoomEvent {
 }
 exports.RoomEvent = RoomEvent;
@@ -68,6 +68,21 @@ class FileUpdatedEvent extends RoomEvent {
     }
 }
 exports.FileUpdatedEvent = FileUpdatedEvent;
+class FileMovedEvent extends RoomEvent {
+    constructor({ sourcePath, destinationPath, participantId, }) {
+        super();
+        this.sourcePath = sourcePath;
+        this.destinationPath = destinationPath;
+        this.participantId = participantId;
+    }
+    get name() {
+        return "file moved";
+    }
+    get description() {
+        return `a file was moved from ${this.sourcePath} to ${this.destinationPath}`;
+    }
+}
+exports.FileMovedEvent = FileMovedEvent;
 class RoomLogEvent extends RoomEvent {
     constructor({ type, data }) {
         super();

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

@@ -73,6 +73,11 @@ export declare class SecretsClient {
         delegateTo?: string | null;
     }): Promise<string | null>;
     listSecrets(): Promise<SecretInfo[]>;
+    exists({ secretId, delegatedTo, forIdentity, }: {
+        secretId: string;
+        delegatedTo?: string | null;
+        forIdentity?: string | null;
+    }): Promise<boolean>;
     deleteSecret({ secretId, delegatedTo, }: {
         secretId: string;
         delegatedTo?: string | null;

package/dist/browser/secrets-client.js

@@ -215,6 +215,17 @@ class SecretsClient {
         }
         return secrets.map((item) => this.parseSecretInfo(item));
     }
+    async exists({ secretId, delegatedTo, forIdentity, }) {
+        const response = await this.invoke("exists", {
+            secret_id: secretId,
+            delegated_to: delegatedTo ?? null,
+            for_identity: forIdentity ?? null,
+        });
+        if (!(response instanceof response_1.JsonContent) || typeof response.json["exists"] !== "boolean") {
+            throw this.unexpectedResponse("exists");
+        }
+        return response.json["exists"];
+    }
     async deleteSecret({ secretId, delegatedTo, }) {
         const response = await this.invoke("delete_secret", {
             id: secretId,

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/storage-client.d.ts

@@ -34,6 +34,7 @@ export declare class StorageClient extends EventEmitter<RoomEvent> {
     });
     private _handleFileUpdated;
     private _handleFileDeleted;
+    private _handleFileMoved;
     private _unexpectedResponseError;
     private _storageEntry;
     private _invoke;
@@ -42,6 +43,9 @@ export declare class StorageClient extends EventEmitter<RoomEvent> {
     delete(path: string, { recursive, }?: {
         recursive?: boolean | null;
     }): Promise<void>;
+    move(sourcePath: string, destinationPath: string, { overwrite, }?: {
+        overwrite?: boolean;
+    }): Promise<void>;
     exists(path: string): Promise<boolean>;
     private _defaultUploadName;
     private _defaultUploadMimeType;

package/dist/browser/storage-client.js

@@ -85,6 +85,7 @@ class StorageClient extends event_emitter_1.EventEmitter {
         super();
         this.client = room;
         this.client.protocol.addHandler("storage.file.deleted", this._handleFileDeleted.bind(this));
+        this.client.protocol.addHandler("storage.file.moved", this._handleFileMoved.bind(this));
         this.client.protocol.addHandler("storage.file.updated", this._handleFileUpdated.bind(this));
     }
     async _handleFileUpdated(protocol, messageId, type, bytes) {
@@ -99,6 +100,16 @@ class StorageClient extends event_emitter_1.EventEmitter {
         this.client.emit(event);
         this.emit('file.deleted', event);
     }
+    async _handleFileMoved(protocol, messageId, type, bytes) {
+        const [data, _] = (0, utils_1.unpackMessage)(bytes || new Uint8Array());
+        const event = new room_event_1.FileMovedEvent({
+            sourcePath: data["source_path"],
+            destinationPath: data["destination_path"],
+            participantId: data["participant_id"],
+        });
+        this.client.emit(event);
+        this.emit("file.moved", event);
+    }
     _unexpectedResponseError(operation) {
         return _unexpectedStorageResponseError(operation);
     }
@@ -147,6 +158,13 @@ class StorageClient extends event_emitter_1.EventEmitter {
     async delete(path, { recursive = null, } = {}) {
         await this._invoke("delete", { path, recursive });
     }
+    async move(sourcePath, destinationPath, { overwrite = false, } = {}) {
+        await this._invoke("move", {
+            source_path: sourcePath,
+            destination_path: destinationPath,
+            overwrite,
+        });
+    }
     async exists(path) {
         const result = await this._invoke("exists", { path });
         if (!(result instanceof response_1.JsonContent)) {

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();