aimyapi 0.1.0

package/dist/example/ordering_api_impl.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrderingAPI = void 0;
+const utils_1 = require("../lib/utils");
+const ordering_api_1 = require("./ordering_api");
+// TODO: make functions to print out an item, and print out the current order with the price totals.
+class OrderingAPI {
+    constructor() {
+        this._order = [];
+        this._lastOrderIdNumber = 0;
+        this._isCompleted = false;
+        this._history = [];
+    }
+    // Mock implementation, doesn't actually send an email
+    sendEmail(to, subject, body) {
+        console.log(`Sending email to "${to}" with subject "${subject}" and body\n"${body}"`);
+        return (0, utils_1.delay)(1000);
+    }
+    respondToUser(text) {
+        console.log(text);
+        this._history.push({
+            role: "assistant",
+            content: "Response output: " + text,
+        });
+    }
+    delay(milliseconds) {
+        return (0, utils_1.delay)(milliseconds);
+    }
+    getCurrentOrder() {
+        return this._order;
+    }
+    // addItemToOrder(item: MenuItemBase) {
+    //     item.orderId = "" + (this._lastOrderIdNumber++);
+    //     this._order.push(item);
+    // }
+    getCustomizationByName(itemName, name) {
+        const item = ordering_api_1.Menu.find((item) => item.name === itemName);
+        if (!item) {
+            return undefined;
+        }
+        return item.allowedCustomizations.find((customization) => customization.name === name);
+    }
+    addItemToOrder(itemName, customizationNames, toppings) {
+        const item = ordering_api_1.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);
+        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) {
+        const item = this._order.find((item) => item.orderId === itemOrderId);
+        if (!item) {
+            return undefined;
+        }
+        return item;
+    }
+    removeItemFromOrder(itemOrderId) {
+        this._order = this._order.filter((item) => item.orderId !== itemOrderId);
+        this.respondToUser(`Removed item ${itemOrderId}`);
+    }
+    modifyItemInOrder(itemOrderId, customizationNames, toppings) {
+        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);
+            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() {
+        this.displayOrder();
+        this.respondToUser("Order completed!");
+        this._lastOrderIdNumber = 0;
+        // clear history
+        this._history = [];
+        this._isCompleted = true;
+    }
+    displayItem(item) {
+        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) {
+        this._history.push(message);
+    }
+    _getHistory() {
+        return this._history;
+    }
+}
+exports.OrderingAPI = OrderingAPI;

package/dist/example/sales_api.d.ts

@@ -0,0 +1,16 @@
+export declare const API_VERSION = "1.0.1";
+export interface SalesData {
+    sales: number;
+    month: number;
+    year: number;
+    businessUnit: "Advertising" | "Hardware" | "Software";
+}
+export interface APIInterface {
+    sendEmail(to: string, subject: string, body: string): Promise<void>;
+    getSalesData(): SalesData[];
+    print(text: string): void;
+    delay(milliseconds: number): Promise<void>;
+}
+declare global {
+    var api: APIInterface;
+}

package/dist/example/sales_api.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.API_VERSION = void 0;
+exports.API_VERSION = "1.0.1";
+;

package/dist/example/sales_api_impl.d.ts

@@ -0,0 +1,7 @@
+import { APIInterface, SalesData } from "./sales_api";
+export declare class API implements APIInterface {
+    sendEmail(to: string, subject: string, body: string): Promise<void>;
+    getSalesData(): SalesData[];
+    print(text: string): void;
+    delay(milliseconds: number): Promise<void>;
+}

package/dist/example/sales_api_impl.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.API = void 0;
+const utils_1 = require("../lib/utils");
+class API {
+    // Mock implementation, doesn't actually send an email
+    sendEmail(to, subject, body) {
+        console.log(`Sending email to "${to}" with subject "${subject}" and body\n"${body}"`);
+        return (0, utils_1.delay)(1000);
+    }
+    getSalesData() {
+        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) {
+        console.log(text);
+    }
+    delay(milliseconds) {
+        return (0, utils_1.delay)(milliseconds);
+    }
+}
+exports.API = API;

package/dist/lib/index.d.ts

@@ -0,0 +1,26 @@
+import { ChatCompletionRequestMessage } from "openai";
+import { QuickJSWASMModule } from "quickjs-emscripten";
+export declare function createBasePrompt(apiFilePath: string, documentationPath: string): string;
+export declare const generateCode: (queryText: string, userChatHistory: ChatCompletionRequestMessage[], createTaskPrompt: string, apiPath: string, debug?: boolean) => Promise<string>;
+export interface AIMyAPIOptions {
+    apiObject: object;
+    apiExports: object;
+    apiGlobals?: object;
+    apiDefFilePath: string;
+    apiGlobalName?: string;
+    apiDocsPath?: string;
+    debug?: boolean;
+}
+export interface CreateWithAPIExports {
+    generateCode: (queryText: string, userChatHistory: ChatCompletionRequestMessage[]) => Promise<string>;
+    runCode: (task: string) => Promise<void>;
+    processRequest: (userQuery: string, context?: object) => Promise<string>;
+}
+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>;
+}
+declare const aimyapi: AIMyAPIExports;
+export default aimyapi;

package/dist/lib/index.js

@@ -0,0 +1,179 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCode = exports.createBasePrompt = void 0;
+require('dotenv').config();
+const openai_1 = require("openai");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const sandbox_1 = __importDefault(require("./sandbox"));
+const sandbox_wrappers_1 = require("./sandbox-wrappers");
+const quickjs_emscripten_1 = require("quickjs-emscripten");
+const configuration = new openai_1.Configuration({
+    apiKey: process.env.OPENAI_API_KEY,
+});
+const openai = new openai_1.OpenAIApi(configuration);
+// function formatObject(obj: any): string {
+//     return Object.keys(obj).reduce((acc, key) => {
+//       return `${acc}${key}:\n${obj[key]}\n\n`;
+//     }, "");
+// }
+function createBasePrompt(apiFilePath, documentationPath) {
+    const apiText = fs_1.default.readFileSync(apiFilePath, 'utf8');
+    const documentationText = documentationPath ? fs_1.default.readFileSync(documentationPath, 'utf8') : '';
+    //console.time("Loading templates");
+    const createTaskPrompt = fs_1.default.readFileSync(path_1.default.join(__dirname, '../prompts/create-task-prompt.md'), 'utf8').replace("{{DOCUMENTATION}}", documentationText).replace("{{API}}", apiText);
+    //console.timeEnd("Loading templates")
+    return createTaskPrompt;
+}
+exports.createBasePrompt = createBasePrompt;
+// userChatHistory is not currently used but could be in the future.
+const generateCode = async function (queryText, userChatHistory, createTaskPrompt, apiPath, debug = false) {
+    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 '';
+    }
+};
+exports.generateCode = generateCode;
+let QuickJS = null;
+;
+async function createWithAPI(options) {
+    // 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, userChatHistory, currentContext = undefined) {
+            if (!queryText)
+                return '';
+            return await (0, exports.generateCode)(queryText, userChatHistory, createTaskPrompt.replace("{{CONTEXT}}", currentContext ? "```" + JSON.stringify(currentContext, null, 2) + "```" : ""), apiDefFilePath, debug);
+        },
+        runCode: async function (generatedCode) {
+            if (!QuickJS) {
+                // Create QuickJS
+                if (debug)
+                    console.log("Creating quick.js");
+                QuickJS = await (0, quickjs_emscripten_1.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 (0, sandbox_1.default)(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));
+            (0, sandbox_wrappers_1.rejectOpenPromises)(vm);
+            vm.dispose();
+        },
+        processRequest: async function (userQuery, currentContext = undefined) {
+            // Create prompt
+            if (debug) {
+                console.log("Query:", userQuery);
+            }
+            // Generate Code
+            console.time("Generate Task");
+            const generatedCode = await (0, exports.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;
+        }
+    };
+}
+const aimyapi = {
+    // Standard way of using the library
+    createWithAPI,
+    // functions for customized usage
+    createBasePrompt,
+    generateTask: exports.generateCode,
+    createSandbox: sandbox_1.default,
+};
+exports.default = aimyapi;

package/dist/lib/sandbox-wrappers.d.ts

@@ -0,0 +1,9 @@
+import "quickjs-emscripten";
+export declare function wrapPromise(vm: any, promise: Promise<any>, beginAsyncProcess: () => void, endAsyncProcess: () => void): any;
+export declare function rejectOpenPromises(vm: any): void;
+export declare function wrap(vm: any, value: any, context: object, beginAsyncProcess: () => void, endAsyncProcess: () => void): any;
+export declare function wrapObject(vm: any, obj: any, beginAsyncProcess: () => void, endAsyncProcess: () => void): any;
+export declare function wrapObjectWhitelist(vm: any, obj: any, whitelist: string[], beginAsyncProcess: () => void, endAsyncProcess: () => void): any;
+export declare function wrapArray(vm: any, arr: any[], beginAsyncProcess: () => void, endAsyncProcess: () => void): any;
+export declare function wrapGenericFunction(vm: any, fn: Function, context: object, beginAsyncProcess: () => void, endAsyncProcess: () => void): any;
+export declare function injectTimingFunctions(vm: any, cbAddedTimer: any, cbRemovedTimer: any, maxTimeout?: number): void;

package/dist/lib/sandbox-wrappers.js

@@ -0,0 +1,237 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.injectTimingFunctions = exports.wrapGenericFunction = exports.wrapArray = exports.wrapObjectWhitelist = exports.wrapObject = exports.wrap = exports.rejectOpenPromises = exports.wrapPromise = void 0;
+require("quickjs-emscripten");
+let promiseId = 0;
+let openPromises = {};
+function wrapPromise(vm, promise, beginAsyncProcess, endAsyncProcess) {
+    promiseId += 1;
+    const vmPromise = vm.newPromise();
+    vmPromise._promiseId = promiseId;
+    beginAsyncProcess();
+    promise.then((...args) => {
+        //console.log("Promised resolved", args);
+        endAsyncProcess();
+        const wrappedArgs = args.map((arg) => wrap(vm, arg, undefined, beginAsyncProcess, endAsyncProcess));
+        openPromises[vmPromise._promiseId] = null;
+        vmPromise.resolve(...wrappedArgs);
+        wrappedArgs.forEach((arg) => arg.dispose());
+    }).catch((...args) => {
+        //console.log("Promised rejected", args);
+        const wrappedArgs = args.map((arg) => wrap(vm, arg, undefined, beginAsyncProcess, endAsyncProcess));
+        vmPromise.reject(...wrappedArgs);
+        wrappedArgs.forEach((arg) => arg.dispose());
+        openPromises[vmPromise._promiseId] = null;
+    });
+    vmPromise.settled.then(() => {
+        endAsyncProcess();
+        vm.runtime.executePendingJobs();
+    });
+    openPromises[promiseId] = vmPromise;
+    return vmPromise.handle;
+}
+exports.wrapPromise = wrapPromise;
+function rejectOpenPromises(vm) {
+    for (const [id, promise] of Object.entries(openPromises)) {
+        if (promise !== null) {
+            promise.reject(vm.newError("Shutting down"));
+            openPromises[id] = null;
+        }
+    }
+    vm.runtime.executePendingJobs();
+}
+exports.rejectOpenPromises = rejectOpenPromises;
+function wrap(vm, value, context, beginAsyncProcess, endAsyncProcess) {
+    if (value === null) {
+        return null;
+    }
+    else if (typeof value === 'object' && typeof value.then === 'function') {
+        //console.log("Wrapped promise");
+        return wrapPromise(vm, value, beginAsyncProcess, endAsyncProcess);
+    }
+    else if (typeof value === "function") {
+        //console.log("Wrapped function")
+        return wrapGenericFunction(vm, value, context, beginAsyncProcess, endAsyncProcess);
+    }
+    else if (Array.isArray(value)) {
+        //console.log("Wrapped array")
+        return wrapArray(vm, value, beginAsyncProcess, endAsyncProcess);
+    }
+    else if (value === null) {
+        //console.log("Wrapped null")
+        return vm.null;
+    }
+    else if (typeof value === "object") {
+        //console.log("Wrapped object")
+        return wrapObject(vm, value, beginAsyncProcess, endAsyncProcess);
+    }
+    else if (typeof value === "string") {
+        //console.log("Wrapped string")
+        return vm.newString(value);
+    }
+    else if (typeof value === "number") {
+        //console.log("Wrapped number")
+        return vm.newNumber(value);
+    }
+    else if (typeof value === "bigint") {
+        //console.log("Wrapped bigint")
+        return vm.newBigInt(value);
+    }
+    else if (typeof value === "boolean") {
+        // since there is no newBoolean, we have to do this
+        return vm.evalCode(value ? "true" : "false").value;
+    }
+    else if (typeof value === "undefined") {
+        return vm.undefined;
+    }
+    else {
+        return null;
+    }
+}
+exports.wrap = wrap;
+function wrapObject(vm, obj, beginAsyncProcess, endAsyncProcess) {
+    const vmObject = vm.newObject();
+    for (const [key, value] of Object.entries(obj)) {
+        //console.log("wrapping", key, value)
+        let wrappedValue = wrap(vm, value, obj, beginAsyncProcess, endAsyncProcess);
+        if (wrappedValue !== null) {
+            vm.setProp(vmObject, key, wrappedValue);
+            if (wrappedValue != vm.undefined && wrappedValue != vm.null && wrappedValue.dispose) {
+                wrappedValue.dispose();
+            }
+        }
+    }
+    return vmObject;
+}
+exports.wrapObject = wrapObject;
+function wrapObjectWhitelist(vm, obj, whitelist, beginAsyncProcess, endAsyncProcess) {
+    const vmObject = vm.newObject();
+    whitelist.forEach((key) => {
+        const value = obj[key];
+        //console.log("wrapping", key, value)
+        const wrappedValue = wrap(vm, value, obj, beginAsyncProcess, endAsyncProcess);
+        if (wrappedValue !== null) {
+            vm.setProp(vmObject, key, wrappedValue);
+            if (wrappedValue != vm.undefined && wrappedValue != vm.null && wrappedValue.dispose) {
+                wrappedValue.dispose();
+            }
+        }
+    });
+    return vmObject;
+}
+exports.wrapObjectWhitelist = wrapObjectWhitelist;
+function wrapArray(vm, arr, beginAsyncProcess, endAsyncProcess) {
+    const vmArray = vm.newArray();
+    for (let i = 0; i < arr.length; i++) {
+        let wrappedValue = wrap(vm, arr[i], arr, beginAsyncProcess, endAsyncProcess);
+        vm.setProp(vmArray, i, wrappedValue);
+        if (wrappedValue != vm.undefined && wrappedValue != vm.null) {
+            wrappedValue.dispose();
+        }
+    }
+    return vmArray;
+}
+exports.wrapArray = wrapArray;
+function wrapGenericFunction(vm, fn, context = undefined, beginAsyncProcess, endAsyncProcess) {
+    const vmFn = vm.newFunction(fn.name, (...args) => {
+        const unwrappedArgs = args.map(vm.dump);
+        //console.log("Wrapped function called", fn.name, unwrappedArgs )
+        try {
+            const result = fn.call(context, ...unwrappedArgs);
+            //console.log("result", result);
+            const wrappedResult = wrap(vm, result, undefined, beginAsyncProcess, endAsyncProcess);
+            return wrappedResult;
+        }
+        catch (e) {
+            console.log("Error", e);
+        }
+    });
+    return vmFn;
+}
+exports.wrapGenericFunction = wrapGenericFunction;
+function injectTimingFunctions(vm, cbAddedTimer, cbRemovedTimer, maxTimeout = 600000) {
+    // Should we impose a limit on how long things can run for?
+    const timeoutFunctionHandles = {};
+    const _setTimeout = vm.newFunction("setTimeout", (vmFnHandle, timeoutHandle) => {
+        // Make a copy because otherwise vmFnHandle does not live long enough to call after the timeout
+        const vmFnHandleCopy = vmFnHandle.dup();
+        let timeout = vm.dump(timeoutHandle);
+        // cap timeout at max timeout
+        if (timeout > maxTimeout) {
+            timeout = maxTimeout;
+        }
+        // console.log("Sandbox calling timeout for: " + timeout);
+        cbAddedTimer();
+        const timeoutID = setTimeout(() => {
+            timeoutFunctionHandles[timeoutID.toString()] = null;
+            // callFunction(vmFnHandleCopy) will call the vm function
+            // in the context of the vm
+            // we pass vm.undefined because we need to pass something for the "this" argument
+            //console.log("Sandbox called timeout function")
+            cbRemovedTimer();
+            vm.callFunction(vmFnHandleCopy, vm.undefined);
+            vmFnHandleCopy.dispose();
+            vm.runtime.executePendingJobs();
+        }, timeout);
+        timeoutFunctionHandles[timeoutID.toString()] = vmFnHandleCopy;
+        return vm.newNumber(timeoutID);
+    });
+    vm.setProp(vm.global, "setTimeout", _setTimeout);
+    _setTimeout.dispose();
+    const intervalFunctionHandles = {};
+    const _setInterval = vm.newFunction("setInterval", (vmFnHandle, timeoutHandle) => {
+        // Make a copy because otherwise vmFnHandle does not live long enough to call after the timeout
+        const vmFnHandleCopy = vmFnHandle.dup();
+        let timeout = vm.dump(timeoutHandle);
+        // cap timeout at max timeout
+        if (timeout > maxTimeout) {
+            timeout = maxTimeout;
+        }
+        //console.log("Sandbox calling interval for: " + timeout);
+        const maxRepetitions = 99;
+        let repetitions = 0;
+        cbAddedTimer();
+        const intervalId = setInterval(() => {
+            repetitions += 1;
+            intervalFunctionHandles[intervalId.toString()] = null;
+            // callFunction(vmFnHandleCopy) will call the vm function
+            // in the context of the vm
+            // we pass vm.undefined because we need to pass something for the "this" argument
+            vm.callFunction(vmFnHandleCopy, vm.undefined);
+            vm.runtime.executePendingJobs();
+            if (repetitions > maxRepetitions) {
+                console.log("Sandbox interval exceeded max repetitions");
+                clearInterval(intervalId);
+                cbRemovedTimer();
+                return;
+            }
+        }, timeout);
+        intervalFunctionHandles[intervalId.toString()] = vmFnHandleCopy;
+        return vm.newNumber(intervalId);
+    });
+    vm.setProp(vm.global, "setInterval", _setInterval);
+    _setInterval.dispose();
+    const _clearTimeout = vm.newFunction("clearTimeout", (timeoutIdHandle) => {
+        const timeoutId = vm.dump(timeoutIdHandle);
+        const timeoutHandle = timeoutFunctionHandles[timeoutId.toString()];
+        if (timeoutHandle) {
+            cbRemovedTimer();
+            timeoutHandle.dispose();
+            clearTimeout(timeoutId);
+        }
+    });
+    vm.setProp(vm.global, "clearTimeout", _clearTimeout);
+    _clearTimeout.dispose();
+    const _clearInterval = vm.newFunction("clearInterval", (intervalIdHandle) => {
+        const intervalId = vm.dump(intervalIdHandle);
+        const intervalHandle = intervalFunctionHandles[intervalId.toString()];
+        if (intervalId) {
+            cbRemovedTimer();
+            intervalHandle.dispose();
+            clearInterval(intervalId);
+        }
+    });
+    vm.setProp(vm.global, "clearInterval", _clearInterval);
+    _clearInterval.dispose();
+}
+exports.injectTimingFunctions = injectTimingFunctions;