ai-functions 0.2.10 → 0.2.13

package/dist/cjs/utils/schema.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSchema = exports.parseStringDescription = void 0;
+// This is a helper function to generate a JSON schema for string properties.
+// It checks if a string includes '|' which would indicate an enum,
+// or if it starts with 'number: ' or 'boolean: ' which would indicate
+// a number or boolean type respectively, otherwise it defaults to string.
+const parseStringDescription = (description) => {
+    // Check if the description indicates an enum for string type
+    if (description.includes('|')) {
+        return { type: 'string', enum: description.split('|').map((v) => v.trim()) };
+    }
+    else {
+        // Check for 'number: ' prefix
+        if (description.startsWith('number: ')) {
+            return {
+                type: 'number',
+                description: description.replace('number: ', ''),
+            };
+        }
+        // Check for 'boolean: ' prefix
+        else if (description.startsWith('boolean: ')) {
+            return {
+                type: 'boolean',
+                description: description.replace('boolean: ', ''),
+            };
+        }
+        // Default to string type
+        else {
+            return { type: 'string', description };
+        }
+    }
+};
+exports.parseStringDescription = parseStringDescription;
+/**
+ * Given a property description object, generate a JSON schema.
+ *
+ * @param propDescriptions - A record object with keys as property names
+ * and values as descriptions or nested property description objects.
+ * @returns A JSON schema object based on the provided descriptions.
+ */
+const generateSchema = (propDescriptions) => {
+    // If the propDescriptions is for an object structure
+    if (typeof propDescriptions !== 'object' || propDescriptions === null || Array.isArray(propDescriptions)) {
+        throw new Error('The propDescriptions parameter should be an object.');
+    }
+    const properties = {};
+    const required = Object.keys(propDescriptions);
+    for (const [key, description] of Object.entries(propDescriptions)) {
+        if (typeof description === 'string') {
+            // Handle the string description
+            properties[key] = (0, exports.parseStringDescription)(description);
+        }
+        else if (typeof description === 'object' && !Array.isArray(description)) {
+            // Recursive call for nested objects
+            properties[key] = (0, exports.generateSchema)(description);
+        }
+        else {
+            throw new Error(`Invalid description for key "${key}".`);
+        }
+    }
+    return { type: 'object', properties, required };
+};
+exports.generateSchema = generateSchema;

package/dist/cjs/utils/schema.test.d.ts

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

package/dist/cjs/utils/schema.test.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const schema_1 = require("./schema");
+// Tests for parseStringDescription function
+(0, vitest_1.describe)('parseStringDescription', () => {
+    (0, vitest_1.it)('should create a string schema for plain strings', () => {
+        const result = (0, schema_1.parseStringDescription)('A plain string description');
+        (0, vitest_1.expect)(result).toEqual({
+            type: 'string',
+            description: 'A plain string description',
+        });
+    });
+    (0, vitest_1.it)('should create a string schema with enum for piped strings', () => {
+        const result = (0, schema_1.parseStringDescription)('option1 | option2 | option3');
+        (0, vitest_1.expect)(result).toEqual({
+            type: 'string',
+            enum: ['option1', 'option2', 'option3'],
+        });
+    });
+    (0, vitest_1.it)('should create a number schema when prefixed with "number: "', () => {
+        const result = (0, schema_1.parseStringDescription)('number: A number description');
+        (0, vitest_1.expect)(result).toEqual({
+            type: 'number',
+            description: 'A number description',
+        });
+    });
+    (0, vitest_1.it)('should create a boolean schema when prefixed with "boolean: "', () => {
+        const result = (0, schema_1.parseStringDescription)('boolean: A boolean description');
+        (0, vitest_1.expect)(result).toEqual({
+            type: 'boolean',
+            description: 'A boolean description',
+        });
+    });
+});
+// Tests for generateSchema function
+(0, vitest_1.describe)('generateSchema', () => {
+    (0, vitest_1.it)('should create a complex object schema', () => {
+        const result = (0, schema_1.generateSchema)({
+            name: 'The name of the person',
+            age: 'number: The age of the person',
+            isActive: 'boolean: Whether the person is active or not',
+        });
+        const expected = {
+            type: 'object',
+            properties: {
+                name: { type: 'string', description: 'The name of the person' },
+                age: { type: 'number', description: 'The age of the person' },
+                isActive: {
+                    type: 'boolean',
+                    description: 'Whether the person is active or not',
+                },
+            },
+            required: ['name', 'age', 'isActive'],
+        };
+        (0, vitest_1.expect)(result).toEqual(expected);
+    });
+    (0, vitest_1.it)('should throw an error for invalid propDescriptions', () => {
+        const callWithInvalidArg = () => (0, schema_1.generateSchema)('invalid argument');
+        (0, vitest_1.expect)(callWithInvalidArg).toThrow('The propDescriptions parameter should be an object.');
+    });
+});

