ai-functions 0.2.11 → 0.2.13

package/dist/mjs/functions/ai.d.ts

@@ -0,0 +1,18 @@
+import { ClientOptions, OpenAI } from 'openai';
+import { ChatCompletionCreateParamsBase } from 'openai/resources/chat/completions';
+export type AIConfig = ClientOptions & {
+    openai?: OpenAI;
+    system?: string;
+    model?: ChatCompletionCreateParamsBase['model'];
+};
+export type FunctionCallOptions = Omit<ChatCompletionCreateParamsBase, 'messages' | 'stream'> & {
+    system?: string;
+    meta?: boolean;
+    description?: string;
+};
+type AIFunctions<T = Record<string, string>> = Record<string, (returnSchema: T, options?: Partial<FunctionCallOptions>) => (args: string | object, callOptions?: Partial<FunctionCallOptions>) => Promise<T>>;
+export declare const AI: (config?: AIConfig) => {
+    ai: AIFunctions<Record<string, string>>;
+    openai: OpenAI;
+};
+export {};

package/dist/mjs/functions/ai.js

@@ -0,0 +1,79 @@
+import { OpenAI, } from 'openai';
+// import { AIDB, AIDBConfig } from '../db/mongo'
+import { dump } from 'js-yaml';
+import { generateSchema } from '../utils/schema';
+export const AI = (config = {}) => {
+    const { model = 'gpt-4-1106-preview', system, ...rest } = config;
+    const openai = config.openai ?? new OpenAI(rest);
+    // const { client, db, cache, events, queue } = config.db ? AIDB(config.db) : {}
+    // const prompt = {
+    //   model,
+    //   messages: [{ role: 'user', content: user }],
+    // }
+    // if (system) prompt.messages.unshift({ role: 'system', content: system })
+    // const messages = system ? [{ role: 'system', content: system }] : []  
+    // const completion = openai.chat.completions.create({
+    //   model,
+    //   messages: [{ role: 'user', content: 'hello' }],
+    // })
+    const ai = new Proxy({}, {
+        get: (target, functionName, receiver) => {
+            target[functionName] = (returnSchema, options) => async (args, callOptions) => {
+                console.log(generateSchema(returnSchema));
+                const { system, description, model = 'gpt-3.5-turbo', meta = false, ...rest } = { ...options, ...callOptions };
+                const prompt = {
+                    model,
+                    messages: [
+                        {
+                            role: 'user',
+                            content: `Call ${functionName} given the context:\n${dump(args)}`,
+                        }, // \nThere is no additional information, so make assumptions/guesses as necessary` },
+                    ],
+                    tools: [
+                        {
+                            type: 'function',
+                            function: {
+                                name: functionName,
+                                description,
+                                parameters: generateSchema(returnSchema),
+                            }
+                        }
+                    ],
+                    tool_choice: {
+                        type: 'function',
+                        function: { name: functionName }
+                    },
+                    ...rest,
+                };
+                if (system)
+                    prompt.messages.unshift({ role: 'system', content: system });
+                const completion = await openai.chat.completions.create(prompt);
+                const schema = generateSchema(returnSchema);
+                let data;
+                let error;
+                const { message } = completion.choices?.[0];
+                console.log({ message });
+                prompt.messages.push(message);
+                const { content, tool_calls } = message;
+                if (tool_calls) {
+                    try {
+                        data = JSON.parse(tool_calls[0].function.arguments);
+                    }
+                    catch (err) {
+                        error = err.message;
+                    }
+                }
+                const gpt4 = model.includes('gpt-4');
+                const cost = completion.usage ?
+                    Math.round((gpt4
+                        ? completion.usage.prompt_tokens * 0.003 + completion.usage.completion_tokens * 0.006
+                        : completion.usage.prompt_tokens * 0.00015 + completion.usage.completion_tokens * 0.0002) * 100000) / 100000 : undefined;
+                // completion.usage = camelcaseKeys(completion.usage)
+                console.log({ data, content, error, cost, usage: completion.usage });
+                return meta ? { prompt, content, data, error, cost, ...completion } : data ?? content;
+            };
+            return target[functionName];
+        },
+    });
+    return { ai, openai }; //, client, db, cache, events, queue }
+};

