@meshagent/meshagent 0.36.3 → 0.37.1

package/dist/browser/index.d.ts

@@ -31,3 +31,4 @@ export * from './api_keys';
 export * from './helpers';
 export * from './tool-content-type';
 export * from './utils';
+export * from './version';

package/dist/browser/index.js

@@ -47,3 +47,4 @@ __exportStar(require("./api_keys"), exports);
 __exportStar(require("./helpers"), exports);
 __exportStar(require("./tool-content-type"), exports);
 __exportStar(require("./utils"), exports);
+__exportStar(require("./version"), exports);

package/dist/browser/meshagent-client.js

@@ -73,6 +73,17 @@ function base64ToBytes(base64) {
     }
     return bytes;
 }
+function toFetchBody(body) {
+    if (body == null) {
+        return undefined;
+    }
+    if (typeof body === "string" || body instanceof ArrayBuffer) {
+        return body;
+    }
+    const copy = new Uint8Array(body.byteLength);
+    copy.set(body);
+    return copy.buffer;
+}
 function normalizeBinary(data) {
     if (data instanceof Uint8Array) {
         return data;
@@ -126,7 +137,7 @@ class Meshagent {
         const response = await fetch(url, {
             method,
             headers: finalHeaders,
-            body: requestBody ?? undefined,
+            body: toFetchBody(requestBody),
         });
         if (!response.ok) {
             let message;

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

@@ -1,3 +1,4 @@
+import type { ConnectorRef, OAuthClientConfig } from "./meshagent-client";
 export type StringList = string[];
 export declare class AgentsGrant {
     registerAgent: boolean;
@@ -6,14 +7,18 @@ export declare class AgentsGrant {
     call: boolean;
     useAgents: boolean;
     useTools: boolean;
-    constructor({ registerAgent, registerPublicToolkit, registerPrivateToolkit, call, useAgents, useTools, }?: {
+    allowedToolkits?: StringList;
+    constructor({ registerAgent, registerPublicToolkit, registerPrivateToolkit, call, useAgents, useTools, allowedToolkits, }?: {
         registerAgent?: boolean;
         registerPublicToolkit?: boolean;
         registerPrivateToolkit?: boolean;
         call?: boolean;
         useAgents?: boolean;
         useTools?: boolean;
+        allowedToolkits?: StringList;
     });
+    toJSON(): Record<string, any>;
+    static fromJSON(obj: unknown): AgentsGrant;
 }
 export declare class LivekitGrant {
     breakoutRooms?: StringList;
@@ -21,52 +26,120 @@ export declare class LivekitGrant {
         breakoutRooms?: StringList;
     });
     canJoinBreakoutRoom(name: string): boolean;
+    toJSON(): Record<string, any>;
+    static fromJSON(obj: unknown): LivekitGrant;
 }
 export declare class QueuesGrant {
     send?: StringList;
     receive?: StringList;
     list: boolean;
-    constructor({ send, receive, list }?: {
+    constructor({ send, receive, list, }?: {
         send?: StringList;
         receive?: StringList;
         list?: boolean;
     });
-    canSend(q: string): boolean;
-    canReceive(q: string): boolean;
+    canSend(queue: string): boolean;
+    canReceive(queue: string): boolean;
+    toJSON(): Record<string, any>;
+    static fromJSON(obj: unknown): QueuesGrant;
 }
 export declare class MessagingGrant {
     broadcast: boolean;
     list: boolean;
     send: boolean;
-    constructor({ broadcast, list, send }?: {
+    constructor({ broadcast, list, send, }?: {
         broadcast?: boolean;
         list?: boolean;
         send?: boolean;
     });
+    toJSON(): Record<string, any>;
+    static fromJSON(obj: unknown): MessagingGrant;
 }
 export declare class TableGrant {
     name: string;
+    namespace?: StringList;
     write: boolean;
     read: boolean;
     alter: boolean;
-    constructor({ name, write, read, alter }: {
+    constructor({ name, namespace, write, read, alter, }: {
         name: string;
+        namespace?: StringList;
         write?: boolean;
         read?: boolean;
         alter?: boolean;
     });
+    toJSON(): Record<string, any>;
+    static fromJSON(obj: unknown): TableGrant;
 }
 export declare class DatabaseGrant {
     tables?: TableGrant[];
     listTables: boolean;
-    constructor({ tables, listTables }?: {
+    constructor({ tables, listTables, }?: {
         tables?: TableGrant[];
         listTables?: boolean;
     });
-    private _match;
-    canWrite(table: string): boolean;
-    canRead(table: string): boolean;
-    canAlter(table: string): boolean;
+    private matchingTables;
+    canWrite(table: string, namespace?: StringList): boolean;
+    canRead(table: string, namespace?: StringList): boolean;
+    canAlter(table: string, namespace?: StringList): boolean;
+    canAccess(table: string, namespace?: StringList): boolean;
+    toJSON(): Record<string, any>;
+    static fromJSON(obj: unknown): DatabaseGrant;
+}
+export declare class MemoryPermissions {
+    create: boolean;
+    drop: boolean;
+    inspect: boolean;
+    query: boolean;
+    upsert: boolean;
+    ingest: boolean;
+    recall: boolean;
+    optimize: boolean;
+    constructor({ create, drop, inspect, query, upsert, ingest, recall, optimize, }?: {
+        create?: boolean;
+        drop?: boolean;
+        inspect?: boolean;
+        query?: boolean;
+        upsert?: boolean;
+        ingest?: boolean;
+        recall?: boolean;
+        optimize?: boolean;
+    });
+    toJSON(): Record<string, any>;
+    static fromJSON(obj: unknown): MemoryPermissions;
+}
+export declare class MemoryEntryGrant {
+    name: string;
+    namespace?: StringList;
+    permissions: MemoryPermissions;
+    constructor({ name, namespace, permissions, }: {
+        name: string;
+        namespace?: StringList;
+        permissions?: MemoryPermissions;
+    });
+    toJSON(): Record<string, any>;
+    static fromJSON(obj: unknown): MemoryEntryGrant;
+}
+export declare class MemoryGrant {
+    list: boolean;
+    memories?: MemoryEntryGrant[];
+    constructor({ list, memories, }?: {
+        list?: boolean;
+        memories?: MemoryEntryGrant[];
+    });
+    private matchingMemories;
+    private can;
+    canCreate(name: string, namespace?: StringList): boolean;
+    canDrop(name: string, namespace?: StringList): boolean;
+    canInspect(name: string, namespace?: StringList): boolean;
+    canQuery(name: string, namespace?: StringList): boolean;
+    canUpsert(name: string, namespace?: StringList): boolean;
+    canIngest(name: string, namespace?: StringList): boolean;
+    canRecall(name: string, namespace?: StringList): boolean;
+    canOptimize(name: string, namespace?: StringList): boolean;
+    canAccessExisting(name: string, namespace?: StringList): boolean;
+    toJSON(): Record<string, any>;
+    static fromJSON(obj: unknown): MemoryGrant;
 }
 export declare class SyncPathGrant {
     path: string;
@@ -75,6 +148,8 @@ export declare class SyncPathGrant {
         path: string;
         readOnly?: boolean;
     });
+    toJSON(): Record<string, any>;
+    static fromJSON(obj: unknown): SyncPathGrant;
 }
 export declare class SyncGrant {
     paths?: SyncPathGrant[];
@@ -84,6 +159,8 @@ export declare class SyncGrant {
     private matches;
     canRead(path: string): boolean;
     canWrite(path: string): boolean;
+    toJSON(): Record<string, any>;
+    static fromJSON(obj: unknown): SyncGrant;
 }
 export declare class StoragePathGrant {
     path: string;
@@ -92,73 +169,163 @@ export declare class StoragePathGrant {
         path: string;
         readOnly?: boolean;
     });
+    toJSON(): Record<string, any>;
+    static fromJSON(obj: unknown): StoragePathGrant;
 }
 export declare class StorageGrant {
     paths?: StoragePathGrant[];
     constructor({ paths }?: {
         paths?: StoragePathGrant[];
     });
-    private matches;
     canRead(path: string): boolean;
     canWrite(path: string): boolean;
+    toJSON(): Record<string, any>;
+    static fromJSON(obj: unknown): StorageGrant;
+}
+export declare class ContainerRegistryGrant {
+    list?: StringList;
+    pull?: StringList;
+    run?: StringList;
+    write?: StringList;
+    constructor({ list, pull, run, write, }?: {
+        list?: StringList;
+        pull?: StringList;
+        run?: StringList;
+        write?: StringList;
+    });
+    canList(repository: string): boolean;
+    canPull(repository: string): boolean;
+    canRun(repository: string): boolean;
+    canWrite(repository: string): boolean;
+    toJSON(): Record<string, any>;
+    static fromJSON(obj: unknown): ContainerRegistryGrant;
 }
 export declare class ContainersGrant {
     logs: boolean;
     pull?: StringList;
     run?: StringList;
+    registry?: ContainerRegistryGrant;
     useContainers: boolean;
-    constructor({ logs, pull, run, useContainers }?: {
+    constructor({ logs, pull, run, registry, useContainers, }?: {
         logs?: boolean;
         pull?: StringList;
         run?: StringList;
+        registry?: ContainerRegistryGrant;
         useContainers?: boolean;
     });
-    private match;
     canPull(tag: string): boolean;
     canRun(tag: string): boolean;
+    canRegistryList(repository: string): boolean;
+    canRegistryPull(repository: string): boolean;
+    canRegistryRun(repository: string): boolean;
+    canRegistryWrite(repository: string): boolean;
+    toJSON(): Record<string, any>;
+    static fromJSON(obj: unknown): ContainersGrant;
 }
 export declare class DeveloperGrant {
     logs: boolean;
     constructor({ logs }?: {
         logs?: boolean;
     });
+    toJSON(): Record<string, any>;
+    static fromJSON(obj: unknown): DeveloperGrant;
 }
 export declare class AdminGrant {
+    config: boolean;
+    constructor({ config }?: {
+        config?: boolean;
+    });
+    toJSON(): Record<string, any>;
+    static fromJSON(obj: unknown): AdminGrant;
+}
+export declare class OAuthEndpoint {
+    endpoint: string;
+    clientId: string;
+    constructor({ endpoint, clientId }: {
+        endpoint: string;
+        clientId: string;
+    });
+    toJSON(): Record<string, any>;
+    static fromJSON(obj: unknown): OAuthEndpoint;
 }
 export declare class SecretsGrant {
-    requestOauthToken?: StringList;
-    canRequestOauthToken(authorizationEndpoint: string): boolean;
+    requestOauthToken?: OAuthEndpoint[];
+    constructor({ requestOauthToken }?: {
+        requestOauthToken?: OAuthEndpoint[];
+    });
+    canRequestOauthToken({ connector, oauth, }?: {
+        connector?: ConnectorRef | null;
+        oauth?: OAuthClientConfig | null;
+    }): boolean;
+    toJSON(): Record<string, any>;
+    static fromJSON(obj: unknown): SecretsGrant;
+}
+export declare class TunnelsGrant {
+    ports?: StringList;
+    constructor({ ports }?: {
+        ports?: StringList;
+    });
+    toJSON(): Record<string, any>;
+    static fromJSON(obj: unknown): TunnelsGrant;
+}
+export declare class ServicesGrant {
+    list: boolean;
+    constructor({ list }?: {
+        list?: boolean;
+    });
+    toJSON(): Record<string, any>;
+    static fromJSON(obj: unknown): ServicesGrant;
+}
+export declare class LLMGrant {
+    models?: StringList;
+    constructor({ models }?: {
+        models?: StringList;
+    });
+    canUseProvider(provider: string): boolean;
+    canUseModel(provider: string, model: string): boolean;
+    toJSON(): Record<string, any>;
+    static fromJSON(obj: unknown): LLMGrant;
 }
 export declare class ApiScope {
     livekit?: LivekitGrant;
     queues?: QueuesGrant;
     messaging?: MessagingGrant;
     database?: DatabaseGrant;
+    memory?: MemoryGrant;
     sync?: SyncGrant;
     storage?: StorageGrant;
     containers?: ContainersGrant;
     developer?: DeveloperGrant;
     agents?: AgentsGrant;
+    llm?: LLMGrant;
     admin?: AdminGrant;
     secrets?: SecretsGrant;
-    constructor({ livekit, queues, messaging, database, sync, storage, containers, developer, agents, admin, secrets, }?: {
+    tunnels?: TunnelsGrant;
+    services?: ServicesGrant;
+    constructor({ livekit, queues, messaging, database, memory, sync, storage, containers, developer, agents, llm, admin, secrets, tunnels, services, }?: {
         livekit?: LivekitGrant;
         queues?: QueuesGrant;
         messaging?: MessagingGrant;
         database?: DatabaseGrant;
+        memory?: MemoryGrant;
         sync?: SyncGrant;
         storage?: StorageGrant;
         containers?: ContainersGrant;
         developer?: DeveloperGrant;
         agents?: AgentsGrant;
+        llm?: LLMGrant;
         admin?: AdminGrant;
         secrets?: SecretsGrant;
+        tunnels?: TunnelsGrant;
+        services?: ServicesGrant;
     });
-    static agentDefault(): ApiScope;
+    static agentDefault({ tunnels }?: {
+        tunnels?: boolean;
+    }): ApiScope;
     static userDefault(): ApiScope;
     static full(): ApiScope;
     toJSON(): Record<string, any>;
-    static fromJSON(obj: any): ApiScope;
+    static fromJSON(obj: unknown): ApiScope;
 }
 export declare class ParticipantGrant {
     name: string;
@@ -174,7 +341,7 @@ export declare class ParticipantToken {
     name: string;
     projectId?: string;
     apiKeyId?: string;
-    version?: string;
+    version: string;
     grants: ParticipantGrant[];
     extra?: Record<string, any>;
     constructor({ name, projectId, apiKeyId, version, extra, grants, }: {
@@ -193,9 +360,9 @@ export declare class ParticipantToken {
     addRoomGrant(roomName: string): void;
     addApiGrant(grant: ApiScope): void;
     grantScope(name: string): string | ApiScope | undefined;
-    getApiGrant(): string | ApiScope | undefined;
+    getApiGrant(): ApiScope | undefined;
     toJson(): Record<string, any>;
-    toJwt({ token, expiration, apiKey }?: {
+    toJwt({ token, expiration, apiKey, }?: {
         token?: string;
         expiration?: Date;
         apiKey?: string;