@meshagent/meshagent 0.36.3 → 0.37.1

package/CHANGELOG.md

@@ -1,3 +1,19 @@
+## [0.37.1]
+- Added `useAuth` to the React auth package to handle OAuth redirect/callback, token refresh, and profile loading without React Query, plus a `useEnsureLogin` compatibility wrapper.
+- React auth `useMAuthResponse` now deduplicates token exchanges per callback parameters to avoid repeated exchanges on re-renders.
+- Breaking: React auth no longer exports React Query `QueryClient` or `QueryClientProvider`.
+- Breaking: `useLoginScope` now delegates to `useAuth` and defaults the OAuth scope to `email`.
+- Breaking: the `staticAuthorization` helper was removed from the React room connection utilities.
+- React dev terminal hooks now return `RefObject`-typed `containerRef` values for stronger typing.
+- Meshagent TS client now normalizes binary request bodies for fetch and includes TypeScript declarations for runtime entrypoint functions.
+
+## [0.37.0]
+- Breaking: Database client now supports `json`, `uuid`, `list`, and `struct` types with typed wrappers (DatabaseJson/DatabaseStruct/DatabaseExpression/DatabaseDate/DatabaseUuid); list/struct values must be wrapped and update now takes `values` only.
+- Breaking: Containers build now streams build contexts (start/data chunks) with `mountPath`/`chunks` and removes `start_build`.
+- Breaking: Toolkit/hosting refactor replaces RemoteToolkit with startHostedToolkit/HostedToolkit, removes ToolkitConfiguration and `supports_context`, and updates React/Tailwind helpers to start hosted toolkits.
+- Participant tokens now include LLM grants and richer grant serialization (including allowed toolkits and extra payload preservation), and schema helpers add `json`/`uuid` data types.
+- The JS SDK now exports its version constant for client-side visibility.
+
 ## [0.36.3]
 - Storage client now supports move operations and emits file moved events.
 - Secrets client now supports existence checks.

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

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AgentsClient = exports.ToolkitConfiguration = exports.ToolkitDescription = exports.ToolDescription = void 0;
+exports.AgentsClient = exports.ToolkitDescription = exports.ToolDescription = void 0;
 const tool_content_type_1 = require("./tool-content-type");
 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;
@@ -44,7 +44,6 @@ class ToolDescription {
         this.thumbnailUrl = thumbnailUrl;
         this.defs = defs;
         this.pricing = pricing;
-        this.supportsContext = supportsContext ?? false;
     }
     get inputSchema() {
         return this.inputSpec?.schema;
@@ -85,7 +84,6 @@ class ToolkitDescription {
                 thumbnail_url: tool.thumbnailUrl,
                 defs: tool.defs,
                 pricing: tool.pricing,
-                supports_context: tool.supportsContext,
             })),
         };
     }
@@ -110,7 +108,6 @@ class ToolkitDescription {
                     thumbnailUrl: tool["thumbnail_url"],
                     defs: tool["defs"],
                     pricing: tool["pricing"],
-                    supportsContext: tool["supports_context"] ?? tool["supportsContext"],
                 }));
             }
         }
@@ -129,7 +126,6 @@ class ToolkitDescription {
                     thumbnailUrl: tool["thumbnail_url"],
                     defs: tool["defs"],
                     pricing: tool["pricing"],
-                    supportsContext: tool["supports_context"] ?? tool["supportsContext"],
                 }));
             }
         }
@@ -144,30 +140,6 @@ class ToolkitDescription {
     }
 }
 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;

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RemoteTaskRunner = exports.RemoteToolkit = exports.Toolkit = exports.Tool = void 0;
+exports.RemoteTaskRunner = exports.HostedToolkit = exports.Toolkit = exports.Tool = void 0;
+exports.startHostedToolkit = startHostedToolkit;
 const response_1 = require("./response");
 const tool_content_type_1 = require("./tool-content-type");
 const utils_1 = require("./utils");
@@ -54,7 +55,11 @@ class Tool {
 }
 exports.Tool = Tool;
 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;
     }
@@ -83,30 +88,38 @@ class Toolkit {
     }
 }
 exports.Toolkit = Toolkit;
-class RemoteToolkit extends Toolkit {
-    constructor({ name, title, description, room, tools, rules = [] }) {
-        super({ tools, rules });
+class HostedToolkit {
+    constructor({ toolkit, stopHostedToolkit }) {
+        this.toolkit = toolkit;
+        this._stopHostedToolkit = stopHostedToolkit;
+    }
+    async stop() {
+        await this._stopHostedToolkit();
+    }
+}
+exports.HostedToolkit = HostedToolkit;
+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"];
@@ -143,7 +156,7 @@ 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) {
@@ -152,7 +165,14 @@ class RemoteToolkit extends Toolkit {
         }
     }
 }
-exports.RemoteToolkit = RemoteToolkit;
+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(),
+    });
+}
 class RemoteTaskRunner {
     constructor({ name, description, client, inputSchema, outputSchema, supportsTools = false, required = [], }) {
         this.client = client;

package/dist/browser/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/browser/containers-client.js

@@ -134,19 +134,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 response_1.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 response_1.BinaryContent({
+            data: new Uint8Array(chunk),
+            headers: { kind: "data" },
+        });
+    }
 }
 class ExecSession {
     constructor(params) {
@@ -387,15 +396,12 @@ class ContainersClient {
         }
         return readStringField(output.json, "container_id", "run");
     }
-    async startBuild(params) {
-        const output = await this.invoke("start_build", buildRequestPayload(params));
-        if (!(output instanceof response_1.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 response_1.JsonContent) || !isRecord(output.json)) {
             throw this.unexpectedResponseError("build");
         }

package/dist/browser/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/browser/data-types.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BinaryDataType = exports.TextDataType = exports.VectorDataType = exports.FloatDataType = exports.DateDataType = exports.IntDataType = exports.BoolDataType = exports.DataType = exports._dataTypes = void 0;
+exports.BinaryDataType = exports.UuidDataType = exports.JsonDataType = exports.TextDataType = exports.VectorDataType = exports.FloatDataType = exports.DateDataType = exports.IntDataType = exports.BoolDataType = exports.DataType = exports._dataTypes = void 0;
 exports._dataTypes = {};
 class DataType {
     constructor(_) { }
@@ -26,6 +26,12 @@ class DataType {
     static text() {
         return new TextDataType();
     }
+    static json() {
+        return new JsonDataType();
+    }
+    static uuid() {
+        return new UuidDataType();
+    }
     static binary() {
         return new BinaryDataType();
     }
@@ -136,6 +142,38 @@ class TextDataType extends DataType {
 }
 exports.TextDataType = TextDataType;
 exports._dataTypes["text"] = TextDataType;
+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" };
+    }
+}
+exports.JsonDataType = JsonDataType;
+exports._dataTypes["json"] = JsonDataType;
+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" };
+    }
+}
+exports.UuidDataType = UuidDataType;
+exports._dataTypes["uuid"] = UuidDataType;
 class BinaryDataType extends DataType {
     constructor() {
         super();