package/dist/mjs/functions/ai.test.d.ts

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

package/dist/mjs/functions/ai.test.js

@@ -0,0 +1,29 @@
+import { describe, it, expect } from 'vitest';
+import { AI } from './ai';
+describe('AI Functions', async () => {
+    const { ai } = AI();
+    it('should be initialized', () => {
+        expect(ai).toBeDefined();
+    });
+    const categorizeWord = ai.categorizeWord({
+        type: 'Noun | Verb | Adjective | Adverb | Pronoun | Preposition | Conjunction | Interjection | Other',
+        example: 'use the word in a sentence',
+        // partOfSpeech: 'Part of speech'
+    }, { seed: 1, model: 'gpt-3.5-turbo' });
+    it('should be a function', () => {
+        expect(typeof categorizeWord).toBe('function');
+    });
+    it('Destroy should be a verb', async () => {
+        expect(await categorizeWord('destroy')).toMatchObject({ type: 'Verb', example: 'I will destroy the old building.' });
+    });
+    it('Dog should be a Noun', async () => {
+        const dog = await categorizeWord({ word: 'dog' });
+        expect(dog).toMatchObject({ type: 'Noun', example: 'I have a dog.' });
+    });
+    it('Large should be an Adjective', async () => {
+        expect(await categorizeWord({ word: 'large' })).toMatchObject({ type: 'Adjective', example: 'She has a large collection of books.' });
+    });
+    it('To should be an Preposition', async () => {
+        expect(await categorizeWord('to')).toMatchObject({ type: 'Preposition', example: "I'm going to the park." });
+    });
+});

package/dist/mjs/functions/gpt.d.ts

@@ -0,0 +1,4 @@
+import { GPTConfig } from '../types';
+export declare const GPT: (config: GPTConfig) => {
+    gpt: (strings: string[], ...values: string[]) => Promise<string | null>;
+};

package/dist/mjs/functions/gpt.js

@@ -0,0 +1,10 @@
+import { chatCompletion } from '../utils/completion';
+export const GPT = (config) => {
+    const gpt = async (strings, ...values) => {
+        const user = values.map((value, i) => strings[i] + value).join('') + strings[strings.length - 1];
+        const completion = await chatCompletion({ user, ...config });
+        const content = completion.choices?.[0].message.content;
+        return content;
+    };
+    return { gpt };
+};

package/dist/mjs/functions/list.d.ts

@@ -0,0 +1,7 @@
+import { GPTConfig } from '../types';
+export declare const List: (config: GPTConfig) => {
+    list: (strings: string[], ...values: string[]) => Promise<string[]>;
+};
+export declare const StreamingList: (config: GPTConfig) => {
+    list: (strings: string[], ...values: string[]) => AsyncGenerator<string | undefined, void, unknown>;
+};

package/dist/mjs/functions/list.js

@@ -0,0 +1,72 @@
+import { OpenAI } from 'openai';
+import { chatCompletion } from '../utils/completion';
+export const List = (config) => {
+    const list = async (strings, ...values) => {
+        const user = values.map((value, i) => strings[i] + value).join('') + strings[strings.length - 1];
+        const completion = await chatCompletion({ user, ...config });
+        const content = completion.choices?.[0].message.content;
+        return content ? parseList(content) : [];
+    };
+    return { list };
+};
+function parseList(listStr) {
+    // Define a regex pattern to match lines with '1. value', '1) value', '- value', or ' - value'
+    const listItemRegex = /^\s*\d+\.\s*(.+)|^\s*\d+\)\s*(.+)|^\s*-\s*(.+)$/gm;
+    let match;
+    const result = [];
+    // Loop over the list string, finding matches with the regex pattern
+    while ((match = listItemRegex.exec(listStr)) !== null) {
+        // The actual value is in one of the capturing groups (1, 2 or 3)
+        const value = match[1] || match[2] || match[3];
+        if (value) {
+            result.push(value.trim());
+        }
+    }
+    return result;
+}
+export const StreamingList = (config) => {
+    async function* list(strings, ...values) {
+        const user = values.map((value, i) => strings[i] + value).join('') + strings[strings.length - 1];
+        const { system, model, db, queue, ...rest } = config;
+        const openai = config.openai ?? new OpenAI(rest);
+        const prompt = {
+            model,
+            messages: [{ role: 'user', content: user }],
+            stream: true,
+        };
+        if (system)
+            prompt.messages.unshift({ role: 'system', content: system });
+        const completion = await openai.chat.completions.create(prompt);
+        const stream = await openai.chat.completions.create(prompt);
+        let content = '';
+        let seperator;
+        let numberedList;
+        for await (const part of stream) {
+            const { delta, finish_reason } = part.choices[0];
+            content += delta?.content || '';
+            if (seperator === undefined && content.length > 4) {
+                numberedList = content.match(/(\d+\.\s)/g);
+                seperator = numberedList ? '\n' : ', ';
+            }
+            const numberedRegex = /\d+\.\s(?:")?([^"]+)(?:")?/;
+            if (seperator && content.includes(seperator)) {
+                // get the string before the newline, and modify `content` to be the string after the newline
+                // then yield the string before the newline
+                const items = content.split(seperator);
+                while (items.length > 1) {
+                    const item = items.shift();
+                    yield numberedList ? item?.match(numberedRegex)?.[1] : item;
+                }
+                content = items[0];
+            }
+            if (finish_reason) {
+                // TODO: Figure out DB saving strategy for streaming
+                // if (db) {
+                //   db.log(prompt, completion as ChatCompletion)
+                // }
+                yield numberedList ? content.match(numberedRegex)?.[1] : content;
+            }
+        }
+    }
+    return { list };
+};

