ai-functions 0.2.1 → 0.2.3

package/functions/ai.test.ts

@@ -13,6 +13,8 @@ describe('AI Functions', async () => {
   
   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', () => {
@@ -20,12 +22,20 @@ describe('AI Functions', async () => {
     expect(typeof categorizeWord).toBe('function')
   })
 
-  it('should return a promise', async () => {
-    expect(await categorizeWord('destroy')).toMatchObject({ type: 'Verb' })
+  it('Destroy should be a verb', async () => {
+    expect(await categorizeWord('destroy')).toMatchObject({ type: 'Verb', example: 'I will destroy the old building.' })
   })
 
-  it('should return a promise', async () => {
-    expect(await categorizeWord('dog')).toMatchObject({ type: 'Noun' })
+  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/functions/ai.ts

@@ -3,6 +3,7 @@ import { ChatCompletion, ChatCompletionCreateParamsBase } from 'openai/resources
 import { AIDB, AIDBConfig } from '../db/mongo'
 import { dump } from 'js-yaml'
 import { generateSchema } from '../utils/schema'
+import { FromSchema } from 'json-schema-to-ts'
 
 export type AIConfig = ClientOptions & {
   db?: AIDBConfig
@@ -17,6 +18,16 @@ export type FunctionCallOptions = Omit<ChatCompletionCreateParamsBase, 'messages
   description?: string
 }
 
+type AIFunctions<T extends Record<string, any> = Record<string,any>> = {
+  [K in keyof T]: (
+    returnSchema: T[K], 
+    callOptions?: FunctionCallOptions
+  ) => (
+    args: string | object, 
+    callOptions?: FunctionCallOptions
+  ) => Promise<{ [P in keyof T[K]]: T[K][P] }>
+}
+
 export const AI = (config: AIConfig = {}) => {
   const { model = 'gpt-4-1106-preview', system, ...rest } = config 
   const openai = config.openai ?? new OpenAI(rest)
@@ -32,8 +43,7 @@ export const AI = (config: AIConfig = {}) => {
   //   messages: [{ role: 'user', content: 'hello' }],
   // })
 
-  const ai: Record<string, (args: string | object, callOptions?: FunctionCallOptions) => 
-    (args: string | object, callOptions?: FunctionCallOptions) => Promise<any>> = new Proxy(
+  const ai: AIFunctions = new Proxy(
     {},
     {
       get: (target, functionName: string, receiver) => {
@@ -69,7 +79,9 @@ export const AI = (config: AIConfig = {}) => {
           }
           if (system) prompt.messages.unshift({ role: 'system', content: system })
           const completion = await openai.chat.completions.create(prompt) as ChatCompletion
-          let data, error
+          const schema = generateSchema(returnSchema)
+          let data: FromSchema<typeof schema>
+          let error
           const { message } = completion.choices?.[0]
           console.log({ message })
           prompt.messages.push(message)
@@ -89,7 +101,7 @@ export const AI = (config: AIConfig = {}) => {
                 : 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 })
+          console.log({ data, content, error, cost, usage: completion.usage })
           return meta ? { prompt, content, data, error, cost, ...completion } : data ?? content
         }
       },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-functions",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "Library for Developing and Managing AI Functions (including OpenAI GPT4 / GPT3.5)",
   "main": "index.js",
   "type": "module",
@@ -37,7 +37,7 @@
   },
   "dependencies": {
     "js-yaml": "^4.1.0",
-    "json-schema-to-ts": "^2.9.2",
+    "json-schema-to-ts": "^3.0.0",
     "kafkajs": "^2.2.4",
     "lodash-es": "^4.17.21",
     "mongodb": "^6.2.0",

package/utils/schema.ts

@@ -1,10 +1,10 @@
-import { JSONSchema7 } from 'json-schema-to-ts'
+import { JSONSchema } from 'json-schema-to-ts'
 
 // 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: string): JSONSchema7 => {
+export const parseStringDescription = (description: string): JSONSchema => {
   // Check if the description indicates an enum for string type
   if (description.includes('|')) {
     return { type: 'string', enum: description.split('|').map((v) => v.trim()) }
@@ -37,13 +37,13 @@ export const parseStringDescription = (description: string): JSONSchema7 => {
  * and values as descriptions or nested property description objects.
  * @returns A JSON schema object based on the provided descriptions.
  */
-export const generateSchema = (propDescriptions: Record<string, string | Record<string, any>>): JSONSchema7 => {
+export const generateSchema = (propDescriptions: Record<string, string | Record<string, any>>): JSONSchema => {
   // 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: Record<string, JSONSchema7> = {}
+  const properties: Record<string, JSONSchema> = {}
   const required: string[] = Object.keys(propDescriptions)
 
   for (const [key, description] of Object.entries(propDescriptions)) {