aimyapi 0.1.0

package/example/ordering_api_impl.ts

@@ -0,0 +1,194 @@
+import { ChatCompletionRequestMessage } from "openai";
+import { delay } from "../lib/utils";
+import {
+	Customization,
+	Menu,
+	MenuItemBase,
+	OrderingAPIInterface,
+} from "./ordering_api";
+
+// TODO: make functions to print out an item, and print out the current order with the price totals.
+
+export class OrderingAPI implements OrderingAPIInterface {
+	private _order: MenuItemBase[] = [];
+	private _lastOrderIdNumber: number = 0;
+    public _isCompleted:boolean = false;
+
+	private _history: ChatCompletionRequestMessage[] = [];
+
+	// Mock implementation, doesn't actually send an email
+	sendEmail(to: string, subject: string, body: string): Promise<void> {
+		console.log(
+			`Sending email to "${to}" with subject "${subject}" and body\n"${body}"`
+		);
+		return delay(1000);
+	}
+
+	respondToUser(text: string): void {
+		console.log(text);
+		this._history.push({
+			role: "assistant",
+			content: "Response output: " + text,
+		});
+	}
+
+	delay(milliseconds: number): Promise<void> {
+		return delay(milliseconds);
+	}
+
+	getCurrentOrder(): MenuItemBase[] {
+		return this._order;
+	}
+
+	// addItemToOrder(item: MenuItemBase) {
+	//     item.orderId = "" + (this._lastOrderIdNumber++);
+	//     this._order.push(item);
+	// }
+
+	getCustomizationByName(
+		itemName: string,
+		name: string
+	): Customization | undefined {
+		const item = Menu.find((item) => item.name === itemName);
+		if (!item) {
+			return undefined;
+		}
+
+		return item.allowedCustomizations.find(
+			(customization) => customization.name === name
+		);
+	}
+
+	addItemToOrder(
+		itemName: string,
+		customizationNames: string[],
+		toppings: string[]
+	) {
+		const item = Menu.find((item) => item.name === itemName);
+		if (!item) {
+			throw new Error(`Item with name "${itemName}" not found`);
+		}
+
+		const customizations = customizationNames
+			.map((customizationName) => {
+				return this.getCustomizationByName(itemName, customizationName);
+			})
+			.filter(
+				(customization) => customization !== undefined
+			) as Customization[];
+
+		const newItem = {
+			...item,
+			customizations,
+			toppings: toppings,
+			orderId: "" + this._lastOrderIdNumber++,
+		};
+
+		this._order.push(newItem);
+
+		this.respondToUser(`Added ${itemName} with id ${newItem.orderId}`);
+		this.displayItem(newItem);
+	}
+
+    getItemInOrder(itemOrderId: string): MenuItemBase {
+        const item = this._order.find((item) => item.orderId === itemOrderId);
+        if (!item) {
+            return undefined;
+        }
+
+        return item;
+    }
+
+	removeItemFromOrder(itemOrderId: string) {
+		this._order = this._order.filter((item) => item.orderId !== itemOrderId);
+
+		this.respondToUser(`Removed item ${itemOrderId}`);
+	}
+
+	modifyItemInOrder(
+		itemOrderId: string,
+		customizationNames: string[],
+		toppings: string[]
+	) {
+		const existingIndex = this._order.findIndex(
+			(item) => item.orderId === itemOrderId
+		);
+
+		if (existingIndex !== -1) {
+			const customizations = customizationNames
+				.map((customizationName) => {
+					return this.getCustomizationByName(
+						this._order[existingIndex].name,
+						customizationName
+					);
+				})
+				.filter(
+					(customization) => customization !== undefined
+				) as Customization[];
+
+			this._order[existingIndex].customizations = customizations;
+			this._order[existingIndex].toppings = toppings;
+		} else {
+			throw new Error(`Item with id #"${itemOrderId}" not found in order`);
+		}
+
+		this.respondToUser(`Modified item ${itemOrderId}`);
+	}
+
+	getOrderTotal() {
+		const total = this._order.reduce((total, item) => {
+			const customizationTotal = item.customizations.reduce(
+				(total, customization) => {
+					return total + customization?.priceAdjustment || 0;
+				},
+				0
+			);
+			return total + item.price + customizationTotal;
+		}, 0);
+
+		return total;
+	}
+
+	completeOrder(): void {
+		this.displayOrder();
+		this.respondToUser("Order completed!");
+
+		this._lastOrderIdNumber = 0;
+        // clear history
+        this._history = []
+
+        this._isCompleted = true;
+	}
+
+	displayItem(item: MenuItemBase) {
+		this.respondToUser(
+			`\t#${item.orderId || ""} ${item.name}...\t\t$${item.price.toFixed(2)}`
+		);
+		item.toppings.forEach((topping) => {
+			this.respondToUser(`\t\t${topping}`);
+		});
+		item.customizations.forEach((customization) => {
+			this.respondToUser(
+				`\t\t${customization.name}...\t$${customization.priceAdjustment.toFixed(
+					2
+				)}`
+			);
+		});
+	}
+
+	displayOrder() {
+		this.respondToUser("----\n\nDisplaying order:\n\n");
+		this._order.forEach((item) => this.displayItem(item));
+		this.respondToUser(`--\tTotal:\t\t$${this.getOrderTotal()}`);
+	}
+
+	_addMessageToHistory(message: ChatCompletionRequestMessage) {
+		this._history.push(message);
+	}
+
+	_getHistory(): ChatCompletionRequestMessage[] {
+		return this._history;
+	}
+
+
+}

