aimyapi 0.1.9 → 0.1.11

package/README.md

@@ -264,7 +264,7 @@ import path from "path";
         console.log(`Query: ${query}`)
 
         // generate the code for this query
-        const code = await aimyapi.generateCode(query, api._getHistory());
+        const codeResult = await aimyapi.generateCode(query, api._getHistory());
 
         api._addMessageToHistory({
             content: query,
@@ -273,13 +273,13 @@ import path from "path";
         });
 
         api._addMessageToHistory({
-            content: '```\n' + code + '\n```',
+            content: '```\n' + codeResult.loggableCode + '\n```',
             role: "assistant",
             name: "assistant",
         });
 
         // run the code in the sandbox
-        await aimyapi.runCode(code);
+        await aimyapi.runCode(codeResult.code);
     }
    
     await runQuery("How's the burger here?");
@@ -389,24 +389,20 @@ 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);
-    }
-})();
+api.print("I'm great, thanks for asking!");
 \`\`\`
+
 ```
 
 Aside from the code generation piece, documenting your API with clearly named functions and comments is important so that the LLM understands how it can be used. A big part of using AIMyAPI is testing out usecases and looking at the code that is generated. Problems can be solved by how you name your api, comments in the api, and examples.
 
 ## A note about history
 
-If you plan to use history, it is vital that you include the generated code in the history. Otherwise, the LLM will start to think that it doesn't need to generate code.
+If you plan to use history, it is vital that you include the generated code in the history. Otherwise, the LLM will start to think that it doesn't need to generate code. Logging is also necessary for keeping track of Id's from past requests so that future requests can leverage that information.
+
+See example2 for more an example on how to do this.
 
-In example2, note that responses to the user and relevant information is also added to the history so that the LLM can reference it for future queries.
+TODO: Add more details explaining how this is done.
 
 ## Safety notes:
 

package/dist/index.d.ts

