@peers-app/peers-sdk 0.1.4

package/dist/data/tool-tests.d.ts

@@ -0,0 +1,37 @@
+import { z } from "zod";
+import type { DataContext } from "../context/data-context";
+export declare const toolTestSchema: z.ZodObject<{
+    toolTestId: z.ZodString;
+    toolId: z.ZodString;
+    description: z.ZodString;
+    code: z.ZodDefault<z.ZodString>;
+    input: z.ZodAny;
+    output: z.ZodAny;
+    mocks: z.ZodOptional<z.ZodAny>;
+}, "strip", z.ZodTypeAny, {
+    code: string;
+    description: string;
+    toolId: string;
+    toolTestId: string;
+    input?: any;
+    output?: any;
+    mocks?: any;
+}, {
+    description: string;
+    toolId: string;
+    toolTestId: string;
+    input?: any;
+    code?: string | undefined;
+    output?: any;
+    mocks?: any;
+}>;
+export type IToolTest = z.infer<typeof toolTestSchema>;
+export declare function ToolTests(dataContext?: DataContext): import("./orm").Table<{
+    code: string;
+    description: string;
+    toolId: string;
+    toolTestId: string;
+    input?: any;
+    output?: any;
+    mocks?: any;
+}>;

package/dist/data/tool-tests.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toolTestSchema = void 0;
+exports.ToolTests = ToolTests;
+const zod_1 = require("zod");
+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");
+exports.toolTestSchema = zod_1.z.object({
+    toolTestId: zod_1.z.string(),
+    toolId: zod_1.z.string(),
+    description: zod_1.z.string(),
+    code: zod_1.z.string().default(''),
+    input: zod_1.z.any(),
+    output: zod_1.z.any(),
+    mocks: zod_1.z.any().optional(),
+});
+const metaData = {
+    name: 'ToolTests',
+    description: 'Tests for tools',
+    primaryKeyName: 'toolTestId',
+    fields: (0, types_1.schemaToFields)(exports.toolTestSchema),
+};
+(0, table_definitions_system_1.registerSystemTableDefinition)(metaData, exports.toolTestSchema);
+function ToolTests(dataContext) {
+    return (0, user_context_singleton_1.getTableContainer)(dataContext).getTable(metaData, exports.toolTestSchema);
+}

package/dist/data/tools.d.ts

@@ -0,0 +1,358 @@
+import { z } from "zod";
+import type { DataContext } from "../context/data-context";
+export declare enum IOSchemaType {
+    none = "none",
+    simple = "simple",
+    complex = "complex",
+    code = "code"
+}
+export declare const ioSchema: z.ZodObject<{
+    type: z.ZodNativeEnum<typeof IOSchemaType>;
+    fields: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        type: z.ZodNativeEnum<typeof import("../types/field-type").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: import("../types/field-type").FieldType;
+        optional?: boolean | undefined;
+        description?: string | undefined;
+        defaultValue?: any;
+        isArray?: boolean | undefined;
+        subType?: string | undefined;
+    }, {
+        name: string;
+        type: import("../types/field-type").FieldType;
+        optional?: boolean | undefined;
+        description?: string | undefined;
+        defaultValue?: any;
+        isArray?: boolean | undefined;
+        subType?: string | undefined;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    type: IOSchemaType;
+    fields: {
+        name: string;
+        type: import("../types/field-type").FieldType;
+        optional?: boolean | undefined;
+        description?: string | undefined;
+        defaultValue?: any;
+        isArray?: boolean | undefined;
+        subType?: string | undefined;
+    }[];
+}, {
+    type: IOSchemaType;
+    fields?: {
+        name: string;
+        type: import("../types/field-type").FieldType;
+        optional?: boolean | undefined;
+        description?: string | undefined;
+        defaultValue?: any;
+        isArray?: boolean | undefined;
+        subType?: string | undefined;
+    }[] | undefined;
+}>;
+export type IOSchema = z.infer<typeof ioSchema>;
+export declare const toolSchema: z.ZodObject<{
+    toolId: z.ZodString;
+    name: z.ZodString;
+    usageDescription: z.ZodString;
+    detailedDescription: z.ZodOptional<z.ZodString>;
+    inputSchema: z.ZodObject<{
+        type: z.ZodNativeEnum<typeof IOSchemaType>;
+        fields: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            type: z.ZodNativeEnum<typeof import("../types/field-type").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: import("../types/field-type").FieldType;
+            optional?: boolean | undefined;
+            description?: string | undefined;
+            defaultValue?: any;
+            isArray?: boolean | undefined;
+            subType?: string | undefined;
+        }, {
+            name: string;
+            type: import("../types/field-type").FieldType;
+            optional?: boolean | undefined;
+            description?: string | undefined;
+            defaultValue?: any;
+            isArray?: boolean | undefined;
+            subType?: string | undefined;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        type: IOSchemaType;
+        fields: {
+            name: string;
+            type: import("../types/field-type").FieldType;
+            optional?: boolean | undefined;
+            description?: string | undefined;
+            defaultValue?: any;
+            isArray?: boolean | undefined;
+            subType?: string | undefined;
+        }[];
+    }, {
+        type: IOSchemaType;
+        fields?: {
+            name: string;
+            type: import("../types/field-type").FieldType;
+            optional?: boolean | undefined;
+            description?: string | undefined;
+            defaultValue?: any;
+            isArray?: boolean | undefined;
+            subType?: string | undefined;
+        }[] | undefined;
+    }>;
+    outputSchema: z.ZodObject<{
+        type: z.ZodNativeEnum<typeof IOSchemaType>;
+        fields: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            type: z.ZodNativeEnum<typeof import("../types/field-type").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: import("../types/field-type").FieldType;
+            optional?: boolean | undefined;
+            description?: string | undefined;
+            defaultValue?: any;
+            isArray?: boolean | undefined;
+            subType?: string | undefined;
+        }, {
+            name: string;
+            type: import("../types/field-type").FieldType;
+            optional?: boolean | undefined;
+            description?: string | undefined;
+            defaultValue?: any;
+            isArray?: boolean | undefined;
+            subType?: string | undefined;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        type: IOSchemaType;
+        fields: {
+            name: string;
+            type: import("../types/field-type").FieldType;
+            optional?: boolean | undefined;
+            description?: string | undefined;
+            defaultValue?: any;
+            isArray?: boolean | undefined;
+            subType?: string | undefined;
+        }[];
+    }, {
+        type: IOSchemaType;
+        fields?: {
+            name: string;
+            type: import("../types/field-type").FieldType;
+            optional?: boolean | undefined;
+            description?: string | undefined;
+            defaultValue?: any;
+            isArray?: boolean | undefined;
+            subType?: string | undefined;
+        }[] | undefined;
+    }>;
+    configSchema: z.ZodOptional<z.ZodObject<{
+        type: z.ZodNativeEnum<typeof IOSchemaType>;
+        fields: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            type: z.ZodNativeEnum<typeof import("../types/field-type").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: import("../types/field-type").FieldType;
+            optional?: boolean | undefined;
+            description?: string | undefined;
+            defaultValue?: any;
+            isArray?: boolean | undefined;
+            subType?: string | undefined;
+        }, {
+            name: string;
+            type: import("../types/field-type").FieldType;
+            optional?: boolean | undefined;
+            description?: string | undefined;
+            defaultValue?: any;
+            isArray?: boolean | undefined;
+            subType?: string | undefined;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        type: IOSchemaType;
+        fields: {
+            name: string;
+            type: import("../types/field-type").FieldType;
+            optional?: boolean | undefined;
+            description?: string | undefined;
+            defaultValue?: any;
+            isArray?: boolean | undefined;
+            subType?: string | undefined;
+        }[];
+    }, {
+        type: IOSchemaType;
+        fields?: {
+            name: string;
+            type: import("../types/field-type").FieldType;
+            optional?: boolean | undefined;
+            description?: string | undefined;
+            defaultValue?: any;
+            isArray?: boolean | undefined;
+            subType?: string | undefined;
+        }[] | undefined;
+    }>>;
+    code: z.ZodDefault<z.ZodString>;
+    codeRepository: z.ZodOptional<z.ZodString>;
+    isAssistantRunner: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    code: string;
+    name: string;
+    toolId: string;
+    usageDescription: string;
+    inputSchema: {
+        type: IOSchemaType;
+        fields: {
+            name: string;
+            type: import("../types/field-type").FieldType;
+            optional?: boolean | undefined;
+            description?: string | undefined;
+            defaultValue?: any;
+            isArray?: boolean | undefined;
+            subType?: string | undefined;
+        }[];
+    };
+    outputSchema: {
+        type: IOSchemaType;
+        fields: {
+            name: string;
+            type: import("../types/field-type").FieldType;
+            optional?: boolean | undefined;
+            description?: string | undefined;
+            defaultValue?: any;
+            isArray?: boolean | undefined;
+            subType?: string | undefined;
+        }[];
+    };
+    detailedDescription?: string | undefined;
+    configSchema?: {
+        type: IOSchemaType;
+        fields: {
+            name: string;
+            type: import("../types/field-type").FieldType;
+            optional?: boolean | undefined;
+            description?: string | undefined;
+            defaultValue?: any;
+            isArray?: boolean | undefined;
+            subType?: string | undefined;
+        }[];
+    } | undefined;
+    codeRepository?: string | undefined;
+    isAssistantRunner?: boolean | undefined;
+}, {
+    name: string;
+    toolId: string;
+    usageDescription: string;
+    inputSchema: {
+        type: IOSchemaType;
+        fields?: {
+            name: string;
+            type: import("../types/field-type").FieldType;
+            optional?: boolean | undefined;
+            description?: string | undefined;
+            defaultValue?: any;
+            isArray?: boolean | undefined;
+            subType?: string | undefined;
+        }[] | undefined;
+    };
+    outputSchema: {
+        type: IOSchemaType;
+        fields?: {
+            name: string;
+            type: import("../types/field-type").FieldType;
+            optional?: boolean | undefined;
+            description?: string | undefined;
+            defaultValue?: any;
+            isArray?: boolean | undefined;
+            subType?: string | undefined;
+        }[] | undefined;
+    };
+    code?: string | undefined;
+    detailedDescription?: string | undefined;
+    configSchema?: {
+        type: IOSchemaType;
+        fields?: {
+            name: string;
+            type: import("../types/field-type").FieldType;
+            optional?: boolean | undefined;
+            description?: string | undefined;
+            defaultValue?: any;
+            isArray?: boolean | undefined;
+            subType?: string | undefined;
+        }[] | undefined;
+    } | undefined;
+    codeRepository?: string | undefined;
+    isAssistantRunner?: boolean | undefined;
+}>;
+export type ITool = z.infer<typeof toolSchema>;
+export interface IToolInstance {
+    tool: ITool;
+    toolFn: (...args: any[]) => any;
+    inputSchema?: z.ZodObject<any>;
+    outputSchema?: z.ZodObject<any>;
+}
+export declare function Tools(dataContext?: DataContext): import("./orm").Table<{
+    code: string;
+    name: string;
+    toolId: string;
+    usageDescription: string;
+    inputSchema: {
+        type: IOSchemaType;
+        fields: {
+            name: string;
+            type: import("../types/field-type").FieldType;
+            optional?: boolean | undefined;
+            description?: string | undefined;
+            defaultValue?: any;
+            isArray?: boolean | undefined;
+            subType?: string | undefined;
+        }[];
+    };
+    outputSchema: {
+        type: IOSchemaType;
+        fields: {
+            name: string;
+            type: import("../types/field-type").FieldType;
+            optional?: boolean | undefined;
+            description?: string | undefined;
+            defaultValue?: any;
+            isArray?: boolean | undefined;
+            subType?: string | undefined;
+        }[];
+    };
+    detailedDescription?: string | undefined;
+    configSchema?: {
+        type: IOSchemaType;
+        fields: {
+            name: string;
+            type: import("../types/field-type").FieldType;
+            optional?: boolean | undefined;
+            description?: string | undefined;
+            defaultValue?: any;
+            isArray?: boolean | undefined;
+            subType?: string | undefined;
+        }[];
+    } | undefined;
+    codeRepository?: string | undefined;
+    isAssistantRunner?: boolean | undefined;
+}>;

package/dist/data/tools.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toolSchema = exports.ioSchema = exports.IOSchemaType = void 0;
+exports.Tools = Tools;
+const zod_1 = require("zod");
+const field_type_1 = require("../types/field-type");
+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");
+var IOSchemaType;
+(function (IOSchemaType) {
+    IOSchemaType["none"] = "none";
+    IOSchemaType["simple"] = "simple";
+    IOSchemaType["complex"] = "complex";
+    IOSchemaType["code"] = "code";
+})(IOSchemaType || (exports.IOSchemaType = IOSchemaType = {}));
+exports.ioSchema = zod_1.z.object({
+    type: zod_1.z.nativeEnum(IOSchemaType),
+    fields: field_type_1.fieldSchema.array().default([]),
+});
+exports.toolSchema = zod_1.z.object({
+    toolId: zod_1.z.string(),
+    name: zod_1.z.string().describe('The name of the tool'),
+    usageDescription: zod_1.z.string().describe('A description of the what the tool does and how to use it.  This is used by the AI to reason about the tool at runtime and in the middle of performing tasks.'),
+    detailedDescription: zod_1.z.string().optional().describe('A full description of the tool which may include examples, references, screenshots, etc.  This is intended for humans and AI to decide if this is a tool they want to include in their toolbox while preparing to work on tasks.'),
+    inputSchema: exports.ioSchema.describe('The input schema of the tool'),
+    outputSchema: exports.ioSchema.describe('The output schema of the tool'),
+    configSchema: exports.ioSchema.optional().describe('The schema of any configuration values that the tool may need'),
+    code: zod_1.z.string().default('').describe('The code that implements the tool'),
+    codeRepository: zod_1.z.string().optional().describe('The repository where the code for the tool is stored'),
+    // TODO versioning somehow, maybe a git tag or branch
+    isAssistantRunner: zod_1.z.boolean().optional().describe('Whether this tool is a model that can be used to run an assistant'),
+});
+const metaData = {
+    name: 'Tools',
+    description: 'Tools that can be used by assistants.',
+    primaryKeyName: 'toolId',
+    fields: (0, types_1.schemaToFields)(exports.toolSchema),
+    iconClassName: 'bi bi-tools',
+    indexes: [
+        { fields: ['name'], },
+        { fields: ['isAssistantRunner'], },
+    ],
+};
+(0, table_definitions_system_1.registerSystemTableDefinition)(metaData, exports.toolSchema);
+function Tools(dataContext) {
+    return (0, user_context_singleton_1.getTableContainer)(dataContext).getTable(metaData, exports.toolSchema);
+}

package/dist/data/user-permissions.d.ts

@@ -0,0 +1,15 @@
+import type { IUser } from './users';
+/**
+ * Signs a user object with the provided secret key
+ * @param user The user object to sign
+ * @param secretKey The secret key to sign with
+ * @returns IUser The signed user object
+ */
+export declare function signUserObject(user: IUser, secretKey: string): IUser;
+/**
+ * Verifies that a user update signature is valid, throws on invalid signature
+ * @param user The user record to verify
+ * @param oldUser The existing user record (if any)
+ * @throws Error if signature is invalid or unauthorized
+ */
+export declare function verifyUserSignature(user: IUser, oldUser?: IUser): void;

package/dist/data/user-permissions.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signUserObject = signUserObject;
+exports.verifyUserSignature = verifyUserSignature;
+const keys_1 = require("../keys");
+/**
+ * Signs a user object with the provided secret key
+ * @param user The user object to sign
+ * @param secretKey The secret key to sign with
+ * @returns IUser The signed user object
+ */
+function signUserObject(user, secretKey) {
+    return (0, keys_1.addSignatureToObject)(user, secretKey);
+}
+/**
+ * Verifies that a user update signature is valid, throws on invalid signature
+ * @param user The user record to verify
+ * @param oldUser The existing user record (if any)
+ * @throws Error if signature is invalid or unauthorized
+ */
+function verifyUserSignature(user, oldUser) {
+    (0, keys_1.verifyObjectSignature)(user);
+    const signerPublicKey = (0, keys_1.getPublicKeyFromObjectSignature)(user) ?? '';
+    // New user: signature must match their own public key
+    if (!oldUser) {
+        if (signerPublicKey !== user.publicKey) {
+            throw new Error('User signature must be signed with their own public key');
+        }
+        return;
+    }
+    // Existing user: signature must match existing public key
+    if (signerPublicKey !== oldUser.publicKey) {
+        throw new Error('User update must be signed by the user themselves');
+    }
+    // Prevent public key changes (for now)
+    if (user.publicKey !== oldUser.publicKey) {
+        throw new Error('Public key changes are not currently supported');
+    }
+}

package/dist/data/user-permissions.test.d.ts

@@ -0,0 +1 @@
+export {};