aimyapi 0.1.0

package/lib/sandbox-wrappers.ts

@@ -0,0 +1,250 @@
+import "quickjs-emscripten";
+import { QuickJSDeferredPromise } from "quickjs-emscripten";
+
+
+let promiseId = 0;
+let openPromises = {};
+
+export function wrapPromise(vm, promise: Promise<any>, beginAsyncProcess: () => void, endAsyncProcess: () => void): any {
+  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
+}
+
+export function rejectOpenPromises(vm) {
+  for (const [id, promise ] of Object.entries(openPromises)) {
+    if (promise !== null) {
+      (promise as QuickJSDeferredPromise).reject(vm.newError("Shutting down"));
+      openPromises[id] = null;
+    }
+  }
+
+  vm.runtime.executePendingJobs();
+}
+
+export function wrap(vm, value: any, context: object,  beginAsyncProcess: () => void, endAsyncProcess: () => void): any {
+  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
+  }
+}
+
+export function wrapObject(vm, obj: any, beginAsyncProcess: () => void, endAsyncProcess: () => void): any {
+  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;
+}
+
+export function wrapObjectWhitelist(vm, obj: any, whitelist: string[], beginAsyncProcess: () => void, endAsyncProcess: () => void): any {
+  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;
+}
+
+export function wrapArray(vm, arr: any[], beginAsyncProcess: () => void, endAsyncProcess: () => void): any {
+  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;
+}
+
+export function wrapGenericFunction(vm, fn: Function, context: object = undefined, beginAsyncProcess: () => void, endAsyncProcess: () => void): any {
+  const vmFn = vm.newFunction(fn.name, (...args) => {
+    const unwrappedArgs: any[] = 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;
+}
+
+export function injectTimingFunctions(vm, cbAddedTimer, cbRemovedTimer, maxTimeout = 600000): void {
+  // 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();
+}

package/lib/sandbox.ts

@@ -0,0 +1,184 @@
+import "quickjs-emscripten";
+
+import * as ts from "typescript";
+import {
+  injectTimingFunctions,
+  wrap,
+  wrapObject,
+  wrapObjectWhitelist,
+} from "./sandbox-wrappers";
+
+// Should we use "noEmitOnError": true ?
+function tsCompile(
+  source: string,
+  options: ts.TranspileOptions = null
+): string {
+  // 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;
+}
+
+export interface GlobalOption {
+  value: any;
+  whitelist?: string[];
+}
+
+export interface Globals {
+  [key: string]: GlobalOption;
+}
+
+// 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..
+export default async function createSandbox(QuickJS, requireLookup:any = {}, globals: Globals = {}, debug:boolean = 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: GlobalOption = globals[globalNames[i]];
+    const globalObj = globalOption.whitelist
+      ? wrapObjectWhitelist(
+          vm,
+          globalOption.value,
+          globalOption.whitelist,
+          beginAsyncProcess,
+          endAsyncProcess
+        )
+      : wrap(vm, globalOption.value, globalOption, beginAsyncProcess, endAsyncProcess);
+
+    vm.setProp(vm.global, globalNames[i], globalObj);
+    globalObj.dispose();
+  }
+
+  injectTimingFunctions(vm, beginAsyncProcess, endAsyncProcess);
+
+  const requireHandle = vm.newFunction("require", (...args) => {
+    const nativeArgs = args.map(vm.dump);
+    if(requireLookup[nativeArgs[0] as string]) {
+      const returnObj = wrapObject(vm, requireLookup[nativeArgs[0] as string], 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: string): boolean => {
+      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;
+    },
+  };
+}

package/lib/utils.ts

@@ -0,0 +1,3 @@
+export function delay(time):Promise<void> {
+    return new Promise<void>(resolve => setTimeout(resolve, time));
+} 

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "aimyapi",
+  "version": "0.1.0",
+  "description": "AI My API! Use LLMs to create small programs that safely* run and make calls against your API.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "directories": {
+    "lib": "lib"
+  },
+  "scripts": {
+    "example1": "ts-node ./example/example1.ts",
+    "example2": "ts-node ./example/example2.ts",
+    "example3": "ts-node ./example/example3.ts",
+    "build": "tsc"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/WhiteNoise/aimyapi.git"
+  },
+  "keywords": [
+    "AI",
+    "LLM",
+    "OpenAI"
+  ],
+  "dependencies": {
+    "dotenv": "^16.0.3",
+    "openai": "^3.2.1",
+    "quickjs-emscripten": "^0.22.0",
+    "typescript": "^5.0.3"
+  },
+  "author": "David Wallin",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/WhiteNoise/aimyapi/issues"
+  },
+  "homepage": "https://github.com/WhiteNoise/aimyapi#readme",
+  "devDependencies": {
+    "@types/node": "^18.16.2",
+    "ts-node": "^10.9.1"
+  }
+}

package/prompts/create-task-prompt.md

@@ -0,0 +1,21 @@
+You are an expert coder, writing typescript code to accomplish tasks for the user.
+We fulfill user requests by writing code that does what the user asked by performing operations on an API.
+Respond only with code - do not include any extra explanations or questions outside of the code.
+if you need to talk to the user, do so using functions provided by the API.
+You comment your code and are sure to properly escape your strings and follow good programming practices.
+
+Here is the API that you will use:
+
+`api.ts`:
+```
+{{API}}
+```
+
+Documentation:
+
+{{DOCUMENTATION}}
+
+Current Context:
+```
+{{CONTEXT}}
+```

package/tsconfig.json

@@ -0,0 +1,12 @@
+{
+    "compilerOptions": {
+        "target": "ES2021" /* Node 16+ per https://github.com/microsoft/TypeScript/wiki/Node-Target-Mapping */,
+        "module": "nodenext" /* Some imports are really imports: https://www.typescriptlang.org/docs/handbook/esm-node.html */,
+        "moduleResolution": "nodenext" /* Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6). */,
+        "lib": ["ES2021", "dom"] /* Specify library files to be included in the compilation. */,
+        "outDir": "dist" /* Redirect output structure to the directory. */,
+        "declaration": true
+    },
+    "include": ["**/*.ts"],
+    "exclude": ["**/node_modules"]    
+}