@@ -1,7 +1,12 @@
 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 GenerateCodeResult {
+    code: string;
+    loggableCode: string;
+    rawResponse?: string;
+}
+export declare const generateCode: (queryText: string, userChatHistory: ChatCompletionRequestMessage[], createTaskPrompt: string, apiPath: string, debug?: boolean) => Promise<GenerateCodeResult>;
 export interface AIMyAPIOptions {
     apiObject: object;
     apiExports: object;
@@ -12,16 +17,17 @@ export interface AIMyAPIOptions {
     apiDocsPath?: string;
     debug?: boolean;
 }
-export interface CreateWithAPIExports {
-    generateCode: (queryText: string, userChatHistory: ChatCompletionRequestMessage[]) => Promise<string>;
+export interface AIMyAPIInstance {
+    options: AIMyAPIOptions;
+    generateCode: (queryText: string, userChatHistory: ChatCompletionRequestMessage[]) => Promise<GenerateCodeResult>;
     runCode: (task: string) => Promise<void>;
-    processRequest: (userQuery: string, context?: object) => Promise<string>;
+    processRequest: (userQuery: string, context?: object) => Promise<GenerateCodeResult>;
 }
-export interface AIMyAPIExports {
-    createWithAPI: (options: AIMyAPIOptions) => Promise<CreateWithAPIExports>;
+export interface AIMyAPIModuleExports {
+    createWithAPI: (options: AIMyAPIOptions) => Promise<AIMyAPIInstance>;
     createBasePrompt: (apiFilePath: string, documentationPath: string) => string;
-    generateCode: (queryText: string, userChatHistory: ChatCompletionRequestMessage[], createTaskPrompt: string, apiPath: string, debug: boolean) => Promise<string>;
+    generateCode: (queryText: string, userChatHistory: ChatCompletionRequestMessage[], createTaskPrompt: string, apiPath: string, debug: boolean) => Promise<GenerateCodeResult>;
     createSandbox: (QuickJS: QuickJSWASMModule, globals: any) => Promise<any>;
 }
-declare const aimyapi: AIMyAPIExports;
+declare const aimyapi: AIMyAPIModuleExports;
 export default aimyapi;

package/dist/index.js

@@ -32,7 +32,7 @@ exports.createBasePrompt = createBasePrompt;
 // FIXME: add an options parameter and allow specifying the token limit
 const generateCode = async function (queryText, userChatHistory, createTaskPrompt, apiPath, debug = false) {
     if (!queryText)
-        return;
+        return { code: '', loggableCode: '' };
     let generatedCode = '';
     const prompt = createTaskPrompt.replace("{{QUERY_TEXT}}", queryText);
     const messages = [
@@ -43,20 +43,11 @@ const generateCode = async function (queryText, userChatHistory, createTaskPromp
         ...userChatHistory,
         {
             role: "user",
-            content: `${queryText}`,
+            content: `${queryText}.\nRespond only with code enclosed in \`\`\`.`,
             name: "user"
         }
     ];
-    // 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: messages,
@@ -71,16 +62,18 @@ const generateCode = async function (queryText, userChatHistory, createTaskPromp
         // 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 '';
+        // error, no code detected inside the response
+        if (codeStart === -1 || codeEnd === -1 || codeStart === codeEnd) {
+            return { code: '', loggableCode: '', rawResponse: response };
+        }
         generatedCode = response.substring(codeStart + 3, codeEnd).replace('typescript', '');
-        generatedCode = generatedCode.replace("./api.ts", apiPath);
-        return generatedCode;
+        const codeHeader = `import * as ApiDefs from '${apiPath}'\n(async() {\n\ttry {`;
+        const codeFooter = `\n\t} catch(err) {\n\t\tconsole.error(err);\n\t}\n})();`;
+        return { code: codeHeader + generatedCode + codeFooter, loggableCode: generatedCode };
     }
     catch (err) {
         console.error(err);
-        console.log("Prompt", messages);
-        return '';
+        return { code: '', loggableCode: '' };
     }
 };
 exports.generateCode = generateCode;
@@ -101,9 +94,10 @@ async function createWithAPI(options) {
     const { apiObject, apiWhitelist, apiGlobalName, apiExports, apiDefFilePath, apiDocsPath, debug } = options;
     const createTaskPrompt = createBasePrompt(apiDefFilePath, apiDocsPath);
     return {
+        options,
         generateCode: async function (queryText, userChatHistory, currentContext = undefined) {
             if (!queryText)
-                return '';
+                return { code: '', loggableCode: '' };
             return await (0, exports.generateCode)(queryText, userChatHistory, createTaskPrompt.replace("{{CONTEXT}}", currentContext ? "```" + JSON.stringify(currentContext, null, 2) + "```" : ""), apiDefFilePath, debug);
         },
         runCode: async function (generatedCode) {
@@ -131,6 +125,9 @@ async function createWithAPI(options) {
                 }
             }, options.debug);
             try {
+                if (debug) {
+                    console.log("Running Code:\n", generatedCode);
+                }
                 const res = await runTask(generatedCode);
                 if (!res) {
                     console.error("Task unsuccessful");
@@ -160,11 +157,8 @@ async function createWithAPI(options) {
             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);
+            await this.runCode(generatedCode.code);
             console.timeEnd("Run Code");
             return generatedCode;
         }

package/example/example1.ts

@@ -14,17 +14,17 @@ import { API } from "./sales_api_impl";
         apiExports: APIExports,
         apiDefFilePath: path.join(__dirname, "./sales_api.ts"),
         apiDocsPath: path.join(__dirname, "./sales_api.md"),
-        debug: false,
+        debug: true,
     })
     
-    console.log("Print 'hello' three times.")
-    await aimyapi.processRequest("Print 'hello' three times.");
+    // console.log("Print 'hello' three times.")
+    // await aimyapi.processRequest("Print 'hello' three times.");
 
-    console.log("What month had the highest sales in 2020 for any business unit?")
-    await aimyapi.processRequest("What was our best month in 2020");
+    // console.log("What month had the highest sales in 2020 for any business unit?")
+    // 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("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

@@ -1,7 +1,7 @@
-import AIMyAPI from "../lib";
-import { OrderingAPI } from "./ordering_api_impl";
-import * as APIExports from "./ordering_api";
 import path from "path";
+import AIMyAPI, { GenerateCodeResult } from "../lib";
+import * as APIExports from "./ordering_api";
+import { OrderingAPI } from "./ordering_api_impl";
 
 // More complex fast food ordering example that uses chat history.
 // Fast food ordering example.
@@ -24,7 +24,7 @@ import path from "path";
         console.log(`Query: ${query}`)
 
         // generate the code for this query
-        const code = await aimyapi.generateCode(query, api._getHistory());
+        const codeResult:GenerateCodeResult = await aimyapi.generateCode(query, api._getHistory());
 
         api._addMessageToHistory({
             content: query,
@@ -33,13 +33,13 @@ import path from "path";
         });
 
         api._addMessageToHistory({
-            content: '```\n' + code.replace(options.apiDefFilePath, "./api.ts") + '\n```',
+            content: '```\n' + codeResult.loggableCode + '\n```',
             role: "assistant",
             name: "assistant",
         });
 
         // run the code in the sandbox
-        await aimyapi.runCode(code);
+        await aimyapi.runCode(codeResult.code);
     }
    
     await runQuery("How's the burger here?");

package/example/ordering_api.md

@@ -10,109 +10,83 @@ 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);
-    }
-})();
+orderingApi.respondToUser("I'm great, thanks for asking!");
 ```
 
 user: Add a hamburger with no cheese to my order
 
 assistant:
 ```
