@meshagent/meshagent 0.44.12 → 0.45.0

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

@@ -1,2 +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";
+export declare const fullOAuthScope: string;

package/dist/esm/oauth-scopes.js

@@ -1,18 +1,68 @@
 export const fullOAuthScopes = [
-    'profile',
+    'profile:read',
+    'profile:write',
     'project/*',
     'room/*',
-    'create_users',
-    'create_rooms',
-    'create_agents',
-    'managed_agents',
-    'llm_proxy',
-    'admin',
-    'developer',
-    'connect_room',
-    'delete_room',
-    'update_room',
-    'delete_agent',
-    'update_agent',
+    'users:create',
+    'users:read',
+    'users:update',
+    'users:delete',
+    'projects:read',
+    'projects:update',
+    'projects:iam.read',
+    'projects:iam.write',
+    'projects:billing.read',
+    'projects:billing.write',
+    'rooms:create',
+    'rooms:read',
+    'rooms:connect',
+    'rooms:update',
+    'rooms:delete',
+    'agents:create',
+    'agents:read',
+    'agents:update',
+    'agents:delete',
+    'agents:run',
+    'agents:sessions.read',
+    'mailboxes:create',
+    'mailboxes:read',
+    'mailboxes:update',
+    'mailboxes:delete',
+    'routes:create',
+    'routes:read',
+    'routes:update',
+    'routes:delete',
+    'scheduledTasks:create',
+    'scheduledTasks:read',
+    'scheduledTasks:update',
+    'scheduledTasks:delete',
+    'services:create',
+    'services:read',
+    'services:update',
+    'services:delete',
+    'repositories:create',
+    'repositories:read',
+    'repositories:update',
+    'repositories:delete',
+    'apiKeys:create',
+    'apiKeys:read',
+    'apiKeys:delete',
+    'serviceAccounts:create',
+    'serviceAccounts:read',
+    'serviceAccounts:update',
+    'serviceAccounts:delete',
+    'oauthClients:create',
+    'oauthClients:read',
+    'oauthClients:update',
+    'oauthClients:delete',
+    'llm:invoke',
+    'llm:usage.read',
+    'llm:logs.read',
+    'llm:logs.write',
+    'secrets:read',
+    'secrets:write',
+    'secrets:delete',
+    'secrets:grant',
+    'secrets:proxy',
 ];
-export 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';
+export const fullOAuthScope = fullOAuthScopes.join(' ');

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

@@ -1,4 +1,3 @@
-import type { ConnectorRef, OAuthClientConfig } from "./meshagent-client.js";
 export type StringList = string[];
 export declare class AgentsGrant {
     registerAgent: boolean;
@@ -86,6 +85,70 @@ export declare class DatasetGrant {
     toJSON(): Record<string, any>;
     static fromJSON(obj: unknown): DatasetGrant;
 }
+export declare class SqliteTableGrant {
+    database: string;
+    table: string;
+    namespace?: StringList;
+    write: boolean;
+    read: boolean;
+    alter: boolean;
+    constructor({ database, table, namespace, write, read, alter, }: {
+        database: string;
+        table: string;
+        namespace?: StringList;
+        write?: boolean;
+        read?: boolean;
+        alter?: boolean;
+    });
+    toJSON(): Record<string, any>;
+    static fromJSON(obj: unknown): SqliteTableGrant;
+}
+export declare class SqliteDatabaseGrant {
+    name: string;
+    namespace?: StringList;
+    createTable: boolean;
+    drop: boolean;
+    inspect: boolean;
+    listTables: boolean;
+    execute: boolean;
+    tables?: SqliteTableGrant[];
+    constructor({ name, namespace, createTable, drop, inspect, listTables, execute, tables, }: {
+        name: string;
+        namespace?: StringList;
+        createTable?: boolean;
+        drop?: boolean;
+        inspect?: boolean;
+        listTables?: boolean;
+        execute?: boolean;
+        tables?: SqliteTableGrant[];
+    });
+    toJSON(): Record<string, any>;
+    static fromJSON(obj: unknown): SqliteDatabaseGrant;
+}
+export declare class SqliteGrant {
+    databases?: SqliteDatabaseGrant[];
+    createDatabase: boolean;
+    listDatabases: boolean;
+    constructor({ databases, createDatabase, listDatabases, }?: {
+        databases?: SqliteDatabaseGrant[];
+        createDatabase?: boolean;
+        listDatabases?: boolean;
+    });
+    private matchingDatabases;
+    private matchingTables;
+    canCreateDatabase(): boolean;
+    canListDatabases(): boolean;
+    canDropDatabase(database: string, namespace?: StringList): boolean;
+    canInspectDatabase(database: string, namespace?: StringList): boolean;
+    canListTables(database: string, namespace?: StringList): boolean;
+    canCreateTable(database: string, namespace?: StringList): boolean;
+    canExecute(database: string, namespace?: StringList): boolean;
+    canWrite(database: string, table: string, namespace?: StringList): boolean;
+    canRead(database: string, table: string, namespace?: StringList): boolean;
+    canAlter(database: string, table: string, namespace?: StringList): boolean;
+    toJSON(): Record<string, any>;
+    static fromJSON(obj: unknown): SqliteGrant;
+}
 export declare class MemoryPermissions {
     create: boolean;
     drop: boolean;
@@ -238,25 +301,8 @@ export declare class AdminGrant {
     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?: OAuthEndpoint[];
-    constructor({ requestOauthToken }?: {
-        requestOauthToken?: OAuthEndpoint[];
-    });
-    canRequestOauthToken({ connector, oauth, }?: {
-        connector?: ConnectorRef | null;
-        oauth?: OAuthClientConfig | null;
-    }): boolean;
+    constructor(options?: Record<string, never>);
     toJSON(): Record<string, any>;
     static fromJSON(obj: unknown): SecretsGrant;
 }
@@ -291,6 +337,7 @@ export declare class ApiScope {
     queues?: QueuesGrant;
     messaging?: MessagingGrant;
     dataset?: DatasetGrant;
+    sqlite?: SqliteGrant;
     memory?: MemoryGrant;
     sync?: SyncGrant;
     storage?: StorageGrant;
@@ -302,11 +349,12 @@ export declare class ApiScope {
     secrets?: SecretsGrant;
     tunnels?: TunnelsGrant;
     services?: ServicesGrant;
-    constructor({ livekit, queues, messaging, dataset, memory, sync, storage, containers, developer, agents, llm, admin, secrets, tunnels, services, }?: {
+    constructor({ livekit, queues, messaging, dataset, sqlite, memory, sync, storage, containers, developer, agents, llm, admin, secrets, tunnels, services, }?: {
         livekit?: LivekitGrant;
         queues?: QueuesGrant;
         messaging?: MessagingGrant;
         dataset?: DatasetGrant;
+        sqlite?: SqliteGrant;
         memory?: MemoryGrant;
         sync?: SyncGrant;
         storage?: StorageGrant;

package/dist/esm/participant-token.js

@@ -288,6 +288,215 @@ export class DatasetGrant {
         });
     }
 }
+export class SqliteTableGrant {
+    constructor({ database, table, namespace, write, read, alter, }) {
+        this.database = database;
+        this.table = table;
+        this.namespace = namespace;
+        this.write = write ?? true;
+        this.read = read ?? true;
+        this.alter = alter ?? false;
+    }
+    toJSON() {
+        const json = {
+            database: this.database,
+            table: this.table,
+        };
+        if (this.namespace !== undefined) {
+            json["namespace"] = this.namespace;
+        }
+        if (this.write !== true) {
+            json["write"] = this.write;
+        }
+        if (this.read !== true) {
+            json["read"] = this.read;
+        }
+        if (this.alter !== false) {
+            json["alter"] = this.alter;
+        }
+        return json;
+    }
+    static fromJSON(obj) {
+        if (!isRecord(obj) || typeof obj.database !== "string" || typeof obj.table !== "string") {
+            throw new Error("SqliteTableGrant requires database and table");
+        }
+        return new SqliteTableGrant({
+            database: obj.database,
+            table: obj.table,
+            namespace: asStringList(obj.namespace),
+            write: obj.write,
+            read: obj.read,
+            alter: obj.alter,
+        });
+    }
+}
+export class SqliteDatabaseGrant {
+    constructor({ name, namespace, createTable, drop, inspect, listTables, execute, tables, }) {
+        this.name = name;
+        this.namespace = namespace;
+        this.createTable = createTable ?? true;
+        this.drop = drop ?? false;
+        this.inspect = inspect ?? true;
+        this.listTables = listTables ?? true;
+        this.execute = execute ?? true;
+        this.tables = tables;
+    }
+    toJSON() {
+        const json = { name: this.name };
+        if (this.namespace !== undefined) {
+            json["namespace"] = this.namespace;
+        }
+        if (this.createTable !== true) {
+            json["create_table"] = this.createTable;
+        }
+        if (this.drop !== false) {
+            json["drop"] = this.drop;
+        }
+        if (this.inspect !== true) {
+            json["inspect"] = this.inspect;
+        }
+        if (this.listTables !== true) {
+            json["list_tables"] = this.listTables;
+        }
+        if (this.execute !== true) {
+            json["execute"] = this.execute;
+        }
+        if (this.tables !== undefined) {
+            json["tables"] = this.tables.map((tableGrant) => tableGrant.toJSON());
+        }
+        return json;
+    }
+    static fromJSON(obj) {
+        if (!isRecord(obj) || typeof obj.name !== "string") {
+            throw new Error("SqliteDatabaseGrant requires a name");
+        }
+        return new SqliteDatabaseGrant({
+            name: obj.name,
+            namespace: asStringList(obj.namespace),
+            createTable: obj.create_table ?? obj.createTable,
+            drop: obj.drop,
+            inspect: obj.inspect,
+            listTables: obj.list_tables ?? obj.listTables,
+            execute: obj.execute,
+            tables: Array.isArray(obj.tables)
+                ? obj.tables.map((tableGrant) => SqliteTableGrant.fromJSON(tableGrant))
+                : undefined,
+        });
+    }
+}
+export class SqliteGrant {
+    constructor({ databases, createDatabase, listDatabases, } = {}) {
+        this.databases = databases;
+        this.createDatabase = createDatabase ?? true;
+        this.listDatabases = listDatabases ?? true;
+    }
+    matchingDatabases(database, namespace) {
+        if (this.databases === undefined) {
+            return [];
+        }
+        return this.databases.filter((databaseGrant) => {
+            if (databaseGrant.name !== database) {
+                return false;
+            }
+            if (databaseGrant.namespace === undefined) {
+                return true;
+            }
+            return namespacesEqual(databaseGrant.namespace, namespace);
+        });
+    }
+    matchingTables(database, table, namespace) {
+        return this.matchingDatabases(database, namespace)
+            .flatMap((databaseGrant) => databaseGrant.tables ?? [])
+            .filter((tableGrant) => {
+            if (tableGrant.database !== database || tableGrant.table !== table) {
+                return false;
+            }
+            if (tableGrant.namespace === undefined) {
+                return true;
+            }
+            return namespacesEqual(tableGrant.namespace, namespace);
+        });
+    }
+    canCreateDatabase() {
+        return this.createDatabase;
+    }
+    canListDatabases() {
+        return this.listDatabases;
+    }
+    canDropDatabase(database, namespace) {
+        if (this.databases === undefined) {
+            return true;
+        }
+        return this.matchingDatabases(database, namespace).some((databaseGrant) => databaseGrant.drop);
+    }
+    canInspectDatabase(database, namespace) {
+        if (this.databases === undefined) {
+            return true;
+        }
+        return this.matchingDatabases(database, namespace).some((databaseGrant) => databaseGrant.inspect);
+    }
+    canListTables(database, namespace) {
+        if (this.databases === undefined) {
+            return true;
+        }
+        return this.matchingDatabases(database, namespace).some((databaseGrant) => databaseGrant.listTables);
+    }
+    canCreateTable(database, namespace) {
+        if (this.databases === undefined) {
+            return true;
+        }
+        return this.matchingDatabases(database, namespace).some((databaseGrant) => databaseGrant.createTable);
+    }
+    canExecute(database, namespace) {
+        if (this.databases === undefined) {
+            return true;
+        }
+        return this.matchingDatabases(database, namespace).some((databaseGrant) => databaseGrant.execute);
+    }
+    canWrite(database, table, namespace) {
+        if (this.databases === undefined) {
+            return true;
+        }
+        return this.matchingTables(database, table, namespace).some((tableGrant) => tableGrant.write);
+    }
+    canRead(database, table, namespace) {
+        if (this.databases === undefined) {
+            return true;
+        }
+        return this.matchingTables(database, table, namespace).some((tableGrant) => tableGrant.read);
+    }
+    canAlter(database, table, namespace) {
+        if (this.databases === undefined) {
+            return true;
+        }
+        return this.matchingTables(database, table, namespace).some((tableGrant) => tableGrant.alter);
+    }
+    toJSON() {
+        const json = {};
+        if (this.databases !== undefined) {
+            json["databases"] = this.databases.map((databaseGrant) => databaseGrant.toJSON());
+        }
+        if (this.createDatabase !== true) {
+            json["create_database"] = this.createDatabase;
+        }
+        if (this.listDatabases !== true) {
+            json["list_databases"] = this.listDatabases;
+        }
+        return json;
+    }
+    static fromJSON(obj) {
+        if (!isRecord(obj)) {
+            return new SqliteGrant();
+        }
+        return new SqliteGrant({
+            databases: Array.isArray(obj.databases)
+                ? obj.databases.map((databaseGrant) => SqliteDatabaseGrant.fromJSON(databaseGrant))
+                : undefined,
+            createDatabase: obj.create_database ?? obj.createDatabase,
+            listDatabases: obj.list_databases ?? obj.listDatabases,
+        });
+    }
+}
 export class MemoryPermissions {
     constructor({ create, drop, inspect, query, upsert, ingest, recall, optimize, } = {}) {
         this.create = create ?? true;
@@ -750,71 +959,25 @@ export class AdminGrant {
         });
     }
 }
-export class OAuthEndpoint {
-    constructor({ endpoint, clientId }) {
-        this.endpoint = endpoint;
-        this.clientId = clientId;
-    }
-    toJSON() {
-        return {
-            endpoint: this.endpoint,
-            client_id: this.clientId,
-        };
-    }
-    static fromJSON(obj) {
-        if (!isRecord(obj) || typeof obj.endpoint !== "string") {
-            throw new Error("OAuthEndpoint requires an endpoint");
-        }
-        const clientId = obj.client_id ?? obj.clientId;
-        if (typeof clientId !== "string") {
-            throw new Error("OAuthEndpoint requires a client_id");
-        }
-        return new OAuthEndpoint({
-            endpoint: obj.endpoint,
-            clientId,
-        });
-    }
-}
 export class SecretsGrant {
-    constructor({ requestOauthToken } = {}) {
-        this.requestOauthToken = requestOauthToken;
-    }
-    canRequestOauthToken({ connector, oauth, } = {}) {
-        void connector;
-        if (this.requestOauthToken === undefined) {
-            return true;
+    constructor(options = {}) {
+        const keys = Object.keys(options);
+        if (keys.length > 0) {
+            throw new Error(`unsupported SecretsGrant fields: ${keys.join(", ")}`);
         }
-        const authorizationEndpoint = typeof oauth?.authorization_endpoint === "string"
-            ? oauth.authorization_endpoint.trim()
-            : "";
-        const clientId = typeof oauth?.client_id === "string"
-            ? oauth.client_id.trim()
-            : "";
-        if (authorizationEndpoint === "" || clientId === "") {
-            return false;
-        }
-        return this.requestOauthToken.some((endpointGrant) => ((endpointGrant.endpoint === authorizationEndpoint
-            || (endpointGrant.endpoint.endsWith("*")
-                && authorizationEndpoint.startsWith(endpointGrant.endpoint.slice(0, -1))))
-            && endpointGrant.clientId === clientId));
     }
     toJSON() {
-        const json = {};
-        if (this.requestOauthToken !== undefined) {
-            json["request_oauth_token"] = this.requestOauthToken.map((endpointGrant) => endpointGrant.toJSON());
-        }
-        return json;
+        return {};
     }
     static fromJSON(obj) {
         if (!isRecord(obj)) {
             return new SecretsGrant();
         }
-        const requestOauthToken = obj.request_oauth_token ?? obj.requestOauthToken;
-        return new SecretsGrant({
-            requestOauthToken: Array.isArray(requestOauthToken)
-                ? requestOauthToken.map((endpointGrant) => OAuthEndpoint.fromJSON(endpointGrant))
-                : undefined,
-        });
+        const keys = Object.keys(obj);
+        if (keys.length > 0) {
+            throw new Error(`unsupported SecretsGrant fields: ${keys.join(", ")}`);
+        }
+        return new SecretsGrant();
     }
 }
 export class TunnelsGrant {
@@ -897,11 +1060,12 @@ export class LLMGrant {
     }
 }
 export class ApiScope {
-    constructor({ livekit, queues, messaging, dataset, memory, sync, storage, containers, developer, agents, llm, admin, secrets, tunnels, services, } = {}) {
+    constructor({ livekit, queues, messaging, dataset, sqlite, memory, sync, storage, containers, developer, agents, llm, admin, secrets, tunnels, services, } = {}) {
         this.livekit = livekit;
         this.queues = queues;
         this.messaging = messaging;
         this.dataset = dataset;
+        this.sqlite = sqlite;
         this.memory = memory;
         this.sync = sync;
         this.storage = storage;
@@ -920,6 +1084,7 @@ export class ApiScope {
             queues: new QueuesGrant(),
             messaging: new MessagingGrant(),
             dataset: new DatasetGrant(),
+            sqlite: new SqliteGrant(),
             memory: new MemoryGrant(),
             sync: new SyncGrant(),
             storage: new StorageGrant(),
@@ -936,6 +1101,7 @@ export class ApiScope {
             queues: new QueuesGrant(),
             messaging: new MessagingGrant(),
             dataset: new DatasetGrant(),
+            sqlite: new SqliteGrant(),
             memory: new MemoryGrant(),
             sync: new SyncGrant(),
             storage: new StorageGrant(),
@@ -943,7 +1109,6 @@ export class ApiScope {
             developer: new DeveloperGrant(),
             agents: new AgentsGrant(),
             llm: new LLMGrant(),
-            secrets: new SecretsGrant(),
             services: new ServicesGrant(),
         });
     }
@@ -953,6 +1118,7 @@ export class ApiScope {
             queues: new QueuesGrant(),
             messaging: new MessagingGrant(),
             dataset: new DatasetGrant(),
+            sqlite: new SqliteGrant(),
             memory: new MemoryGrant(),
             sync: new SyncGrant(),
             storage: new StorageGrant(),
@@ -961,7 +1127,6 @@ export class ApiScope {
             agents: new AgentsGrant(),
             llm: new LLMGrant(),
             admin: new AdminGrant(),
-            secrets: new SecretsGrant(),
             tunnels: new TunnelsGrant(),
             services: new ServicesGrant(),
         });
@@ -980,6 +1145,9 @@ export class ApiScope {
         if (this.dataset !== undefined) {
             json["dataset"] = this.dataset.toJSON();
         }
+        if (this.sqlite !== undefined) {
+            json["sqlite"] = this.sqlite.toJSON();
+        }
         if (this.memory !== undefined) {
             json["memory"] = this.memory.toJSON();
         }
@@ -1025,6 +1193,7 @@ export class ApiScope {
             queues: obj.queues ? QueuesGrant.fromJSON(obj.queues) : undefined,
             messaging: obj.messaging ? MessagingGrant.fromJSON(obj.messaging) : undefined,
             dataset: rawDataset ? DatasetGrant.fromJSON(rawDataset) : undefined,
+            sqlite: obj.sqlite ? SqliteGrant.fromJSON(obj.sqlite) : undefined,
             memory: obj.memory ? MemoryGrant.fromJSON(obj.memory) : undefined,
             sync: obj.sync ? SyncGrant.fromJSON(obj.sync) : undefined,
             storage: obj.storage ? StorageGrant.fromJSON(obj.storage) : undefined,

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

@@ -1,4 +1,5 @@
 import { DatasetsClient } from "./datasets-client.js";
+import { SqliteClient } from "./sqlite-client.js";
 import { DeveloperClient } from "./developer-client.js";
 import { type EventHandler, type EventName } from "./event-emitter.js";
 import { MessagingClient } from "./messaging-client.js";
@@ -9,7 +10,6 @@ import { QueuesClient } from "./queues-client.js";
 import type { Content } from "./response.js";
 import { RoomEvent } from "./room-event.js";
 import { RoomServerException } from "./room-server-client.js";
-import { SecretsClient, type OAuthTokenRequestHandler, type SecretRequestHandler } from "./secrets-client.js";
 import { ServicesClient } from "./services-client.js";
 import { StorageClient } from "./storage-client.js";
 import { SyncClient } from "./sync-client.js";
@@ -54,8 +54,8 @@ export declare class RoomClient {
     readonly messaging: MessagingClient;
     readonly queues: QueuesClient;
     readonly datasets: DatasetsClient;
+    readonly sqlite: SqliteClient;
     readonly agents: AgentsClient;
-    readonly secrets: SecretsClient;
     readonly containers: ContainersClient;
     readonly memory: MemoryClient;
     readonly services: ServicesClient;
@@ -94,17 +94,13 @@ export declare class RoomClient {
     private readonly _handleParticipantBound;
     private readonly _handleResponseBound;
     private readonly _handleToolCallResponseChunkBound;
-    constructor({ protocolFactory, reconnectTimeout, oauthTokenRequestHandler, secretRequestHandler, }?: {
+    constructor({ protocolFactory, reconnectTimeout, }?: {
         protocolFactory?: ProtocolFactory | null;
         reconnectTimeout?: number | null;
-        oauthTokenRequestHandler?: OAuthTokenRequestHandler;
-        secretRequestHandler?: SecretRequestHandler;
     });
-    static withIAP({ url, reconnectTimeout, oauthTokenRequestHandler, secretRequestHandler, }?: {
+    static withIAP({ url, reconnectTimeout, }?: {
         url?: string;
         reconnectTimeout?: number | null;
-        oauthTokenRequestHandler?: OAuthTokenRequestHandler;
-        secretRequestHandler?: SecretRequestHandler;
     }): RoomClient;
     get localParticipant(): LocalParticipant | null;
     get ready(): Promise<void>;

package/dist/esm/room-client.js

@@ -1,5 +1,6 @@
 import { Completer } from "./completer.js";
 import { DatasetsClient } from "./datasets-client.js";
+import { SqliteClient } from "./sqlite-client.js";
 import { DeveloperClient } from "./developer-client.js";
 import { EventEmitter } from "./event-emitter.js";
 import { MessagingClient } from "./messaging-client.js";
@@ -10,7 +11,6 @@ import { QueuesClient } from "./queues-client.js";
 import { BinaryContent, ControlCloseStatus, ControlContent, EmptyContent, ErrorContent, FileContent, JsonContent, LinkContent, TextContent, unpackContent } from "./response.js";
 import { RoomStatusEvent } from "./room-event.js";
 import { RoomServerException } from "./room-server-client.js";
-import { SecretsClient } from "./secrets-client.js";
 import { ServicesClient } from "./services-client.js";
 import { StorageClient } from "./storage-client.js";
 import { StreamController } from "./stream-controller.js";
@@ -205,7 +205,7 @@ export class RoomProtocolProxy {
     }
 }
 export class RoomClient {
-    constructor({ protocolFactory = null, reconnectTimeout = null, oauthTokenRequestHandler, secretRequestHandler, } = {}) {
+    constructor({ protocolFactory = null, reconnectTimeout = null, } = {}) {
         this._entered = false;
         this._allowDisconnectedRequests = false;
         this._eventsController = new StreamController();
@@ -252,22 +252,16 @@ export class RoomClient {
         this.messaging = new MessagingClient({ room: this });
         this.queues = new QueuesClient({ room: this });
         this.datasets = new DatasetsClient({ room: this });
+        this.sqlite = new SqliteClient({ room: this });
         this.agents = new AgentsClient({ room: this });
-        this.secrets = new SecretsClient({
-            room: this,
-            oauthTokenRequestHandler,
-            secretRequestHandler,
-        });
         this.containers = new ContainersClient({ room: this });
         this.memory = new MemoryClient({ room: this });
         this.services = new ServicesClient({ room: this });
     }
-    static withIAP({ url = "./.well-known/meshagent/room/connect", reconnectTimeout = null, oauthTokenRequestHandler, secretRequestHandler, } = {}) {
+    static withIAP({ url = "./.well-known/meshagent/room/connect", reconnectTimeout = null, } = {}) {
         return new RoomClient({
             protocolFactory: () => WebSocketClientProtocol.withIAP({ url }),
             reconnectTimeout,
-            oauthTokenRequestHandler,
-            secretRequestHandler,
         });
     }
     get localParticipant() {

package/dist/esm/services-client.d.ts

@@ -9,6 +9,17 @@ export interface ServiceRuntimeState {
     restartCount: number;
     lastExitCode?: number;
     lastExitAt?: number;
+    lastStartError?: string;
+    lastStartErrorAt?: number;
+    events: ServiceRuntimeEvent[];
+}
+export interface ServiceRuntimeEvent {
+    type: string;
+    reason: string;
+    message: string;
+    count: number;
+    firstTimestamp: number;
+    lastTimestamp: number;
 }
 export interface ListServicesResult {
     services: ServiceSpec[];