aimyapi 0.1.0

package/dist/lib/sandbox.d.ts

@@ -0,0 +1,14 @@
+import "quickjs-emscripten";
+export interface GlobalOption {
+    value: any;
+    whitelist?: string[];
+}
+export interface Globals {
+    [key: string]: GlobalOption;
+}
+export default function createSandbox(QuickJS: any, requireLookup?: any, globals?: Globals, debug?: boolean): Promise<{
+    vm: any;
+    getLastError: () => string;
+    isAsyncProcessRunning: () => boolean;
+    runTask: (task: string) => boolean;
+}>;

package/dist/lib/sandbox.js

@@ -0,0 +1,161 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("quickjs-emscripten");
+const ts = __importStar(require("typescript"));
+const sandbox_wrappers_1 = require("./sandbox-wrappers");
+// Should we use "noEmitOnError": true ?
+function tsCompile(source, options = null) {
+    // Default options -- you could also perform a merge, or use the project tsconfig.json
+    if (null === options) {
+        options = {
+            compilerOptions: {
+                target: ts.ScriptTarget.ES2020,
+                module: ts.ModuleKind.None,
+            },
+        };
+    }
+    return ts.transpileModule(source, options).outputText;
+}
+// function whitelist can be produced using something like:
+// const assistantFunctions =  Object.getOwnPropertyNames(Object.getPrototypeOf(apiObject))
+//   .filter((f) => f !== "constructor" && !f.startsWith("_"));
+// Is there some way we can treat the API and globals the same?
+// We could just provide an object for all globals (including the API) and also have the whitelist as a parameter..
+async function createSandbox(QuickJS, requireLookup = {}, globals = {}, debug = false) {
+    const vm = QuickJS.newContext();
+    let errorState = false;
+    let lastError = "";
+    let asyncProcessesRunning = 0;
+    let beginAsyncProcess = () => {
+        asyncProcessesRunning++;
+    };
+    let endAsyncProcess = () => {
+        if (asyncProcessesRunning > 0) {
+            asyncProcessesRunning--;
+        }
+    };
+    let isAsyncProcessRunning = () => {
+        //console.log("asyncProcessesRunning:", asyncProcessesRunning);
+        return asyncProcessesRunning > 0;
+    };
+    // const assistantHandle = wrapObjectWhitelist(vm, apiObject, functionWhitelist, beginAsyncProcess, endAsyncProcess);
+    // vm.setProp(vm.global, apiGlobalName, assistantHandle)
+    // assistantHandle.dispose();
+    const logHandle = vm.newFunction("log", (...args) => {
+        const nativeArgs = args.map(vm.dump);
+        console.log("QuickJS Log:", ...nativeArgs);
+    });
+    const consoleHandle = vm.newObject();
+    const exportsHandle = vm.newObject();
+    const errorHandle = vm.newFunction("error", (...args) => {
+        try {
+            const nativeArgs = args.map(vm.dump);
+            console.log("QuickJS console.error:", ...nativeArgs);
+            lastError = JSON.stringify(nativeArgs);
+            errorState = true;
+        }
+        catch (e) {
+            console.log("Error in error:", e);
+        }
+    });
+    const globalNames = Object.getOwnPropertyNames(globals);
+    for (let i = 0; i < globalNames.length; i++) {
+        const globalOption = globals[globalNames[i]];
+        const globalObj = globalOption.whitelist
+            ? (0, sandbox_wrappers_1.wrapObjectWhitelist)(vm, globalOption.value, globalOption.whitelist, beginAsyncProcess, endAsyncProcess)
+            : (0, sandbox_wrappers_1.wrap)(vm, globalOption.value, globalOption, beginAsyncProcess, endAsyncProcess);
+        vm.setProp(vm.global, globalNames[i], globalObj);
+        globalObj.dispose();
+    }
+    (0, sandbox_wrappers_1.injectTimingFunctions)(vm, beginAsyncProcess, endAsyncProcess);
+    const requireHandle = vm.newFunction("require", (...args) => {
+        const nativeArgs = args.map(vm.dump);
+        if (requireLookup[nativeArgs[0]]) {
+            const returnObj = (0, sandbox_wrappers_1.wrapObject)(vm, requireLookup[nativeArgs[0]], beginAsyncProcess, endAsyncProcess);
+            return returnObj;
+        }
+        else {
+            return vm.undefined;
+        }
+    });
+    vm.setProp(consoleHandle, "log", logHandle);
+    vm.setProp(consoleHandle, "error", errorHandle);
+    vm.setProp(vm.global, "require", requireHandle);
+    vm.setProp(vm.global, "console", consoleHandle);
+    vm.setProp(vm.global, "exports", exportsHandle);
+    consoleHandle.dispose();
+    logHandle.dispose();
+    exportsHandle.dispose();
+    errorHandle.dispose();
+    requireHandle.dispose();
+    return {
+        vm,
+        getLastError: () => {
+            return lastError;
+        },
+        isAsyncProcessRunning,
+        runTask: (task) => {
+            try {
+                const compiled = tsCompile(task);
+                if (!compiled || compiled.length === 0) {
+                    console.log("Could not compile");
+                    return false;
+                }
+                // View compiled typescript code for debugging
+                // if(debug)
+                //   console.log(compiled);
+                errorState = false;
+                const result = vm.evalCode(compiled);
+                if (result.error) {
+                    // log out the compiled program with line numbers
+                    const lines = compiled.split("\n");
+                    for (let i = 0; i < lines.length; i++) {
+                        console.log(`${i + 1}: ${lines[i]}`);
+                    }
+                    console.log("Execution failed:", vm.dump(result.error));
+                    result.error.dispose();
+                    return false;
+                }
+                else {
+                    //console.log("Task Result:", vm.dump(result.value));
+                    result.value.dispose();
+                    if (errorState) {
+                        const lines = compiled.split("\n");
+                        for (let i = 0; i < lines.length; i++) {
+                            console.log(`${i + 1}: ${lines[i]}`);
+                        }
+                    }
+                    return !errorState;
+                }
+            }
+            catch (e) {
+                console.log(e);
+            }
+            return false;
+        },
+    };
+}
+exports.default = createSandbox;