-import * as ApiDefs from './api.ts'
-(async() {
-    try {
-        const itemName = "Hamburger";
-		const item = ApiDefs.Menu.find((item) => item.name === itemName);
-		if (!item) {
-			throw new Error(`Item with name "${itemName}" not found`);
-		}
-
-        orderingApi.addItemToOrder(itemName, undefined, item.toppings.filter( topping => topping.name != "cheese") );
-        orderingApi.respondToUser("Ok, I added a Hamburger. What else would you like?");
-    } catch(e) {
-        console.error(e);
-    }
-})();
+const itemName = "Hamburger";
+const item = ApiDefs.Menu.find((item) => item.name === itemName);
+if (!item) {
+    throw new Error(`Item with name "${itemName}" not found`);
+}
+
+orderingApi.addItemToOrder(itemName, undefined, item.toppings.filter( topping => topping.name != "cheese") );
+orderingApi.respondToUser("Ok, I added a Hamburger. What else would you like?");
 ```
 
-assistant: Added Hamburger with id 1
+log: Added Hamburger with id 1
 
 user: I'd like a large pizza with mushrooms
 
 assistant:
 ```
-import * as ApiDefs from './api.ts'
-(async() {
-    try {
-        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.");
-    }
-})();
+orderingApi.addItemToOrder("Pizza", ["Large"], ["mushrooms"]);
+orderingApi.respondToUser("Ok, I added a Large Pizza with mushrooms");
 ```
 
 user: Add a hamburger with bacon
 
 assistant:
 ```
-import * as ApiDefs from './api.ts'
-(async() {
-    try {
-        const itemName = "Hamburger";
-		const item = ApiDefs.Menu.find((item) => item.name === itemName);
-		if (!item) {
-			throw new Error(`Item with name "${itemName}" not found`);
-		}
-
-        orderingApi.addItemToOrder(itemName, undefined, [...item.toppings, "bacon"]);
-        orderingApi.respondToUser("Ok, I added a Hamburger with no cheese or onions. What else would you like?");
-    } catch(e) {
-        console.error(e);
-    }
-})();
+const itemName = "Hamburger";
+const item = ApiDefs.Menu.find((item) => item.name === itemName);
+if (!item) {
+    throw new Error(`Item with name "${itemName}" not found`);
+}
+
+orderingApi.addItemToOrder(itemName, undefined, [...item.toppings, "bacon"]);
+orderingApi.respondToUser("Ok, I added a Hamburger with no cheese or onions. What else would you like?");
 ```
 
-assistant: Added Hamburger with id 2
+log: Added Hamburger with id 2
 
 user: Add jalapenos to that
 
 assistant: 
 ```
