@meshagent/meshagent 0.41.4 → 0.41.5

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

@@ -206,6 +206,31 @@ export declare class DatasetsClient {
         branch?: string;
         metadata?: Record<string, unknown>;
     }): Promise<void>;
+    createTableWithArrowSchema({ name, schema, batches, mode, namespace, branch, metadata }: {
+        name: string;
+        schema: Schema;
+        batches?: ArrowTableChunks;
+        mode?: CreateMode;
+        namespace?: string[];
+        branch?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<void>;
+    createTableFromArrowBatches({ name, batches, mode, namespace, branch, metadata }: {
+        name: string;
+        batches: ArrowTableChunks;
+        mode?: CreateMode;
+        namespace?: string[];
+        branch?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<void>;
+    createTableFromArrowTable({ name, table, mode, namespace, branch, metadata }: {
+        name: string;
+        table: Table;
+        mode?: CreateMode;
+        namespace?: string[];
+        branch?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<void>;
     createTableFromData({ name, data, mode, namespace, branch, metadata }: {
         name: string;
         data?: Iterable<Table> | Table;
@@ -237,6 +262,12 @@ export declare class DatasetsClient {
         namespace?: string[];
         branch?: string;
     }): Promise<void>;
+    renameTable({ name, newName, namespace, branch }: {
+        name: string;
+        newName: string;
+        namespace?: string[];
+        branch?: string;
+    }): Promise<void>;
     importFromStorage({ table, path, mode, format, on, sheet, batchSize, namespace, branch }: {
         table: string;
         path: string;
@@ -256,6 +287,13 @@ export declare class DatasetsClient {
         branch?: string;
         version?: number;
     }): Promise<void>;
+    updateColumnMetadata({ table, column, metadata, namespace, branch }: {
+        table: string;
+        column: string;
+        metadata: Record<string, string>;
+        namespace?: string[];
+        branch?: string;
+    }): Promise<void>;
     dropIndex({ table, name, namespace, branch }: {
         table: string;
         name: string;
@@ -280,6 +318,12 @@ export declare class DatasetsClient {
         namespace?: string[];
         branch?: string;
     }): Promise<void>;
+    insertTable({ table, records, namespace, branch }: {
+        table: string;
+        records: Table;
+        namespace?: string[];
+        branch?: string;
+    }): Promise<void>;
     insertStream({ table, chunks, namespace, branch }: {
         table: string;
         chunks: ArrowTableChunks;
@@ -306,6 +350,13 @@ export declare class DatasetsClient {
         namespace?: string[];
         branch?: string;
     }): Promise<void>;
+    mergeTable({ table, on, records, namespace, branch }: {
+        table: string;
+        on: string;
+        records: Table;
+        namespace?: string[];
+        branch?: string;
+    }): Promise<void>;
     mergeStream({ table, on, chunks, namespace, branch }: {
         table: string;
         on: string;
@@ -320,6 +371,13 @@ export declare class DatasetsClient {
         namespace?: string[];
         branch?: string;
     }): Promise<Table[]>;
+    sqlTable({ query, tables, params, namespace, branch }: {
+        query: string;
+        tables?: Array<TableRef | string>;
+        params?: Table;
+        namespace?: string[];
+        branch?: string;
+    }): Promise<Table>;
     openSqlQuery({ query, tables, params, namespace, branch }: {
         query: string;
         tables?: Array<TableRef | string>;
@@ -369,6 +427,18 @@ export declare class DatasetsClient {
         branch?: string;
         version?: number;
     }): Promise<Table[]>;
+    searchTable({ table, text, vector, where, offset, limit, select, namespace, branch, version }: {
+        table: string;
+        text?: string;
+        vector?: number[];
+        where?: DatasetWhere;
+        offset?: number;
+        limit?: number;
+        select?: string[];
+        namespace?: string[];
+        branch?: string;
+        version?: number;
+    }): Promise<Table>;
     searchStream({ table, text, vector, where, offset, limit, select, namespace, branch, version }: {
         table: string;
         text?: string;

package/dist/browser/datasets-client.js

@@ -537,6 +537,13 @@ function tableFromIPCBytes(data) {
     }
     return table;
 }
+function tableFromChunks(chunks) {
+    if (chunks.length === 0) {
+        return new apache_arrow_1.Table(new apache_arrow_1.Schema([]), []);
+    }
+    const [first, ...rest] = chunks;
+    return first.concat(...rest);
+}
 function schemaFromIPCBytes(data) {
     return tableFromIPCBytes(data).schema;
 }
@@ -846,6 +853,38 @@ class DatasetsClient {
             metadata,
         });
     }
+    async createTableWithArrowSchema({ name, schema, batches, mode = "create", namespace, branch, metadata }) {
+        return this.createTable({
+            name,
+            schema,
+            data: batches,
+            mode,
+            namespace,
+            branch,
+            metadata,
+        });
+    }
+    async createTableFromArrowBatches({ name, batches, mode = "create", namespace, branch, metadata }) {
+        return this.createTable({
+            name,
+            data: batches,
+            mode,
+            namespace,
+            branch,
+            metadata,
+        });
+    }
+    async createTableFromArrowTable({ name, table, mode = "create", namespace, branch, metadata }) {
+        return this.createTableWithArrowSchema({
+            name,
+            schema: table.schema,
+            batches: [table],
+            mode,
+            namespace,
+            branch,
+            metadata,
+        });
+    }
     async createTableFromData({ name, data, mode = "create", namespace, branch, metadata }) {
         return this.createTable({
             name,
@@ -882,6 +921,14 @@ class DatasetsClient {
             },
         });
     }
+    async renameTable({ name, newName, namespace, branch }) {
+        await this.invoke("rename_table", {
+            name,
+            new_name: newName,
+            namespace: namespace ?? null,
+            branch: branch ?? null,
+        });
+    }
     async importFromStorage({ table, path, mode = "create", format = "auto", on, sheet, batchSize, namespace, branch }) {
         const input = {
             table,
@@ -908,6 +955,15 @@ class DatasetsClient {
             version: version ?? null,
         });
     }
+    async updateColumnMetadata({ table, column, metadata, namespace, branch }) {
+        await this.invoke("update_column_metadata", {
+            table,
+            column,
+            metadata: metadataEntries(metadata),
+            namespace: namespace ?? null,
+            branch: branch ?? null,
+        });
+    }
     async dropIndex({ table, name, namespace, branch }) {
         await this.room.invoke({
             toolkit: "dataset",
@@ -949,6 +1005,9 @@ class DatasetsClient {
     async insert({ table, records, namespace, branch }) {
         await this.insertStream({ table, chunks: [records], namespace, branch });
     }
+    async insertTable({ table, records, namespace, branch }) {
+        await this.insertStream({ table, chunks: [records], namespace, branch });
+    }
     async insertStream({ table, chunks, namespace, branch }) {
         const input = new DatasetArrowWriteInputStream({
             kind: "start",
@@ -981,6 +1040,9 @@ class DatasetsClient {
     async merge({ table, on, records, namespace, branch }) {
         await this.mergeStream({ table, on, chunks: [records], namespace, branch });
     }
+    async mergeTable({ table, on, records, namespace, branch }) {
+        await this.mergeStream({ table, on, chunks: [records], namespace, branch });
+    }
     async mergeStream({ table, on, chunks, namespace, branch }) {
         const input = new DatasetArrowWriteInputStream({
             kind: "start",
@@ -998,6 +1060,9 @@ class DatasetsClient {
         }
         return results;
     }
+    async sqlTable({ query, tables, params, namespace, branch }) {
+        return tableFromChunks(await this.sql({ query, tables, params, namespace, branch }));
+    }
     async openSqlQuery({ query, tables, params, namespace, branch }) {
         const response = await this.invokeContent("open_sql_query", new response_1.BinaryContent({
             data: params == null ? new Uint8Array() : (0, apache_arrow_1.tableToIPC)(params, "stream"),
@@ -1126,6 +1191,20 @@ class DatasetsClient {
         }
         return results;
     }
+    async searchTable({ table, text, vector, where, offset, limit, select, namespace, branch, version }) {
+        return tableFromChunks(await this.search({
+            table,
+            text,
+            vector,
+            where,
+            offset,
+            limit,
+            select,
+            namespace,
+            branch,
+            version,
+        }));
+    }
     async *searchStream({ table, text, vector, where, offset, limit, select, namespace, branch, version }) {
         yield* this.streamArrow("search", {
             kind: "start",

package/dist/browser/index.d.ts

@@ -10,6 +10,7 @@ export * from './document';
 export * from './meshagent-client';
 export * from './messaging-client';
 export * from './memory-client';
+export * from './oauth-scopes';
 export * from './participant-token';
 export * from './participant';
 export * from './protocol';
@@ -29,5 +30,6 @@ export * from './sync-client';
 export * from './api_keys';
 export * from './helpers';
 export * from './tool-content-type';
+export * from './toolkit-config';
 export * from './utils';
 export * from './version';

package/dist/browser/index.js

@@ -26,6 +26,7 @@ __exportStar(require("./document"), exports);
 __exportStar(require("./meshagent-client"), exports);
 __exportStar(require("./messaging-client"), exports);
 __exportStar(require("./memory-client"), exports);
+__exportStar(require("./oauth-scopes"), exports);
 __exportStar(require("./participant-token"), exports);
 __exportStar(require("./participant"), exports);
 __exportStar(require("./protocol"), exports);
@@ -45,5 +46,6 @@ __exportStar(require("./sync-client"), exports);
 __exportStar(require("./api_keys"), exports);
 __exportStar(require("./helpers"), exports);
 __exportStar(require("./tool-content-type"), exports);
+__exportStar(require("./toolkit-config"), exports);
 __exportStar(require("./utils"), exports);
 __exportStar(require("./version"), exports);

package/dist/browser/oauth-scopes.d.ts

@@ -0,0 +1,2 @@
+export declare const fullOAuthScopes: string[];
+export declare const fullOAuthScope = "profile project/* room/* create_users create_rooms create_agents managed_agents llm_proxy admin developer connect_room delete_room update_room delete_agent update_agent";

package/dist/browser/oauth-scopes.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fullOAuthScope = exports.fullOAuthScopes = void 0;
+exports.fullOAuthScopes = [
+    'profile',
+    'project/*',
+    'room/*',
+    'create_users',
+    'create_rooms',
+    'create_agents',
+    'managed_agents',
+    'llm_proxy',
+    'admin',
+    'developer',
+    'connect_room',
+    'delete_room',
+    'update_room',
+    'delete_agent',
+    'update_agent',
+];
+exports.fullOAuthScope = 'profile project/* room/* create_users create_rooms create_agents managed_agents llm_proxy admin developer connect_room delete_room update_room delete_agent update_agent';

package/dist/browser/participant-token.d.ts

@@ -319,9 +319,7 @@ export declare class ApiScope {
         tunnels?: TunnelsGrant;
         services?: ServicesGrant;
     });
-    static agentDefault({ tunnels }?: {
-        tunnels?: boolean;
-    }): ApiScope;
+    static agentDefault(): ApiScope;
     static userDefault(): ApiScope;
     static full(): ApiScope;
     toJSON(): Record<string, any>;

package/dist/browser/participant-token.js

@@ -939,7 +939,7 @@ class ApiScope {
         this.tunnels = tunnels;
         this.services = services;
     }
-    static agentDefault({ tunnels = false } = {}) {
+    static agentDefault() {
         return new ApiScope({
             livekit: new LivekitGrant(),
             queues: new QueuesGrant(),
@@ -952,9 +952,7 @@ class ApiScope {
             developer: new DeveloperGrant(),
             agents: new AgentsGrant(),
             llm: new LLMGrant(),
-            secrets: new SecretsGrant(),
             services: new ServicesGrant(),
-            tunnels: tunnels ? new TunnelsGrant() : undefined,
         });
     }
     static userDefault() {
@@ -969,6 +967,7 @@ class ApiScope {
             containers: new ContainersGrant(),
             developer: new DeveloperGrant(),
             agents: new AgentsGrant(),
+            llm: new LLMGrant(),
             secrets: new SecretsGrant(),
             services: new ServicesGrant(),
         });

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

@@ -204,6 +204,22 @@ export declare class RoomClient {
         participantId?: string;
         onBehalfOfId?: string;
     }): Promise<Content>;
+    invokeToolCall(params: {
+        toolkit: string;
+        tool: string;
+        input: Content | AsyncIterable<Content>;
+        streamInput?: boolean;
+        participantId?: string;
+        onBehalfOfId?: string;
+    }): Promise<{
+        kind: "content";
+        content: Content;
+        inputClosed?: Promise<void>;
+    } | {
+        kind: "stream";
+        stream: AsyncIterable<Content>;
+        inputClosed?: Promise<void>;
+    }>;
     invokeWithStreamInput(params: {
         toolkit: string;
         tool: string;

package/dist/browser/room-client.js

@@ -1229,6 +1229,75 @@ class RoomClient {
         }
         return await this.sendRequest("room.invoke_tool", request, requestData);
     }
+    async invokeToolCall(params) {
+        const toolCallId = `${Date.now()}-${Math.random().toString(16).slice(2)}`;
+        const controller = new stream_controller_1.StreamController();
+        const responseIterator = controller.stream[Symbol.asyncIterator]();
+        this._toolCallStreams.set(toolCallId, controller);
+        const request = {
+            toolkit: params.toolkit,
+            tool: params.tool,
+            tool_call_id: toolCallId,
+        };
+        let requestData;
+        let requestTask;
+        if (params.streamInput === true) {
+            request["arguments"] = { type: "control", method: "open" };
+            requestTask = this._streamInvokeToolRequestChunks(toolCallId, params.input);
+        }
+        else {
+            const input = params.input;
+            const packed = input.pack();
+            request["arguments"] = JSON.parse((0, utils_1.splitMessageHeader)(packed));
+            const payload = (0, utils_1.splitMessagePayload)(packed);
+            if (payload.length > 0) {
+                requestData = payload;
+            }
+        }
+        if (params.participantId != null) {
+            request["participant_id"] = params.participantId;
+        }
+        if (params.onBehalfOfId != null) {
+            request["on_behalf_of_id"] = params.onBehalfOfId;
+        }
+        try {
+            const response = await this.sendRequest("room.invoke_tool", request, requestData);
+            if (response instanceof response_1.ControlContent && response.method === "open") {
+                if (requestTask != null) {
+                    void requestTask.catch((error) => {
+                        const stream = this._toolCallStreams.get(toolCallId);
+                        if (stream == null) {
+                            return;
+                        }
+                        stream.add(new response_1.ErrorContent({ text: `request stream failed: ${String(error)}` }));
+                        stream.close();
+                        this._toolCallStreams.delete(toolCallId);
+                    });
+                }
+                return {
+                    kind: "stream",
+                    stream: {
+                        [Symbol.asyncIterator]() {
+                            return responseIterator;
+                        },
+                    },
+                    inputClosed: requestTask,
+                };
+            }
+            if (requestTask != null) {
+                await requestTask;
+            }
+            this._toolCallStreams.delete(toolCallId);
+            controller.close();
+            return { kind: "content", content: response, inputClosed: requestTask };
+        }
+        catch (error) {
+            await Promise.resolve(requestTask).catch(() => undefined);
+            this._toolCallStreams.delete(toolCallId);
+            controller.close();
+            throw error;
+        }
+    }
     async invokeWithStreamInput(params) {
         const toolCallId = `${Date.now()}-${Math.random().toString(16).slice(2)}`;
         const request = {

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

@@ -66,6 +66,8 @@ export declare class StorageClient extends EventEmitter<RoomEvent> {
     downloadStream(path: string, { chunkSize, }?: {
         chunkSize?: number;
     }): Promise<AsyncIterable<BinaryContent>>;
-    downloadUrl(path: string): Promise<string>;
+    downloadUrl(path: string, options?: {
+        download?: boolean;
+    }): Promise<string>;
 }
 export {};

package/dist/browser/storage-client.js

@@ -372,8 +372,11 @@ class StorageClient extends event_emitter_1.EventEmitter {
             },
         };
     }
-    async downloadUrl(path) {
-        const response = await this._invoke("download_url", { path });
+    async downloadUrl(path, options = {}) {
+        const response = await this._invoke("download_url", {
+            path,
+            download: options.download ?? false,
+        });
         if (!(response instanceof response_1.JsonContent)) {
             throw this._unexpectedResponseError("download_url");
         }

package/dist/browser/tool-content-type.d.ts

@@ -1,4 +1,4 @@
-export type ToolContentType = "json" | "text" | "file" | "link" | "empty";
+export type ToolContentType = "binary" | "json" | "text" | "file" | "link" | "empty";
 export declare class ToolContentSpec {
     readonly types: ToolContentType[];
     readonly stream: boolean;

package/dist/browser/tool-content-type.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ToolContentSpec = void 0;
 const SUPPORTED_TOOL_CONTENT_TYPES = new Set([
+    "binary",
     "json",
     "text",
     "file",
@@ -58,10 +59,10 @@ class ToolContentSpec {
         const rawStream = value["stream"];
         const stream = typeof rawStream === "boolean" ? rawStream : false;
         const rawSchema = value["schema"];
-        if (rawSchema !== undefined && !isRecord(rawSchema)) {
+        if (rawSchema !== undefined && rawSchema !== null && !isRecord(rawSchema)) {
             throw new Error("ToolContentSpec.schema must be an object when provided");
         }
-        const schema = rawSchema;
+        const schema = rawSchema == null ? undefined : rawSchema;
         return new ToolContentSpec({ types, stream, schema });
     }
 }

package/dist/browser/toolkit-config.d.ts

@@ -0,0 +1,84 @@
+import type { ConnectorRef, OAuthClientConfig, ServiceSpec } from "./meshagent-client";
+import type { RemoteParticipant } from "./participant";
+import type { RoomClient } from "./room-client";
+export declare class MCPHeader {
+    readonly name: string;
+    readonly value: string;
+    constructor({ name, value }: {
+        name: string;
+        value: string;
+    });
+    static fromJson(json: Record<string, unknown>): MCPHeader;
+    toJson(): Record<string, string>;
+}
+export type MCPRequireApproval = "always" | "never";
+export declare class MCPServer {
+    readonly serverLabel: string;
+    readonly authorization?: string;
+    readonly serverUrl?: string;
+    readonly allowedTools?: string[];
+    readonly headers?: MCPHeader[];
+    readonly requireApproval?: MCPRequireApproval;
+    readonly alwaysRequireApproval?: string[];
+    readonly neverRequireApproval?: string[];
+    readonly openaiConnectorId?: string;
+    constructor({ serverLabel, authorization, serverUrl, allowedTools, headers, requireApproval, alwaysRequireApproval, neverRequireApproval, openaiConnectorId, }: {
+        serverLabel: string;
+        authorization?: string | null;
+        serverUrl?: string | null;
+        allowedTools?: string[] | null;
+        headers?: MCPHeader[] | null;
+        requireApproval?: MCPRequireApproval | null;
+        alwaysRequireApproval?: string[] | null;
+        neverRequireApproval?: string[] | null;
+        openaiConnectorId?: string | null;
+    });
+    static fromJson(json: Record<string, unknown>): MCPServer;
+    static fromJsonString(data: string): MCPServer;
+    toJson(): Record<string, unknown>;
+    toJsonString(): string;
+    copyWith({ serverLabel, authorization, serverUrl, allowedTools, headers, requireApproval, alwaysRequireApproval, neverRequireApproval, openaiConnectorId, }: {
+        serverLabel?: string;
+        authorization?: string | null;
+        serverUrl?: string | null;
+        allowedTools?: string[] | null;
+        headers?: MCPHeader[] | null;
+        requireApproval?: MCPRequireApproval | null;
+        alwaysRequireApproval?: string[] | null;
+        neverRequireApproval?: string[] | null;
+        openaiConnectorId?: string | null;
+    }): MCPServer;
+}
+export declare class Connector {
+    readonly name: string;
+    readonly oauth?: OAuthClientConfig;
+    readonly server: MCPServer;
+    constructor({ name, server, oauth, }: {
+        name: string;
+        server: MCPServer;
+        oauth?: OAuthClientConfig | null;
+    });
+    private static oauthClientSecretIdFromHeaders;
+    static buildConnectorRef({ server, oauth, }: {
+        server: MCPServer;
+        oauth?: OAuthClientConfig | null;
+    }): ConnectorRef | null;
+    private buildConnectorRef;
+    isConnected(room: RoomClient, agentName: string): Promise<boolean>;
+    authenticate(client: RoomClient, agent: RemoteParticipant, redirectUri: string | URL): Promise<string | null>;
+}
+export declare function mcpConnectorsFromRoomServices({ services, agentName, }: {
+    services: Iterable<ServiceSpec>;
+    agentName?: string | null;
+}): Connector[];
+export declare class OpenAIConnectors {
+    static readonly dropbox: Connector;
+    static readonly gmail: Connector;
+    static readonly googleCalendar: Connector;
+    static readonly googleDrive: Connector;
+    static readonly microsoftTeams: Connector;
+    static readonly outlookCalendar: Connector;
+    static readonly outlookEmail: Connector;
+    static readonly sharepoint: Connector;
+    static readonly all: Connector[];
+}