@meshagent/meshagent 0.41.4 → 0.41.6

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[];
+}