-import * as ApiDefs from './api.ts'
-(async() {
-    try {
-        const existingItem = orderingApi.getItemInOrder("2");
-
-        if(existingItem) {
-            orderingApi.modifyItemInOrder("2", 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);
-    }
-})();
+const existingItem = orderingApi.getItemInOrder("2");
+
+if(existingItem) {
+    orderingApi.modifyItemInOrder("2", 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.");
+}
 ```
 
+user: Add a hamburger with no lettuce
+
+assistant:
+```
+const itemName = "Hamburger";
+const item = ApiDefs.Menu.find((item) => item.name === itemName);
+if (!item) {
+    throw new Error(`Item with name "${itemName}" not found`);
+}
+
+orderingApi.addItemToOrder(itemName, undefined, [...item.toppings.filter(topping => topping != "lettuce")]);
+orderingApi.respondToUser("Ok, I added a Hamburger with no cheese or onions. What else would you like?");
+```
+
+log: Added Hamburger with id 2
+
+
 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);
-    }
-})();
+orderingApi.respondToUser("I'm sorry, but that isn't on our menu.");
 ```

package/example/ordering_api_impl.ts

@@ -87,12 +87,13 @@ export class OrderingAPI implements OrderingAPIInterface {
 
 		this._history.push({
 			role: "user",
-			content: `I see you have added added ${itemName} with id ${newItem.orderId}`,
+			name: "log",
+			content: `added added ${itemName} with id ${newItem.orderId}`,
 		});
 		this.displayItem(newItem, true);
 	}
 
-    getItemInOrder(itemOrderId: string): MenuItemBase {
+    getItemInOrder(itemOrderId: string): MenuItemBase | undefined {
         const item = this._order.find((item) => item.orderId === itemOrderId);
         if (!item) {
             return undefined;
@@ -106,7 +107,8 @@ export class OrderingAPI implements OrderingAPIInterface {
 
 		this._history.push({
 			role: "user",
-			content: `I see you have removed item ${itemOrderId}`,
+			name: "log",
+			content: `removed item ${itemOrderId}`,
 		});
 		this.respondToUser(`Removed item ${itemOrderId}`);
 	}
@@ -140,7 +142,8 @@ export class OrderingAPI implements OrderingAPIInterface {
 
 		this._history.push({
 			role: "user",
-			content: `I see you have modified item ${itemOrderId}`,
+			name: "log",
+			content: `modified item ${itemOrderId}`,
 		});
 		this.respondToUser(`Modified item ${itemOrderId}`);
 	}
@@ -188,7 +191,7 @@ export class OrderingAPI implements OrderingAPIInterface {
 	displayOrder() {
 		this.respondToUser("----\n\nDisplaying order:\n\n");
 		this._order.forEach((item) => this.displayItem(item));
-		this.respondToUser(`--\tTotal:\t\t$${this.getOrderTotal()}`);
+		this.respondToUser(`--\tTotal:\t\t$${this.getOrderTotal().toFixed(2)}`);
 	}
 
 	_addMessageToHistory(message: ChatCompletionRequestMessage) {

package/example/sales_api.md

@@ -4,12 +4,5 @@ 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);
-    }
-})();
+api.print("I'm great, thanks for asking!");
 ```

package/lib/index.ts

@@ -31,10 +31,16 @@ export function createBasePrompt(apiFilePath:string, documentationPath: string):
     return createTaskPrompt;
 }
 
+export interface GenerateCodeResult {
+    code: string;
+    loggableCode: string;
+    rawResponse?: string;
+}
+
 // FIXME: add an options parameter and allow specifying the token limit
-export const generateCode = async function(queryText:string, userChatHistory:ChatCompletionRequestMessage[], createTaskPrompt:string, apiPath:string, debug:boolean = false): Promise<string> {
+export const generateCode = async function(queryText:string, userChatHistory:ChatCompletionRequestMessage[], createTaskPrompt:string, apiPath:string, debug:boolean = false): Promise<GenerateCodeResult> {
     if(!queryText)
-        return;
+        return { code: '', loggableCode: '' };
 
     let generatedCode = '';
     const prompt = createTaskPrompt.replace("{{QUERY_TEXT}}", queryText);
@@ -46,21 +52,11 @@ export const generateCode = async function(queryText:string, userChatHistory:Cha
         ...userChatHistory,
         {
             role: "user",
-            content: `${queryText}`,
+            content: `${queryText}.\nRespond only with code enclosed in \`\`\`.`,
             name: "user"
         }
     ];
-    // 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: messages,
@@ -81,17 +77,19 @@ export const generateCode = async function(queryText:string, userChatHistory:Cha
         const codeStart = response.indexOf('```');
         const codeEnd = response.lastIndexOf('```');
 
-        if(codeStart === -1 || codeEnd === -1 || codeStart === codeEnd)
-            return '';
+        // error, no code detected inside the response
+        if(codeStart === -1 || codeEnd === -1 || codeStart === codeEnd) {
+            return { code: '', loggableCode: '', rawResponse: response };
+        }
 
         generatedCode = response.substring(codeStart + 3, codeEnd).replace('typescript', '');
        
-        generatedCode = generatedCode.replace("./api.ts", apiPath);
-        return generatedCode;
+        const codeHeader = `import * as ApiDefs from '${apiPath}'\n(async() {\n\ttry {`;
+        const codeFooter = `\n\t} catch(err) {\n\t\tconsole.error(err);\n\t}\n})();`;
+        return { code: codeHeader + generatedCode + codeFooter, loggableCode: generatedCode };
     } catch(err) {
         console.error(err);
-        console.log("Prompt", messages);
-        return '';
+        return { code: '', loggableCode: '' };
     } 
 };
 
@@ -108,16 +106,17 @@ export interface AIMyAPIOptions {
     debug?: boolean;
 };
 