package/dist/lib/utils.d.ts

@@ -0,0 +1 @@
+export declare function delay(time: any): Promise<void>;

package/dist/lib/utils.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.delay = void 0;
+function delay(time) {
+    return new Promise(resolve => setTimeout(resolve, time));
+}
+exports.delay = delay;

package/example/example1.ts

@@ -0,0 +1,33 @@
+
+import AIMyAPI from "../lib";
+import { API } from "./sales_api_impl";
+import * as APIExports from "./sales_api";
+import path from "path";
+
+
+// Simpler example using no support for chat history; 
+
+(async () => {
+    const api = new API();
+
+    const aimyapi = await AIMyAPI.createWithAPI({
+        apiObject: api,
+        apiGlobalName: "api", // Should match whatever you declared as your global in your api.
+        apiExports: APIExports,
+        apiDefFilePath: path.join(__dirname, "./sales_api.ts"),
+        apiDocsPath: path.join(__dirname, "./sales_api.md"),
+        debug: false,
+    })
+    
+    console.log("Print 'hello' three times.")
+    await aimyapi.processRequest("Print 'hello' three times.");
+
+    console.log("What was our best month in 2020")
+    await aimyapi.processRequest("What was our best month in 2020");
+
+    console.log("Which business unit had the highest sales in 2020?")
+    await aimyapi.processRequest("Which business unit had the highest sales in 2020?");
+
+    console.log("Compute the total sales for each month in 2020 then email the top 3 to test@email.com")
+    await aimyapi.processRequest("Compute the total sales for each month in 2020 then email the top 3 to test@email.com");
+})();

package/example/example2.ts

@@ -0,0 +1,50 @@
+
+import AIMyAPI from "../lib";
+import { OrderingAPI } from "./ordering_api_impl";
+import * as APIExports from "./ordering_api";
+import path from "path";
+
+
+
+// More complex fast food ordering example that uses chat history.
+// Fast food ordering example.
+(async () => {
+    const api = new OrderingAPI();
+
+    const aimyapi = await AIMyAPI.createWithAPI({
+        apiObject: api,
+        apiGlobalName: "orderingApi",       // Should match whatever you declared as your global in your ordering api.
+        apiExports: APIExports,
+        apiDefFilePath: path.join(__dirname, "./ordering_api.ts"),
+        apiDocsPath: path.join(__dirname, "./ordering_api.md"),
+        debug: false,
+    })
+
+    async function runQuery(query:string) {
+        console.log(`Query: ${query}`)
+
+        // generate the code for this query
+        const code = await aimyapi.generateCode(query, api._getHistory());
+
+        api._addMessageToHistory({
+            content: query,
+            role: "user",
+            name: "user",
+        });
+
+        api._addMessageToHistory({
+            content: '```\n' + code + '\n```',
+            role: "assistant",
+            name: "assistant",
+        });
+
+        // run the code in the sandbox
+        await aimyapi.runCode(code);
+    }
+   
+    await runQuery("How's the burger here?");
+    await runQuery("I'd like a plain hamburger and a large fries, a pizza with anchovies and a cola. I'd also like a cheese burger with bacon and avocado.");
+    await runQuery("I changed my mind, instead of anchovies, can I get a large gluten free pizza with pineapple instead.");
+    await runQuery("email me the total at myemail@test.com and complete the order");
+
+})();

package/example/example3.ts

@@ -0,0 +1,64 @@
+
+import AIMyAPI from "../lib";
+import { OrderingAPI } from "./ordering_api_impl";
+import * as APIExports from "./ordering_api";
+import path from "path";
+
+import readline from 'readline';
+
+function getInput(query): Promise<string> {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+
+    return new Promise(resolve => rl.question(query, ans => {
+        rl.close();
+        resolve(ans);
+    }))
+}
+
+// More complex fast food ordering example that uses chat history.
+// Fast food ordering example.
+// Interactive version
+(async () => {
+    const api = new OrderingAPI();
+
+    const aimyapi = await AIMyAPI.createWithAPI({
+        apiObject: api,
+        apiGlobalName: "orderingApi",       // Should match whatever you declared as your global in your ordering api.
+        apiExports: APIExports,
+        apiDefFilePath: path.join(__dirname, "./ordering_api.ts"),
+        apiDocsPath: path.join(__dirname, "./ordering_api.md"),
+        debug: false,
+    })
+
+    async function runQuery(query:string) {
+        console.log(`Query: ${query}`)
+
+        // generate the code for this query
+        const code = await aimyapi.generateCode(query, api._getHistory());
+
+        api._addMessageToHistory({
+            content: query,
+            role: "user",
+            name: "user",
+        });
+
+        api._addMessageToHistory({
+            content: '```\n' + code + '\n```',
+            role: "assistant",
+            name: "assistant",
+        });
+
+        // run the code in the sandbox
+        await aimyapi.runCode(code);
+    }
+   
+    console.log("Welcome to the restaurant. You can ask to hear the menu or order something. What would you like to do?");
+    while (!api._isCompleted) {
+        const query:string = await getInput("Your query: ");
+        await runQuery(query);
+    }
+
+})();

package/example/ordering_api.md

@@ -0,0 +1,106 @@
+You are an order taking assistant at a restaurant. 
+Your responses should be energetic, positive and polite.
+Help the customer with whatever questions they may have and ring up their orders.
+Do not complete the order until the user says they are finished ordering.
+Your code should check for errors or for cases where items may not be found.
+
+Examples of how you should respond:
+
+user: How are you today?
+
+assistant:
+```
+import * as ApiDefs from './api.ts'
+(async() {
+    try {
+        orderingApi.respondToUser("I'm great, thanks for asking!");
+    } catch(e) {
+        console.error(e);
+    }
+})();
+```
+
+user: Add a hamburger to my order
+
+assistant:
+```
+import * as ApiDefs from './api.ts'
+(async() {
+    try {
+        orderingApi.addItemToOrder("Hamburger", [], []);
+        orderingApi.respondToUser("Ok, I added a Hamburger. What else would you like?");
+    } catch(e) {
+        console.error(e);
+    }
+})();
+```
+
+user: I'd like a large pizza with mushrooms
+
+assistant:
+```
+import * as ApiDefs from './api.ts'
+(async() {
+    try {
+        ApiDefs.Menu
+        orderingApi.addItemToOrder("Pizza", ["Large"], ["mushrooms"]);
+        orderingApi.respondToUser("Ok, I added a Large Pizza with mushrooms");
+    } catch(err) {
+        orderingApi.respondToUser("Apologies, something went wrong with that request.");
+    }
+})();
+```
+
+user: I'd like a cheese burger
+
+assistant: 
+```
+import * as ApiDefs from './api.ts'
+(async() {
+    try {
+        orderingApi.addItemToOrder("Hamburger", [], ["cheese"]);
+        orderingApi.respondToUser("Ok, I added a Hamburger. What else would you like?");
+    } catch(e) {
+        orderingApi.respondToUser("Apologies, something went wrong with that request.");
+        console.error(e);
+    }
+})();
+```
+
+assistant: Added Hamburger with id 1
+
+user: Add jalapenos to that
+
+assistant: 
+```
+import * as ApiDefs from './api.ts'
+(async() {
+    try {
+        const existingItem = orderingApi.getItemInOrder("1");
+
+        if(existingItem) {
+            orderingApi.modifyItemInOrder("1", existingItem.customizations.map(item => item.name), [...existingItem.toppings, "jalapenos"]);
+            orderingApi.respondToUser("Ok, I added jalapenos to your Hamburger");
+        } else {
+            orderingApi.respondToUser("Hmm, I can't find that item.");
+        }
+    } catch(e) {
+        orderingApi.respondToUser("Apologies, something went wrong with that request.");
+        console.error(e);
+    }
+})();
+```
+
+user: I want an elephant.
+
+assistant:
+```
+import * as ApiDefs from './api.ts'
+(async() {
+    try {
+        orderingApi.respondToUser("I'm sorry, but that isn't on our menu.");
+    } catch(e) {
+        console.error(e);
+    }
+})();
+```

package/example/ordering_api.ts

@@ -0,0 +1,194 @@
+export const API_VERSION="1.0.1";
+
+export interface Customization {
+    name: string;
+    priceAdjustment: number;
+}
+
+export interface MenuItemBase {
+    orderId?: string;
+    name: string;
+    price: number;
+    description: string;
+    category: string;
+    tags: string[];
+    customizations: Customization[];
+    readonly allowedCustomizations: Customization[];
+    toppings: string[];
+    readonly allowedToppings: string[];
+}
+
+export const Menu: MenuItemBase[] = [
+    {
+        "name": "Pizza",
+        "price": 10.99,
+        "description": "A classic pizza with your choice of toppings.",
+        "category": "Pizza",
+        "tags": [
+            "cheese",
+            "pizza"
+        ],
+        "customizations": [],
+        "allowedCustomizations": [
+            {
+                "name": "Extra Cheese",
+                "priceAdjustment": 1.99
+            },
+            {
+                "name": "Extra Sauce",
+                "priceAdjustment": 0.99
+            },
+            {
+                "name": "Gluten Free Crust",
+                "priceAdjustment": 2.99
+            },
+            {
+                "name": "Large",
+                "priceAdjustment": 3.99
+            }
+        ],
+        "toppings": [],
+        "allowedToppings": [
+            "pepperoni",
+            "sausage",
+            "mushrooms",
+            "onions",
+            "green peppers",
+            "black olives",
+            "green olives",
+            "anchovies",
+            "pineapple",
+            "ham",
+            "bacon",
+            "chicken",
+        ]
+    },
+    {
+        "name": "Hamburger",
+        "price": 8.99,
+        "description": "A classic american hamburger with your choice of toppings. Cheese, lettuce, tomato, and onion are included by default. Other toppings available on request.",
+        "category": "Burgers",
+        "tags": [
+            "hamburger",
+            "burger"
+        ],
+        "customizations": [],
+        "allowedCustomizations": [
+            {
+                "name": "Special sauce",
+                "priceAdjustment": 1.99
+            }
+        ],
+        "toppings": [],
+        "allowedToppings": [
+            "cheese",
+            "lettuce",
+            "tomato",
+            "onion",
+            "pickles",
+            "bacon",
+            "mushrooms",
+            "avocado",
+            "jalapenos",
+        ],
+    },
+    {
+        "name": "Fries",
+        "price": 2.99,
+        "description": "A classic side of fries.",
+        "category": "Sides",
+        "tags": [
+            "fries",
+            "french fries"
+        ],
+        "customizations": [],
+        "allowedCustomizations": [
+            {
+                "name": "Large",
+                "priceAdjustment": 1.99
+            },           
+        ],
+        "toppings": [],
+        "allowedToppings": [
+            "old bay",
+        ]
+    },
+    {
+        "name": "Fountain Drink",
+        "price": 1.99,
+        "description": "A classic fountain drink. Choose from Cola, Diet Cola, Dr. Dazzle, or Mountain Rush.",
+        "category": "Drinks",
+        "tags": [
+            "drink",
+            "soda",
+            "fountain drink"
+        ],
+        "customizations": [],
+        "allowedCustomizations": [
+            {
+                "name": "Large",
+                "priceAdjustment": 0.99
+            },
+            {
+                "name": "Extra Ice",
+                "priceAdjustment": 0.99
+            },
+        ],
+        "toppings": [],
+        "allowedToppings": []
+    }
+];
+
+
+
+export interface OrderingAPIInterface {
+
+    sendEmail(to: string, subject: string, body: string): Promise<void>;
+    // Sends an email to the specified address with the specified subject and body.
+
+    getCurrentOrder(): MenuItemBase[];
+    // Gets the list of items that the user has added to the order so far.
+
+    getItemInOrder(itemOrderId: string): MenuItemBase | undefined;
+    // Gets the item with the specified id from the order.
+    // If the item is not in the order, returns undefined.
+
+    getCustomizationByName(itemName:string, name: string): Customization | undefined;
+    // Gets the customization with the specified name for the specified item.
+    // If the item does not have a customization with the specified name, returns undefined.
+
+    addItemToOrder(itemName:string, customizationNames: string[], toppings: string[]): void;
+    // Adds the specified item to the order.
+    // when adding an item, you should always create a new object that matches the existing menu item structure. Only include the toppings that the user has specified unless they come by default with the item.
+
+    removeItemFromOrder(itemOrderId: string): void;
+    // Removes the item with the specified id from the order.
+
+    modifyItemInOrder(itemOrderId: string, customizationNames: string[], toppings: string[]): void;
+    // Replace the item in the order with the specified item.
+
+    getOrderTotal(): number;
+    // Gets the total price for the current order
+
+    completeOrder(): void;
+    // Completes the order and sends it to the kitchen.
+
+    respondToUser(text: string): void;
+    // Sends a message to the user.
+
+    delay(milliseconds: number): Promise<void>;
+    // waits for the specified number of milliseconds before resolving the promise.
+
+    displayItem(item: MenuItemBase): void;
+    // Displays the specified item to the user.
+
+    displayOrder(): void;
+    // Displays the current order to the user.
+    
+
+};
+
+// Global object you will use for accessing the APIInterface
+declare global {
+    var orderingApi: OrderingAPIInterface;
+}