package/example/sales_api.md

@@ -0,0 +1,15 @@
+Examples of how you should respond:
+
+user: How are you today?
+
+assistant:
+```
+import * as ApiDefs from './api.ts'
+(async() {
+    try {
+        api.print("I'm great, thanks for asking!");
+    } catch(e) {
+        console.error(e);
+    }
+})();
+```

package/example/sales_api.ts

@@ -0,0 +1,29 @@
+export const API_VERSION="1.0.1";
+
+// Sales data for each month, per business unit
+export interface SalesData {
+    sales: number;
+    month: number;  // 1...12
+    year: number;
+    businessUnit: "Advertising" | "Hardware" | "Software";
+}
+
+export interface APIInterface {
+
+    sendEmail(to: string, subject: string, body: string): Promise<void>;
+
+    getSalesData(): SalesData[];
+    // Returns an array of sales data.
+
+    print(text: string): void;
+    // Prints the specified text to the user.
+
+    delay(milliseconds: number): Promise<void>;
+    // waits for the specified number of milliseconds before resolving the promise.
+
+};
+
+// Global object you will use for accessing the APIInterface
+declare global {
+    var api: APIInterface;
+}

package/example/sales_api_impl.ts

@@ -0,0 +1,60 @@
+import { delay } from "../lib/utils";
+import { APIInterface, SalesData } from "./sales_api";
+
+export class API implements APIInterface {
+
+    // Mock implementation, doesn't actually send an email
+    sendEmail(to: string, subject: string, body: string): Promise<void> {
+        console.log(`Sending email to "${to}" with subject "${subject}" and body\n"${body}"`);
+        return delay(1000);
+    }
+
+    getSalesData(): SalesData[] {
+        return [
+            { sales: 100, month: 1, year: 2020, businessUnit: "Advertising" },
+            { sales: 200, month: 2, year: 2020, businessUnit: "Advertising" },
+            { sales: 300, month: 3, year: 2020, businessUnit: "Advertising" },
+            { sales: 400, month: 4, year: 2020, businessUnit: "Advertising" },
+            { sales: 500, month: 5, year: 2020, businessUnit: "Advertising" },
+            { sales: 600, month: 6, year: 2020, businessUnit: "Advertising" },
+            { sales: 700, month: 7, year: 2020, businessUnit: "Advertising" },
+            { sales: 800, month: 8, year: 2020, businessUnit: "Advertising" },
+            { sales: 900, month: 9, year: 2020, businessUnit: "Advertising" },
+            { sales: 1000, month: 10, year: 2020, businessUnit: "Advertising" },
+            { sales: 1100, month: 11, year: 2020, businessUnit: "Advertising" },
+            { sales: 1100, month: 12, year: 2020, businessUnit: "Advertising" },
+            { sales: 1200, month: 1, year: 2020, businessUnit: "Software" },
+            { sales: 1300, month: 2, year: 2020, businessUnit: "Software" },
+            { sales: 1400, month: 3, year: 2020, businessUnit: "Software" },
+            { sales: 1500, month: 4, year: 2020, businessUnit: "Software" },
+            { sales: 1600, month: 5, year: 2020, businessUnit: "Software" },
+            { sales: 1700, month: 6, year: 2020, businessUnit: "Software" },
+            { sales: 1800, month: 7, year: 2020, businessUnit: "Software" },
+            { sales: 1800, month: 8, year: 2020, businessUnit: "Software" },
+            { sales: 1500, month: 9, year: 2020, businessUnit: "Software" },
+            { sales: 1200, month: 10, year: 2020, businessUnit: "Software" },
+            { sales: 1000, month: 11, year: 2020, businessUnit: "Software" },
+            { sales: 100, month: 12, year: 2020, businessUnit: "Software" },
+            { sales: 1200, month: 1, year: 2020, businessUnit: "Hardware" },
+            { sales: 1300, month: 2, year: 2020, businessUnit: "Hardware" },
+            { sales: 1400, month: 3, year: 2020, businessUnit: "Hardware" },
+            { sales: 1500, month: 4, year: 2020, businessUnit: "Hardware" },
+            { sales: 1600, month: 5, year: 2020, businessUnit: "Hardware" },
+            { sales: 1700, month: 6, year: 2020, businessUnit: "Hardware" },
+            { sales: 1800, month: 7, year: 2020, businessUnit: "Hardware" },
+            { sales: 1800, month: 8, year: 2020, businessUnit: "Hardware" },
+            { sales: 1500, month: 9, year: 2020, businessUnit: "Hardware" },
+            { sales: 1200, month: 10, year: 2020, businessUnit: "Hardware" },
+            { sales: 1000, month: 11, year: 2020, businessUnit: "Hardware" },
+            { sales: 100, month: 12, year: 2020, businessUnit: "Hardware" },            
+        ]
+    };
+
+    print(text: string): void {
+        console.log(text);
+    }
+    delay(milliseconds: number): Promise<void> {
+        return delay(milliseconds);
+    }
+}
+

package/lib/index.ts

@@ -0,0 +1,247 @@
+require('dotenv').config()
+import { ChatCompletionRequestMessage, Configuration, OpenAIApi } from "openai";
+import fs from 'fs';
+import path from 'path';
+
+import createSandbox from "./sandbox";
+import { rejectOpenPromises } from './sandbox-wrappers';
+
+
+
+import { QuickJSWASMModule, getQuickJS } from "quickjs-emscripten";
+
+const configuration = new Configuration({
+    apiKey: process.env.OPENAI_API_KEY,
+  });
+
+const openai = new OpenAIApi(configuration);
+
+// function formatObject(obj: any): string {
+//     return Object.keys(obj).reduce((acc, key) => {
+//       return `${acc}${key}:\n${obj[key]}\n\n`;
+//     }, "");
+// }
+
+export function createBasePrompt(apiFilePath:string, documentationPath: string): string {
+    const apiText: string = fs.readFileSync(apiFilePath, 'utf8');
+    const documentationText: string = documentationPath ? fs.readFileSync(documentationPath, 'utf8') : '';
+
+    //console.time("Loading templates");
+    
+    const createTaskPrompt: string = fs.readFileSync( path.join(__dirname, '../prompts/create-task-prompt.md'), 'utf8').replace("{{DOCUMENTATION}}", documentationText).replace("{{API}}", apiText);
+    
+    //console.timeEnd("Loading templates")
+    
+    return createTaskPrompt;
+}
+
+// userChatHistory is not currently used but could be in the future.
+export const generateCode = async function(queryText:string, userChatHistory:ChatCompletionRequestMessage[], createTaskPrompt:string, apiPath:string, debug:boolean = false): Promise<string> {
+    if(!queryText)
+        return;
+
+    let generatedCode = '';
+    const prompt = createTaskPrompt.replace("{{QUERY_TEXT}}", queryText);
+
+    // TODO: I should switch this back to gpt3.5 turbo since it's cheaper
+    try {
+        // const task = await openai.createCompletion(
+        //     {
+        //     model: "text-davinci-003",
+        //     prompt,
+        //     temperature: 0.1,
+        //     max_tokens: 1100,
+        //     }
+        // );
+
+        const results = await openai.createChatCompletion({
+            model: "gpt-3.5-turbo",
+            messages: [
+                {
+                    role: "system",
+                    content: prompt,
+                },
+                ...userChatHistory,
+                {
+                    role: "user",
+                    content: `${queryText}`,
+                    name: "user"
+                }
+            ],
+            temperature: 0.1,
+            max_tokens: 800,
+            }
+        );
+
+
+        if(debug)
+            console.log(results.data.usage);
+        
+        const response = results.data.choices[0].message.content;
+
+        if(debug)
+            console.log(response);
+            
+        // Return only the code between ``` and ``` (usually at the end of the completion)
+        const codeStart = response.indexOf('```');
+        const codeEnd = response.lastIndexOf('```');
+
+        if(codeStart === -1 || codeEnd === -1 || codeStart === codeEnd)
+            return '';
+
+        generatedCode = response.substring(codeStart + 3, codeEnd).replace('typescript', '');
+       
+        generatedCode = `// Query=${queryText}\n` + generatedCode.replace("./api.ts", apiPath);
+        return generatedCode;
+    } catch(err) {
+        console.error(err);
+        return '';
+    } 
+
+};
+
+let QuickJS:QuickJSWASMModule = null;
+
+export interface AIMyAPIOptions {
+    apiObject: object;
+    apiExports: object;
+    apiGlobals?: object;
+    apiDefFilePath: string;     // Full path to the api definition file so that it can be loaded into the prompt
+    apiGlobalName?: string;    
+    apiDocsPath?: string;
+    debug?: boolean;
+};
+
+export interface CreateWithAPIExports {
+    // see xample 2
+    generateCode: (queryText:string, userChatHistory:ChatCompletionRequestMessage[]) => Promise<string>;
+    runCode: (task:string) => Promise<void>;
+    // run a single request with no history
+    processRequest: (userQuery:string, context?: object) => Promise<string>;
+    
+}
+
+async function createWithAPI(options:AIMyAPIOptions): Promise<CreateWithAPIExports> {
+    // extend options with defaults
+    options = {
+        apiGlobalName: "api",
+        apiGlobals: {},
+        debug: false,
+        ...options
+    };
+
+    if(!options.apiObject || !options.apiDefFilePath) {
+        throw new Error("apiObject and apiFilePath are required");
+    }
+
+    const {apiObject, apiGlobalName, apiExports, apiDefFilePath, apiDocsPath, debug} = options;
+
+    const whitelist =  Object.getOwnPropertyNames(Object.getPrototypeOf(apiObject)).filter((f) => f !== "constructor" && !f.startsWith("_"));
+    const createTaskPrompt = createBasePrompt( apiDefFilePath, apiDocsPath);
+
+    return {
+        generateCode: async function(queryText:string, userChatHistory:ChatCompletionRequestMessage[], currentContext:any = undefined) {
+            if(!queryText)
+                return '';
+
+            return await generateCode(queryText, userChatHistory, createTaskPrompt.replace("{{CONTEXT}}", currentContext ? "```" + JSON.stringify(currentContext, null, 2) + "```" : ""), apiDefFilePath, debug);
+        },
+        runCode: async function(generatedCode:string) {
+            if(!QuickJS) {
+                // Create QuickJS
+                if(debug)
+                    console.log("Creating quick.js");
+                QuickJS = await getQuickJS();
+            }
+
+            let apiGlobals = {}
+
+            for(const key in options.apiGlobals) {
+                apiGlobals[key] = {
+                    value: options.apiGlobals[key],
+                }
+            }
+      
+            // Create sandbox           
+            // NOTE: not sure why I have to replace the backslash here
+            const {vm, runTask, isAsyncProcessRunning} = await createSandbox(QuickJS, {
+                [apiDefFilePath.replaceAll("\\", "")]: apiExports,
+            }, { 
+                ...apiGlobals,
+                [apiGlobalName]: {
+                    value: apiObject,
+                    whitelist
+                }
+            }, options.debug);
+
+            try {
+                const res = await runTask(generatedCode);
+        
+                if(!res) {
+                    console.error("Task unsuccessful");
+                } 
+        
+                while(isAsyncProcessRunning()) {
+                    await new Promise((resolve) => setTimeout(resolve, 100));
+                }
+            
+                if(debug) {
+                    console.log("Completed");
+                }
+            } catch(err) {
+                if(debug) {
+                    console.error("Error running task:", err);
+                }
+            }
+        
+            await new Promise((resolve) => setTimeout(resolve, 100));
+        
+            rejectOpenPromises(vm);
+            vm.dispose()             
+        
+        }, 
+        processRequest: async function (userQuery, currentContext:any = undefined):Promise<string> {
+            // Create prompt
+            
+            if(debug) {
+                console.log("Query:", userQuery);
+            }
+        
+            // Generate Code
+            console.time("Generate Task")
+            const generatedCode = await generateCode(userQuery, [], createTaskPrompt.replace("{{CONTEXT}}", currentContext ? "```" + JSON.stringify(currentContext, null, 2) + "```" : "" ), apiDefFilePath);
+            console.timeEnd("Generate Task")
+        
+            if(debug) {
+                console.log("Generated Code:", generatedCode);
+            }
+
+            console.time("Run Code")
+            await this.runCode(generatedCode);
+            console.timeEnd("Run Code")
+
+            return generatedCode;
+        }
+    }
+
+}
+
+export interface AIMyAPIExports {
+    createWithAPI: (options:AIMyAPIOptions) => Promise<CreateWithAPIExports>;
+    
+    createBasePrompt: (apiFilePath:string, documentationPath: string) => string;
+    generateTask: (queryText:string, userChatHistory:any[], createTaskPrompt:string, apiPath:string) => Promise<string>;
+    createSandbox: (QuickJS:QuickJSWASMModule, globals: any) => Promise<any>;
+}
+
+const aimyapi:AIMyAPIExports = {
+    // Standard way of using the library
+    createWithAPI,      
+
+    // functions for customized usage
+    createBasePrompt,   
+    generateTask: generateCode,
+    createSandbox,
+}
+
+ export default aimyapi;