-export interface CreateWithAPIExports {
+export interface AIMyAPIInstance {
     // see xample 2
-    generateCode: (queryText:string, userChatHistory:ChatCompletionRequestMessage[]) => Promise<string>;
+    options:AIMyAPIOptions;
+    generateCode: (queryText:string, userChatHistory:ChatCompletionRequestMessage[]) => Promise<GenerateCodeResult>;
     runCode: (task:string) => Promise<void>;
     // run a single request with no history
-    processRequest: (userQuery:string, context?: object) => Promise<string>;
+    processRequest: (userQuery:string, context?: object) => Promise<GenerateCodeResult>;
     
 }
 
-async function createWithAPI(options:AIMyAPIOptions): Promise<CreateWithAPIExports> {
+async function createWithAPI(options:AIMyAPIOptions): Promise<AIMyAPIInstance> {
     // extend options with defaults
     options = {
         apiGlobalName: "api",
@@ -136,9 +135,10 @@ async function createWithAPI(options:AIMyAPIOptions): Promise<CreateWithAPIExpor
     const createTaskPrompt = createBasePrompt( apiDefFilePath, apiDocsPath);
 
     return {
+        options,
         generateCode: async function(queryText:string, userChatHistory:ChatCompletionRequestMessage[], currentContext:any = undefined) {
             if(!queryText)
-                return '';
+                return { code: '', loggableCode: '' };
 
             return await generateCode(queryText, userChatHistory, createTaskPrompt.replace("{{CONTEXT}}", currentContext ? "```" + JSON.stringify(currentContext, null, 2) + "```" : ""), apiDefFilePath, debug);
         },
@@ -171,6 +171,10 @@ async function createWithAPI(options:AIMyAPIOptions): Promise<CreateWithAPIExpor
             }, options.debug);
 
             try {
+                if(debug) {
+                    console.log("Running Code:\n", generatedCode);
+                }
+
                 const res = await runTask(generatedCode);
         
                 if(!res) {
@@ -196,7 +200,7 @@ async function createWithAPI(options:AIMyAPIOptions): Promise<CreateWithAPIExpor
             vm.dispose()             
         
         }, 
-        processRequest: async function (userQuery, currentContext:any = undefined):Promise<string> {
+        processRequest: async function (userQuery, currentContext:any = undefined):Promise<GenerateCodeResult> {
             // Create prompt
             
             if(debug) {
@@ -205,15 +209,11 @@ async function createWithAPI(options:AIMyAPIOptions): Promise<CreateWithAPIExpor
         
             // Generate Code
             console.time("Generate Task")
-            const generatedCode = await generateCode(userQuery, [], createTaskPrompt.replace("{{CONTEXT}}", currentContext ? "```" + JSON.stringify(currentContext, null, 2) + "```" : "" ), apiDefFilePath);
+            const generatedCode:GenerateCodeResult = 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);
+            await this.runCode(generatedCode.code);
             console.timeEnd("Run Code")
 
             return generatedCode;
@@ -222,15 +222,15 @@ async function createWithAPI(options:AIMyAPIOptions): Promise<CreateWithAPIExpor
 
 }
 
-export interface AIMyAPIExports {
-    createWithAPI: (options:AIMyAPIOptions) => Promise<CreateWithAPIExports>;
+export interface AIMyAPIModuleExports {
+    createWithAPI: (options:AIMyAPIOptions) => Promise<AIMyAPIInstance>;
     
     createBasePrompt: (apiFilePath:string, documentationPath: string) => string;
-    generateCode: (queryText:string, userChatHistory:ChatCompletionRequestMessage[], createTaskPrompt:string, apiPath:string, debug:boolean) => Promise<string>;
+    generateCode: (queryText:string, userChatHistory:ChatCompletionRequestMessage[], createTaskPrompt:string, apiPath:string, debug:boolean) => Promise<GenerateCodeResult>;
     createSandbox: (QuickJS:QuickJSWASMModule, globals: any) => Promise<any>;
 }
 
-const aimyapi:AIMyAPIExports = {
+const aimyapi:AIMyAPIModuleExports = {
     // Standard way of using the library
     createWithAPI,      
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "aimyapi",
-  "version": "0.1.9",
-  "description": "AI My API! Use LLMs to create small programs that safely* run and make calls against your API.",
+  "version": "0.1.11",
+  "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.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "directories": {

package/prompts/create-task-prompt.md

@@ -1,5 +1,5 @@
 You are a helpful assistant who speaks only in Typescript.
-You fulfill user requests by writing code. 
+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:
@@ -11,6 +11,8 @@ Here is the API that you will use:
 
 Documentation:
 
+Note: the api definitions are available as `ApiDefs`;
+
 {{DOCUMENTATION}}
 
 Current Context: