ai-functions 0.0.1 → 0.0.2

package/README.md

@@ -8,7 +8,50 @@ Key Features:
 ```javascript
 import { AI } from 'ai-functions'
 
-const ai = AI({ apiKey: OPENAI_API_KEY })
+const { ai, gpt, list } = AI({ apiKey: OPENAI_API_KEY })
+```
 
+Then you can use magic `ai` functions:
+```javascript
+
+const product = await ai.categorizeProduct({ domain: name }, { 
+  productType: 'App | API | Marketplace | Platform | Packaged Service | Professional Service | Website',
+  customer: 'ideal customer profile in 3-5 words',
+  solution: 'describe the offer in 4-10 words',
+  description: 'website meta description',
+})
+```
+
+you can also use `list` tagged template as a convienence function:
+
+```javascript
+const things = await list`fun things to do in Miami`
+console.log(things)
+```
+
+or with Async iterators:
+
+```javascript
+for await (const thing of list`fun things to do in Miami`) {
+  console.log(thing)
+}
+```
+
+Or in a more complex example:
+
+```javascript
+
+const listBlogPosts => (count, topic) => list`${count} blog post titles about ${topic}`
+const writeBlogPost => title => gpt`write a blog post in markdown starting with "# ${title}"`
+
+const writeBlog = async (count, topic) => {
+  for await (const title of listBlogPosts(count, topic)) {
+    const content = await writeBlogPost(title)
+    yield { title, content }
+  }
+}
 
+for await (const post of writeBlog(25, 'future of car sales')) {
+  console.log({ post })
+}
 ```

package/ai.js

@@ -0,0 +1,105 @@
+import { OpenAI } from 'openai'
+import camelcaseKeys from 'camelcase-keys'
+import { dump } from 'js-yaml'
+import { schema } from './schema.js'
+
+export const AI = opts => {
+  const { system, model = 'gpt-3.5-turbo', apiKey, OPENAI_API_KEY, ...rest } = opts || {}
+
+  const openai = new OpenAI({ apiKey: apiKey ?? OPENAI_API_KEY, ...rest })
+
+  const gpt = async (strings, ...values) => {
+    const user = values.map((value, i) => strings[i] + value).join('') + strings[strings.length - 1]
+    const prompt = {
+      model,
+      messages: [
+        { role: 'user', content: user },
+      ],
+    }
+    if (system) prompt.messages.unshift({ role: 'system', content: system })
+    const completion = await openai.chat.completions.create(prompt)
+    return completion.choices?.[0].message.content
+  }
+
+  const ai = new Proxy({}, {
+    get: (target, functionName, receiver) => {
+      return async (args, returnSchema, options) => {
+        console.log(schema(returnSchema))
+        const { system, description, model = 'gpt-3.5-turbo', meta = false, ...rest } = options || {}
+        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` },
+          ],
+          functions: [{ 
+            name: functionName, 
+            description, 
+            parameters: schema(returnSchema),
+          }],
+          ...rest,
+        }
+        if (system) prompt.messages.unshift({ role: 'system', content: system })
+        const completion = await openai.chat.completions.create(prompt)
+        let data, error
+        const { message } = completion.choices?.[0]
+        prompt.messages.push(message)
+        const { content, function_call } = message
+        if (function_call) {
+          try {
+            data = JSON.parse(function_call.arguments)
+          } catch (err) {
+            error = err.message
+          }
+        }
+        const gpt4 = model.includes('gpt-4')
+        const cost = 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
+        completion.usage = camelcaseKeys(completion.usage)
+        console.log({ data, content, error, cost })
+        return meta ? { prompt, content, data, error, cost, ...completion } : data ?? content
+      }
+    }
+  })
+
+  async function* list(strings, ...values) {
+    const listPrompt = values.map((value, i) => strings[i] + value).join('') + strings[strings.length - 1]
+    const prompt = {
+      model,
+      messages: [{ role: 'user', content: 'List ' + listPrompt }],
+      stream: true,
+    }
+    if (system) prompt.messages.unshift({ role: 'system', content: system })
+    const stream = await openai.chat.completions.create(prompt)
+    let content = ''
+    let seperator = undefined
+    let numberedList = undefined
+
+    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 (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) yield numberedList ? content.match(numberedRegex)?.[1] : content
+    }
+    
+  }
+
+  return { ai, list, gpt }
+}

package/example.js

@@ -0,0 +1,12 @@
+import { AI } from './ai.js'
+
+const { ai, list, gpt } = AI()
+
+for await (const item of list`synonyms for "fun"`) {
+  console.log(item)
+}
+
+
+for await (const item of list`fun things to do in Miami`) {
+  console.log(item)
+}

package/index.js

@@ -1,84 +0,0 @@
-import { Configuration, OpenAIApi } from 'openai-edge'
-
-const configuration = new Configuration({
-  apiKey: process.env.OPENAI_API_KEY,
-  basePath: 'https://aihooks.dev/v1',
-  baseOptions: {
-    headers: {
-      'webhook-app-id': process.env.AIHOOKS_APP_ID
-    }
-  }
-})
-const openai = new OpenAIApi(configuration)
-
-// const startTime = Date.now()
-// const response = await openai.createChatCompletion({
-//   // model: 'gpt-3.5-turbo-0613',
-//   model: 'gpt-4-0613',
-//   messages: [
-//     { role: 'system', content: 'You are an expert marketer.' },
-//     // { role: 'user', content: 'Write an ES6 function to convert base16 to base62' },
-//     // { role: 'user', content: 'Write an ES6 function to do Fizz Buzz' },
-//     // { role: 'user', content: 'List 2 possible blog post titles about APIs' },
-//     // { role: 'assistant', content: 'The Los Angeles Dodgers won the World Series in 2020.' },
-//     // { role: 'user', content: 'Where was it played?' },
-//     { role: 'user', content: 'Write a landing page for Driv.ly' },
-//   ],
-//   functions: [{
-//     name: 'writeLandingPage',
-//     // description: 'Write a landing page',
-//     parameters: {
-//       type: 'object',
-//       properties: {
-//         title: { type: 'string', description: 'The title of the landing page' },
-//         description: { type: 'string', description: 'The description of the landing page' },
-//         heroTitle: { type: 'string', description: 'The hero title of the landing page' },
-//         heroDescription: { type: 'string', description: 'The hero description of the landing page' },
-//         // features: { type: 'array', description: 'The features of the landing page' },
-//         featuresTitle: { type: 'string', description: 'The features title of the landing page' },
-//         featuresDescription: { type: 'string', description: 'The features description of the landing page' },
-//         // features: { type: 'array', description: 'The features of the landing page' },
-//       },
-//       required: ['title', 'description', 'heroTitle', 'heroDescription', 'featuresTitle', 'featuresDescription',]
-//     }
-//   }]
-  
-//   // max_tokens: 7,
-//   // temperature: 0,
-//   // stream: true,
-//   // go: true,
-// })
-// const completion = await response.json()
-// const requestTime = Date.now() - startTime
-// // console.timeEnd('openai')
-// const processingTime = parseInt(response.headers.get('openai-processing-ms'))
-// const latency = requestTime - processingTime
-// const status = response.status
-
-// const functionName = completion?.choices?.[0]?.message?.function_call?.name
-// const args = JSON.parse(completion?.choices?.[0]?.message?.function_call?.arguments)
-
-// console.log({ requestTime, processingTime, latency })
-// console.log(completion?.choices?.[0])
-// console.log(completion?.error)
-// console.log({ functionName, args })
-
-export const runtime = {
-
-}
-
-export const AI = (functionName, callback) => {
-    runtime[functionName] = callback
-}
-
-export const getJsonSchema = propDescriptions => {
-  // assume an object like this: { name: 'The name of the person', age: 'The age of the person' }
-  // return an object like this: { type: 'object', properties: { name: { type: 'string', description: 'The name of the person' }, age: { type: 'number', description: 'The age of the person' } } required: ['name', 'age'] }
-  const properties = Object.entries(propDescriptions).reduce((acc, [key, value]) => {
-    acc[key] = { type: typeof value, description: value }
-    return acc
-  }
-  , {})
-  const required = Object.keys(properties)
-  return { type: 'object', properties, required }
-}

package/index.test.js

@@ -1,10 +1,7 @@
-// import assert from 'node:assert'
-// import { describe, it } from 'node:test'
-
 import { describe, test, it, expect } from 'vitest'
 
 import { AI } from './index.js'
-import { getJsonSchema } from './index.js'
+const { ai, list, gpt } = AI()
 
 test('Math.sqrt()', () => {
   expect(Math.sqrt(4)).toBe(2)
@@ -12,43 +9,56 @@ test('Math.sqrt()', () => {
   expect(Math.sqrt(2)).toBe(Math.SQRT2)
 })
 
+test('getJsonSchema', () => {
 
-describe('getJsonSchema', () => {
+  const jsonSchema = schema({ 
+    name: 'The name of the person',
+    age: 'The age of the person' 
+  })
 
-  it('JSON Schema', () => {
+  expect(jsonSchema).toEqual({ 
+    type: 'object', 
+    properties: { 
+      name: { type: 'string', description: 'The name of the person' }, 
+      age: { type: 'string', description: 'The age of the person' } }, 
+      required: ['name', 'age']
+  })
 
-    const schema = getJsonSchema({ 
-      name: 'The name of the person',
-      age: 'The age of the person' 
-    })
+})
 
-    expect(schema).toEqual({ 
-      type: 'object', 
-      properties: { 
-        name: { type: 'string', description: 'The name of the person' }, 
-        age: { type: 'string', description: 'The age of the person' } }, 
-        required: ['name', 'age']
-    })
-    
-  })
+test('list', () => {
 
-  it('should be ok', () => {
-    assert.strictEqual(2, 2)
+})
+
+test('ai', () => {
+  expect(ai.writeLandingPage({
+    brand: 'Auto.dev',
+    audience: 'developers',
+    offers: 'Automotive Data APIs',
+  })).toEqual({
+    functionName: 'writeLandingPage',
+    args: {
+      brand: 'Auto.dev',
+      audience: 'developers',
+      offers: 'Automotive Data APIs',
+    }
   })
+  
+    // AI('writeLandingPage', ({ title, description, heroTitle, heroDescription, featuresTitle, featuresDescription }) => 
 })
 
-describe('A thing', () => {
+test('A thing', () => {
   it('should work', () => {
-    assert.strictEqual(1, 1)
+    expect(3).toBe(3)
   })
 
   it('should be ok', () => {
-    assert.strictEqual(2, 2)
+    expect(2).toBe(2)
   })
 
   describe('a nested thing', () => {
     it('should work', () => {
-      assert.strictEqual(3, 3)
+      expect(3).toBe(3)
     })
   })
 })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-functions",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "Library for Developing and Managing AI Functions (including OpenAI GPT4 / GPT3.5)",
   "main": "index.js",
   "type": "module",
@@ -19,10 +19,14 @@
     "url": "https://github.com/nathanclevenger/ai-functions/issues"
   },
   "homepage": "https://github.com/nathanclevenger/ai-functions#readme",
-  "dependencies": {
-    "openai-edge": "^1.1.0"
-  },
   "devDependencies": {
     "vitest": "^0.33.0"
+  },
+  "dependencies": {
+    "camelcase-keys": "^9.1.0",
+    "js-yaml": "^4.1.0",
+    "openai": "^4.11.1",
+    "partial-json-parser": "^1.2.2",
+    "yaml": "^2.3.2"
   }
 }

package/schema.js

@@ -0,0 +1,50 @@
+export const schema = propDescriptions => {
+  // assume an object like this: { name: 'The name of the person', age: 'The age of the person' }
+  // return an object like this: { type: 'object', properties: { name: { type: 'string', description: 'The name of the person' }, age: { type: 'number', description: 'The age of the person' } } required: ['name', 'age'] }
+  if (Array.isArray(propDescriptions)) {
+    const [ itemValue ] = propDescriptions
+    const itemType = typeof itemValue
+    if (itemType == 'string') {
+      return { type: 'array', description: itemValue, items: { type: 'string' }}
+    } else if (itemType == 'object') {
+      const { _description, itemSchema } = itemValue
+      return { type: 'array', description: _description, items: schema(itemSchema)}
+    }
+  } else {
+    const properties = Object.entries(propDescriptions).reduce((acc, [key, value]) => {
+      const type = typeof value
+      if (Array.isArray(value)) {
+        const [ itemValue ] = value
+        const itemType = typeof itemValue
+        if (itemType == 'string') {
+          if (itemValue.includes('|')) {
+            acc[key] = { type: 'string', enum: itemValue.split('|').map(value => value.trim()) }
+          } else {
+            acc[key] = { type: 'array', description: itemValue, items: { type: 'string' }}
+          }
+        } else if (itemType == 'object') {
+          // const { _description, itemSchema } = itemValue
+          const description = itemValue._description ? `${itemValue._description}` : undefined
+          if (description) delete itemValue._description
+          acc[key] = { type: 'array', description, items: schema(itemValue)}
+        }
+      } else {
+        if (type == 'string') {
+          if (value.includes('|')) {
+            acc[key] = { type: 'string', enum: value.split('|').map(value => value.trim()) }
+          } else {
+            acc[key] = { type, description: value }
+          }
+        } else if (type == 'object') {
+          if (value._description) value._description = undefined
+          acc[key] = schema(value)
+        } else {
+          acc[key] = { type, description: value }
+        }
+      }
+      return acc
+    }, {})
+    const required = Object.keys(properties)
+    return { type: 'object', properties, required }
+  }
+}