@peers-app/peers-sdk 0.1.4

package/dist/types/app-nav.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.appNavSchema = void 0;
+const zod_1 = require("zod");
+exports.appNavSchema = zod_1.z.object({
+    name: zod_1.z.string(),
+    displayName: zod_1.z.string().optional(),
+    iconClassName: zod_1.z.string(),
+    navigationPath: zod_1.z.string(),
+});

package/dist/types/assistant-runner-args.d.ts

@@ -0,0 +1,9 @@
+import { IAssistant } from "../data/assistants";
+import { IMessage } from "../data/messages";
+import { IWorkflowLog } from "../data/workflow-logs";
+export interface IAssistantRunnerArgs {
+    assistant: IAssistant;
+    message: IMessage;
+    threadHistory: Readonly<IMessage[]>;
+    messageLogs: Readonly<IWorkflowLog[]>;
+}

package/dist/types/assistant-runner-args.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/field-type.d.ts

@@ -0,0 +1,37 @@
+import { z } from "zod";
+export declare enum FieldType {
+    id = "id",
+    string = "string",
+    number = "number",
+    boolean = "boolean",
+    Date = "Date",
+    object = "object",
+    blob = "blob",
+    any = "any"
+}
+export declare const fieldSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    type: z.ZodNativeEnum<typeof FieldType>;
+    defaultValue: z.ZodOptional<z.ZodAny>;
+    optional: z.ZodOptional<z.ZodBoolean>;
+    isArray: z.ZodOptional<z.ZodBoolean>;
+    subType: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    type: FieldType;
+    optional?: boolean | undefined;
+    description?: string | undefined;
+    defaultValue?: any;
+    isArray?: boolean | undefined;
+    subType?: string | undefined;
+}, {
+    name: string;
+    type: FieldType;
+    optional?: boolean | undefined;
+    description?: string | undefined;
+    defaultValue?: any;
+    isArray?: boolean | undefined;
+    subType?: string | undefined;
+}>;
+export type IField = z.infer<typeof fieldSchema>;

package/dist/types/field-type.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fieldSchema = exports.FieldType = void 0;
+const zod_1 = require("zod");
+//export type FieldType = 'id' | 'string' | 'number' | 'boolean' | 'Date' | 'object' | 'blob' | 'any';
+var FieldType;
+(function (FieldType) {
+    FieldType["id"] = "id";
+    FieldType["string"] = "string";
+    FieldType["number"] = "number";
+    FieldType["boolean"] = "boolean";
+    FieldType["Date"] = "Date";
+    FieldType["object"] = "object";
+    FieldType["blob"] = "blob";
+    FieldType["any"] = "any";
+})(FieldType || (exports.FieldType = FieldType = {}));
+exports.fieldSchema = zod_1.z.object({
+    name: zod_1.z.string(),
+    description: zod_1.z.string().optional(),
+    type: zod_1.z.nativeEnum(FieldType),
+    defaultValue: zod_1.z.any().optional(),
+    optional: zod_1.z.boolean().optional(),
+    isArray: zod_1.z.boolean().optional(),
+    // enumValues: z.array(z.string()).optional(),
+    subType: zod_1.z.string().optional(),
+});

package/dist/types/peer-device.d.ts

@@ -0,0 +1,40 @@
+import type { IChange, GroupMemberRole } from "../data";
+import type { DataFilter, IDataQueryParams } from "../data/orm";
+export interface IPeerDevice {
+    deviceId: string;
+    userId: string;
+    role: GroupMemberRole;
+    listChanges(filter?: DataFilter<IChange>, opts?: IDataQueryParams<IChange>): Promise<IChange[]>;
+    getNetworkInfo(): Promise<INetworkInfo>;
+    notifyOfChanges(deviceId: string, timestampLastApplied: number): Promise<void>;
+}
+export interface INetworkInfo {
+    deviceId: string;
+    timestampLastApplied: number;
+    connections: IDeviceConnection[];
+    preferredDeviceIds: string[];
+}
+export interface IDeviceConnection {
+    deviceId: string;
+    latencyMs: number;
+    errorRate: number;
+    timestampLastApplied: number;
+    onClose?(): Promise<void>;
+}
+export declare const PeerDeviceConsts: Readonly<{
+    MAX_CONNECTIONS: 30;
+    RESYNC_INTERVAL: number;
+    NOTIFY_CHANGE_DELAY: 100;
+    CHANGES_PAGE_SIZE: 100;
+    RETRY_COUNT: 2;
+    TIMEOUT_MIN: number;
+    TIMEOUT_MAX: number;
+    NETWORK_INFO_CACHE_TIME: 1000;
+}>;
+export type IFileChunkInfo = {
+    hasChunk: false;
+} | {
+    hasChunk: true;
+    downloadQueueSize: number;
+    estimatedWaitMs: number;
+};

package/dist/types/peer-device.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PeerDeviceConsts = void 0;
+exports.PeerDeviceConsts = Object.freeze({
+    // TODO set this based on device type (desktops and servers should be able to handle 100 connections)
+    MAX_CONNECTIONS: 30,
+    RESYNC_INTERVAL: 1 * 60 * 1000, // play with this to find the right balance
+    NOTIFY_CHANGE_DELAY: 100,
+    CHANGES_PAGE_SIZE: 100,
+    RETRY_COUNT: 2,
+    TIMEOUT_MIN: 3 * 1000,
+    TIMEOUT_MAX: 30 * 1000,
+    NETWORK_INFO_CACHE_TIME: 1000,
+});

package/dist/types/peers-package.d.ts

@@ -0,0 +1,23 @@
+import type { IAssistant } from "../data";
+import type { IAppNav } from "./app-nav";
+import type { IPeerEventType } from "../data/peer-events/peer-event-types";
+import type { IToolInstance } from "../data/tools";
+import type { IWorkflow } from "./workflow";
+import type { IPeersUI } from "../peers-ui/peers-ui";
+import type { IPeersUIRoute } from "../peers-ui/peers-ui.types";
+import type { ITableDefinition } from "../data/orm/table-definitions.type";
+export interface IPeersPackage {
+    packageId: string;
+    toolInstances?: IToolInstance[];
+    assistants?: IAssistant[];
+    workflows?: IWorkflow[];
+    events?: IPeerEventType[];
+    appNavs?: IAppNav[];
+    tableDefinitions?: ITableDefinition[];
+}
+export interface IPeersPackageRoutes {
+    routes: IPeersUIRoute[];
+}
+export interface IPeersPackageUIs {
+    uis: IPeersUI[];
+}

package/dist/types/peers-package.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/workflow-logger.d.ts

@@ -0,0 +1,2 @@
+import { IWorkflowLog } from "../data/workflow-logs";
+export type IWorkflowLogger = (logData: string | Omit<Partial<IWorkflowLog>, "workflowRunId" | "workflowLogId">) => Promise<IWorkflowLog>;

package/dist/types/workflow-logger.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/workflow-run-context.d.ts

@@ -0,0 +1,12 @@
+import { IAssistantRunnerArgs } from "./assistant-runner-args";
+import { IToolInstance } from "../data/tools";
+import { IWorkflowLogger } from "./workflow-logger";
+import { IWorkflowRun } from "../data/workflow-runs";
+export interface IWorkflowRunContext {
+    contextId: string;
+    workflowRun: IWorkflowRun;
+    logger: IWorkflowLogger;
+    getAssistantRunnerArgs: (assistantId: string) => Promise<IAssistantRunnerArgs>;
+    getAvailableTools: (args: IAssistantRunnerArgs, similarityText?: string) => Promise<IToolInstance[]>;
+    getVariable: (variableName: string, toolId?: string) => Promise<string>;
+}

package/dist/types/workflow-run-context.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/workflow.d.ts

@@ -0,0 +1,72 @@
+import { z } from "zod";
+export declare const workflowInstructionSchema: z.ZodObject<{
+    markdown: z.ZodOptional<z.ZodString>;
+    onError: z.ZodOptional<z.ZodString>;
+    directCallToolId: z.ZodOptional<z.ZodString>;
+    subWorkflowId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    markdown?: string | undefined;
+    onError?: string | undefined;
+    directCallToolId?: string | undefined;
+    subWorkflowId?: string | undefined;
+}, {
+    markdown?: string | undefined;
+    onError?: string | undefined;
+    directCallToolId?: string | undefined;
+    subWorkflowId?: string | undefined;
+}>;
+export type IWorkflowInstruction = z.infer<typeof workflowInstructionSchema>;
+export declare const workflowSchema: z.ZodObject<{
+    workflowId: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodString;
+    defaultAssistantId: z.ZodString;
+    instructions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        markdown: z.ZodOptional<z.ZodString>;
+        onError: z.ZodOptional<z.ZodString>;
+        directCallToolId: z.ZodOptional<z.ZodString>;
+        subWorkflowId: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        markdown?: string | undefined;
+        onError?: string | undefined;
+        directCallToolId?: string | undefined;
+        subWorkflowId?: string | undefined;
+    }, {
+        markdown?: string | undefined;
+        onError?: string | undefined;
+        directCallToolId?: string | undefined;
+        subWorkflowId?: string | undefined;
+    }>, "many">>;
+    createdBy: z.ZodString;
+    createdAt: z.ZodDefault<z.ZodDate>;
+    updatedAt: z.ZodDefault<z.ZodDate>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    description: string;
+    createdAt: Date;
+    workflowId: string;
+    defaultAssistantId: string;
+    instructions: {
+        markdown?: string | undefined;
+        onError?: string | undefined;
+        directCallToolId?: string | undefined;
+        subWorkflowId?: string | undefined;
+    }[];
+    createdBy: string;
+    updatedAt: Date;
+}, {
+    name: string;
+    description: string;
+    workflowId: string;
+    defaultAssistantId: string;
+    createdBy: string;
+    createdAt?: Date | undefined;
+    instructions?: {
+        markdown?: string | undefined;
+        onError?: string | undefined;
+        directCallToolId?: string | undefined;
+        subWorkflowId?: string | undefined;
+    }[] | undefined;
+    updatedAt?: Date | undefined;
+}>;
+export type IWorkflow = z.infer<typeof workflowSchema>;

package/dist/types/workflow.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.workflowSchema = exports.workflowInstructionSchema = void 0;
+const zod_1 = require("zod");
+exports.workflowInstructionSchema = zod_1.z.object({
+    markdown: zod_1.z.string().optional().describe('The instruction in markdown format'),
+    onError: zod_1.z.string().optional().describe('The instruction to run if there is an error while running this instruction'),
+    directCallToolId: zod_1.z.string().optional().describe('The tool to call directly with the tool id'),
+    subWorkflowId: zod_1.z.string().optional().describe('The sub workflow to run with the workflow id'),
+});
+exports.workflowSchema = zod_1.z.object({
+    workflowId: zod_1.z.string(),
+    name: zod_1.z.string().describe('The name of the workflow'),
+    description: zod_1.z.string().describe('A detailed description of the workflow that can be used to help users and assistants understand what the workflow does'),
+    defaultAssistantId: zod_1.z.string().describe('The default assistant to handle instructions when the workflow is run'),
+    instructions: exports.workflowInstructionSchema
+        .array().describe([
+        'The instructions for the workflow.  This should be written in markdown and can include special links to other workflows, tools, etc. via mentions',
+        'The instructions should be broken down into discrete steps and should be as clear as possible.',
+    ].join(' ')).default([]),
+    createdBy: zod_1.z.string().describe('The user who created the workflow'),
+    createdAt: zod_1.z.date().default(() => new Date()).describe('The date the workflow was created'),
+    updatedAt: zod_1.z.date().default(() => new Date()).describe('The date the workflow was last updated'),
+});

package/dist/types/zod-types.d.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+export declare const zodAnyObject: z.ZodObject<{}, "strip", z.ZodAny, z.objectOutputType<{}, z.ZodAny, "strip">, z.objectInputType<{}, z.ZodAny, "strip">>;
+export declare const zodAnyObjectOrArray: z.ZodUnion<[z.ZodObject<{}, "strip", z.ZodAny, z.objectOutputType<{}, z.ZodAny, "strip">, z.objectInputType<{}, z.ZodAny, "strip">>, z.ZodArray<z.ZodAny, "many">]>;
+export declare const zodPeerId: z.ZodEffects<z.ZodString, string, string>;
+export type ZodObjectType = z.ZodObject<any>;
+export type ZodArrayType = z.ZodArray<any>;
+export type ZodAnyObjectOrArrayType = ZodArrayType | ZodObjectType;

package/dist/types/zod-types.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zodPeerId = exports.zodAnyObjectOrArray = exports.zodAnyObject = void 0;
+const zod_1 = require("zod");
+const utils_1 = require("../utils");
+exports.zodAnyObject = zod_1.z.object({}).catchall(zod_1.z.any());
+exports.zodAnyObjectOrArray = zod_1.z.union([exports.zodAnyObject, zod_1.z.array(zod_1.z.any())]);
+exports.zodPeerId = zod_1.z.string().refine(value => {
+    return (0, utils_1.isid)(value);
+}, {
+    message: "Invalid peer id, it must be a 25 character alphanumeric string",
+});

package/dist/users.query.d.ts

@@ -0,0 +1,13 @@
+import { DataContext, DataFilter, ICursorIterable, IUser } from "./index";
+export interface IUsersQueryOpts {
+    currentDataContext?: DataContext;
+    includeCurrentDataContext?: boolean;
+    includeUserDataContext?: boolean;
+    includeOtherDataContexts?: boolean;
+}
+export type IUserSource = 'currentDataContext' | 'userDataContext' | 'otherDataContexts';
+export interface IUserWithSource extends IUser {
+    source: IUserSource;
+}
+export declare function usersCursor(filter: DataFilter<IUser>, opts?: IUsersQueryOpts): Promise<ICursorIterable<IUserWithSource>>;
+export declare function getUserById(userId: string, opts?: IUsersQueryOpts): Promise<IUserWithSource | undefined>;

package/dist/users.query.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usersCursor = usersCursor;
+exports.getUserById = getUserById;
+const index_1 = require("./index");
+async function usersCursor(filter, opts = {}) {
+    const { currentDataContext, includeCurrentDataContext = true, includeUserDataContext = true, includeOtherDataContexts = true } = opts;
+    const userContext = await (0, index_1.getUserContext)();
+    const contextToUse = currentDataContext || userContext.defaultDataContext();
+    let finalCursor = null;
+    // Include current data context
+    if (includeCurrentDataContext) {
+        const primaryTable = (0, index_1.Users)(contextToUse);
+        const primarySource = (contextToUse === userContext.userDataContext) ? 'userDataContext' : 'currentDataContext';
+        const primaryCursor = index_1.Cursor.fromDataSource(primaryTable, filter)
+            .map(user => {
+            const userWithSource = {
+                ...user,
+                source: primarySource,
+            };
+            return userWithSource;
+        });
+        finalCursor = primaryCursor;
+    }
+    // Include user data context (if different from current and requested)
+    if (includeUserDataContext && contextToUse !== userContext.userDataContext) {
+        const userDataContextTable = (0, index_1.Users)(userContext.userDataContext);
+        const userDataContextCursor = index_1.Cursor.fromDataSource(userDataContextTable, filter)
+            .map(user => {
+            const userWithSource = {
+                ...user,
+                source: 'userDataContext'
+            };
+            return userWithSource;
+        });
+        finalCursor = finalCursor ? finalCursor.union(userDataContextCursor) : userDataContextCursor;
+    }
+    // Include other data contexts (group contexts)
+    if (includeOtherDataContexts) {
+        const otherDataContexts = [];
+        for (const [, dataContext] of userContext.groupDataContexts) {
+            if (contextToUse !== dataContext) {
+                otherDataContexts.push(dataContext);
+            }
+        }
+        if (otherDataContexts.length > 0) {
+            const otherDataContextTables = otherDataContexts.map(dataContext => (0, index_1.Users)(dataContext));
+            const otherDataContextsCursor = index_1.Cursor.fromDataSources(otherDataContextTables, filter)
+                .map(user => {
+                const userWithSource = {
+                    ...user,
+                    source: 'otherDataContexts'
+                };
+                return userWithSource;
+            });
+            finalCursor = finalCursor ? finalCursor.union(otherDataContextsCursor) : otherDataContextsCursor;
+        }
+    }
+    // If no cursor was created, return empty cursor
+    if (!finalCursor) {
+        return index_1.Cursor.fromDataSource((0, index_1.Users)(contextToUse), { userId: { $eq: '__non_existent__' } })
+            .map(user => ({ ...user, source: 'userDataContext' }));
+    }
+    // Deduplication by userId
+    // TODO: Push deduplication logic down into the queries for better performance
+    const userIdsSeen = new Set();
+    return finalCursor.filter(user => {
+        if (userIdsSeen.has(user.userId)) {
+            return false;
+        }
+        userIdsSeen.add(user.userId);
+        return true;
+    });
+}
+async function getUserById(userId, opts = {}) {
+    const { currentDataContext, includeCurrentDataContext = true, includeUserDataContext = true, includeOtherDataContexts = true } = opts;
+    const userContext = await (0, index_1.getUserContext)();
+    const contextToUse = currentDataContext || userContext.defaultDataContext();
+    // Try current data context first
+    if (includeCurrentDataContext) {
+        try {
+            const primaryTable = (0, index_1.Users)(contextToUse);
+            const user = await primaryTable.get(userId);
+            if (user) {
+                const source = (contextToUse === userContext.userDataContext) ? 'userDataContext' : 'currentDataContext';
+                return {
+                    ...user,
+                    source
+                };
+            }
+        }
+        catch (error) {
+            // User not found in this context, continue to next
+        }
+    }
+    // Try user data context (if different from current and requested)
+    if (includeUserDataContext && contextToUse !== userContext.userDataContext) {
+        try {
+            const userDataContextTable = (0, index_1.Users)(userContext.userDataContext);
+            const user = await userDataContextTable.get(userId);
+            if (user) {
+                return {
+                    ...user,
+                    source: 'userDataContext'
+                };
+            }
+        }
+        catch (error) {
+            // User not found in this context, continue to next
+        }
+    }
+    // Try other data contexts (group contexts)
+    if (includeOtherDataContexts) {
+        for (const [, dataContext] of userContext.groupDataContexts) {
+            if (contextToUse !== dataContext) {
+                try {
+                    const table = (0, index_1.Users)(dataContext);
+                    const user = await table.get(userId);
+                    if (user) {
+                        return {
+                            ...user,
+                            source: 'otherDataContexts'
+                        };
+                    }
+                }
+                catch (error) {
+                    // User not found in this context, continue to next
+                }
+            }
+        }
+    }
+    // User not found in any context
+    return undefined;
+}

