aimyapi 0.2.1 → 1.0.3

package/example/example2.ts

@@ -1,19 +1,22 @@
+// Note: This example is quite stupid and slow and you'd be better off using Tool calling for something like this, but I'm leaving it for demonstration purposes
+
 import path from "path";
-import { AIMyAPI, GenerateCodeResult } from "../src";
-import * as APIExports from "./ordering_api";
+import { AIMyAPI } from "../src";
+import { Menu } from "./ordering_api";
 import { OrderingAPI } from "./ordering_api_impl";
 
 // More complex fast food ordering example that uses chat history.
 // Fast food ordering example.
 
-// IDEA: If the order history becomes too long, we could summarize it by listing the current order state and remove the rest.
 (async () => {
-    const api = new OrderingAPI();
+    const orderingApi = new OrderingAPI();
 
     const options = {
-        apiObject: api,
+        apiObject: orderingApi,
         apiGlobalName: "orderingApi",       // Should match whatever you declared as your global in your ordering api.
-        apiExports: APIExports,
+        apiGlobals: {
+            Menu: Menu,
+        },
         apiDefFilePath: path.join(__dirname, "./ordering_api.ts"),
         apiDocsPath: path.join(__dirname, "./ordering_api.md"),
         debug: false,
@@ -24,22 +27,29 @@ import { OrderingAPI } from "./ordering_api_impl";
         console.log(`Query: ${query}`)
 
         // generate the code for this query
-        const codeResult:GenerateCodeResult = await aimyapi.generateCode(query, api._getHistory());
-
-        api._addMessageToHistory({
-            content: query,
-            role: "user",
-            name: "user",
-        });
-
-        api._addMessageToHistory({
-            content: '```\n' + codeResult.loggableCode + '\n```',
-            role: "assistant",
-            name: "assistant",
-        });
-
-        // run the code in the sandbox
-        await aimyapi.runCode(codeResult.code);
+        const codeResult = await aimyapi.generateCode(query, orderingApi._getHistory());
+
+        if(codeResult) {
+            orderingApi._addMessageToHistory({
+                content: query,
+                role: "user",
+                name: "user",
+            });
+
+            orderingApi._addMessageToHistory({
+                content: codeResult.comments || "done",
+                role: "assistant",
+                name: "assistant",
+            });
+
+            // run the code in the sandbox
+            if(codeResult.code) {
+                await aimyapi.runCode(codeResult.code);
+            }
+        } else {
+            console.error("No code generated for this query.");
+        }
+
     }
    
     await runQuery("How's the burger here?");

package/example/example3.ts

@@ -1,12 +1,12 @@
 
 import path from "path";
 import { AIMyAPI } from "../src";
-import * as APIExports from "./ordering_api";
+import { Menu } from "./ordering_api";
 import { OrderingAPI } from "./ordering_api_impl";
 
 import readline from 'readline';
 
-function getInput(query): Promise<string> {
+function getInput(query: string): Promise<string> {
     const rl = readline.createInterface({
         input: process.stdin,
         output: process.stdout,
@@ -20,14 +20,16 @@ function getInput(query): Promise<string> {
 
 // More complex fast food ordering example that uses chat history.
 // Fast food ordering example.
-// Interactive version
+// -- Interactive version
 (async () => {
-    const api = new OrderingAPI();
+    const orderingApi = new OrderingAPI();
     
     const options = {
-        apiObject: api,
+        apiObject: orderingApi,
         apiGlobalName: "orderingApi",       // Should match whatever you declared as your global in your ordering api.
-        apiExports: APIExports,
+        apiGlobals: {
+            Menu: Menu,
+        },
         apiDefFilePath: path.join(__dirname, "./ordering_api.ts"),
         apiDocsPath: path.join(__dirname, "./ordering_api.md"),
         debug: false,
@@ -38,26 +40,30 @@ function getInput(query): Promise<string> {
         console.log(`Query: ${query}`)
 
         // generate the code for this query
-        const result = await aimyapi.generateCode(query, api._getHistory());
+        const result = await aimyapi.generateCode(query, orderingApi._getHistory());
 
-        api._addMessageToHistory({
-            content: query,
-            role: "user",
-            name: "user",
-        });
+        if(result) {
+            orderingApi._addMessageToHistory({
+                content: query,
+                role: "user",
+                name: "user",
+            });
 
-        api._addMessageToHistory({
-            content: '```\n' + result.code.replace(options.apiDefFilePath, "./api.ts") + '\n```',
-            role: "assistant",
-            name: "assistant",
-        });
+            orderingApi._addMessageToHistory({
+                content: result.comments || "done",
+                role: "assistant",
+                name: "assistant",
+            });
 
-        // run the code in the sandbox
-        await aimyapi.runCode(result.code);
+            // run the code in the sandbox
+            if(result.code) {
+                await aimyapi.runCode(result.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) {
+    while (!orderingApi._isCompleted) {
         const query:string = await getInput("Your query: ");
         await runQuery(query);
     }

package/example/ordering_api.md

@@ -1,24 +1,26 @@
-You are an order taking assistant at a restaurant. 
+# Documentation
+
+You work 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:
+## Examples of how you should respond:
 
 user: How are you today?
 
-assistant:
-```
+code:
+```typescript
 orderingApi.respondToUser("I'm great, thanks for asking!");        
 ```
 
 user: Add a hamburger with no cheese to my order
 
-assistant:
-```
+code:
+```typescript
 const itemName = "Hamburger";
-const item = ApiDefs.Menu.find((item) => item.name === itemName);
+const item = Menu.find((item) => item.name === itemName);
 if (!item) {
     throw new Error(`Item with name "${itemName}" not found`);
 }
@@ -31,18 +33,18 @@ log: Added Hamburger with id 1
 
 user: I'd like a large pizza with mushrooms
 
-assistant:
-```
+code:
+```typescript
 orderingApi.addItemToOrder("Pizza", ["Large"], ["mushrooms"]);
 orderingApi.respondToUser("Ok, I added a Large Pizza with mushrooms");        
 ```
 
 user: Add a hamburger with bacon
 
-assistant:
-```
+code:
+```typescript
 const itemName = "Hamburger";
-const item = ApiDefs.Menu.find((item) => item.name === itemName);
+const item = Menu.find((item) => item.name === itemName);
 if (!item) {
     throw new Error(`Item with name "${itemName}" not found`);
 }
@@ -55,8 +57,8 @@ log: Added Hamburger with id 2
 
 user: Add jalapenos to that
 
-assistant: 
-```
+code: 
+```typescript
 const existingItem = orderingApi.getItemInOrder("2");
 
 if(existingItem) {
@@ -69,10 +71,10 @@ if(existingItem) {
 
 user: Add a hamburger with no lettuce
 
-assistant:
-```
+code:
+```typescript
 const itemName = "Hamburger";
-const item = ApiDefs.Menu.find((item) => item.name === itemName);
+const item = Menu.find((item) => item.name === itemName);
 if (!item) {
     throw new Error(`Item with name "${itemName}" not found`);
 }
@@ -86,7 +88,7 @@ log: Added Hamburger with id 2
 
 user: I want an elephant.
 
-assistant:
-```
+code:
+```typescript
 orderingApi.respondToUser("I'm sorry, but that isn't on our menu.");        
 ```

package/example/ordering_api.ts

@@ -184,7 +184,8 @@ export interface OrderingAPIInterface {
 
 };
 
-// Global object you will use for accessing the APIInterface
+// Global object for accessing the OrderingAPIInterface
 declare global {
-    var orderingApi: OrderingAPIInterface;
+    const orderingApi: OrderingAPIInterface;
+    const Menu: MenuItemBase[];
 }

package/example/ordering_api_impl.ts

@@ -7,7 +7,7 @@ import {
 	OrderingAPIInterface,
 } from "./ordering_api";
 
-// TODO: make functions to print out an item, and print out the current order with the price totals.
+// TODO: Typescript typing could be better on this API and it would probably benefit the agent.
 
 export class OrderingAPI implements OrderingAPIInterface {
 	private _order: MenuItemBase[] = [];
@@ -66,6 +66,7 @@ export class OrderingAPI implements OrderingAPIInterface {
 			throw new Error(`Item with name "${itemName}" not found`);
 		}
 
+		// FIXME: we shouldn't allow adding an item with customizations that aren't in the allowedCustomizations list for that item
 		const customizations = customizationNames ? customizationNames
 			.map((customizationName) => {
 				return this.getCustomizationByName(itemName, customizationName);

package/example/sales_api.md

@@ -1,10 +1,5 @@
-Use `api.getSalesData()` to get the sales data array.
+## Examples:
 
-Examples of how you should respond:
+to print hello:
 
-user: How are you today?
-
-assistant:
-```
-api.print("I'm great, thanks for asking!");
-```
+submitCode("salesApi.print(\"Hello\")");

package/example/sales_api.ts

@@ -23,7 +23,7 @@ export interface APIInterface {
 
 };
 
-// Global object you will use for accessing the APIInterface
+// Global object for accessing the APIInterface
 declare global {
-    var api: APIInterface;
+    const salesApi: APIInterface;
 }

package/example/sales_api_impl.ts

@@ -51,7 +51,7 @@ export class API implements APIInterface {
     };
 
     print(text: string): void {
-        console.log(text);
+        console.log(`[API]: ${text}`);
     }
     delay(milliseconds: number): Promise<void> {
         return delay(milliseconds);

package/package.json

@@ -1,18 +1,18 @@
 {
   "name": "aimyapi",
-  "version": "0.2.1",
-  "description": "AI My API! Use LLMs to create small programs that safely* run and make calls against your API. Similar to ChatGPT's Code Interpreter.",
+  "version": "1.0.3",
+  "description": "AI My API! Typescript sandbox for AI agents to interact with your API in a safe way.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
-  "module": "./dist/index.mjs",  
+  "module": "./dist/index.mjs",
   "exports": {
     "require": {
-        "types": "./dist/index.d.cts",
-        "default": "./dist/index.cjs"
+      "types": "./dist/index.d.cts",
+      "default": "./dist/index.cjs"
     },
     "import": {
-        "types": "./dist/index.d.mts",
-        "default": "./dist/index.mjs"
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
     }
   },
   "directories": {
@@ -35,9 +35,11 @@
   ],
   "dependencies": {
     "dotenv": "^16.0.3",
-    "openai": "^4.61.0",
+    "openai": "^6.33.0",
     "quickjs-emscripten": "^0.22.0",
-    "typescript": "^5.0.3"
+    "typescript": "^5.0.3",
+    "zod": "^3.23.8",
+    "zod-to-json-schema": "^3.23.3"
   },
   "author": "David Wallin",
   "license": "MIT",
@@ -46,7 +48,7 @@
   },
   "homepage": "https://github.com/WhiteNoise/aimyapi#readme",
   "devDependencies": {
-    "@types/node": "^18.16.2",
+    "@types/node": "^18.19.130",
     "pkgroll": "^2.5.0",
     "tsx": "^4.19.1"
   }

package/prompts/create-task-prompt.md

@@ -1,32 +1,30 @@
-You are a helpful assistant who speaks only in Typescript.
-You work just like a regular assistant, but you fulfill user requests by writing code. 
-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:
+Most recent user query: 
+```
+{{USER_QUERY}}
+```
+
+Based on the above conversation, write a typescript script that performs the next operation requested by the user. 
+
+Here's the typescript API to use for your script.
 
 `api.ts`:
-```
+```typescript
 {{API}}
 ```
 
-Documentation:
+Use the global api object to make calls to the API.
+You may use top level `await`. 
 
-Write your code in this format:
-```
-import * as ApiDefs from 'api.ts'
-
-(async() {
-    try {
-        // ... your code here
-    } catch(err) { 
-        console.error(err); 
-    }
-})();
-```
+If needed, gather any information you need to complete the request. 
+You may use `runCode` to run any non-destructive API calls to understand what you need to do. Nothing will be returned unless you `console.log` it.
+In your code, `console.log` and `console.error` can be used to understand the execution or indicate that an error happened, but debug logs should be removed in the final version.
+You can use the `checkCode` tool to confirm that the code passes the typescript compilation and doesn't have errors
+You can call `submitCode` to submit the final version of the code.
+
+---
 
 {{DOCUMENTATION}}
 
-Contextual data:
-```
 {{CONTEXT}}
-```
+