aimyapi 1.0.2 → 1.0.3

package/README.md

@@ -8,16 +8,13 @@ AIMyAPI will handle async operations and timers in your API object.
 
 ## About version 1.0 rewrite and motivation
 
-AIMyAPI was originally written at a time (circa ChatGPT 3.5 / GPT-4) before tool calling existed, before Claude code and codex and just before OpenAI released their code interpreter. LLM models have also gotten drastically better since. Some of the problems it originally aimed to solve are better solved today with simple tool calling. However, there is still a need to safely run small programs in a sandboxed way, reliable way. Tools are good if you have a set interface but there may be times that an agent needs to do some sorting or filtering, or an algorithm or analysis, or some repeatable workflow which isn't implemented by the available tool functions. Writing code allows the agent to do things it might not otherwise be able to do with tools alone. 
+AIMyAPI was originally written at a time (circa ChatGPT 3.5 / GPT-4) before tool calling existed, before Claude code and codex and just before OpenAI released their code interpreter. LLM models have also gotten drastically better since. Some of the problems it originally aimed to solve are better solved today with simple tool calling. However, there is still a need to safely run small programs in a sandboxed way, reliable way. Tools are good if you have a set interface but there may be times that an agent needs to do some sorting or filtering, or an algorithm or analysis, or some repeatable workflow which isn't implemented by the available tool functions. Writing code allows the agent to do things it might not otherwise be able to do with tools alone. Having the ability to write code allows the tools API surface to be smaller; it could simply be a set of CRUD operations.
 
-Having the ability to write code allows the tools API surface to be smaller; it could simply be a set of CRUD operations.
-
-The other advantage of writing code is privacy and security. When an agent executes code in a sandbox, it doesn't see any of the results*, API keys or other things you may want to keep hidden. When an agent uses tools, it sees all the parameters and results of the tool calls. Code can be audited for security and correctness before running it. Finally, code can encompass a series of operations, whereas tool calls need to be approved one at a time or just trusted often without knowing what will come next.
-
-*You'll have the option to hide logs and errors from the agent - logging can allow the agent to fix it's own coding mistakes and test the code, but it also allows information to leave the sandbox which you may want to limit depending on the sensitivity the data your api is handling. Another approach would be to implement a mocked version of your API that the agent can use to write code and debug against while keeping your real data hidden and safe from potentially destructive operations.
+The other advantage of writing code is privacy and security. When an agent executes code in a sandbox, it doesn't see any of the results*, API keys or other things you may want to keep hidden. When an agent uses tools, it sees all the parameters and results of the tool calls. Code can be audited for security and correctness before running it. Finally, code can encompass a series of operations, whereas tool calls need to be approved one at a time or just trusted, often without knowing what will come next.
 
 Version 1.0 updates AIMyAPI code generation to use the tool calling process for writing code. This allows the agent to check the code and run some tests or API calls before committing to a final version. This should result in better code since the previous model relied on the agent always being able to one-shot the code, which depended on it having a complete view of the problem before writing the code which wasn't always realistic. We could also update this process a bit to add "Plan" / "Build" / "Test" phases instead of just one code generation prompt.
 
+*You'll have the option to hide logs and errors from the agent - logging can allow the agent to fix it's own coding mistakes and test the code, but it also allows information to leave the sandbox which you may want to limit depending on the sensitivity the data your api is handling. Another approach would be to implement a mocked version of your API that the agent can use to write code and debug against while keeping your real data hidden and safe from potentially destructive operations.
 
 ## Quickstart
 

package/example/example1.ts

@@ -1,6 +1,5 @@
 import path from "path";
 import { AIMyAPI } from "../src";
-import * as APIExports from "./sales_api";
 import { API } from "./sales_api_impl";
 
 // Simpler example using no support for chat history; 