package/dist/utils.d.ts

@@ -0,0 +1,39 @@
+import { IDeviceConnection } from './types/peer-device';
+import type { ITableMetaData } from './data/orm';
+export declare function cryptoRandomString(length: number): string;
+export declare function newid(): string;
+export declare const MIN_ID: string;
+export declare const MAX_ID: string;
+export declare function isid(id: any): boolean;
+export declare function idTime(id: string): number;
+export declare function idDate(id: string): Date;
+/**
+ * This returns the random number as two parts to prevent loss of precision when converting to large numbers
+ */
+export declare function idRandNums(id: string): [number, number];
+export declare function simpleHash(str: string): number;
+export type Optional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+export declare function simpleObjectHash(obj: any): number;
+export declare function sleep(ms?: number): Promise<void>;
+export declare function camelCaseToSpaces(s: string): string;
+export declare function camelCaseToHyphens(s: string): string;
+export declare const moneyFormatter: Intl.NumberFormat;
+export declare function formatMoney(value: number, precision?: number): string;
+export declare function memoizePromise<F extends (...args: any[]) => Promise<any>>(fn: F, opts?: {
+    cacheTtl?: number;
+}): F;
+export declare function debounceByArgs<F extends (...args: any[]) => any>(fn: F, wait?: number): F;
+export declare function getTimestamp(): number;
+export declare function retryOnErrorOrTimeout<T>({ fn, connection, opts, }: {
+    fn: () => Promise<T>;
+    connection: IDeviceConnection;
+    opts?: {
+        timeout?: number;
+        retriesOnError?: number;
+        retriesOnTimeout?: number;
+    };
+}): Promise<T>;
+/**
+ * Table name is "name_id" if `id` is present, otherwise just "name"
+ */
+export declare function getFullTableName(metaData: ITableMetaData): string;