package/dist/mjs/index.d.ts

@@ -0,0 +1,3 @@
+export * from './functions/ai';
+export * from './functions/gpt';
+export * from './functions/list';

package/dist/mjs/index.js

@@ -0,0 +1,3 @@
+export * from './functions/ai';
+export * from './functions/gpt';
+export * from './functions/list';

package/dist/mjs/package.json

@@ -0,0 +1,3 @@
+{
+    "type": "module"
+}

package/dist/mjs/queue/kafka.js

@@ -0,0 +1 @@
+"use strict";

package/dist/mjs/queue/memory.js

@@ -0,0 +1 @@
+"use strict";

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

@@ -0,0 +1,30 @@
+import { AIDB } from '../db/mongo';
+import { CompletionInput } from '../utils/completion';
+import { BSON, ObjectId } from 'mongodb';
+export type QueueConfig = AIDB & {
+    batchSize?: number;
+    concurrency?: number;
+    lockExpiration?: number;
+};
+export type QueueInputMerge = {
+    into: string;
+    on?: BSON.Document;
+    let?: BSON.Document;
+    contentAs?: string;
+    itemsAs?: string;
+    functionDataAs?: string;
+    forEachItem?: boolean;
+};
+export type QueueInput = (CompletionInput | ({
+    list: string;
+} & Partial<CompletionInput>)) & {
+    _id?: ObjectId;
+    metadata?: object;
+    merge?: string | QueueInputMerge;
+    target?: string;
+};
+export type QueueDocument = QueueInput & {
+    lockedAt: Date;
+    lockedBy: string;
+};
+export declare const startQueue: (config: QueueConfig) => Promise<void>;

package/dist/mjs/queue/mongo.js

@@ -0,0 +1,42 @@
+import PQueue from 'p-queue';
+import { chatCompletion } from '../utils/completion';
+let localQueue;
+export const startQueue = async (config) => {
+    const { concurrency = 10, batchSize = 100, lockExpiration = 3600, ...db } = config;
+    const instance = Math.random().toString(36).substring(2, 6);
+    const queue = new PQueue({ concurrency });
+    const clearExpiredLocks = () => db.queue.updateMany({ lockedAt: { $lt: new Date(Date.now() - lockExpiration * 1000) } }, { $unset: { lockedAt: '', lockedBy: '' } });
+    const lockBatch = () => db.queue.aggregate([
+        { $match: { lockedAt: { $exists: false } } },
+        { $limit: batchSize },
+        { $set: { lockedAt: new Date(), lockedBy: instance } },
+        { $merge: { into: 'queue', on: '_id', whenMatched: 'replace' } }, // TODO: Change the `into` to the name of the `queue` collection
+    ]).toArray();
+    db.queue.watch([
+        { $match: { lockedBy: instance } },
+    ]).on('change', async (change) => {
+        const { _id, metadata, merge, target, ...input } = change.fullDocument; // TODO: Move input to child object not catchall spread
+        const completion = await queue.add(() => chatCompletion(input));
+        if (merge) {
+            const coll = typeof merge === 'string' ? merge : merge.into;
+            const match = typeof merge === 'string' ? undefined : merge.on;
+            // TODO: Add support to make completion optional, and specify field names for content, items, and functionData
+            const mergeResult = match
+                ? await db.db.collection(coll).updateOne(match, { $set: { completion, ...metadata ?? {} } })
+                : await db.db.collection(coll).insertOne({ completion, ...metadata ?? {} });
+            if (mergeResult.acknowledged && (mergeResult.modifiedCount ||
+                mergeResult.insertedId)) {
+                // TODO: We may want to store the merge result in the Events collection to link the queue input to the merge result
+                await db.queue.deleteOne({ _id });
+            }
+        }
+    });
+    queue.on('idle', async () => {
+        await clearExpiredLocks();
+        await lockBatch();
+    });
+    queue.start();
+    // TODO: Add Find() and Watch() for Actors collection
+    // TODO: For each actor, create a state machine and start it
+    // TODO: Figure out how to create new queued jobs from the results of the state machine
+};

package/dist/mjs/streams/kafka.js

@@ -0,0 +1 @@
+"use strict";

package/dist/mjs/streams/memory.js

@@ -0,0 +1 @@
+"use strict";

package/dist/mjs/streams/mongo.js

@@ -0,0 +1 @@
+"use strict";

package/dist/mjs/streams/types.js

@@ -0,0 +1 @@
+"use strict";

package/dist/mjs/types.d.ts

@@ -0,0 +1,11 @@
+import type { OpenAI, ClientOptions } from 'openai';
+import type { ChatCompletionCreateParamsNonStreaming } from 'openai/resources';
+import type { AIDB } from './db/mongo';
+import type PQueue from 'p-queue';
+export type GPTConfig = {
+    openai?: OpenAI;
+    system?: string;
+    model?: ChatCompletionCreateParamsNonStreaming['model'] | 'gpt-4-1106-preview' | 'gpt-3.5-turbo-1106';
+    db?: AIDB;
+    queue?: PQueue;
+} & ClientOptions;

package/dist/mjs/types.js

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

package/dist/mjs/utils/completion.d.ts

@@ -0,0 +1,9 @@
+import { OpenAI } from 'openai';
+import type { ChatCompletionCreateParamsNonStreaming } from 'openai/resources';
+import { GPTConfig } from '../types';
+export type CompletionInput = GPTConfig & ((({
+    user: string;
+} | {
+    list: string;
+}) & Partial<ChatCompletionCreateParamsNonStreaming>) | ChatCompletionCreateParamsNonStreaming);
+export declare const chatCompletion: (config: CompletionInput) => Promise<OpenAI.Chat.Completions.ChatCompletion>;

package/dist/mjs/utils/completion.js

@@ -0,0 +1,20 @@
+import { OpenAI } from 'openai';
+// TODO: add support for list input and parsing
+// TODO: add support for caching w/ seed generation for unit tests
+export const chatCompletion = async (config) => {
+    const { user, system, model, db, queue, ...rest } = config;
+    const openai = config.openai ?? new OpenAI(rest);
+    const prompt = {
+        model,
+        messages: [{ role: 'user', content: user }],
+    };
+    if (system)
+        prompt.messages.unshift({ role: 'system', content: system });
+    const completion = queue
+        ? await queue.add(() => openai.chat.completions.create(prompt))
+        : await openai.chat.completions.create(prompt);
+    if (db) {
+        db.log(prompt, completion);
+    }
+    return completion;
+};

package/dist/mjs/utils/schema.d.ts

@@ -0,0 +1,10 @@
+import { JSONSchema } from 'json-schema-to-ts';
+export declare const parseStringDescription: (description: string) => JSONSchema;
+/**
+ * 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.
+ */
+export declare const generateSchema: (propDescriptions: Record<string, string | Record<string, any>>) => JSONSchema;

package/dist/mjs/utils/schema.js

