@misterscan/sesi 1.1.2 → 1.2.0

package/dist/sesi.bundled.js

@@ -1,3 +1,4 @@
+#!/usr/bin/env node
 "use strict";
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -12552,6 +12553,7 @@ var require_parser = __commonJS({
           modelName,
           config,
           prompt,
+          images: config?.images,
           line
         };
       }
@@ -12633,6 +12635,7 @@ var require_parser = __commonJS({
           modelName,
           config,
           prompt,
+          images: config?.images,
           line
         };
       }
@@ -12910,7 +12913,7 @@ var require_builtins = __commonJS({
     var fs3 = __importStar(require("fs"));
     var path2 = __importStar(require("path"));
     var child_process_1 = require("child_process");
-    function getBuiltins() {
+    function getBuiltins(interpreter) {
       const builtins = /* @__PURE__ */ new Map();
       builtins.set("print", {
         type: "function",
@@ -12990,6 +12993,36 @@ var require_builtins = __commonJS({
           }
         }
       });
+      builtins.set("from_json", {
+        type: "function",
+        name: "from_json",
+        params: [{ name: "string" }],
+        body: {},
+        closure: {},
+        isBuiltin: true,
+        builtin: (str) => {
+          if (typeof str !== "string")
+            return null;
+          try {
+            return JSON.parse(str);
+          } catch (e2) {
+            return null;
+          }
+        }
+      });
+      builtins.set("exp", {
+        type: "function",
+        name: "exp",
+        params: [{ name: "x" }],
+        body: {},
+        closure: {},
+        isBuiltin: true,
+        builtin: (x2) => {
+          if (typeof x2 !== "number")
+            return null;
+          return Math.exp(x2);
+        }
+      });
       builtins.set("num", {
         type: "function",
         name: "num",
@@ -13121,14 +13154,14 @@ var require_builtins = __commonJS({
         body: {},
         closure: {},
         isBuiltin: true,
-        builtin: (filePath2) => {
-          if (typeof filePath2 !== "string")
+        builtin: (filePath) => {
+          if (typeof filePath !== "string")
             return null;
           try {
-            const absolutePath = path2.resolve(process.cwd(), filePath2);
+            const absolutePath = path2.resolve(process.cwd(), filePath);
             return fs3.readFileSync(absolutePath, "utf-8");
           } catch (e2) {
-            throw new Error(`Failed to read file: ${filePath2}`);
+            throw new Error(`Failed to read file: ${filePath}`);
           }
         }
       });
@@ -13139,15 +13172,15 @@ var require_builtins = __commonJS({
         body: {},
         closure: {},
         isBuiltin: true,
-        builtin: (filePath2, content) => {
-          if (typeof filePath2 !== "string" || typeof content !== "string")
+        builtin: (filePath, content) => {
+          if (typeof filePath !== "string" || typeof content !== "string")
             return null;
           try {
-            const absolutePath = path2.resolve(process.cwd(), filePath2);
+            const absolutePath = path2.resolve(process.cwd(), filePath);
             fs3.writeFileSync(absolutePath, content, "utf-8");
             return true;
           } catch (e2) {
-            throw new Error(`Failed to write file: ${filePath2}`);
+            throw new Error(`Failed to write file: ${filePath}`);
           }
         }
       });
@@ -13158,16 +13191,16 @@ var require_builtins = __commonJS({
         body: {},
         closure: {},
         isBuiltin: true,
-        builtin: (filePath2, content) => {
-          if (typeof filePath2 !== "string" || typeof content !== "string")
+        builtin: (filePath, content) => {
+          if (typeof filePath !== "string" || typeof content !== "string")
             return null;
           try {
-            const absolutePath = path2.resolve(process.cwd(), filePath2);
+            const absolutePath = path2.resolve(process.cwd(), filePath);
             const buffer = Buffer.from(content, "base64");
             fs3.writeFileSync(absolutePath, buffer);
             return true;
           } catch (e2) {
-            throw new Error(`Failed to write image: ${filePath2}`);
+            throw new Error(`Failed to write image: ${filePath}`);
           }
         }
       });
@@ -13220,11 +13253,11 @@ var require_builtins = __commonJS({
         body: {},
         closure: {},
         isBuiltin: true,
-        builtin: (filePath2) => {
-          if (typeof filePath2 !== "string")
+        builtin: (filePath) => {
+          if (typeof filePath !== "string")
             return null;
           try {
-            const absolutePath = path2.resolve(process.cwd(), filePath2);
+            const absolutePath = path2.resolve(process.cwd(), filePath);
             const sesiBin = path2.resolve(__dirname, "../bin/sesi.js");
             const child = (0, child_process_1.spawn)("node", [sesiBin, absolutePath], {
               detached: true,
@@ -13234,7 +13267,7 @@ var require_builtins = __commonJS({
             child.unref();
             return child.pid || true;
           } catch (e2) {
-            throw new Error(`Failed to spawn process: ${filePath2}`);
+            throw new Error(`Failed to spawn process: ${filePath}`);
           }
         }
       });
@@ -13273,6 +13306,86 @@ var require_builtins = __commonJS({
         isBuiltin: true,
         builtin: () => Math.random()
       });
+      builtins.set("web_get", {
+        type: "function",
+        name: "web_get",
+        params: [{ name: "url" }, { name: "headers", defaultValue: {} }],
+        body: {},
+        closure: {},
+        isBuiltin: true,
+        builtin: async (...args2) => {
+          const [urlVal, headersVal] = args2;
+          const url = typeof urlVal === "string" ? urlVal : "";
+          const headersObj = {};
+          if (headersVal && typeof headersVal === "object" && !Array.isArray(headersVal)) {
+            for (const [k, v] of Object.entries(headersVal)) {
+              headersObj[k] = String(v);
+            }
+          }
+          try {
+            const response = await fetch(url, {
+              method: "GET",
+              headers: headersObj
+            });
+            return await response.text();
+          } catch (e2) {
+            throw new Error(`web_get failed: ${e2.message}`);
+          }
+        }
+      });
+      builtins.set("web_send", {
+        type: "function",
+        name: "web_send",
+        params: [{ name: "url" }, { name: "body" }, { name: "headers", defaultValue: {} }],
+        body: {},
+        closure: {},
+        isBuiltin: true,
+        builtin: async (...args2) => {
+          const [urlVal, bodyVal, headersVal] = args2;
+          const url = typeof urlVal === "string" ? urlVal : "";
+          const body = typeof bodyVal === "string" ? bodyVal : JSON.stringify(bodyVal);
+          const headersObj = { "Content-Type": "application/json" };
+          if (headersVal && typeof headersVal === "object" && !Array.isArray(headersVal)) {
+            for (const [k, v] of Object.entries(headersVal)) {
+              headersObj[k] = String(v);
+            }
+          }
+          try {
+            const response = await fetch(url, {
+              method: "POST",
+              headers: headersObj,
+              body
+            });
+            return await response.text();
+          } catch (e2) {
+            throw new Error(`web_send failed: ${e2.message}`);
+          }
+        }
+      });
+      builtins.set("multi_req", {
+        type: "function",
+        name: "multi_req",
+        params: [{ name: "fns" }],
+        body: {},
+        closure: {},
+        isBuiltin: true,
+        builtin: async (...args2) => {
+          const [fnsVal] = args2;
+          if (!Array.isArray(fnsVal)) {
+            throw new Error("multi_req expects an array of functions");
+          }
+          if (!interpreter) {
+            throw new Error("multi_req interpreter reference is missing");
+          }
+          const promises = fnsVal.map(async (fn) => {
+            if (typeof fn !== "object" || fn === null || fn.type !== "function") {
+              throw new Error("multi_req elements must be functions");
+            }
+            return await interpreter.callSesiFunction(fn, []);
+          });
+          return await Promise.all(promises);
+        }
+      });
       return builtins;
     }
     function isTruthy(value) {
@@ -25413,9 +25526,9 @@ var require_util2 = __commonJS({
       });
       return object;
     }
-    async function isValidFile(filePath2) {
+    async function isValidFile(filePath) {
       try {
-        const stats = await fs3.promises.lstat(filePath2);
+        const stats = await fs3.promises.lstat(filePath);
         return stats.isFile();
       } catch (e2) {
         return false;
@@ -30105,16 +30218,16 @@ var require_pluggable_auth_handler = __commonJS({
         if (!this.outputFile || this.outputFile.length === 0) {
           return void 0;
         }
-        let filePath2;
+        let filePath;
         try {
-          filePath2 = await fs3.promises.realpath(this.outputFile);
+          filePath = await fs3.promises.realpath(this.outputFile);
         } catch {
           return void 0;
         }
-        if (!(await fs3.promises.lstat(filePath2)).isFile()) {
+        if (!(await fs3.promises.lstat(filePath)).isFile()) {
           return void 0;
         }
-        const responseString = await fs3.promises.readFile(filePath2, {
+        const responseString = await fs3.promises.readFile(filePath, {
           encoding: "utf8"
         });
         if (responseString === "") {
@@ -30836,22 +30949,22 @@ var require_googleauth = __commonJS({
        * @returns Promise that resolves with the OAuth2Client
        * @api private
        */
-      async _getApplicationCredentialsFromFilePath(filePath2, options = {}) {
-        if (!filePath2 || filePath2.length === 0) {
+      async _getApplicationCredentialsFromFilePath(filePath, options = {}) {
+        if (!filePath || filePath.length === 0) {
           throw new Error("The file path is invalid.");
         }
         try {
-          filePath2 = fs3.realpathSync(filePath2);
-          if (!fs3.lstatSync(filePath2).isFile()) {
+          filePath = fs3.realpathSync(filePath);
+          if (!fs3.lstatSync(filePath).isFile()) {
             throw new Error();
           }
         } catch (err) {
           if (err instanceof Error) {
-            err.message = `The file at ${filePath2} does not exist, or it is not a file. ${err.message}`;
+            err.message = `The file at ${filePath} does not exist, or it is not a file. ${err.message}`;
           }
           throw err;
         }
-        const readStream = fs3.createReadStream(filePath2);
+        const readStream = fs3.createReadStream(filePath);
         return this.fromStream(readStream, options);
       }
       /**
@@ -31163,8 +31276,8 @@ var require_googleauth = __commonJS({
         if (this.jsonContent) {
           return this._cacheClientFromJSON(this.jsonContent, this.clientOptions);
         } else if (this.keyFilename) {
-          const filePath2 = path2.resolve(this.keyFilename);
-          const stream = fs3.createReadStream(filePath2);
+          const filePath = path2.resolve(this.keyFilename);
+          const stream = fs3.createReadStream(filePath);
           return await this.fromStreamAsync(stream, this.clientOptions);
         } else if (this.apiKey) {
           const client = await this.fromAPIKey(this.apiKey, this.clientOptions);
@@ -53289,8 +53402,8 @@ ${underline}`);
        * @param filePath The path to the file.
        * @returns The MIME type of the file, or undefined if it cannot be inferred.
        */
-      inferMimeType(filePath2) {
-        const fileExtension = filePath2.slice(filePath2.lastIndexOf(".") + 1);
+      inferMimeType(filePath) {
+        const fileExtension = filePath.slice(filePath.lastIndexOf(".") + 1);
         const mimeTypes = {
           "aac": "audio/aac",
           "abw": "application/x-abiword",
@@ -53723,8 +53836,47 @@ ${underline}`);
 var require_ai_runtime = __commonJS({
   "dist/ai-runtime.js"(exports2) {
     "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m2, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m2, k);
+      if (!desc || ("get" in desc ? !m2.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m2[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m2, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m2[k];
+    }));
+    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports2 && exports2.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i2 = 0; i2 < k.length; i2++) if (k[i2] !== "default") __createBinding(result, mod, k[i2]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.aiRuntime = exports2.AIRuntime = void 0;
+    var fs3 = __importStar(require("fs"));
+    var path2 = __importStar(require("path"));
     var AIRuntime = class {
       constructor() {
         this._client = null;
@@ -53741,13 +53893,97 @@ var require_ai_runtime = __commonJS({
         }
         return this._client;
       }
+      getCacheFile() {
+        return path2.resolve(process.cwd(), ".sesi_cache.json");
+      }
+      readCache() {
+        const file = this.getCacheFile();
+        if (fs3.existsSync(file)) {
+          try {
+            return JSON.parse(fs3.readFileSync(file, "utf-8"));
+          } catch (e2) {
+            return {};
+          }
+        }
+        return {};
+      }
+      writeCache(cache) {
+        const file = this.getCacheFile();
+        try {
+          fs3.writeFileSync(file, JSON.stringify(cache, null, 2), "utf-8");
+        } catch (e2) {
+        }
+      }
+      computeCacheHash(request) {
+        const crypto2 = require("crypto");
+        const hash = crypto2.createHash("sha256");
+        const input = {
+          model: request.model,
+          prompt: request.prompt,
+          temperature: request.temperature,
+          maxTokens: request.maxTokens,
+          topK: request.topK,
+          topP: request.topP,
+          ratio: request.ratio,
+          size: request.size,
+          images: request.images,
+          thinkingLevel: request.thinkingLevel
+        };
+        hash.update(JSON.stringify(input));
+        return hash.digest("hex");
+      }
+      resolveImageParts(imagePaths) {
+        const mimeMap = {
+          ".jpg": "image/jpeg",
+          ".jpeg": "image/jpeg",
+          ".png": "image/png",
+          ".gif": "image/gif",
+          ".webp": "image/webp",
+          ".bmp": "image/bmp"
+        };
+        const parts = [];
+        for (const imgPath of imagePaths) {
+          const abs = path2.isAbsolute(imgPath) ? imgPath : path2.resolve(process.cwd(), imgPath);
+          const ext = path2.extname(abs).toLowerCase();
+          const mimeType = mimeMap[ext] ?? "image/jpeg";
+          const data = fs3.readFileSync(abs).toString("base64");
+          parts.push({ inlineData: { mimeType, data } });
+        }
+        return parts;
+      }
       async callModel(request) {
+        const useCache = request.cache !== false;
+        let cacheHash = "";
+        if (useCache) {
+          cacheHash = this.computeCacheHash(request);
+          const cache = this.readCache();
+          if (cache[cacheHash]) {
+            console.log("\u26A1 [Sesi Logic Cache] Served from local cache");
+            return cache[cacheHash];
+          }
+        }
         try {
           const client = this.client;
           const timeContext = `[System context: Current date and time is ${(/* @__PURE__ */ new Date()).toUTCString()}]
 
 `;
           const fullPrompt = timeContext + request.prompt;
+          let thinkingConfig = void 0;
+          if (request.thinkingLevel) {
+            const thinking = request.thinkingLevel.thinking !== "no";
+            const level = request.thinkingLevel.level || "low";
+            const isGemini3 = request.model.includes("gemini-3");
+            if (isGemini3) {
+              const isPro = request.model.includes("pro");
+              thinkingConfig = {
+                thinkingLevel: thinking ? level : isPro ? "low" : "minimal"
+              };
+            } else {
+              thinkingConfig = {
+                thinkingBudget: thinking ? level === "low" ? 1024 : level === "medium" ? 2048 : 4096 : 0
+              };
+            }
+          }
           if (request.model.includes("image")) {
             const imageConfig = {};
             if (request.ratio)
@@ -53768,9 +54004,11 @@ var require_ai_runtime = __commonJS({
               configObj.topK = request.topK;
             if (request.topP !== void 0)
               configObj.topP = request.topP;
+            if (thinkingConfig)
+              configObj.thinkingConfig = thinkingConfig;
             const response = await client.models.generateContent({
               model: request.model,
-              contents: request.prompt,
+              contents: request.images && request.images.length > 0 ? [{ role: "user", parts: [...this.resolveImageParts(request.images), { text: request.prompt }] }] : request.prompt,
               config: configObj
             });
             let base64String = null;
@@ -53785,7 +54023,7 @@ var require_ai_runtime = __commonJS({
             if (!base64String) {
               throw new Error("Image generation failed or returned no image output.");
             }
-            return {
+            const resObj2 = {
               text: base64String,
               // Return the base64 string directly
               finishReason: "STOP",
@@ -53794,6 +54032,12 @@ var require_ai_runtime = __commonJS({
                 outputTokens: 0
               }
             };
+            if (useCache) {
+              const cache = this.readCache();
+              cache[cacheHash] = resObj2;
+              this.writeCache(cache);
+            }
+            return resObj2;
           }
           let accumulatedText = "";
           let currentFinishReason = "";
@@ -53802,9 +54046,12 @@ var require_ai_runtime = __commonJS({
           let totalOutputTokens = 0;
           let maxPolls = 10;
           let currentPoll = 0;
-          const contents = [
-            { role: "user", parts: [{ text: fullPrompt }] }
-          ];
+          const contents = [];
+          const imageParts = request.images && request.images.length > 0 ? this.resolveImageParts(request.images) : [];
+          contents.push({
+            role: "user",
+            parts: [...imageParts, { text: fullPrompt }]
+          });
           while (!isComplete && currentPoll < maxPolls) {
             const genConfig = {
               temperature: request.temperature ?? 0.3,
@@ -53815,6 +54062,9 @@ var require_ai_runtime = __commonJS({
             if (request.tools) {
               genConfig.tools = request.tools;
             }
+            if (thinkingConfig) {
+              genConfig.thinkingConfig = thinkingConfig;
+            }
             const response = await client.models.generateContent({
               model: request.model,
               contents,
@@ -53826,7 +54076,7 @@ var require_ai_runtime = __commonJS({
             if (candidate?.content?.parts) {
               for (const part of candidate.content.parts) {
                 if (part.call) {
-                  return {
+                  const toolRes = {
                     text: JSON.stringify(part.call),
                     finishReason: "TOOL_CALL",
                     usage: {
@@ -53834,6 +54084,7 @@ var require_ai_runtime = __commonJS({
                       outputTokens: response.usageMetadata?.candidatesTokenCount ?? 0
                     }
                   };
+                  return toolRes;
                 }
               }
             }
@@ -53865,7 +54116,7 @@ var require_ai_runtime = __commonJS({
           if (currentFinishReason !== "STOP" && currentFinishReason !== "MAX_TOKENS") {
             throw new Error(`Generation did not complete successfully (finish reason: ${currentFinishReason})`);
           }
-          return {
+          const resObj = {
             text: accumulatedText,
             finishReason: currentFinishReason,
             usage: {
@@ -53873,6 +54124,12 @@ var require_ai_runtime = __commonJS({
               outputTokens: totalOutputTokens
             }
           };
+          if (useCache) {
+            const cache = this.readCache();
+            cache[cacheHash] = resObj;
+            this.writeCache(cache);
+          }
+          return resObj;
         } catch (error) {
           throw new Error(`Sesi: ${error.message}`);
         }
@@ -53940,13 +54197,14 @@ var require_interpreter = __commonJS({
     var types_1 = require_types2();
     var builtins_1 = require_builtins();
     var ai_runtime_1 = require_ai_runtime();
-    var Interpreter = class {
+    var Interpreter = class _Interpreter {
       constructor() {
         this.prompts = /* @__PURE__ */ new Map();
         this.memory = /* @__PURE__ */ new Map();
+        this.exports = /* @__PURE__ */ new Map();
         this.globalEnv = new types_1.Environment();
         this.currentEnv = this.globalEnv;
-        const builtins = (0, builtins_1.getBuiltins)();
+        const builtins = (0, builtins_1.getBuiltins)(this);
         for (const [name, fn] of builtins) {
           this.globalEnv.define(name, fn);
         }
@@ -53995,10 +54253,10 @@ var require_interpreter = __commonJS({
             await this.executeMemory(statement);
             break;
           case "ImportStatement":
-            console.log("Import not yet implemented");
+            await this.executeImport(statement);
             break;
           case "ExportStatement":
-            console.log("Export not yet implemented");
+            await this.executeExport(statement);
             break;
         }
       }
@@ -54264,28 +54522,7 @@ var require_interpreter = __commonJS({
         for (const arg of expr.arguments) {
           args2.push(await this.evaluateExpression(arg));
         }
-        if (fn.isBuiltin && fn.builtin) {
-          return fn.builtin(...args2);
-        }
-        const callEnv = new types_1.Environment(fn.closure);
-        for (let i2 = 0; i2 < fn.params.length; i2++) {
-          const param = fn.params[i2];
-          const value = i2 < args2.length ? args2[i2] : param.defaultValue ? await this.evaluateExpression(param.defaultValue) : null;
-          callEnv.define(param.name, value);
-        }
-        const previous = this.currentEnv;
-        this.currentEnv = callEnv;
-        try {
-          await this.executeBlock(fn.body, callEnv);
-          return null;
-        } catch (e2) {
-          if (e2 instanceof types_1.ReturnValue) {
-            return e2.value;
-          }
-          throw e2;
-        } finally {
-          this.currentEnv = previous;
-        }
+        return await this.callSesiFunction(fn, args2);
       }
       async evaluateMember(expr) {
         const obj = await this.evaluateExpression(expr.object);
@@ -54335,6 +54572,29 @@ var require_interpreter = __commonJS({
         if (typeof promptText !== "string") {
           promptText = (0, builtins_1.stringify)(promptText);
         }
+        let imagePaths;
+        if (expr.images) {
+          const raw = await this.evaluateExpression(expr.images);
+          if (Array.isArray(raw)) {
+            imagePaths = raw.map((v) => (0, builtins_1.stringify)(v));
+          } else if (typeof raw === "string" && raw.trim() !== "") {
+            imagePaths = [raw];
+          }
+        }
+        let thinkingLevel;
+        if (expr.config?.thinkingLevel) {
+          const raw = await this.evaluateExpression(expr.config.thinkingLevel);
+          if (typeof raw === "object" && raw !== null) {
+            thinkingLevel = raw;
+          }
+        }
+        let cache;
+        if (expr.config?.cache) {
+          const raw = await this.evaluateExpression(expr.config.cache);
+          if (typeof raw === "boolean") {
+            cache = raw;
+          }
+        }
         const response = await ai_runtime_1.aiRuntime.callModel({
           model: expr.modelName,
           prompt: promptText,
@@ -54343,7 +54603,10 @@ var require_interpreter = __commonJS({
           topK: expr.config?.top_k ? await this.evaluateExpression(expr.config.top_k) : void 0,
           topP: expr.config?.top_p ? await this.evaluateExpression(expr.config.top_p) : void 0,
           ratio: expr.config?.ratio ? await this.evaluateExpression(expr.config.ratio) : void 0,
-          size: expr.config?.size ? await this.evaluateExpression(expr.config.size) : void 0
+          size: expr.config?.size ? await this.evaluateExpression(expr.config.size) : void 0,
+          images: imagePaths,
+          thinkingLevel,
+          cache
         });
         return response.text;
       }
@@ -54352,11 +54615,37 @@ var require_interpreter = __commonJS({
         if (typeof promptText !== "string") {
           promptText = (0, builtins_1.stringify)(promptText);
         }
+        let imagePaths;
+        if (expr.images) {
+          const raw = await this.evaluateExpression(expr.images);
+          if (Array.isArray(raw)) {
+            imagePaths = raw.map((v) => (0, builtins_1.stringify)(v));
+          } else if (typeof raw === "string" && raw.trim() !== "") {
+            imagePaths = [raw];
+          }
+        }
+        let thinkingLevel;
+        if (expr.config?.thinkingLevel) {
+          const raw = await this.evaluateExpression(expr.config.thinkingLevel);
+          if (typeof raw === "object" && raw !== null) {
+            thinkingLevel = raw;
+          }
+        }
+        let cache;
+        if (expr.config?.cache) {
+          const raw = await this.evaluateExpression(expr.config.cache);
+          if (typeof raw === "boolean") {
+            cache = raw;
+          }
+        }
         const response = await ai_runtime_1.aiRuntime.callModel({
           model: expr.modelName,
           prompt: promptText,
           temperature: expr.config?.temperature ? await this.evaluateExpression(expr.config.temperature) : void 0,
-          maxTokens: expr.config?.max_tokens ? await this.evaluateExpression(expr.config.max_tokens) : void 0
+          maxTokens: expr.config?.max_tokens ? await this.evaluateExpression(expr.config.max_tokens) : void 0,
+          images: imagePaths,
+          thinkingLevel,
+          cache
         });
         return response.text;
       }
@@ -54378,20 +54667,22 @@ var require_interpreter = __commonJS({
         for (const arg of expr.arguments) {
           args2.push(await this.evaluateExpression(arg));
         }
-        const runtimeFn = fn;
-        if (runtimeFn.isBuiltin && runtimeFn.builtin) {
-          return runtimeFn.builtin(...args2);
+        return await this.callSesiFunction(fn, args2);
+      }
+      async callSesiFunction(fn, args2) {
+        if (fn.isBuiltin && fn.builtin) {
+          return await fn.builtin(...args2);
         }
-        const callEnv = new types_1.Environment(runtimeFn.closure);
-        for (let i2 = 0; i2 < runtimeFn.params.length; i2++) {
-          const param = runtimeFn.params[i2];
+        const callEnv = new types_1.Environment(fn.closure);
+        for (let i2 = 0; i2 < fn.params.length; i2++) {
+          const param = fn.params[i2];
           const value = i2 < args2.length ? args2[i2] : param.defaultValue ? await this.evaluateExpression(param.defaultValue) : null;
           callEnv.define(param.name, value);
         }
         const previous = this.currentEnv;
         this.currentEnv = callEnv;
         try {
-          await this.executeBlock(runtimeFn.body, callEnv);
+          await this.executeBlock(fn.body, callEnv);
           return null;
         } catch (e2) {
           if (e2 instanceof types_1.ReturnValue) {
@@ -54402,6 +54693,141 @@ var require_interpreter = __commonJS({
           this.currentEnv = previous;
         }
       }
+      async executeExport(stmt) {
+        await this.executeStatement(stmt.statement);
+        const name = stmt.statement.name;
+        const val = this.currentEnv.get(name);
+        this.exports.set(name, val);
+      }
+      async executeImport(stmt) {
+        const source = stmt.source;
+        let moduleExports = null;
+        if (source.startsWith("std/")) {
+          moduleExports = this.loadStdModule(source);
+        } else {
+          const fs3 = require("fs");
+          const path2 = require("path");
+          let filePath = source;
+          if (!filePath.endsWith(".sesi")) {
+            filePath += ".sesi";
+          }
+          const resolvedPath = path2.resolve(process.cwd(), filePath);
+          if (!fs3.existsSync(resolvedPath)) {
+            throw new Error(`Module not found: ${source}`);
+          }
+          const content = fs3.readFileSync(resolvedPath, "utf-8");
+          const { Lexer } = require_lexer();
+          const { Parser } = require_parser();
+          const lexer = new Lexer(content);
+          const parser = new Parser(lexer.scanTokens());
+          const program = parser.parse();
+          const subInterpreter = new _Interpreter();
+          await subInterpreter.interpret(program);
+          moduleExports = subInterpreter.exports;
+        }
+        if (!moduleExports) {
+          throw new Error(`Failed to load module: ${source}`);
+        }
+        if (stmt.names.length === 1 && stmt.names[0] === stmt.names[0].toLowerCase() && !moduleExports.has(stmt.names[0])) {
+          const nsObj = {};
+          for (const [key, val] of moduleExports.entries()) {
+            nsObj[key] = val;
+          }
+          this.currentEnv.define(stmt.names[0], nsObj);
+        } else {
+          for (const name of stmt.names) {
+            if (!moduleExports.has(name)) {
+              throw new Error(`Module "${source}" does not export "${name}"`);
+            }
+            this.currentEnv.define(name, moduleExports.get(name));
+          }
+        }
+      }
+      loadStdModule(source) {
+        const exports3 = /* @__PURE__ */ new Map();
+        if (source === "std/math") {
+          exports3.set("PI", Math.PI);
+          exports3.set("E", Math.E);
+          const mathFns = ["sin", "cos", "tan", "sqrt", "floor", "ceil", "abs", "pow", "log", "exp"];
+          for (const name of mathFns) {
+            exports3.set(name, {
+              type: "function",
+              name,
+              params: name === "pow" ? [{ name: "x" }, { name: "y" }] : [{ name: "x" }],
+              body: {},
+              closure: {},
+              isBuiltin: true,
+              builtin: (...args2) => {
+                const x2 = typeof args2[0] === "number" ? args2[0] : 0;
+                if (name === "pow") {
+                  const y = typeof args2[1] === "number" ? args2[1] : 0;
+                  return Math.pow(x2, y);
+                }
+                return Math[name](x2);
+              }
+            });
+          }
+          return exports3;
+        } else if (source === "std/time") {
+          exports3.set("now", {
+            type: "function",
+            name: "now",
+            params: [],
+            body: {},
+            closure: {},
+            isBuiltin: true,
+            builtin: (...args2) => Date.now()
+          });
+          exports3.set("sleep", {
+            type: "function",
+            name: "sleep",
+            params: [{ name: "ms" }],
+            body: {},
+            closure: {},
+            isBuiltin: true,
+            builtin: async (...args2) => {
+              const [ms] = args2;
+              const duration = typeof ms === "number" ? ms : 0;
+              await new Promise((resolve) => setTimeout(resolve, duration));
+              return null;
+            }
+          });
+          return exports3;
+        } else if (source === "std/json") {
+          exports3.set("stringify", {
+            type: "function",
+            name: "stringify",
+            params: [{ name: "val" }],
+            body: {},
+            closure: {},
+            isBuiltin: true,
+            builtin: (...args2) => {
+              const [val] = args2;
+              return JSON.stringify(val);
+            }
+          });
+          exports3.set("parse", {
+            type: "function",
+            name: "parse",
+            params: [{ name: "str" }],
+            body: {},
+            closure: {},
+            isBuiltin: true,
+            builtin: (...args2) => {
+              const [str] = args2;
+              if (typeof str !== "string")
+                return null;
+              try {
+                return JSON.parse(str);
+              } catch (e2) {
+                return null;
+              }
+            }
+          });
+          return exports3;
+        }
+        return null;
+      }
     };
     exports2.Interpreter = Interpreter;
   }
@@ -54469,13 +54895,13 @@ var require_dist5 = __commonJS({
         process.exit(1);
       }
     }
-    async function runSesiFile2(filePath2) {
+    async function runSesiFile2(filePath) {
       try {
-        const filepath = path2.resolve(filePath2);
+        const filepath = path2.resolve(filePath);
         const source = fs3.readFileSync(filepath, "utf-8");
         await runSesi(source);
       } catch (error) {
-        console.error(`Error reading file ${filePath2}:`, error.message);
+        console.error(`Error reading file ${filePath}:`, error.message);
         process.exit(1);
       }
     }
@@ -54490,48 +54916,49 @@ var path = require("path");
 var args = process.argv.slice(2);
 if (args.length === 0) {
   console.log(`
-Sesi Programming Language v1.1.1
+Sesi Programming Language v1.2.0
 
 Usage:
   sesi <file>          Run a Sesi program
-  sesi --help          Show this help
-
-Examples:
-  sesi main/start.sesi
-  sesi examples/01_hello.sesi
-  `);
-  process.exit(0);
-}
-if (args[0] === "--help" || args[0] === "-h") {
-  console.log(`
-Sesi Programming Language v1.1.1
+  sesi -help <query>   Ask for help from our Sesi Co-Pilot
+  sesi --help <query>  
+  sesi -h <query>      
 
-Usage:
-  sesi <file>          Run a Sesi program
-  sesi --help          Show this help
-  
-Options:
+  Options:
   --version            Show version
-  
+
 Examples:
   sesi main/start.sesi
   sesi examples/01_hello.sesi
+  sesi -help "how do I parse a json string?"
   `);
   process.exit(0);
 }
-if (args[0] === "--version") {
-  console.log("Sesi v1.1.1");
+if (args[0] === "--help" || args[0] === "-help" || args[0] === "-h") {
+  let queryText = args.slice(1).join(" ").trim();
+  if (!queryText) {
+    queryText = "how do I parse a json string?";
+  }
+  fs2.writeFileSync("query.txt", queryText, "utf-8");
+  const copilotPath = path.join(__dirname, "../main/sesi_db_chatbot.sesi");
+  runSesiFile(copilotPath).catch((error) => {
+    console.error("Fatal error in RAG Co-Pilot:", error.message);
+    process.exit(1);
+  });
+} else if (args[0] === "--version") {
+  console.log("Sesi v1.2.0");
   process.exit(0);
+} else {
+  const filePath = args[0];
+  if (!fs2.existsSync(filePath)) {
+    console.error(`Error: File not found: ${filePath}`);
+    process.exit(1);
+  }
+  runSesiFile(filePath).catch((error) => {
+    console.error("Fatal error:", error.message);
+    process.exit(1);
+  });
 }
-var filePath = args[0];
-if (!fs2.existsSync(filePath)) {
-  console.error(`Error: File not found: ${filePath}`);
-  process.exit(1);
-}
-runSesiFile(filePath).catch((error) => {
-  console.error("Fatal error:", error.message);
-  process.exit(1);
-});
 /*! Bundled license information:
 
 @noble/ciphers/utils.js: