ai-functions 0.1.4 → 0.2.0

package/utils/schema.ts

@@ -0,0 +1,62 @@
+import { JSONSchema7 } 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 => {
+  // 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: Record<string, string | Record<string, any>>): JSONSchema7 => {
+  // 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 required: string[] = 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/utils/state.ts

@@ -0,0 +1,23 @@
+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/example.js

@@ -1,38 +0,0 @@
-import { AI } from './proxy.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)
-}
-
-const listBlogPosts = (count, topic) => list`${count} blog post titles about ${topic}`
-const writeBlogPost = title => gpt`write a blog post in markdown starting with "# ${title}"`
-
-async function* writeBlog(count, topic) {
-  for await (const title of listBlogPosts(count, topic)) {
-    const contentPromise = writeBlogPost(title).then(content => {
-      console.log({ title, content })
-      return { title, content }
-    })
-    yield { title, contentPromise }
-  }
-}
-
-for await (const post of writeBlog(3, 'future of car sales')) {
-  console.log({ post })
-}
-
-const product = await ai.categorizeProduct({ 
-  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',
-})({ domain: 'OpenSaaS.org' })
-
-console.log({ product })

package/fetcher.js

@@ -1,48 +0,0 @@
-const headers = {
-  'Authorization': `Bearer ${process.env.OPENAI_API_KEY}`,
-  'Content-Type': 'application/json',
-}
-const openaiFetch = obj => fetch('https://api.openai.com/v1/chat/completions', { method: 'POST', headers, body: JSON.stringify(obj) }).then(res => res.json())
-
-const openaiStream = obj => fetch('https://api.openai.com/v1/chat/completions', { method: 'POST', headers, body: JSON.stringify(obj) })
-
-
-const response = await openaiStream({ 
-	model: 'gpt-3.5-turbo',
-	messages: [{ role: 'user', content: 'Tell me a funny joke about OpenAI' }],
-	stream: true
-})
-
-const decoder = new TextDecoder('utf-8')
-let completion = ''
-
-try {
-	for await (const chunk of response.body) {
-		let done = false
-		const currentChunk = decoder.decode(chunk)
-		const lines = currentChunk.split('\n').filter(Boolean)
-		// console.log(lines)
-		for (const line of lines) {
-			if (line.includes('[DONE]')) { 
-				done = true 
-				break
-			}
-			try {
-				const data = JSON.parse(line.replace('data: ', ''))
-				if (data.choices[0].delta.content) {
-					const deltaContent = data.choices[0].delta.content
-					completion += deltaContent
-					console.log(deltaContent)
-				}
-				// console.log(chunks)
-			} catch (error) {
-				console.log(error.message, line)
-			}
-		}
-		if (done) break
-	}
-} catch (err) {
-	console.error(err.stack);
-}
-console.log({ completion })
-

package/functions/generateBlogPost.js

@@ -1,12 +0,0 @@
-export const generateBlogPost = {
-  name: 'generateBlogPost',
-  description: 'Generate high-converting marketing content for a landing page',
-  parameters: {
-    type: 'object',
-    properties: {
-      title: { type: 'string', description: 'The title of the Blog Post' },
-      tags: { type: 'array', items: { type: 'string' } },
-      markdown: { type: 'string', description: 'The content of the Blog Post in Markdown format' },
-    }
-  }
-}

package/functions/generateLandingPage.js

@@ -1,11 +0,0 @@
-export const generateLandingPage = {
-  name: 'generateLandingPage',
-  description: 'Generate high-converting marketing content for 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' },
-    }
-  }
-}

package/functions/generatePossibleBlogPostTitles.js

@@ -1,11 +0,0 @@
-export const generateLandingPage = {
-  name: 'generateLandingPage',
-  description: 'Generate high-converting marketing content for a landing page',
-  parameters: {
-    type: 'object',
-    properties: {
-      titles: { type: 'array', items: { type: 'string' }, description: 'The title of the landing page' },
-      description: { type: 'string', description: 'The description of the landing page' },
-    }
-  }
-}

package/index.js

@@ -1,3 +0,0 @@
-export * from './proxy.js'
-export * from './schema.js'
-export * from './withAI.js'

package/index.test.js

@@ -1,64 +0,0 @@
-import { describe, test, it, expect } from 'vitest'
-
-import { AI } from './index.js'
-const { ai, list, gpt } = AI()
-
-test('Math.sqrt()', () => {
-  expect(Math.sqrt(4)).toBe(2)
-  expect(Math.sqrt(144)).toBe(12)
-  expect(Math.sqrt(2)).toBe(Math.SQRT2)
-})
-
-test('getJsonSchema', () => {
-
-  const jsonSchema = schema({ 
-    name: 'The name of the person',
-    age: 'The age of the person' 
-  })
-
-  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']
-  })
-
-})
-
-test('list', () => {
-
-})
-
-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 }) => 
-})
-
-test('A thing', () => {
-  it('should work', () => {
-    expect(3).toBe(3)
-  })
-
-  it('should be ok', () => {
-    expect(2).toBe(2)
-  })
-
-  describe('a nested thing', () => {
-    it('should work', () => {
-      expect(3).toBe(3)
-    })
-  })
-})

package/proxy.js

@@ -1,121 +0,0 @@
-// 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 headers = {
-    'Authorization': `Bearer ${apiKey ?? OPENAI_API_KEY ?? globalThis.process?.env?.OPENAI_API_KEY}`,
-    'Content-Type': 'application/json',
-  }
-  const openaiFetch = obj => fetch('https://api.openai.com/v1/chat/completions', { method: 'POST', headers, body: JSON.stringify(obj) }).then(res => res.json())
-  
-  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 openaiFetch(prompt)
-    return completion.choices?.[0].message.content
-  }
-
-  const ai = new Proxy({}, {
-    get: (target, functionName, receiver) => {
-      return (returnSchema, options) => async args => {
-        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 openaiFetch(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 response = await fetch('https://api.openai.com/v1/chat/completions', { method: 'POST', headers, body: JSON.stringify(prompt) })
-    const decoder = new TextDecoder('utf-8')
-
-    let content = ''
-    let seperator = undefined
-    let numberedList = undefined
-
-    for await (const chunk of response.body) {
-      const lines = decoder.decode(chunk).split('\n').filter(Boolean)
-      for (const line of lines) {
-        try {
-          if (line.includes('[DONE]')) break
-          const part = JSON.parse(line.replace('data: ', ''))
-          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
-        } catch (error) {
-          console.log(error.message, line)
-        }
-      }
-    }
-    
-  }
-
-  return { ai, list, gpt }
-}

package/schema.js

@@ -1,50 +0,0 @@
-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 }
-  }
-}

package/withAI.js

@@ -1,8 +0,0 @@
-import { AI } from './proxy.js'
-
-export const withAI = options => (req, env) => {
-  const { ai, gpt, list } = AI({ apiKey: env.OPENAI_API_KEY, ...options })
-  env.ai = ai
-  env.gpt = gpt
-  env.list = list
-}