@@ -0,0 +1,59 @@
+// 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.
+export 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 };
+        }
+    }
+};
+/**
+ * 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.
+ */
+export 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] = parseStringDescription(description);
+        }
+        else if (typeof description === 'object' && !Array.isArray(description)) {
+            // Recursive call for nested objects
+            properties[key] = generateSchema(description);
+        }
+        else {
+            throw new Error(`Invalid description for key "${key}".`);
+        }
+    }
+    return { type: 'object', properties, required };
+};

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

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

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

@@ -0,0 +1,60 @@
+import { describe, it, expect } from 'vitest';
+import { generateSchema, parseStringDescription } from './schema';
+// Tests for parseStringDescription function
+describe('parseStringDescription', () => {
+    it('should create a string schema for plain strings', () => {
+        const result = parseStringDescription('A plain string description');
+        expect(result).toEqual({
+            type: 'string',
+            description: 'A plain string description',
+        });
+    });
+    it('should create a string schema with enum for piped strings', () => {
+        const result = parseStringDescription('option1 | option2 | option3');
+        expect(result).toEqual({
+            type: 'string',
+            enum: ['option1', 'option2', 'option3'],
+        });
+    });
+    it('should create a number schema when prefixed with "number: "', () => {
+        const result = parseStringDescription('number: A number description');
+        expect(result).toEqual({
+            type: 'number',
+            description: 'A number description',
+        });
+    });
+    it('should create a boolean schema when prefixed with "boolean: "', () => {
+        const result = parseStringDescription('boolean: A boolean description');
+        expect(result).toEqual({
+            type: 'boolean',
+            description: 'A boolean description',
+        });
+    });
+});
+// Tests for generateSchema function
+describe('generateSchema', () => {
+    it('should create a complex object schema', () => {
+        const result = 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'],
+        };
+        expect(result).toEqual(expected);
+    });
+    it('should throw an error for invalid propDescriptions', () => {
+        const callWithInvalidArg = () => generateSchema('invalid argument');
+        expect(callWithInvalidArg).toThrow('The propDescriptions parameter should be an object.');
+    });
+});

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

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

package/dist/mjs/utils/state.js

@@ -0,0 +1,19 @@
+import { createMachine, createActor } from 'xstate';
+// Stateless machine definition
+// machine.transition(...) is a pure function used by the interpreter.
+const toggleMachine = createMachine({
+    id: 'Switch',
+    initial: 'inactive',
+    states: {
+        inactive: { on: { Toggle: 'active' } },
+        active: { on: { Toggle: 'inactive' } },
+    },
+});
+// Machine instance with internal state
+const toggleService = createActor(toggleMachine).start();
+toggleService.subscribe((state) => console.log(state.value));
+// => 'inactive'
+toggleService.send({ type: 'Toggle' });
+// => 'active'
+toggleService.send({ type: 'Toggle' });
+// => 'inactive'

package/fixup

@@ -0,0 +1,11 @@
+cat >dist/cjs/package.json <<!EOF
+{
+    "type": "commonjs"
+}
+!EOF
+
+cat >dist/mjs/package.json <<!EOF
+{
+    "type": "module"
+}
+!EOF

package/functions/list.ts

@@ -1,5 +1,5 @@
 import { OpenAI } from 'openai'
-import { ChatCompletionCreateParamsStreaming } from 'openai/resources/index.mjs'
+import { ChatCompletionCreateParamsStreaming } from 'openai/resources'
 import { GPTConfig } from '../types'
 import { chatCompletion } from '../utils/completion'
 

package/package.json

@@ -1,11 +1,18 @@
 {
   "name": "ai-functions",
-  "version": "0.2.11",
+  "version": "0.2.13",
   "description": "Library for Developing and Managing AI Functions (including OpenAI GPT4 / GPT3.5)",
-  "main": "index.js",
-  "type": "module",
+  "main": "dist/cjs/index.js",
+  "module": "dist/mjs/index.js",
+  "exports": {
+      ".": {
+          "import": "./dist/mjs/index.js",
+          "require": "./dist/cjs/index.js"
+      }
+  },
   "scripts": {
     "build": "tsc",
+    "builds": "rm -fr dist/* && tsc -p tsconfig.json && tsc -p tsconfig-cjs.json && ./fixup",
     "format": "prettier --write .",
     "test": "dotenv -- vitest --globals"
   },