@peers-app/peers-sdk 0.1.4

package/README.md

@@ -0,0 +1 @@
+Common types, zod schemas, functions, and classes that are used internally in Peers and for building packages.  

package/dist/context/data-context.d.ts

@@ -0,0 +1,31 @@
+import { EventRegistry, TableContainer, ITableDependencies, ITableMetaData, Table } from "../data/orm";
+import { DataSourceFactory } from "../data/orm/table-definitions.type";
+import { PackageLoader } from "../package-loader/package-loader";
+import { UserContext } from "./user-context";
+import { z } from "zod";
+export declare class DataContext {
+    readonly userContext: UserContext;
+    readonly groupId?: string | undefined;
+    readonly dataSourceFactory: DataSourceFactory;
+    readonly tableContainer: TableContainer;
+    readonly packageLoader: PackageLoader;
+    readonly eventRegistry: EventRegistry;
+    constructor(userContext: UserContext, groupId?: string | undefined);
+    get dataContextId(): string;
+    /**
+     * Call this to indicate that this should be the current data context to be used unless otherwise specified
+     */
+    setAsDefault(): void;
+    /**
+     * Creates table dependencies for the new DI pattern.
+     * This factory method provides all dependencies a table needs in one object.
+     */
+    createTableDependencies(metaData: ITableMetaData, schema?: z.AnyZodObject): ITableDependencies;
+    /**
+     * Convenience method for creating tables with the new DI pattern.
+     * This is the preferred way to create custom table classes.
+     */
+    createTable<T extends {
+        [key: string]: any;
+    }>(metaData: ITableMetaData, schema?: z.AnyZodObject, TableClass?: new (metaData: ITableMetaData, deps: ITableDependencies) => Table<T>): Table<T>;
+}

package/dist/context/data-context.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataContext = void 0;
+const orm_1 = require("../data/orm");
+const package_loader_1 = require("../package-loader/package-loader");
+class DataContext {
+    userContext;
+    groupId;
+    dataSourceFactory;
+    tableContainer;
+    packageLoader;
+    eventRegistry;
+    constructor(userContext, groupId) {
+        this.userContext = userContext;
+        this.groupId = groupId;
+        // Initialize dependencies in the correct order to avoid circular references
+        this.eventRegistry = new orm_1.EventRegistry(this.dataContextId);
+        this.packageLoader = new package_loader_1.PackageLoader(this);
+        // Set up data source factory with group wrapping
+        const baseFactory = userContext.dataSourceFactory;
+        this.dataSourceFactory = (metaData, schema) => baseFactory(metaData, schema, this.groupId);
+        // Set up table factory and table container
+        const tableFactory = (metaData, schema, TableClass) => this.createTable(metaData, schema, TableClass);
+        this.tableContainer = new orm_1.TableContainer(tableFactory, groupId);
+    }
+    get dataContextId() {
+        return this.groupId || this.userContext.userId();
+    }
+    /**
+     * Call this to indicate that this should be the current data context to be used unless otherwise specified
+     */
+    setAsDefault() {
+        this.userContext.defaultDataContext(this);
+    }
+    /**
+     * Creates table dependencies for the new DI pattern.
+     * This factory method provides all dependencies a table needs in one object.
+     */
+    createTableDependencies(metaData, schema) {
+        return {
+            dataSource: this.dataSourceFactory(metaData, schema),
+            eventRegistry: this.eventRegistry,
+            schema,
+            groupId: this.groupId
+        };
+    }
+    /**
+     * Convenience method for creating tables with the new DI pattern.
+     * This is the preferred way to create custom table classes.
+     */
+    createTable(metaData, schema, TableClass = orm_1.Table) {
+        const deps = this.createTableDependencies(metaData, schema);
+        return new TableClass(metaData, deps);
+    }
+}
+exports.DataContext = DataContext;

package/dist/context/index.d.ts

@@ -0,0 +1,3 @@
+export * from './user-context-singleton';
+export * from './data-context';
+export * from './user-context';

package/dist/context/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./user-context-singleton"), exports);
+__exportStar(require("./data-context"), exports);
+__exportStar(require("./user-context"), exports);

package/dist/context/user-context-singleton.d.ts