package/dist/cjs/utils/state.d.ts

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

package/dist/cjs/utils/state.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const xstate_1 = require("xstate");
+// Stateless machine definition
+// machine.transition(...) is a pure function used by the interpreter.
+const toggleMachine = (0, xstate_1.createMachine)({
+    id: 'Switch',
+    initial: 'inactive',
+    states: {
+        inactive: { on: { Toggle: 'active' } },
+        active: { on: { Toggle: 'inactive' } },
+    },
+});
+// Machine instance with internal state
+const toggleService = (0, xstate_1.createActor)(toggleMachine).start();
+toggleService.subscribe((state) => console.log(state.value));
+// => 'inactive'
+toggleService.send({ type: 'Toggle' });
+// => 'active'
+toggleService.send({ type: 'Toggle' });
+// => 'inactive'

package/dist/mjs/db/cache.d.ts

@@ -0,0 +1 @@
+export declare const md5: (data: string | object) => string;

package/dist/mjs/db/cache.js

@@ -0,0 +1,5 @@
+import crypto from 'node:crypto';
+export const md5 = (data) => {
+    const input = typeof data === 'string' ? data : JSON.stringify(data);
+    return crypto.createHash('md5').update(input).digest('hex');
+};

package/dist/mjs/db/mongo.d.ts

@@ -0,0 +1,31 @@
+import type { MongoClient, Db, Collection, InsertOneResult } from 'mongodb';
+import type { ChatCompletion, ChatCompletionCreateParamsNonStreaming } from 'openai/resources';
+import { QueueInput } from '../queue/mongo';
+export declare let client: MongoClient;
+export declare let db: Db;
+export declare let cache: Collection;
+export declare let cacheTTL: number;
+export declare let events: Collection;
+export declare let queue: Collection;
+export declare let actors: Collection;
+export type AIDBConfig = {
+    client: MongoClient;
+    db?: Db | string;
+    cache?: Collection | string;
+    cacheTTL?: number;
+    actors?: Collection | string;
+    events?: Collection | string;
+    queue?: Collection | string;
+};
+export type AIDB = {
+    client: MongoClient;
+    db: Db;
+    cache: Collection;
+    cacheTTL: number;
+    actors: Collection;
+    events: Collection;
+    queue: Collection;
+    log: (prompt: ChatCompletionCreateParamsNonStreaming, completion: ChatCompletion) => Promise<InsertOneResult<any>>;
+    send: (input: QueueInput | QueueInput[]) => Promise<InsertOneResult<any>>;
+};
+export declare const AIDB: (args: AIDBConfig | MongoClient) => AIDB;

package/dist/mjs/db/mongo.js

@@ -0,0 +1,48 @@
+export let client;
+export let db;
+export let cache;
+export let cacheTTL;
+export let events;
+export let queue;
+export let actors;
+export const AIDB = (args) => {
+    const config = args.client ? args : { client: args };
+    client = config.client;
+    db = typeof config.db === 'string' ? client.db(config.db) : config.db ?? client.db();
+    cache = typeof config.cache === 'string' ? db.collection(config.cache) : config.cache ?? db.collection('ai-cache');
+    cacheTTL = config.cacheTTL ?? 1000 * 60 * 60 * 24 * 30;
+    events =
+        typeof config.events === 'string' ? db.collection(config.events) : config.events ?? db.collection('ai-events');
+    // queue = typeof config.queue === 'string' ? db.collection(config.queue) : config.queue ?? db.collection('ai-queue')
+    // actors = typeof config.queue === 'string' ? db.collection(config.queue) : config.queue ?? db.collection('ai-actors')
+    return { client, db, cache, actors, events, queue, log }; // , send } as AIDB
+};
+// const send = (input: QueueInput | QueueInput[]) =>
+//   Array.isArray(input) ? queue.insertMany(input) : queue.insertOne(input)
+const log = (prompt, completion) => {
+    const system = prompt.messages.find((message) => message.role === 'system')?.content;
+    const userMessages = prompt.messages.filter((message) => message.role === 'user').map((message) => message.content);
+    const user = userMessages.length === 1 ? userMessages[0] : userMessages;
+    const content = completion.choices?.[0].message.content;
+    const tool = completion.choices?.[0].message.tool_calls?.[0].function;
+    let functionData;
+    try {
+        if (tool)
+            functionData = JSON.parse(tool.arguments);
+    }
+    catch (err) {
+        functionData = tool?.arguments;
+    }
+    const timestamp = new Date();
+    const event = {
+        timestamp,
+        user,
+        system,
+        content,
+        functionName: tool?.name,
+        functionData,
+        prompt,
+        completion,
+    };
+    return events.insertOne(event, { ignoreUndefined: true });
+};