ai-functions 0.1.4 → 0.2.0

package/functions/ai.test.ts

@@ -0,0 +1,31 @@
+import { describe, test, 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',
+  }, { seed: 1, model: 'gpt-3.5-turbo' })
+
+  it('should be a function', () => {
+    
+    expect(typeof categorizeWord).toBe('function')
+  })
+
+  it('should return a promise', async () => {
+    expect(await categorizeWord('destroy')).toMatchObject({ type: 'Verb' })
+  })
+
+  it('should return a promise', async () => {
+    expect(await categorizeWord('dog')).toMatchObject({ type: 'Noun' })
+  })
+  
+})

package/functions/ai.ts

@@ -0,0 +1,99 @@
+import { ClientOptions, OpenAI,  } from 'openai'
+import { ChatCompletion, ChatCompletionCreateParamsBase } from 'openai/resources/chat/completions'
+import { AIDB, AIDBConfig } from '../db/mongo'
+import { dump } from 'js-yaml'
+import { generateSchema } from '../utils/schema'
+
+export type AIConfig = ClientOptions & {
+  db?: AIDBConfig
+  openai?: OpenAI
+  system?: string
+  model?: ChatCompletionCreateParamsBase['model']
+}
+
+export type FunctionCallOptions = Omit<ChatCompletionCreateParamsBase, 'messages' | 'stream' > & {
+  system?: string
+  meta?: boolean
+  description?: string
+}
+
+export const AI = (config: AIConfig = {}) => {
+  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: Record<string, (args: string | object, callOptions?: FunctionCallOptions) => 
+    (args: string | object, callOptions?: FunctionCallOptions) => Promise<object>> = new Proxy(
+    {},
+    {
+      get: (target, functionName: string, receiver) => {
+        return (returnSchema: Record<string,any>, options: FunctionCallOptions) => async (args: string | object, callOptions?: FunctionCallOptions) => {
+          console.log(generateSchema(returnSchema))
+          const { system, description, model = 'gpt-3.5-turbo', meta = false, ...rest } = { ...options, ...callOptions }
+          const prompt: ChatCompletionCreateParamsBase = {
+            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) as Record<string,unknown>,
+                }
+              }
+            ],
+
+            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) as ChatCompletion
+          let data, 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: any) {
+              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 })
+          return meta ? { prompt, content, data, error, cost, ...completion } : data ?? content
+        }
+      },
+    }
+  )
+  return { ai, openai } //, client, db, cache, events, queue }
+}

package/functions/gpt.ts

@@ -0,0 +1,12 @@
+import { GPTConfig } from '../types'
+import { chatCompletion } from '../utils/completion'
+
+export const GPT = (config: GPTConfig) => {
+  const gpt = async (strings: string[], ...values: string[]) => {
+    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/functions/list.ts

@@ -0,0 +1,84 @@
+import { OpenAI } from 'openai'
+import { ChatCompletionCreateParamsStreaming } from 'openai/resources/index.mjs'
+import { GPTConfig } from '../types'
+import { chatCompletion } from '../utils/completion'
+
+export const List = (config: GPTConfig) => {
+  const list = async (strings: string[], ...values: string[]) => {
+    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: string): string[] {
+  // 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: RegExpExecArray | null
+  const result: string[] = []
+
+  // 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: GPTConfig) => {
+  async function* list(strings: string[], ...values: string[]) {
+    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,
+    } as ChatCompletionCreateParamsStreaming
+    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: string | undefined
+    let numberedList: RegExpMatchArray | undefined | null
+
+    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/index.ts

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

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "ai-functions",
-  "version": "0.1.4",
+  "version": "0.2.0",
   "description": "Library for Developing and Managing AI Functions (including OpenAI GPT4 / GPT3.5)",
   "main": "index.js",
   "type": "module",
   "scripts": {
-    "start": "doppler run -- node index.js",
-    "test": "doppler run -- vitest --globals"
+    "build": "tsc",
+    "format": "prettier --write .",
+    "test": "dotenv -- vitest --globals"
   },
   "repository": {
     "type": "git",
@@ -19,14 +20,30 @@
     "url": "https://github.com/nathanclevenger/ai-functions/issues"
   },
   "homepage": "https://github.com/nathanclevenger/ai-functions#readme",
+  "prettier": {
+    "semi": false,
+    "singleQuote": true,
+    "trailingComma": "es5",
+    "tabWidth": 2,
+    "printWidth": 120
+  },
   "devDependencies": {
+    "@types/js-yaml": "^4.0.9",
+    "@types/json-schema": "^7.0.14",
+    "dotenv-cli": "^7.3.0",
+    "prettier": "^3.0.3",
+    "typescript": "^5.3.3",
     "vitest": "^0.33.0"
   },
   "dependencies": {
-    "camelcase-keys": "^9.1.0",
     "js-yaml": "^4.1.0",
-    "openai": "^4.11.1",
+    "json-schema-to-ts": "^2.9.2",
+    "kafkajs": "^2.2.4",
+    "lodash-es": "^4.17.21",
+    "mongodb": "^6.2.0",
+    "openai": "^4.16.1",
+    "p-queue": "^7.4.1",
     "partial-json-parser": "^1.2.2",
-    "yaml": "^2.3.2"
+    "xstate": "^5.0.0-beta.40"
   }
 }

package/queue/mongo.ts

@@ -0,0 +1,88 @@
+import { BSON, ObjectId } from 'bson'
+import { AIDB } from '../db/mongo'
+import PQueue from 'p-queue'
+import { chatCompletion, CompletionInput } from '../utils/completion'
+import { createMachine, createActor } from 'xstate'
+import { ChangeStreamInsertDocument, InsertOneResult, UpdateOneModel, UpdateResult } from 'mongodb'
+
+let localQueue
+
+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 const startQueue = async (config: QueueConfig) => {
+
+  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<QueueInput, ChangeStreamInsertDocument< QueueInput >>([
+    { $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 as UpdateResult).modifiedCount ||
+          (mergeResult as InsertOneResult).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/tsconfig.json

@@ -0,0 +1,105 @@
+{
+  "compilerOptions": {
+    /* Visit https://aka.ms/tsconfig to read more about this file */
+
+    /* Projects */
+    // "incremental": true,                              /* Save .tsbuildinfo files to allow for incremental compilation of projects. */
+    // "composite": true,                                /* Enable constraints that allow a TypeScript project to be used with project references. */
+    // "tsBuildInfoFile": "./.tsbuildinfo",              /* Specify the path to .tsbuildinfo incremental compilation file. */
+    // "disableSourceOfProjectReferenceRedirect": true,  /* Disable preferring source files instead of declaration files when referencing composite projects. */
+    // "disableSolutionSearching": true,                 /* Opt a project out of multi-project reference checking when editing. */
+    // "disableReferencedProjectLoad": true,             /* Reduce the number of projects loaded automatically by TypeScript. */
+
+    /* Language and Environment */
+    "target": "es2016" /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */,
+    // "lib": [],                                        /* Specify a set of bundled library declaration files that describe the target runtime environment. */
+    // "jsx": "preserve",                                /* Specify what JSX code is generated. */
+    // "experimentalDecorators": true,                   /* Enable experimental support for TC39 stage 2 draft decorators. */
+    // "emitDecoratorMetadata": true,                    /* Emit design-type metadata for decorated declarations in source files. */
+    // "jsxFactory": "",                                 /* Specify the JSX factory function used when targeting React JSX emit, e.g. 'React.createElement' or 'h'. */
+    // "jsxFragmentFactory": "",                         /* Specify the JSX Fragment reference used for fragments when targeting React JSX emit e.g. 'React.Fragment' or 'Fragment'. */
+    // "jsxImportSource": "",                            /* Specify module specifier used to import the JSX factory functions when using 'jsx: react-jsx*'. */
+    // "reactNamespace": "",                             /* Specify the object invoked for 'createElement'. This only applies when targeting 'react' JSX emit. */
+    // "noLib": true,                                    /* Disable including any library files, including the default lib.d.ts. */
+    // "useDefineForClassFields": true,                  /* Emit ECMAScript-standard-compliant class fields. */
+    // "moduleDetection": "auto",                        /* Control what method is used to detect module-format JS files. */
+
+    /* Modules */
+    "module": "ES6" /* Specify what module code is generated. */,
+    // "rootDir": "./",                                  /* Specify the root folder within your source files. */
+    "moduleResolution": "Bundler" /* Specify how TypeScript looks up a file from a given module specifier. */,
+    // "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
+    // "paths": {},                                      /* Specify a set of entries that re-map imports to additional lookup locations. */
+    // "rootDirs": [],                                   /* Allow multiple folders to be treated as one when resolving modules. */
+    // "typeRoots": [],                                  /* Specify multiple folders that act like './node_modules/@types'. */
+    "types": [
+      "vitest/globals"
+    ] /* Specify type package names to be included without being referenced in a source file. */,
+    // "allowUmdGlobalAccess": true,                     /* Allow accessing UMD globals from modules. */
+    // "moduleSuffixes": [],                             /* List of file name suffixes to search when resolving a module. */
+    // "resolveJsonModule": true,                        /* Enable importing .json files. */
+    // "noResolve": true,                                /* Disallow 'import's, 'require's or '<reference>'s from expanding the number of files TypeScript should add to a project. */
+
+    /* JavaScript Support */
+    // "allowJs": true,                                  /* Allow JavaScript files to be a part of your program. Use the 'checkJS' option to get errors from these files. */
+    // "checkJs": true,                                  /* Enable error reporting in type-checked JavaScript files. */
+    // "maxNodeModuleJsDepth": 1,                        /* Specify the maximum folder depth used for checking JavaScript files from 'node_modules'. Only applicable with 'allowJs'. */
+
+    /* Emit */
+    // "declaration": true,                              /* Generate .d.ts files from TypeScript and JavaScript files in your project. */
+    // "declarationMap": true,                           /* Create sourcemaps for d.ts files. */
+    // "emitDeclarationOnly": true,                      /* Only output d.ts files and not JavaScript files. */
+    // "sourceMap": true,                                /* Create source map files for emitted JavaScript files. */
+    // "outFile": "./dist",                                  /* Specify a file that bundles all outputs into one JavaScript file. If 'declaration' is true, also designates a file that bundles all .d.ts output. */
+    "outDir": "./dist" /* Specify an output folder for all emitted files. */,
+    // "removeComments": true,                           /* Disable emitting comments. */
+    // "noEmit": true,                                   /* Disable emitting files from a compilation. */
+    // "importHelpers": true,                            /* Allow importing helper functions from tslib once per project, instead of including them per-file. */
+    // "importsNotUsedAsValues": "remove",               /* Specify emit/checking behavior for imports that are only used for types. */
+    // "downlevelIteration": true,                       /* Emit more compliant, but verbose and less performant JavaScript for iteration. */
+    // "sourceRoot": "",                                 /* Specify the root path for debuggers to find the reference source code. */
+    // "mapRoot": "",                                    /* Specify the location where debugger should locate map files instead of generated locations. */
+    // "inlineSourceMap": true,                          /* Include sourcemap files inside the emitted JavaScript. */
+    // "inlineSources": true,                            /* Include source code in the sourcemaps inside the emitted JavaScript. */
+    // "emitBOM": true,                                  /* Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files. */
+    // "newLine": "crlf",                                /* Set the newline character for emitting files. */
+    // "stripInternal": true,                            /* Disable emitting declarations that have '@internal' in their JSDoc comments. */
+    // "noEmitHelpers": true,                            /* Disable generating custom helper functions like '__extends' in compiled output. */
+    // "noEmitOnError": true,                            /* Disable emitting files if any type checking errors are reported. */
+    // "preserveConstEnums": true,                       /* Disable erasing 'const enum' declarations in generated code. */
+    // "declarationDir": "./",                           /* Specify the output directory for generated declaration files. */
+    // "preserveValueImports": true,                     /* Preserve unused imported values in the JavaScript output that would otherwise be removed. */
+
+    /* Interop Constraints */
+    // "isolatedModules": true,                          /* Ensure that each file can be safely transpiled without relying on other imports. */
+    // "allowSyntheticDefaultImports": true,             /* Allow 'import x from y' when a module doesn't have a default export. */
+    "esModuleInterop": true /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */,
+    // "preserveSymlinks": true,                         /* Disable resolving symlinks to their realpath. This correlates to the same flag in node. */
+    "forceConsistentCasingInFileNames": true /* Ensure that casing is correct in imports. */,
+
+    /* Type Checking */
+    "strict": true /* Enable all strict type-checking options. */,
+    // "noImplicitAny": true,                            /* Enable error reporting for expressions and declarations with an implied 'any' type. */
+    // "strictNullChecks": true,                         /* When type checking, take into account 'null' and 'undefined'. */
+    // "strictFunctionTypes": true,                      /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */
+    // "strictBindCallApply": true,                      /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */
+    // "strictPropertyInitialization": true,             /* Check for class properties that are declared but not set in the constructor. */
+    // "noImplicitThis": true,                           /* Enable error reporting when 'this' is given the type 'any'. */
+    // "useUnknownInCatchVariables": true,               /* Default catch clause variables as 'unknown' instead of 'any'. */
+    // "alwaysStrict": true,                             /* Ensure 'use strict' is always emitted. */
+    // "noUnusedLocals": true,                           /* Enable error reporting when local variables aren't read. */
+    // "noUnusedParameters": true,                       /* Raise an error when a function parameter isn't read. */
+    // "exactOptionalPropertyTypes": true,               /* Interpret optional property types as written, rather than adding 'undefined'. */
+    // "noImplicitReturns": true,                        /* Enable error reporting for codepaths that do not explicitly return in a function. */
+    // "noFallthroughCasesInSwitch": true,               /* Enable error reporting for fallthrough cases in switch statements. */
+    // "noUncheckedIndexedAccess": true,                 /* Add 'undefined' to a type when accessed using an index. */
+    // "noImplicitOverride": true,                       /* Ensure overriding members in derived classes are marked with an override modifier. */
+    // "noPropertyAccessFromIndexSignature": true,       /* Enforces using indexed accessors for keys declared using an indexed type. */
+    // "allowUnusedLabels": true,                        /* Disable error reporting for unused labels. */
+    // "allowUnreachableCode": true,                     /* Disable error reporting for unreachable code. */
+
+    /* Completeness */
+    // "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
+    "skipLibCheck": true /* Skip type checking all .d.ts files. */
+  }
+}

package/types.ts

@@ -0,0 +1,12 @@
+import type { OpenAI, ClientOptions } from 'openai'
+import type { ChatCompletion, ChatCompletionCreateParamsNonStreaming } from 'openai/resources/index.mjs'
+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/utils/completion.ts

@@ -0,0 +1,28 @@
+import { OpenAI, ClientOptions } from 'openai'
+import type { ChatCompletion, ChatCompletionCreateParamsNonStreaming } from 'openai/resources/index.mjs'
+import { GPTConfig } from '../types'
+
+export type CompletionInput = GPTConfig &
+  (
+    | (({ user: string } | { list: string }) & Partial<ChatCompletionCreateParamsNonStreaming>)
+    | ChatCompletionCreateParamsNonStreaming
+  )
+// TODO: add support for list input and parsing
+// TODO: add support for caching w/ seed generation for unit tests
+
+export const chatCompletion = async (config: CompletionInput) => {
+  const { user, system, model, db, queue, ...rest } = config
+  const openai = config.openai ?? new OpenAI(rest)
+  const prompt = {
+    model,
+    messages: [{ role: 'user', content: user }],
+  } as ChatCompletionCreateParamsNonStreaming
+  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 as ChatCompletion)
+  }
+  return completion as ChatCompletion
+}

package/utils/schema.test.ts

@@ -0,0 +1,69 @@
+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' as any)
+
+    expect(callWithInvalidArg).toThrow('The propDescriptions parameter should be an object.')
+  })
+})