@@ -11,7 +10,6 @@ import { API } from "./sales_api_impl";
     const aimyapi = await AIMyAPI.createWithAPI({
         apiObject: api,
         apiGlobalName: "salesApi", // 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,

package/example/example2.ts

@@ -2,7 +2,7 @@
 
 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";
 
 // More complex fast food ordering example that uses chat history.
@@ -15,9 +15,8 @@ import { OrderingAPI } from "./ordering_api_impl";
         apiObject: orderingApi,
         apiGlobalName: "orderingApi",       // Should match whatever you declared as your global in your ordering api.
         apiGlobals: {
-            Menu: APIExports.Menu,
+            Menu: Menu,
         },
-        apiExports: APIExports,
         apiDefFilePath: path.join(__dirname, "./ordering_api.ts"),
         apiDocsPath: path.join(__dirname, "./ordering_api.md"),
         debug: false,

package/example/example3.ts

@@ -1,7 +1,7 @@
 
 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';
@@ -28,9 +28,8 @@ function getInput(query: string): Promise<string> {
         apiObject: orderingApi,
         apiGlobalName: "orderingApi",       // Should match whatever you declared as your global in your ordering api.
         apiGlobals: {
-            Menu: APIExports.Menu,
+            Menu: Menu,
         },
-        apiExports: APIExports,
         apiDefFilePath: path.join(__dirname, "./ordering_api.ts"),
         apiDocsPath: path.join(__dirname, "./ordering_api.md"),
         debug: false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aimyapi",
-  "version": "1.0.2",
+  "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",

package/src/index.ts

@@ -13,13 +13,13 @@ import { AutoParseableTool } from 'openai/lib/parser.js';
 import { ZodSchema, z } from 'zod';
 import { zodToJsonSchema } from 'zod-to-json-schema';
 
-const openai = new OpenAI();
+const openai = new OpenAI( { baseURL: process.env.OPENAI_API_BASE_URL || undefined, apiKey: process.env.OPENAI_API_KEY || undefined } );
 
 let QuickJS:QuickJSWASMModule | null = null;
 
 export interface AIMyAPIOptions {
     apiObject: object;
-    apiExports: object;
+    apiExports?: object;
     apiWhitelist?: string[];      // List of functions to expose to the user. Necessary to pass this yourself if you are extending your api from another class.
     apiGlobals?: object;
     apiDefFilePath: string;     // Full path to the api definition file so that it can be loaded into the prompt
@@ -222,7 +222,7 @@ async function createWithAPI(options:AIMyAPIOptions): Promise<AIMyAPIInstance> {
             apiGlobals: {},
             apiWhitelist: Object.getOwnPropertyNames(Object.getPrototypeOf(options.apiObject)).filter((f) => f !== "constructor" && !f.startsWith("_")),
             debug: false, 
-            model: process.env.OPENAI_API_MODEL ||"gpt-5.4-mini",
+            model: process.env.OPENAI_API_MODEL || "gpt-5.4-mini",
             additionalModelOptions: {},
             hideLogsFromAgent: false,
         },
@@ -274,9 +274,9 @@ async function createWithAPI(options:AIMyAPIOptions): Promise<AIMyAPIInstance> {
             }
         
             // Create sandbox           
-            const {vm, checkCode} = await createSandbox(QuickJS, {
+            const {vm, checkCode} = await createSandbox(QuickJS, apiExports ? {
                 [apiDefFilePath]: apiExports,
-            }, { 
+            } : undefined, { 
                 ...apiGlobals,
                 [apiGlobalName]: {
                     value: apiObject,
@@ -348,9 +348,9 @@ async function createWithAPI(options:AIMyAPIOptions): Promise<AIMyAPIInstance> {
         
             // Create sandbox           
             // NOTE: not sure why I have to replace the backslash here
-            const {vm, runCode: runTask, isAsyncProcessRunning} = await createSandbox(QuickJS, {
+            const {vm, runCode: runTask, isAsyncProcessRunning} = await createSandbox(QuickJS, apiExports ? {
                 [apiDefFilePath]: apiExports,
-            }, { 
+            } : undefined, { 
                 ...apiGlobals,
                 [apiGlobalName]: {
                     value: apiObject,