@@ -0,0 +1,11 @@
+import type { Table } from "../data/orm";
+import type { DataContext } from "./data-context";
+import { UserContext } from "./user-context";
+export declare function getUserContext(): Promise<UserContext>;
+export declare function setUserContext(userContext: UserContext): void;
+export declare function getDefaultDataContext(): Promise<DataContext>;
+export declare function getTableContainer(dataContext?: DataContext | undefined): import("../data/orm").TableContainer;
+export declare function setDefaultClientUserContext(): void;
+export declare function getAllTables(): {
+    [tableName: string]: Table<any>;
+};

package/dist/context/user-context-singleton.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUserContext = getUserContext;
+exports.setUserContext = setUserContext;
+exports.getDefaultDataContext = getDefaultDataContext;
+exports.getTableContainer = getTableContainer;
+exports.setDefaultClientUserContext = setDefaultClientUserContext;
+exports.getAllTables = getAllTables;
+const client_proxy_data_source_1 = require("../data/orm/client-proxy.data-source");
+const rpc_types_1 = require("../rpc-types");
+const user_context_1 = require("./user-context");
+const utils_1 = require("../utils");
+// This should be the only singleton pattern in the application
+// everything should be driven off the UserContext instance
+var userContextInstance = undefined;
+var userContextResolved;
+var userContextPromise;
+async function getUserContext() {
+    if (userContextInstance) {
+        return userContextInstance.loadingPromise;
+    }
+    if (!userContextPromise) {
+        userContextPromise = new Promise(resolve => {
+            userContextResolved = resolve;
+            if (userContextInstance) {
+                resolve(userContextInstance.loadingPromise);
+            }
+        });
+    }
+    return userContextPromise;
+}
+function setUserContext(userContext) {
+    if (userContextInstance) {
+        throw new Error(`Cannot set user context again after it has already been set`);
+    }
+    userContextInstance = userContext;
+    if (userContextResolved) {
+        userContextResolved(userContext.loadingPromise);
+    }
+    if (typeof window !== 'undefined') {
+        // @ts-ignore
+        window.userContext = userContext;
+    }
+}
+async function getDefaultDataContext() {
+    const userContext = await getUserContext();
+    return userContext.defaultDataContext();
+}
+function getTableContainer(dataContext) {
+    dataContext ??= userContextInstance?.defaultDataContext();
+    if (!dataContext) {
+        throw new Error('dataContext not provided and user context singleton not yet set');
+    }
+    return dataContext.tableContainer;
+}
+function setDefaultClientUserContext() {
+    const clientProxyDataSourceFactory = (metaData, schema, groupId) => {
+        return new client_proxy_data_source_1.ClientProxyDataSource(metaData, schema, groupId ?? '');
+    };
+    const userContext = new user_context_1.UserContext(clientProxyDataSourceFactory);
+    (async () => {
+        const { GroupsTable } = await Promise.resolve().then(() => require("../data/groups"));
+        const { GroupMembersTable } = await Promise.resolve().then(() => require("../data/group-members"));
+        const { UsersTable } = await Promise.resolve().then(() => require("../data/users"));
+        GroupsTable.isPassthrough = true;
+        GroupMembersTable.isPassthrough = true;
+        UsersTable.isPassthrough = true;
+    })();
+    setUserContext(userContext);
+}
+function getAllTables() {
+    const tables = getTableContainer().getAllTables();
+    const tableMap = {};
+    for (const table of tables) {
+        const tableName = (0, utils_1.getFullTableName)(table.metaData);
+        tableMap[tableName] = table;
+    }
+    return tableMap;
+}
+async function getTable(dataContextId, tableName) {
+    const userContext = await getUserContext();
+    const table = userContext
+        .getDataContext(dataContextId || userContext.userId())
+        .tableContainer
+        .getTable(tableName);
+    return table;
+}
+// TODO: add check that client has permission to do the operation to the table
+rpc_types_1.rpcServerCalls.tableGet = async (dataContextId, tableName, id) => {
+    const table = await getTable(dataContextId, tableName);
+    return table.get(id);
+};
+rpc_types_1.rpcServerCalls.tableList = async (dataContextId, tableName, filter, opts) => {
+    const table = await getTable(dataContextId, tableName);
+    return table.list(filter, opts);
+};
+rpc_types_1.rpcServerCalls.tableCount = async (dataContextId, tableName, filter) => {
+    const table = await getTable(dataContextId, tableName);
+    return table.count(filter);
+};
+rpc_types_1.rpcServerCalls.tableSave = async (dataContextId, tableName, data, opts) => {
+    const table = await getTable(dataContextId, tableName);
+    return table.save(data, opts);
+};
+rpc_types_1.rpcServerCalls.tableInsert = async (dataContextId, tableName, data) => {
+    const table = await getTable(dataContextId, tableName);
+    return table.insert(data);
+};
+rpc_types_1.rpcServerCalls.tableUpdate = async (dataContextId, tableName, data) => {
+    const table = await getTable(dataContextId, tableName);
+    return table.update(data);
+};
+rpc_types_1.rpcServerCalls.tableDelete = async (dataContextId, tableName, idOrRecord) => {
+    const table = await getTable(dataContextId, tableName);
+    return table.delete(idOrRecord);
+};
+rpc_types_1.rpcServerCalls.tableMethodCall = async (dataContextId, tableName, methodName, ...args) => {
+    const table = await getTable(dataContextId, tableName);
+    // @ts-ignore
+    return table[methodName](...args);
+};

package/dist/context/user-context.d.ts

@@ -0,0 +1,55 @@
+import { DataContext } from "../context/data-context";
+import { IUser } from "../data";
+import type { DataSourceFactory, IDataChangedEvent, Table } from "../data/orm";
+import { TrustLevel } from "../device/socket.type";
+import { IPublicPrivateKeys } from "../keys";
+import { Observable } from "../observable";
+export declare class UserContext {
+    readonly dataSourceFactory: DataSourceFactory;
+    readonly userId: Observable<string>;
+    readonly deviceId: Observable<string>;
+    readonly currentlyActiveGroupId: Observable<string | undefined>;
+    readonly packagesRootDir: Observable<string>;
+    readonly reloadPackagesOnPageRefresh: Observable<boolean>;
+    readonly packageLocalPathsResolved: Observable<{
+        [packageId: string]: string;
+    }>;
+    readonly groupIds: Observable<string[]>;
+    readonly userDataContext: DataContext;
+    readonly groupDataContexts: Map<string, DataContext>;
+    readonly defaultDataContext: Observable<DataContext>;
+    readonly loadingPromise: Promise<UserContext>;
+    constructor(dataSourceFactory: DataSourceFactory);
+    private init;
+    /**
+     * We want to load all packages as part of user context initialization
+     * so any tables in packages have been registered are available at sync time
+     */
+    private loadAllPackages;
+    private loadGroupContexts;
+    getDataContext(groupId: string): DataContext;
+    /**
+     * Load observables from the database
+     * This is pretty ugly but get's around guards on the default logic which is waiting
+     * for the user context to be fully loaded before proceeding with standard data access
+     */
+    private loadUserContextObservablesFromDB;
+    getMe(): Promise<{
+        name: string;
+        publicKey: string;
+        userId: string;
+        publicBoxKey: string;
+        signature?: string | undefined;
+        trustLevel?: TrustLevel | undefined;
+    } | undefined>;
+    syncUserAndGroupObjects(keys: IPublicPrivateKeys, me?: IUser): Promise<void>;
+    subscribeToDataChangedAcrossAllGroups<T extends {
+        [key: string]: any;
+    }>(table: Table<T>, handler: (evt: ICrossGroupSubscriptionHandlerArgs<T>) => any): import("../events").ISubscriptionResult;
+}
+export interface ICrossGroupSubscriptionHandlerArgs<T> {
+    name: string;
+    userContext: UserContext;
+    dataContext: DataContext;
+    data: IDataChangedEvent<T>;
+}

package/dist/context/user-context.js

@@ -0,0 +1,205 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserContext = void 0;
+const lodash_1 = require("lodash");
+const data_context_1 = require("../context/data-context");
+const data_1 = require("../data");
+const socket_type_1 = require("../device/socket.type");
+const events_1 = require("../events");
+const keys_1 = require("../keys");
+const observable_1 = require("../observable");
+const utils_1 = require("../utils");
+class UserContext {
+    dataSourceFactory;
+    userId = (0, observable_1.observable)('');
+    deviceId = (0, observable_1.observable)('');
+    currentlyActiveGroupId = (0, observable_1.observable)();
+    packagesRootDir = (0, observable_1.observable)('');
+    reloadPackagesOnPageRefresh = (0, observable_1.observable)(false);
+    packageLocalPathsResolved = (0, observable_1.observable)({});
+    groupIds = (0, observable_1.observable)([]);
+    userDataContext;
+    groupDataContexts = new Map();
+    defaultDataContext = (0, observable_1.observable)();
+    loadingPromise;
+    constructor(dataSourceFactory) {
+        this.dataSourceFactory = dataSourceFactory;
+        this.userDataContext = new data_context_1.DataContext(this);
+        this.defaultDataContext(this.userDataContext);
+        this.loadingPromise = this.init();
+    }
+    async init() {
+        await this.loadUserContextObservablesFromDB();
+        await this.loadGroupContexts();
+        await this.loadAllPackages();
+        return this;
+    }
+    /**
+     * We want to load all packages as part of user context initialization
+     * so any tables in packages have been registered are available at sync time
+     */
+    loadAllPackages() {
+        this.userDataContext.packageLoader.loadAllPackages();
+        for (const groupContext of this.groupDataContexts.values()) {
+            groupContext.packageLoader.loadAllPackages();
+        }
+    }
+    async loadGroupContexts() {
+        const groupsTable = (0, data_1.Groups)(this.userDataContext);
+        const groups = await groupsTable.list({ disabled: { $ne: true } });
+        this.groupIds(groups.map(g => g.groupId));
+        groupsTable.dataChanged.subscribe(evt => {
+            const groupId = evt.dataObject.groupId;
+            if (evt.op === 'delete' || evt.dataObject.disabled) {
+                this.groupIds(this.groupIds().filter(id => id !== groupId));
+                this.groupDataContexts.delete(groupId);
+            }
+            else {
+                this.getDataContext(groupId);
+            }
+        });
+        // load up group data contexts and set currently active group
+        const activeGroupId = this.currentlyActiveGroupId();
+        for (const groupId of this.groupIds()) {
+            const groupContext = this.getDataContext(groupId);
+            if (groupId === activeGroupId) {
+                this.defaultDataContext(groupContext);
+            }
+        }
+        // if no active group, set to user data context
+        if (!this.defaultDataContext()) {
+            this.defaultDataContext(this.userDataContext);
+        }
+        // ensure when currentlyActiveGroupId changes, currentlyActiveGroup is updated and vice versa
+        this.currentlyActiveGroupId.subscribe(async (groupId) => {
+            const dataContext = this.getDataContext(groupId || this.userId());
+            this.defaultDataContext(dataContext);
+        });
+        this.defaultDataContext.subscribe((group) => {
+            if (!group) {
+                this.defaultDataContext(this.userDataContext);
+            }
+            else {
+                this.currentlyActiveGroupId(group.dataContextId);
+            }
+        });
+    }
+    getDataContext(groupId) {
+        if (groupId === this.userId()) {
+            return this.userDataContext;
+        }
+        if (!(0, utils_1.isid)(groupId)) {
+            throw new Error(`dataContextId is not a valid id: ${groupId}`);
+        }
+        if (!this.groupDataContexts.has(groupId)) {
+            if (!this.groupIds().includes(groupId)) {
+                this.groupIds([...this.groupIds(), groupId]);
+            }
+            const groupContext = new data_context_1.DataContext(this, groupId);
+            this.groupDataContexts.set(groupId, groupContext);
+        }
+        return this.groupDataContexts.get(groupId);
+    }
+    /**
+     * Load observables from the database
+     * This is pretty ugly but get's around guards on the default logic which is waiting
+     * for the user context to be fully loaded before proceeding with standard data access
+     */
+    async loadUserContextObservablesFromDB() {
+        const persistentVars = await this.userDataContext.tableContainer.getTableByName(data_1.persistentVarsMetaData.name);
+        const vars = await persistentVars.list({ name: { $in: ['myUserId', 'thisDeviceId', 'currentlyActiveGroupId', 'packagesRootDir', 'reloadPackagesOnPageRefresh', 'packageLocalPathsResolved'] } });
+        const varDbValues = vars.reduce((acc, curr) => {
+            acc[curr.name] = curr.value?.value;
+            return acc;
+        }, {});
+        const userIdPVar = (0, data_1.deviceVar)('myUserId', { dbValue: varDbValues['myUserId'], userContext: this });
+        this.userId(userIdPVar());
+        (0, observable_1.linkObservables)(userIdPVar, this.userId);
+        const deviceIdPVar = (0, data_1.deviceVar)('thisDeviceId', { dbValue: varDbValues['thisDeviceId'], userContext: this });
+        this.deviceId(deviceIdPVar());
+        (0, observable_1.linkObservables)(deviceIdPVar, this.deviceId);
+        const currentlyActiveGroupIdPVar = (0, data_1.deviceVar)('currentlyActiveGroupId', { dbValue: varDbValues['currentlyActiveGroupId'], userContext: this });
+        this.currentlyActiveGroupId(currentlyActiveGroupIdPVar());
+        (0, observable_1.linkObservables)(currentlyActiveGroupIdPVar, this.currentlyActiveGroupId);
+        const packagesRootDirPVar = (0, data_1.deviceVar)('packagesRootDir', { defaultValue: '~/peers-packages', dbValue: varDbValues['packagesRootDir'], userContext: this });
+        this.packagesRootDir(packagesRootDirPVar());
+        (0, observable_1.linkObservables)(packagesRootDirPVar, this.packagesRootDir);
+        const reloadPackagesOnPageRefreshPVar = (0, data_1.deviceVar)('reloadPackagesOnPageRefresh', { defaultValue: false, dbValue: varDbValues['reloadPackagesOnPageRefresh'], userContext: this });
+        this.reloadPackagesOnPageRefresh(reloadPackagesOnPageRefreshPVar());
+        (0, observable_1.linkObservables)(reloadPackagesOnPageRefreshPVar, this.reloadPackagesOnPageRefresh);
+        const packageLocalPathsResolvedPVar = (0, data_1.deviceVar)('packageLocalPathsResolved', { defaultValue: {}, dbValue: varDbValues['packageLocalPathsResolved'], userContext: this });
+        this.packageLocalPathsResolved(packageLocalPathsResolvedPVar());
+        (0, observable_1.linkObservables)(packageLocalPathsResolvedPVar, this.packageLocalPathsResolved);
+        if (typeof process !== 'undefined' && process.env) {
+            if (process.env.USER_ID) {
+                this.userId(process.env.USER_ID);
+            }
+            if (process.env.DEVICE_ID) {
+                this.deviceId(process.env.DEVICE_ID);
+            }
+        }
+        await Promise.all([
+            userIdPVar.loadingPromise,
+            deviceIdPVar.loadingPromise,
+            packagesRootDirPVar.loadingPromise,
+            reloadPackagesOnPageRefreshPVar.loadingPromise,
+            packageLocalPathsResolvedPVar.loadingPromise,
+        ]);
+    }
+    async getMe() {
+        let dbMe = await (0, data_1.Users)(this.userDataContext).get(this.userId(), { useCache: true });
+        return dbMe;
+    }
+    async syncUserAndGroupObjects(keys, me) {
+        // update my user object for all contexts
+        const userContext = this;
+        me ??= await this.getMe();
+        if (!me) {
+            throw new Error('My user object was not passed in and was not found in my personal db');
+        }
+        me.publicKey = keys.publicKey;
+        me.publicBoxKey = keys.publicBoxKey;
+        const meSigned = (0, keys_1.addSignatureToObject)(me, keys.secretKey);
+        // sync my user to personal db
+        if (!(0, lodash_1.isEqual)(me, meSigned)) {
+            (0, keys_1.verifyObjectSignature)(meSigned);
+            await (0, data_1.Users)(userContext.userDataContext).save(meSigned);
+        }
+        // sync my user to all all my groups
+        for (const [, dataContext] of userContext.groupDataContexts) {
+            let groupMe = await (0, data_1.Users)(dataContext).get(me.userId);
+            if (!groupMe || groupMe.name !== me.name || groupMe.publicKey !== me.publicKey) {
+                groupMe = (0, keys_1.addSignatureToObject)({ ...me, trustLevel: groupMe?.trustLevel || socket_type_1.TrustLevel.NewUser }, keys.secretKey);
+                await (0, data_1.Users)(dataContext).save(groupMe);
+            }
+        }
+        // sync group objects to my personal db
+        for (const [, dataContext] of userContext.groupDataContexts) {
+            if (!dataContext.groupId) {
+                console.error('Group data context is missing group id. Something went wrong');
+                continue;
+            }
+            const groupObject = await (0, data_1.Groups)(dataContext).get(dataContext.groupId);
+            const myGroupObject = await (0, data_1.Groups)(this.userDataContext).get(dataContext.groupId);
+            if (groupObject && !(0, lodash_1.isEqual)(groupObject, myGroupObject)) {
+                (0, keys_1.verifyObjectSignature)(groupObject);
+                await (0, data_1.Groups)(this.userDataContext).save(groupObject);
+            }
+        }
+    }
+    subscribeToDataChangedAcrossAllGroups(table, handler) {
+        const tableEventPrefix = `${table.tableName}_DataChanged_`;
+        const subscription = (0, events_1.subscribe)(evt => evt.name.startsWith(tableEventPrefix), async (evt) => {
+            const dataContextId = evt.name.endsWith('_') ? this.userId() : evt.name.split('_').pop();
+            const dataContext = this.getDataContext(dataContextId);
+            handler({
+                name: evt.name,
+                userContext: this,
+                dataContext,
+                data: evt.data,
+            });
+        });
+        return subscription;
+    }
+}
+exports.UserContext = UserContext;

package/dist/data/assistants.d.ts

@@ -0,0 +1,68 @@
+import { z } from 'zod';
+import type { DataContext } from "../context/data-context";
+export declare enum ToolInclusionStrategy {
+    Fixed = "Fixed",
+    Linked = "Linked",
+    Relevant = "Relevant"
+}
+export declare const assistantSchema: z.ZodObject<{
+    assistantId: z.ZodEffects<z.ZodString, string, string>;
+    name: z.ZodString;
+    createdAt: z.ZodDefault<z.ZodDate>;
+    updatedAt: z.ZodOptional<z.ZodDate>;
+    description: z.ZodOptional<z.ZodString>;
+    assistantRunnerToolId: z.ZodDefault<z.ZodString>;
+    assistantRunnerConfig: z.ZodDefault<z.ZodObject<{}, "strip", z.ZodAny, z.objectOutputType<{}, z.ZodAny, "strip">, z.objectInputType<{}, z.ZodAny, "strip">>>;
+    toolsToInclude: z.ZodDefault<z.ZodString>;
+    toolInclusionStrategy: z.ZodDefault<z.ZodNativeEnum<typeof ToolInclusionStrategy>>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    createdAt: Date;
+    assistantId: string;
+    assistantRunnerToolId: string;
+    assistantRunnerConfig: {} & {
+        [k: string]: any;
+    };
+    toolsToInclude: string;
+    toolInclusionStrategy: ToolInclusionStrategy;
+    description?: string | undefined;
+    updatedAt?: Date | undefined;
+}, {
+    name: string;
+    assistantId: string;
+    description?: string | undefined;
+    createdAt?: Date | undefined;
+    updatedAt?: Date | undefined;
+    assistantRunnerToolId?: string | undefined;
+    assistantRunnerConfig?: z.objectInputType<{}, z.ZodAny, "strip"> | undefined;
+    toolsToInclude?: string | undefined;
+    toolInclusionStrategy?: ToolInclusionStrategy | undefined;
+}>;
+export type IAssistant = z.infer<typeof assistantSchema>;
+export declare function Assistants(dataContext?: DataContext): import("./orm").Table<{
+    name: string;
+    createdAt: Date;
+    assistantId: string;
+    assistantRunnerToolId: string;
+    assistantRunnerConfig: {} & {
+        [k: string]: any;
+    };
+    toolsToInclude: string;
+    toolInclusionStrategy: ToolInclusionStrategy;
+    description?: string | undefined;
+    updatedAt?: Date | undefined;
+}>;
+export declare const getPrimaryAssistant: (dataContext?: DataContext) => Promise<{
+    name: string;
+    createdAt: Date;
+    assistantId: string;
+    assistantRunnerToolId: string;
+    assistantRunnerConfig: {} & {
+        [k: string]: any;
+    };
+    toolsToInclude: string;
+    toolInclusionStrategy: ToolInclusionStrategy;
+    description?: string | undefined;
+    updatedAt?: Date | undefined;
+}>;
+export declare function getAllAssistantIdsMentioned(message: string): Promise<string[]>;

package/dist/data/assistants.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPrimaryAssistant = exports.assistantSchema = exports.ToolInclusionStrategy = void 0;
+exports.Assistants = Assistants;
+exports.getAllAssistantIdsMentioned = getAllAssistantIdsMentioned;
+const mentions_1 = require("../mentions");
+const types_1 = require("./orm/types");
+const user_context_singleton_1 = require("../context/user-context-singleton");
+const table_definitions_system_1 = require("./orm/table-definitions.system");
+const zod_1 = require("zod");
+const system_ids_1 = require("../system-ids");
+const zod_types_1 = require("../types/zod-types");
+const persistent_vars_1 = require("./persistent-vars");
+var ToolInclusionStrategy;
+(function (ToolInclusionStrategy) {
+    ToolInclusionStrategy["Fixed"] = "Fixed";
+    ToolInclusionStrategy["Linked"] = "Linked";
+    ToolInclusionStrategy["Relevant"] = "Relevant";
+})(ToolInclusionStrategy || (exports.ToolInclusionStrategy = ToolInclusionStrategy = {}));
+exports.assistantSchema = zod_1.z.object({
+    assistantId: zod_types_1.zodPeerId,
+    name: zod_1.z.string(),
+    createdAt: zod_1.z.date().default(() => new Date()),
+    updatedAt: zod_1.z.date().optional(),
+    description: zod_1.z.string().optional().describe(`Information about the assistant that won't be used in the interaction but can still be used to differentiate between assistants`),
+    assistantRunnerToolId: zod_1.z.string().default(system_ids_1.defaultAssistantRunnerToolId).describe('The tool id of the model to use to run the assistant'),
+    assistantRunnerConfig: zod_types_1.zodAnyObject.default({}).describe('The configuration to use when running the assistant'),
+    toolsToInclude: zod_1.z.string().default('').describe('Link the tools that should always be available to this assistant.  Only linked tools will be included.  All other content will be ignored.\n\nex: `$hello-world-tool`'),
+    // toolsToExclude: z.string().optional().describe('Describe or link the tools that should never be available to this assistant'),
+    toolInclusionStrategy: zod_1.z.nativeEnum(ToolInclusionStrategy).default(ToolInclusionStrategy.Linked).describe([
+        'Describe if and how additional tools should be included on each run of the assistant.',
+        '- **Fixed** - Only include the tools specified in `toolsToInclude`.',
+        "- **Linked** - `Fixed` plus tools linked in the message or chat history of the assistant's current conversation.",
+        '- **Relevant** - `Linked` plus tools matching the context of the conversation determined via vector search (embeddings) of the tools descriptions.',
+    ].join('\n')),
+});
+const metaData = {
+    name: 'Assistants',
+    description: 'The assistants that are available to help users',
+    primaryKeyName: 'assistantId',
+    fields: (0, types_1.schemaToFields)(exports.assistantSchema),
+    iconClassName: 'bi bi-person-fill-gear',
+    indexes: [
+        { fields: ['name'], },
+    ],
+};
+(0, table_definitions_system_1.registerSystemTableDefinition)(metaData, exports.assistantSchema);
+function Assistants(dataContext) {
+    return (0, user_context_singleton_1.getTableContainer)(dataContext).getTable(metaData, exports.assistantSchema);
+}
+const getPrimaryAssistant = async (dataContext) => {
+    let myPrimaryAssistant = undefined;
+    const assistantId = (await (0, persistent_vars_1.getPersistentVar)("primaryAssistantId", dataContext))?.value;
+    myPrimaryAssistant = await Assistants(dataContext).get(assistantId || system_ids_1.defaultAssistantId);
+    if (!myPrimaryAssistant) {
+        throw new Error('Primary assistant not found');
+    }
+    return myPrimaryAssistant;
+};
+exports.getPrimaryAssistant = getPrimaryAssistant;
+async function getAllAssistantIdsMentioned(message) {
+    const mentions = (0, mentions_1.getAllMentions)(message);
+    return mentions.filter(m => m.kind === 'assistant').map(m => m.id);
+}