llmz 0.0.28 → 0.0.30

package/dist/{chunk-7G5QAIUX.js → chunk-DCYSCVQM.js}

@@ -1,5 +1,4 @@
 import {
-  AssignmentError,
   CodeExecutionError,
   InvalidCodeError,
   Signals,
@@ -1936,6 +1935,7 @@ var require_source_map = __commonJS({
 
 // src/vm.ts
 var import_source_map_js = __toESM(require_source_map(), 1);
+import { newQuickJSWASMModuleFromVariant, shouldInterruptAfterDeadline } from "quickjs-emscripten-core";
 
 // src/compiler/compiler.ts
 import jsxPlugin from "@babel/plugin-transform-react-jsx";
@@ -1944,17 +1944,22 @@ import * as Babel from "@babel/standalone";
 // src/compiler/plugins/async-iterator.ts
 var Open = "async function* __fn__() {";
 var Close = "}";
+var USER_CODE_START_MARKER = "/* __LLMZ_USER_CODE_START__ */";
+var USER_CODE_END_MARKER = "/* __LLMZ_USER_CODE_END__ */";
 var AsyncIterator = {
   preProcessing: (code) => {
     return `"use strict";
 ${Open}
+${USER_CODE_START_MARKER}
 ${code}
+${USER_CODE_END_MARKER}
 ${Close}
 `.trim();
   },
   postProcessing: (code) => {
     code = code.slice(code.indexOf(Open) + Open.length).trim();
     code = code.slice(0, code.lastIndexOf(Close));
+    code = code.replace(USER_CODE_START_MARKER, "").replace(USER_CODE_END_MARKER, "");
     return code;
   }
 };
@@ -2031,19 +2036,59 @@ function escapeBracesInCodeFences(tsx) {
   let i = 0;
   let output = "";
   let insideFencedBlock = false;
+  let jsxDepth = 0;
+  let braceDepth = 0;
   while (i < tsx.length) {
+    const char = tsx[i];
+    if (char === "<" && !insideFencedBlock) {
+      if (tsx[i + 1] !== "/") {
+        jsxDepth++;
+      } else {
+        jsxDepth--;
+      }
+      output += char;
+      i++;
+      continue;
+    }
+    if (jsxDepth > 0 && !insideFencedBlock) {
+      if (char === "{") {
+        braceDepth++;
+        output += char;
+        i++;
+        continue;
+      } else if (char === "}") {
+        braceDepth--;
+        output += char;
+        i++;
+        continue;
+      }
+    }
     if (tsx.startsWith("```", i)) {
       insideFencedBlock = !insideFencedBlock;
       output += "```";
       i += 3;
       continue;
     }
-    if (insideFencedBlock && tsx[i] in HTML_ENTITIES) {
-      output += HTML_ENTITIES[tsx[i]];
+    if (jsxDepth > 0 && braceDepth === 0 && !insideFencedBlock && char === "`") {
+      const closingIndex = tsx.indexOf("`", i + 1);
+      if (closingIndex !== -1) {
+        const inlineCode = tsx.slice(i + 1, closingIndex);
+        let escaped = "`";
+        for (const c of inlineCode) {
+          escaped += HTML_ENTITIES[c] || c;
+        }
+        escaped += "`";
+        output += escaped;
+        i = closingIndex + 1;
+        continue;
+      }
+    }
+    if (insideFencedBlock && char in HTML_ENTITIES) {
+      output += HTML_ENTITIES[char];
       i++;
       continue;
     }
-    output += tsx[i];
+    output += char;
     i++;
   }
   return output;
@@ -2146,7 +2191,7 @@ var replaceCommentBabelPlugin = function({
                 return;
               }
               comments.sort((a, b) => a.start > b.start ? -1 : 1).forEach((comment) => {
-                var _a3;
+                var _a;
                 if (processed.has(comment.loc)) {
                   return;
                 }
@@ -2154,7 +2199,7 @@ var replaceCommentBabelPlugin = function({
                 const commentCall = t.expressionStatement(
                   t.callExpression(t.identifier(CommentFnIdentifier), [
                     t.stringLiteral(comment.value.trim()),
-                    t.numericLiteral(((_a3 = comment.loc) == null ? void 0 : _a3.start.line) ?? 0)
+                    t.numericLiteral(((_a = comment.loc) == null ? void 0 : _a.start.line) ?? 0)
                   ])
                 );
                 const isInsideObjectProperty = t.isObjectProperty(node) || path2.findParent((path3) => t.isObjectProperty(path3.node));
@@ -2181,8 +2226,8 @@ var instrumentLastLinePlugin = function({
   return {
     visitor: {
       FunctionDeclaration(path) {
-        var _a3, _b;
-        if (((_a3 = path.node.id) == null ? void 0 : _a3.name) !== "__fn__") {
+        var _a, _b;
+        if (((_a = path.node.id) == null ? void 0 : _a.name) !== "__fn__") {
           return;
         }
         const statements = path.node.body.body;
@@ -2268,7 +2313,7 @@ var toolCallTrackingPlugin = (calls = /* @__PURE__ */ new Map()) => function({})
         skip.clear();
       },
       CallExpression(path) {
-        var _a3;
+        var _a;
         if (skip.has(path.node) || path.findParent((p) => skip.has(p.node))) {
           return;
         }
@@ -2283,7 +2328,7 @@ var toolCallTrackingPlugin = (calls = /* @__PURE__ */ new Map()) => function({})
           (p) => p.isAssignmentExpression()
         );
         if (declaration) {
-          lval = (_a3 = declaration.get("declarations")[0]) == null ? void 0 : _a3.get("id");
+          lval = (_a = declaration.get("declarations")[0]) == null ? void 0 : _a.get("id");
         }
         if (assignment) {
           const left = assignment.get("left");
@@ -2562,8 +2607,7 @@ function compile(code) {
   let output = Babel.transform(code, {
     parserOpts: {
       allowReturnOutsideFunction: true,
-      allowAwaitOutsideFunction: true,
-      startLine: -1
+      allowAwaitOutsideFunction: true
     },
     presets: ["typescript"],
     plugins: [
@@ -2586,46 +2630,52 @@ function compile(code) {
   });
   const variables = /* @__PURE__ */ new Set();
   const toolCalls = /* @__PURE__ */ new Map();
+  const codeWithMarkers = output.code;
   output = Babel.transform(output.code, {
     ...DEFAULT_TRANSFORM_OPTIONS,
     parserOpts: {
-      ...DEFAULT_TRANSFORM_OPTIONS.parserOpts,
-      startLine: -1
+      ...DEFAULT_TRANSFORM_OPTIONS.parserOpts
     },
     plugins: [
       lineTrackingBabelPlugin,
       replaceCommentBabelPlugin,
       variableTrackingPlugin(variables),
       toolCallTrackingPlugin(toolCalls)
-    ]
+    ],
+    retainLines: true
   });
   let outputCode = output.code;
   outputCode = AsyncIterator.postProcessing(outputCode);
   outputCode = JSXNewLines.postProcessing(outputCode);
   return {
     code: outputCode,
+    codeWithMarkers,
+    // Code from before second transform, still has literal markers
     map: output.map,
     variables,
     toolCalls
   };
 }
 
-// src/vm.ts
-var IS_NODE = typeof process !== "undefined" && process.versions != null && process.versions.node != null;
-var _a;
-var IS_CI = typeof process !== "undefined" && !!((_a = process == null ? void 0 : process.env) == null ? void 0 : _a.CI);
-var _a2;
-var VM_DRIVER = (typeof process !== "undefined" && ((_a2 = process == null ? void 0 : process.env) == null ? void 0 : _a2.VM_DRIVER)) ?? (IS_CI ? "node" : "isolated-vm");
-var CAN_USE_ISOLATED_VM = IS_NODE && VM_DRIVER === "isolated-vm";
-var MAX_VM_EXECUTION_TIME = 6e4;
-var requireEsm = async (id) => {
-  if (typeof globalThis.window === "undefined" && typeof globalThis.require !== "undefined") {
-    return eval("require")(id);
-  } else {
-    return await import(id).then((m) => m.default ?? m);
+// src/quickjs-variant.ts
+var getVariant = async () => {
+  const module = await import("@jitl/quickjs-singlefile-browser-release-sync");
+  return module.default;
+};
+var BundledReleaseSyncVariant = {
+  type: "sync",
+  importFFI: async () => {
+    const variant = await getVariant();
+    return variant.importFFI();
+  },
+  importModuleLoader: async () => {
+    const variant = await getVariant();
+    return variant.importModuleLoader();
   }
 };
-var getIsolatedVm = async () => await requireEsm("isolated-vm");
+
+// src/vm.ts
+var MAX_VM_EXECUTION_TIME = 6e4;
 var NO_TRACKING = [
   Identifiers.CommentFnIdentifier,
   Identifiers.ToolCallTrackerFnIdentifier,
@@ -2648,7 +2698,7 @@ function getCompiledCode(code, traces = []) {
   }
 }
 async function runAsyncFunction(context, code, traces = [], signal = null, timeout = MAX_VM_EXECUTION_TIME) {
-  var _a3;
+  var _a, _b, _c, _d, _e, _f, _g;
   const transformed = getCompiledCode(code, traces);
   const lines_executed = /* @__PURE__ */ new Map();
   const variables = {};
@@ -2662,76 +2712,715 @@ async function runAsyncFunction(context, code, traces = [], signal = null, timeo
     sourceRoot: transformed.map.sourceRoot
   });
   context ??= {};
-  for (const name of transformed.variables) {
+  for (const name of Array.from(transformed.variables)) {
     delete context[name];
   }
-  context[Identifiers.CommentFnIdentifier] = (comment, line) => traces.push({ type: "comment", comment, line, started_at: Date.now() });
-  context[Identifiers.LineTrackingFnIdentifier] = (line) => {
-    lines_executed.set(line, (lines_executed.get(line) ?? 0) + 1);
-  };
-  context[Identifiers.JSXFnIdentifier] = (tool, props, ...children) => createJsxComponent({
-    type: tool,
-    props,
-    children
-  });
-  context[Identifiers.VariableTrackingFnIdentifier] = (name, getter) => {
-    if (NO_TRACKING.includes(name)) {
-      return;
-    }
-    variables[name] = () => {
-      try {
-        const value = getter();
-        if (typeof value === "function") {
-          return "[[non-primitive]]";
+  let DRIVER = "quickjs";
+  if (typeof process !== "undefined" && ((_a = process == null ? void 0 : process.env) == null ? void 0 : _a.USE_QUICKJS) === "false") {
+    DRIVER = "node";
+  }
+  if (DRIVER === "quickjs") {
+    try {
+      context[Identifiers.CommentFnIdentifier] = (comment, line) => {
+        if (comment.includes("__LLMZ_USER_CODE_START__") || comment.includes("__LLMZ_USER_CODE_END__")) {
+          return;
+        }
+        traces.push({ type: "comment", comment, line, started_at: Date.now() });
+      };
+      const codeWithMarkers = transformed.codeWithMarkers || transformed.code;
+      const markerLines = codeWithMarkers.split("\n");
+      const USER_CODE_START_MARKER2 = "/* __LLMZ_USER_CODE_START__ */";
+      let userCodeStartLine = -1;
+      for (let i = 0; i < markerLines.length; i++) {
+        if ((_b = markerLines[i]) == null ? void 0 : _b.includes(USER_CODE_START_MARKER2)) {
+          userCodeStartLine = i + 1;
+          break;
         }
-        return value;
-      } catch {
-        return "[[non-primitive]]";
       }
-    };
-  };
-  let currentToolCall;
-  context[Identifiers.ToolCallTrackerFnIdentifier] = (callId, type, outputOrError) => {
-    var _a4;
-    const temp = Signals.maybeDeserializeError(outputOrError == null ? void 0 : outputOrError.message);
-    if (type === "end" && temp instanceof SnapshotSignal && (temp == null ? void 0 : temp.toolCall)) {
-      currentToolCall = {
-        ...temp.toolCall,
-        assignment: (_a4 = transformed.toolCalls.get(callId)) == null ? void 0 : _a4.assignment
+      context[Identifiers.LineTrackingFnIdentifier] = (line) => {
+        const originalLine = consumer.originalPositionFor({
+          line,
+          column: 0
+        });
+        const mappedLine = originalLine.line ?? line;
+        const userCodeLine = Math.max(1, mappedLine - userCodeStartLine);
+        lines_executed.set(userCodeLine, (lines_executed.get(userCodeLine) ?? 0) + 1);
       };
+      context[Identifiers.JSXFnIdentifier] = (tool, props, ...children) => createJsxComponent({
+        type: tool,
+        props,
+        children
+      });
+      context[Identifiers.VariableTrackingFnIdentifier] = (name, getter) => {
+        if (NO_TRACKING.includes(name)) {
+          return;
+        }
+        variables[name] = () => {
+          try {
+            const value = getter();
+            if (typeof value === "function") {
+              return "[[non-primitive]]";
+            }
+            return value;
+          } catch {
+            return "[[non-primitive]]";
+          }
+        };
+      };
+      let currentToolCall;
+      context[Identifiers.ToolCallTrackerFnIdentifier] = (callId, type, outputOrError) => {
+        var _a2;
+        const temp = Signals.maybeDeserializeError(outputOrError == null ? void 0 : outputOrError.message);
+        if (type === "end" && temp instanceof SnapshotSignal && (temp == null ? void 0 : temp.toolCall)) {
+          currentToolCall = {
+            ...temp.toolCall,
+            assignment: (_a2 = transformed.toolCalls.get(callId)) == null ? void 0 : _a2.assignment
+          };
+        }
+      };
+      context[Identifiers.ConsoleObjIdentifier] = {
+        log: (...args) => {
+          const message = args.shift();
+          traces.push({ type: "log", message, args, started_at: Date.now() });
+        }
+      };
+      context[Identifiers.AsyncIterYieldFnIdentifier] = async function(value) {
+        const startedAt = Date.now();
+        try {
+          if (typeof value.type !== "string" || value.type.trim().length === 0) {
+            throw new Error("A yield statement must yield a valid tool");
+          }
+          const toolName = Object.keys(context).find((x) => x.toUpperCase() === value.type.toUpperCase());
+          if (!toolName) {
+            throw new Error(`Yield tool "${value.type}", but tool is not found`);
+          }
+          await context[toolName](value);
+        } finally {
+          traces.push({ type: "yield", value, started_at: startedAt, ended_at: Date.now() });
+        }
+      };
+      const QuickJS = await newQuickJSWASMModuleFromVariant(BundledReleaseSyncVariant);
+      const runtime = QuickJS.newRuntime();
+      runtime.setDebugMode(true);
+      runtime.setMemoryLimit(128 * 1024 * 1024);
+      const startTime = Date.now();
+      const timeoutHandler = shouldInterruptAfterDeadline(startTime + timeout);
+      runtime.setInterruptHandler(() => {
+        if (signal == null ? void 0 : signal.aborted) {
+          return true;
+        }
+        return timeoutHandler(runtime);
+      });
+      const vm = runtime.newContext();
+      const trackedProperties = /* @__PURE__ */ new Set();
+      const referenceProperties = /* @__PURE__ */ new Set();
+      const pendingPromises = [];
+      const toVmValue = (value) => {
+        var _a2;
+        if (typeof value === "string") {
+          return vm.newString(value);
+        } else if (typeof value === "number") {
+          return vm.newNumber(value);
+        } else if (typeof value === "boolean") {
+          return value ? vm.true : vm.false;
+        } else if (value === null) {
+          return vm.null;
+        } else if (value === void 0) {
+          return vm.undefined;
+        } else if (Array.isArray(value)) {
+          const items = value.map((item) => {
+            if (typeof item === "string") {
+              return JSON.stringify(item);
+            } else if (typeof item === "number" || typeof item === "boolean") {
+              return String(item);
+            } else if (item === null) {
+              return "null";
+            } else if (item === void 0) {
+              return "undefined";
+            } else if (typeof item === "object") {
+              return JSON.stringify(item);
+            }
+            return "undefined";
+          });
+          const arrayLiteral = `[${items.join(",")}]`;
+          const result = vm.evalCode(arrayLiteral);
+          if ("error" in result) {
+            (_a2 = result.error) == null ? void 0 : _a2.dispose();
+            return vm.undefined;
+          }
+          const arrHandle = result.value;
+          return arrHandle;
+        } else if (typeof value === "object") {
+          const obj = vm.newObject();
+          for (const [k, v] of Object.entries(value)) {
+            if (typeof v !== "function") {
+              const propHandle = toVmValue(v);
+              vm.setProp(obj, k, propHandle);
+              if (propHandle !== vm.true && propHandle !== vm.false && propHandle !== vm.null && propHandle !== vm.undefined) {
+                propHandle.dispose();
+              }
+            }
+          }
+          return obj;
+        }
+        return vm.undefined;
+      };
+      const bridgeFunction = (fn, _fnName = "anonymous") => {
+        return (...argHandles) => {
+          const args = argHandles.map((h) => vm.dump(h));
+          try {
+            const result = fn(...args);
+            if (result && typeof result.then === "function") {
+              const promise = vm.newPromise();
+              pendingPromises.push({
+                hostPromise: result,
+                deferredPromise: promise
+              });
+              void promise.settled.then(() => {
+                if (runtime.alive) {
+                  runtime.executePendingJobs();
+                }
+              });
+              return promise.handle;
+            }
+            return toVmValue(result);
+          } catch (err) {
+            const serialized = err instanceof Error ? err.message : String(err);
+            throw new Error(serialized);
+          }
+        };
+      };
+      try {
+        for (const [key, value] of Object.entries(context)) {
+          const descriptor = Object.getOwnPropertyDescriptor(context, key);
+          if (descriptor && (descriptor.get || descriptor.set)) {
+            referenceProperties.add(key);
+            trackedProperties.add(key);
+            let getterCode = "undefined";
+            if (descriptor.get) {
+              const getterBridge = vm.newFunction(`get_${key}`, () => {
+                try {
+                  const hostValue = context[key];
+                  return toVmValue(hostValue);
+                } catch (err) {
+                  const serialized = err instanceof Error ? err.message : String(err);
+                  throw new Error(serialized);
+                }
+              });
+              const getterName = `__getter_${key}__`;
+              vm.setProp(vm.global, getterName, getterBridge);
+              getterBridge.dispose();
+              getterCode = getterName;
+            }
+            let setterCode = "undefined";
+            if (descriptor.set) {
+              const setterBridge = vm.newFunction(`set_${key}`, (valueHandle) => {
+                try {
+                  const jsValue = vm.dump(valueHandle);
+                  context[key] = jsValue;
+                  return vm.undefined;
+                } catch (err) {
+                  const serialized = err instanceof Error ? err.message : String(err);
+                  throw new Error(serialized);
+                }
+              });
+              const setterName = `__setter_${key}__`;
+              vm.setProp(vm.global, setterName, setterBridge);
+              setterBridge.dispose();
+              setterCode = setterName;
+            }
+            const definePropertyCode = `
+          Object.defineProperty(globalThis, '${key}', {
+            enumerable: true,
+            configurable: ${descriptor.configurable !== false},
+            get: ${getterCode},
+            set: ${setterCode}
+          });
+        `;
+            const result = vm.evalCode(definePropertyCode);
+            if ("error" in result) {
+              (_c = result.error) == null ? void 0 : _c.dispose();
+            } else {
+              result.value.dispose();
+            }
+            continue;
+          }
+          if (typeof value === "function") {
+            const fnHandle = vm.newFunction(key, bridgeFunction(value, key));
+            vm.setProp(vm.global, key, fnHandle);
+            fnHandle.dispose();
+          } else if (Array.isArray(value)) {
+            trackedProperties.add(key);
+            const arrayHandle = toVmValue(value);
+            vm.setProp(vm.global, key, arrayHandle);
+            const shouldDispose = arrayHandle !== vm.true && arrayHandle !== vm.false && arrayHandle !== vm.null && arrayHandle !== vm.undefined;
+            if (shouldDispose) {
+              arrayHandle.dispose();
+            }
+          } else if (typeof value === "object" && value !== null) {
+            trackedProperties.add(key);
+            const objHandle = vm.newObject();
+            const props = /* @__PURE__ */ new Set([...Object.keys(value), ...Object.getOwnPropertyNames(value)]);
+            const getterSetterProps = [];
+            for (const prop of props) {
+              const propDescriptor = Object.getOwnPropertyDescriptor(value, prop);
+              if (propDescriptor && (propDescriptor.get || propDescriptor.set)) {
+                referenceProperties.add(`${key}.${prop}`);
+                getterSetterProps.push({ prop, descriptor: propDescriptor });
+              } else if (typeof value[prop] === "function") {
+                const propFnHandle = vm.newFunction(prop, bridgeFunction(value[prop], `${key}.${prop}`));
+                vm.setProp(objHandle, prop, propFnHandle);
+                propFnHandle.dispose();
+              } else {
+                const propHandle = toVmValue(value[prop]);
+                vm.setProp(objHandle, prop, propHandle);
+                const shouldDispose = propHandle !== vm.true && propHandle !== vm.false && propHandle !== vm.null && propHandle !== vm.undefined;
+                if (shouldDispose) {
+                  propHandle.dispose();
+                }
+              }
+            }
+            vm.setProp(vm.global, key, objHandle);
+            objHandle.dispose();
+            for (const { prop, descriptor: descriptor2 } of getterSetterProps) {
+              let getterCode = "undefined";
+              if (descriptor2.get) {
+                const getterBridge = vm.newFunction(`get_${prop}`, () => {
+                  try {
+                    const hostValue = context[key][prop];
+                    return toVmValue(hostValue);
+                  } catch (err) {
+                    const serialized = err instanceof Error ? err.message : String(err);
+                    throw new Error(serialized);
+                  }
+                });
+                const getterName = `__getter_${key}_${prop}__`;
+                vm.setProp(vm.global, getterName, getterBridge);
+                getterBridge.dispose();
+                getterCode = getterName;
+              }
+              let setterCode = "undefined";
+              if (descriptor2.set) {
+                const setterBridge = vm.newFunction(`set_${prop}`, (valueHandle) => {
+                  try {
+                    const jsValue = vm.dump(valueHandle);
+                    context[key][prop] = jsValue;
+                    return vm.undefined;
+                  } catch (err) {
+                    const serialized = err instanceof Error ? err.message : String(err);
+                    throw new Error(serialized);
+                  }
+                });
+                const setterName = `__setter_${key}_${prop}__`;
+                vm.setProp(vm.global, setterName, setterBridge);
+                setterBridge.dispose();
+                setterCode = setterName;
+              }
+              const definePropertyCode = `
+            Object.defineProperty(${key}, '${prop}', {
+              enumerable: true,
+              configurable: ${descriptor2.configurable !== false},
+              get: ${getterCode},
+              set: ${setterCode}
+            });
+          `;
+              const result = vm.evalCode(definePropertyCode);
+              if ("error" in result) {
+                (_d = result.error) == null ? void 0 : _d.dispose();
+              } else {
+                result.value.dispose();
+              }
+            }
+            if (Object.isSealed(value)) {
+              const sealResult = vm.evalCode(`Object.seal(globalThis['${key}']);`);
+              if ("error" in sealResult) {
+                (_e = sealResult.error) == null ? void 0 : _e.dispose();
+              } else {
+                sealResult.value.dispose();
+              }
+            }
+            if (!Object.isExtensible(value)) {
+              const preventResult = vm.evalCode(`Object.preventExtensions(globalThis['${key}']);`);
+              if ("error" in preventResult) {
+                (_f = preventResult.error) == null ? void 0 : _f.dispose();
+              } else {
+                preventResult.value.dispose();
+              }
+            }
+          } else {
+            trackedProperties.add(key);
+            const valueHandle = toVmValue(value);
+            vm.setProp(vm.global, key, valueHandle);
+            const shouldDispose = valueHandle !== vm.true && valueHandle !== vm.false && valueHandle !== vm.null && valueHandle !== vm.undefined;
+            if (shouldDispose) {
+              valueHandle.dispose();
+            }
+          }
+        }
+        const varTrackFnHandle = vm.newFunction(
+          Identifiers.VariableTrackingFnIdentifier,
+          (nameHandle, getterHandle) => {
+            var _a2;
+            const name = vm.getString(nameHandle);
+            if (NO_TRACKING.includes(name)) {
+              return;
+            }
+            try {
+              const valueResult = vm.callFunction(getterHandle, vm.undefined);
+              if ("error" in valueResult) {
+                variables[name] = "[[non-primitive]]";
+                (_a2 = valueResult.error) == null ? void 0 : _a2.dispose();
+                return;
+              }
+              const value = vm.dump(valueResult.value);
+              valueResult.value.dispose();
+              if (typeof value === "function" || typeof value === "string" && value.includes("=>")) {
+                variables[name] = "[[non-primitive]]";
+              } else {
+                variables[name] = value;
+              }
+            } catch {
+              variables[name] = "[[non-primitive]]";
+            }
+          }
+        );
+        vm.setProp(vm.global, Identifiers.VariableTrackingFnIdentifier, varTrackFnHandle);
+        varTrackFnHandle.dispose();
+        const scriptCode = `
+"use strict";
+globalThis.__llmz_result = undefined;
+globalThis.__llmz_result_set = false;
+globalThis.__llmz_error = null;
+globalThis.__llmz_error_stack = null;
+globalThis.__llmz_yields = [];
+
+(async () => {
+  try {
+    async function* __fn__() {
+${transformed.code}
     }
-  };
-  context[Identifiers.ConsoleObjIdentifier] = {
-    log: (...args) => {
-      const message = args.shift();
-      traces.push({ type: "log", message, args, started_at: Date.now() });
-    }
-  };
-  context[Identifiers.AsyncIterYieldFnIdentifier] = async function(value) {
-    const startedAt = Date.now();
-    try {
-      if (typeof value.type !== "string" || value.type.trim().length === 0) {
-        throw new Error("A yield statement must yield a valid tool");
-      }
-      const toolName = Object.keys(context).find((x) => x.toUpperCase() === value.type.toUpperCase());
-      if (!toolName) {
-        throw new Error(`Yield tool "${value.type}", but tool is not found`);
+
+    const fn = __fn__();
+    let iteration = 0;
+    const maxIterations = 10000; // Safety limit
+
+    while (iteration < maxIterations) {
+      const { value, done } = await fn.next();
+
+      if (done) {
+        globalThis.__llmz_result = value;
+        globalThis.__llmz_result_set = true;
+        break;
       }
-      await context[toolName](value);
-    } finally {
-      traces.push({ type: "yield", value, started_at: startedAt, ended_at: Date.now() });
+
+      // Store yielded value
+      globalThis.__llmz_yields.push(value);
+
+      // Call yield handler
+      await ${Identifiers.AsyncIterYieldFnIdentifier}(value);
+
+      iteration++;
     }
-  };
-  let DRIVER = CAN_USE_ISOLATED_VM ? "isolated-vm" : "node";
-  let isolatedVm;
-  if (DRIVER === "isolated-vm") {
-    try {
-      isolatedVm = await getIsolatedVm();
-    } catch {
+
+    if (iteration >= maxIterations) {
+      throw new Error('Maximum iterations exceeded');
+    }
+  } catch (err) {
+    // Store both the error message (which may contain serialized signal data)
+    // and the stack trace from QuickJS
+    // If err is a string (as thrown from promise rejection), use it directly
+    // Otherwise extract the message property
+    globalThis.__llmz_error = typeof err === 'string' ? err : String(err.message || err || '');
+    // Force the stack to be converted to a string in QuickJS context
+    globalThis.__llmz_error_stack = '' + (err.stack || '');
+  }
+})();
+`.trim();
+        const copyBackContextFromVM = () => {
+          for (const key of trackedProperties) {
+            if (referenceProperties.has(key)) {
+              continue;
+            }
+            try {
+              const valueResult = vm.evalCode(`globalThis['${key}']`);
+              const vmValue = vm.dump(valueResult.unwrap());
+              valueResult.unwrap().dispose();
+              try {
+                context[key] = vmValue;
+              } catch {
+              }
+            } catch {
+            }
+          }
+        };
+        const execResult = vm.evalCode(scriptCode, "<quickjs>");
+        if ("error" in execResult) {
+          if (execResult.error) {
+            const err = vm.dump(execResult.error);
+            execResult.error.dispose();
+            throw new Error((err == null ? void 0 : err.message) || "Execution failed");
+          }
+          throw new Error("Execution failed");
+        }
+        execResult.value.dispose();
+        const maxIterations = 1e3;
+        let iteration = 0;
+        while (iteration < maxIterations) {
+          let hasJobs = false;
+          const maxJobs = 1e4;
+          for (let i = 0; i < maxJobs; i++) {
+            const pending = (_g = runtime.executePendingJobs) == null ? void 0 : _g.call(runtime, -1);
+            const jobCount = pending === void 0 ? 0 : pending.unwrap();
+            if (jobCount <= 0)
+              break;
+            hasJobs = true;
+          }
+          const currentPromises = [...pendingPromises];
+          pendingPromises.length = 0;
+          if (currentPromises.length > 0) {
+            if (signal == null ? void 0 : signal.aborted) {
+              const reason = signal.reason;
+              const abortMessage = reason instanceof Error ? `${reason.name}: ${reason.message}` : reason ? String(reason) : "Execution was aborted";
+              for (const { deferredPromise } of currentPromises) {
+                const errValue = vm.newString(abortMessage);
+                deferredPromise.reject(errValue);
+                errValue.dispose();
+              }
+              runtime.executePendingJobs();
+              break;
+            }
+            let abortListener = null;
+            if (signal) {
+              abortListener = () => {
+                const reason = signal.reason;
+                const abortMessage = reason instanceof Error ? `${reason.name}: ${reason.message}` : reason ? String(reason) : "Execution was aborted";
+                for (const { deferredPromise } of currentPromises) {
+                  const errValue = vm.newString(abortMessage);
+                  deferredPromise.reject(errValue);
+                  errValue.dispose();
+                }
+                runtime.executePendingJobs();
+              };
+              signal.addEventListener("abort", abortListener);
+            }
+            try {
+              await Promise.all(
+                currentPromises.map(async ({ hostPromise, deferredPromise }) => {
+                  if (signal == null ? void 0 : signal.aborted) {
+                    return;
+                  }
+                  try {
+                    const value = await hostPromise;
+                    if (signal == null ? void 0 : signal.aborted) {
+                      return;
+                    }
+                    const vmValue = toVmValue(value);
+                    deferredPromise.resolve(vmValue);
+                  } catch (err) {
+                    if (signal == null ? void 0 : signal.aborted) {
+                      return;
+                    }
+                    const serialized = err instanceof Error ? err.message : String(err);
+                    const createErrorResult = vm.evalCode(`new Error(${JSON.stringify(serialized)})`);
+                    if ("error" in createErrorResult) {
+                      const errValue = vm.newString(serialized);
+                      deferredPromise.reject(errValue);
+                      errValue.dispose();
+                    } else {
+                      const errorHandle = createErrorResult.value;
+                      deferredPromise.reject(errorHandle);
+                      errorHandle.dispose();
+                    }
+                  }
+                })
+              );
+            } finally {
+              if (signal && abortListener) {
+                signal.removeEventListener("abort", abortListener);
+              }
+            }
+            runtime.executePendingJobs();
+            if (signal == null ? void 0 : signal.aborted) {
+              break;
+            }
+          }
+          if (!hasJobs && pendingPromises.length === 0) {
+            break;
+          }
+          iteration++;
+        }
+        if (iteration >= maxIterations) {
+          throw new Error("Maximum event loop iterations exceeded");
+        }
+        const errorResult = vm.evalCode("globalThis.__llmz_error");
+        const errorValue = vm.dump(errorResult.unwrap());
+        errorResult.unwrap().dispose();
+        if (signal == null ? void 0 : signal.aborted) {
+          const reason = signal.reason;
+          if (reason instanceof Error) {
+            throw reason;
+          }
+          throw new Error(reason ? String(reason) : "Execution was aborted");
+        }
+        if (errorValue !== null && errorValue !== "") {
+          try {
+            copyBackContextFromVM();
+          } catch {
+          }
+          const errorStackResult = vm.evalCode("globalThis.__llmz_error_stack");
+          const errorStack = vm.dump(errorStackResult.unwrap()) || "";
+          errorStackResult.unwrap().dispose();
+          const deserializedError = Signals.maybeDeserializeError(errorValue);
+          if (deserializedError instanceof VMSignal) {
+            deserializedError.stack = errorStack;
+            throw deserializedError;
+          }
+          const error = new Error(errorValue);
+          error.stack = errorStack;
+          throw error;
+        }
+        copyBackContextFromVM();
+        const resultSetResult = vm.evalCode("globalThis.__llmz_result_set");
+        const resultSet = vm.dump(resultSetResult.unwrap());
+        resultSetResult.unwrap().dispose();
+        let returnValue = void 0;
+        if (resultSet) {
+          const resultResult = vm.evalCode("globalThis.__llmz_result");
+          returnValue = vm.dump(resultResult.unwrap());
+          resultResult.unwrap().dispose();
+        }
+        returnValue = Signals.maybeDeserializeError(returnValue);
+        return {
+          success: true,
+          variables: mapValues_default(variables, (getter) => isFunction_default(getter) ? getter() : getter),
+          signal: returnValue instanceof VMSignal ? returnValue : void 0,
+          lines_executed: Array.from(lines_executed),
+          return_value: returnValue
+        };
+      } catch (err) {
+        if (signal == null ? void 0 : signal.aborted) {
+          const reason = signal.reason;
+          const abortError = reason instanceof Error ? reason : new Error(reason ? String(reason) : "Execution was aborted");
+          return handleErrorQuickJS(
+            abortError,
+            code,
+            consumer,
+            traces,
+            variables,
+            lines_executed,
+            userCodeStartLine,
+            currentToolCall
+          );
+        }
+        await Promise.all(
+          pendingPromises.map(async ({ hostPromise, deferredPromise }) => {
+            try {
+              const value = await hostPromise;
+              const vmValue = toVmValue(value);
+              deferredPromise.resolve(vmValue);
+            } catch (err2) {
+              const serialized = err2 instanceof Error ? err2.message : String(err2);
+              const errValue = vm.newString(serialized);
+              deferredPromise.reject(errValue);
+            }
+          })
+        ).catch(() => {
+        });
+        return handleErrorQuickJS(
+          err,
+          code,
+          consumer,
+          traces,
+          variables,
+          lines_executed,
+          userCodeStartLine,
+          currentToolCall
+        );
+      } finally {
+        try {
+          vm.dispose();
+        } catch {
+        }
+        try {
+          runtime.dispose();
+        } catch {
+        }
+      }
+    } catch (quickjsError) {
+      const debugInfo = {
+        error: (quickjsError == null ? void 0 : quickjsError.message) || String(quickjsError),
+        errorStack: quickjsError == null ? void 0 : quickjsError.stack,
+        wasmSource: BundledReleaseSyncVariant._wasmSource,
+        wasmLoadedSuccessfully: BundledReleaseSyncVariant._wasmLoadedSuccessfully,
+        wasmSize: BundledReleaseSyncVariant._wasmSize,
+        wasmLoadError: BundledReleaseSyncVariant._wasmLoadError,
+        nodeVersion: typeof process !== "undefined" && process.version ? process.version : "undefined",
+        platform: typeof process !== "undefined" && process.platform ? process.platform : "undefined"
+      };
+      console.warn("QuickJS failed to load, falling back to node driver.");
+      console.warn("Error:", (quickjsError == null ? void 0 : quickjsError.message) || quickjsError);
+      console.warn("Debug info:", JSON.stringify(debugInfo, null, 2));
       DRIVER = "node";
     }
   }
   if (DRIVER === "node") {
+    context[Identifiers.CommentFnIdentifier] = (comment, line) => traces.push({ type: "comment", comment, line, started_at: Date.now() });
+    context[Identifiers.LineTrackingFnIdentifier] = (line) => {
+      lines_executed.set(line, (lines_executed.get(line) ?? 0) + 1);
+    };
+    context[Identifiers.JSXFnIdentifier] = (tool, props, ...children) => createJsxComponent({
+      type: tool,
+      props,
+      children
+    });
+    context[Identifiers.VariableTrackingFnIdentifier] = (name, getter) => {
+      if (NO_TRACKING.includes(name)) {
+        return;
+      }
+      variables[name] = () => {
+        try {
+          const value = getter();
+          if (typeof value === "function") {
+            return "[[non-primitive]]";
+          }
+          return value;
+        } catch {
+          return "[[non-primitive]]";
+        }
+      };
+    };
+    let currentToolCall;
+    context[Identifiers.ToolCallTrackerFnIdentifier] = (callId, type, outputOrError) => {
+      var _a2;
+      const temp = Signals.maybeDeserializeError(outputOrError == null ? void 0 : outputOrError.message);
+      if (type === "end" && temp instanceof SnapshotSignal && (temp == null ? void 0 : temp.toolCall)) {
+        currentToolCall = {
+          ...temp.toolCall,
+          assignment: (_a2 = transformed.toolCalls.get(callId)) == null ? void 0 : _a2.assignment
+        };
+      }
+    };
+    context[Identifiers.ConsoleObjIdentifier] = {
+      log: (...args) => {
+        const message = args.shift();
+        traces.push({ type: "log", message, args, started_at: Date.now() });
+      }
+    };
+    context[Identifiers.AsyncIterYieldFnIdentifier] = async function(value) {
+      const startedAt = Date.now();
+      try {
+        if (typeof value.type !== "string" || value.type.trim().length === 0) {
+          throw new Error("A yield statement must yield a valid tool");
+        }
+        const toolName = Object.keys(context).find((x) => x.toUpperCase() === value.type.toUpperCase());
+        if (!toolName) {
+          throw new Error(`Yield tool "${value.type}", but tool is not found`);
+        }
+        await context[toolName](value);
+      } finally {
+        traces.push({ type: "yield", value, started_at: startedAt, ended_at: Date.now() });
+      }
+    };
     const AsyncFunction = async function* () {
     }.constructor;
     return await (async () => {
@@ -2766,293 +3455,109 @@ async function runAsyncFunction(context, code, traces = [], signal = null, timeo
         lines_executed: Array.from(lines_executed),
         return_value: res
       };
-    }).catch((err) => handleError(err, code, consumer, traces, variables, lines_executed, currentToolCall, DRIVER)).catch((err) => handleCatch(err, traces, variables, lines_executed));
-  }
-  if (!isolatedVm) {
-    throw new Error("isolated-vm is not available");
-  }
-  const isolate = new isolatedVm.Isolate({ memoryLimit: 128 });
-  const isolatedContext = await isolate.createContext();
-  const jail = isolatedContext.global;
-  const trackedProperties = /* @__PURE__ */ new Set();
-  const referenceProperties = /* @__PURE__ */ new Set();
-  const abort = () => {
-    if (DRIVER === "isolated-vm") {
-      isolate.dispose();
-      isolatedContext.release();
-    }
-  };
-  if (signal) {
-    signal.addEventListener("abort", abort);
+    }).catch((err) => handleErrorNode(err, code, consumer, traces, variables, lines_executed, currentToolCall)).catch((err) => handleCatch(err, traces, variables, lines_executed));
   }
-  await jail.set("global", jail.derefInto());
-  for (const key of Object.keys(context)) {
-    if (typeof context[key] === "function") {
-      await isolatedContext.evalClosure(
-        `global['${key}'] = (...args) => $0.applySyncPromise(null, args, {arguments: {copy: true}});`,
-        [async (...args) => new isolatedVm.ExternalCopy(await context[key](...args)).copyInto()],
-        {
-          arguments: { reference: true }
-        }
-      );
-    } else if (typeof context[key] === "object" && !((_a3 = Object.getOwnPropertyDescriptor(context, key)) == null ? void 0 : _a3.get)) {
-      try {
-        trackedProperties.add(key);
-        const initial = Array.isArray(context[key]) ? new Array(context[key].length) : {};
-        await jail.set(key, initial, { copy: true });
-        const props = /* @__PURE__ */ new Set([...Object.keys(context[key]), ...Object.getOwnPropertyNames(context[key])]);
-        for (const prop of props) {
-          try {
-            if (typeof context[key][prop] === "function") {
-              await isolatedContext.evalClosure(
-                `global['${key}']['${prop}'] = (...args) => $0.applySyncPromise(null, args, {arguments: {copy: true}});`,
-                [async (...args) => new isolatedVm.ExternalCopy(await context[key][prop](...args)).copyInto()],
-                {
-                  arguments: { reference: true }
-                }
-              );
-            } else {
-              const descriptor = Object.getOwnPropertyDescriptor(context[key], prop);
-              if (descriptor && (descriptor.get || descriptor.set)) {
-                referenceProperties.add(`${key}.${prop}`);
-                await isolatedContext.evalClosure(
-                  `Object.defineProperty(global['${key}'], '${prop}', {
-                    get: () => $0.applySync(null, [], {arguments: {copy: true}}),
-                    set: (value) => $1.applySync(null, [value], {arguments: {copy: true}})
-                  });`,
-                  [
-                    () => context[key][prop],
-                    (value) => {
-                      context[key][prop] = value;
-                      return value;
-                    }
-                  ],
-                  { arguments: { reference: true } }
-                );
-              } else {
-                await isolatedContext.evalClosure(`global['${key}']['${prop}'] = $0;`, [context[key][prop]], {
-                  arguments: { copy: true }
-                });
-              }
-            }
-          } catch (err) {
-            console.error(`Could not copy "${key}.${prop}" (typeof = ${typeof context[key][prop]}) to the sandbox`, err);
-          }
-        }
-      } catch (err) {
-        console.error(`Could not create object "${key}" (typeof = ${typeof context[key]}) in the sandbox`, err);
-      }
-    } else {
-      try {
-        const descriptor = Object.getOwnPropertyDescriptor(context, key);
-        if (descriptor && (descriptor.get || descriptor.set)) {
-          referenceProperties.add(key);
-          await isolatedContext.evalClosure(
-            `Object.defineProperty(global, '${key}', {
-              get: () => $0.applySync(null, [], {arguments: {copy: true}}),
-              set: (value) => $1.applySync(null, [value], {arguments: {copy: true}})
-            });`,
-            [
-              () => context[key],
-              (value) => {
-                context[key] = value;
-                return value;
-              }
-            ],
-            { arguments: { reference: true } }
-          );
-        } else {
-          await jail.set(key, context[key], { copy: true });
-        }
-        trackedProperties.add(key);
-      } catch (err) {
-        console.error(`Could not copy "${key}" to the sandbox (typeof = ${typeof context[key]})`, err);
-      }
-    }
-  }
-  for (const key of Object.keys(context)) {
-    if (Object.isSealed(context[key])) {
-      await isolatedContext.evalClosure(`Object.seal(global['${key}']);`, []);
-    }
-    if (!Object.isExtensible(context[key])) {
-      await isolatedContext.evalClosure(`Object.preventExtensions(global['${key}']);`, []);
-    }
-  }
-  const Console = await jail.get(Identifiers.ConsoleObjIdentifier, { reference: true });
-  await Console.set("log", (...args) => {
-    const message = args.shift();
-    traces.push({ type: "log", message, args, started_at: Date.now() });
-  });
-  await isolatedContext.evalClosure(
-    `${Identifiers.VariableTrackingFnIdentifier} = (name, getter) => {
-        const value = getter();
-        try {
-          $0.applySync(null, [name, getter()], { arguments: { copy: true } });
-        } catch {
-          $0.applySync(null, [name, '[[non-primitive]]'], { arguments: { copy: true } });
-        }
-      };`,
-    [
-      (name, value) => {
-        variables[name] = value;
-      }
-    ],
-    {
-      arguments: { reference: true }
-    }
-  );
-  const scriptCode = `
-"use strict";
-new Promise(async (resolve) => {
-
-async function* __fn__() {
-${transformed.code}
+  throw new Error(`Unknown driver: ${DRIVER}`);
 }
-
-const fn = __fn__();
-do {
-  const { value, done } = await fn.next();
-  if (done) {
-    const ret = await value;
-    return resolve(ret);
+var handleErrorQuickJS = (err, code, _consumer, traces, variables, lines_executed, userCodeStartLine, currentToolCall) => {
+  var _a, _b, _c;
+  err = Signals.maybeDeserializeError(err);
+  const lines = code.split("\n");
+  const stackTrace = err.stack || "";
+  const LINE_OFFSET = 1;
+  const regex = /<quickjs>:(\d+)/g;
+  const QUICKJS_WRAPPER_OFFSET = 10;
+  const matches = Array.from(stackTrace.matchAll(regex)).map((x) => {
+    const quickjsLine = Number(x[1]);
+    const transformedCodeLine = quickjsLine - QUICKJS_WRAPPER_OFFSET;
+    const line = Math.max(1, transformedCodeLine - userCodeStartLine + 1);
+    const actualLine = lines[line - LINE_OFFSET] ?? "";
+    const whiteSpacesCount = actualLine.length - actualLine.trimStart().length;
+    const minColumn = whiteSpacesCount;
+    return {
+      line,
+      column: minColumn
+    };
+  });
+  if (matches.length === 0 && lines_executed.size > 0) {
+    const lastLine2 = Math.max(...Array.from(lines_executed.keys()));
+    const actualLine = lines[lastLine2 - LINE_OFFSET] ?? "";
+    const whiteSpacesCount = actualLine.length - actualLine.trimStart().length;
+    matches.push({
+      line: lastLine2,
+      column: whiteSpacesCount
+    });
   }
-  await ${Identifiers.AsyncIterYieldFnIdentifier}(value);
-} while(true);
-
-})`.trim();
-  const script = await isolate.compileScript(scriptCode, { filename: "<isolated-vm>", columnOffset: 0, lineOffset: 0 });
-  const copyErrors = [];
-  let copied = false;
-  const copyBackContextFromJail = () => {
-    if (copied) {
-      return;
-    }
-    copied = true;
-    for (const key of trackedProperties) {
-      if (typeof context[key] === "object" && !referenceProperties.has(key)) {
-        try {
-          let properties = [];
-          try {
-            properties = isolatedContext.evalClosureSync(`return Object.getOwnPropertyNames(global['${key}'])`, [], {
-              result: { copy: true }
-            }) ?? [];
-          } catch (err) {
-            console.error(`Could not get properties of object "${key}" from the sandbox`, err);
-          }
-          const propsToDelete = Object.getOwnPropertyNames(context[key]).filter((x) => !properties.includes(x));
-          for (const prop of propsToDelete) {
-            delete context[key][prop];
-          }
-          for (const prop of properties) {
-            if (typeof context[key][prop] === "function" || referenceProperties.has(`${key}.${prop}`)) {
-              continue;
-            }
-            try {
-              const obj = isolatedContext.evalClosureSync(`return global['${key}']['${prop}']`, [], {
-                result: { copy: true }
-              });
-              try {
-                Object.assign(context[key], { [prop]: obj });
-              } catch (err) {
-                if (err instanceof AssignmentError) {
-                  traces.push({
-                    type: "code_execution_exception",
-                    position: [0, 0],
-                    message: err.message,
-                    stackTrace: "",
-                    started_at: Date.now(),
-                    ended_at: Date.now()
-                  });
-                  copyErrors.push(err);
-                }
-              }
-            } catch (err) {
-              console.error(`Could not copy back "${key}.${prop}" from the sandbox`, err);
-            }
-          }
-        } catch (err) {
-          console.error(`Could not copy back object "${key}" from the sandbox`, err);
-        }
-      } else {
-        try {
-          if (referenceProperties.has(key)) {
-            continue;
-          }
-          const value = jail.getSync(key, { copy: true });
-          try {
-            Object.assign(context, { [key]: value });
-          } catch (err) {
-            if (err instanceof AssignmentError) {
-              traces.push({
-                type: "code_execution_exception",
-                position: [0, 0],
-                message: err.message,
-                stackTrace: "",
-                started_at: Date.now(),
-                ended_at: Date.now()
-              });
-              copyErrors.push(err);
-            }
-          }
-        } catch (err) {
-          console.error(`Could not copy back "${key}" from the sandbox`, err);
-        }
-      }
+  const lastLine = ((_a = maxBy_default(matches, (x) => x.line ?? 0)) == null ? void 0 : _a.line) ?? 0;
+  let debugUserCode = "";
+  let truncatedCode = "";
+  let truncated = false;
+  const appendCode = (line) => {
+    debugUserCode += line;
+    if (!truncated) {
+      truncatedCode += line;
     }
   };
-  const final = await script.run(isolatedContext, {
-    timeout,
-    copy: true,
-    promise: true
-  }).then((res) => {
-    copyBackContextFromJail();
-    if (copyErrors.length) {
-      throw new CodeExecutionError(copyErrors.map((x) => x.message).join(", "), code, "");
-    }
-    return res;
-  }).then(
-    (res) => {
-      res = Signals.maybeDeserializeError(res);
-      return {
-        success: true,
-        variables: mapValues_default(variables, (getter) => isFunction_default(getter) ? getter() : getter),
-        signal: res instanceof VMSignal ? res : void 0,
-        lines_executed: Array.from(lines_executed),
-        return_value: res
-      };
-    },
-    (err) => {
-      return handleError(err, code, consumer, traces, variables, lines_executed, currentToolCall, DRIVER);
-    }
-  ).catch((err) => {
-    if (signal == null ? void 0 : signal.aborted) {
-      return handleCatch(new Error("Execution was aborted"), traces, variables, lines_executed);
+  for (let i = 0; i < lines.length; i++) {
+    const VM_OFFSET = 2;
+    const DISPLAY_OFFSET = 0;
+    const line = lines[i];
+    const correctedStackLineIndex = i + LINE_OFFSET + VM_OFFSET;
+    const match = matches.find((x) => x.line + VM_OFFSET === correctedStackLineIndex);
+    const paddedLineNumber = String(correctedStackLineIndex - VM_OFFSET - DISPLAY_OFFSET).padStart(3, "0");
+    if (match) {
+      appendCode(`> ${paddedLineNumber} | ${line}
+`);
+      appendCode(`    ${" ".repeat(paddedLineNumber.length + match.column)}^^^^^^^^^^
+`);
+      if (match.line >= lastLine) {
+        truncated = true;
+      }
     } else {
-      copyBackContextFromJail();
+      appendCode(`  ${paddedLineNumber} | ${line}
+`);
     }
-    return handleCatch(err, traces, variables, lines_executed);
-  });
-  signal == null ? void 0 : signal.removeEventListener("abort", abort);
-  try {
-    isolate.dispose();
-  } catch {
   }
-  try {
-    isolatedContext.release();
-  } catch {
+  debugUserCode = cleanStackTrace(debugUserCode).trim();
+  truncatedCode = cleanStackTrace(truncatedCode).trim();
+  if (err instanceof VMSignal) {
+    const signalError = err;
+    signalError.stack = debugUserCode;
+    signalError.truncatedCode = truncatedCode;
+    signalError.variables = mapValues_default(variables, (getter) => isFunction_default(getter) ? getter() : getter);
+    signalError.toolCall = currentToolCall;
+    return {
+      success: true,
+      variables: mapValues_default(variables, (getter) => isFunction_default(getter) ? getter() : getter),
+      signal: err,
+      lines_executed: Array.from(lines_executed)
+    };
+  } else {
+    traces.push({
+      type: "code_execution_exception",
+      position: [((_b = matches[0]) == null ? void 0 : _b.line) ?? 0, ((_c = matches[0]) == null ? void 0 : _c.column) ?? 0],
+      message: err.message,
+      stackTrace: debugUserCode,
+      started_at: Date.now()
+    });
+    const codeError = new CodeExecutionError(err.message, code, debugUserCode);
+    const deserializedError = Signals.maybeDeserializeError(codeError);
+    return {
+      success: false,
+      variables: mapValues_default(variables, (getter) => isFunction_default(getter) ? getter() : getter),
+      error: deserializedError,
+      traces,
+      lines_executed: Array.from(lines_executed)
+    };
   }
-  return final;
-}
-var handleError = (err, code, consumer, traces, variables, lines_executed, currentToolCall, driver = "isolated-vm") => {
-  var _a3, _b, _c;
+};
+var handleErrorNode = (err, code, consumer, traces, variables, _lines_executed, currentToolCall) => {
+  var _a, _b, _c;
   err = Signals.maybeDeserializeError(err);
   const lines = code.split("\n");
   const stackTrace = err.stack || "";
-  const LINE_OFFSET = driver === "isolated-vm" ? 3 : 1;
-  let regex = /\(<isolated-vm>:(\d+):(\d+)/g;
-  if (driver === "node") {
-    regex = /<anonymous>:(\d+):(\d+)/g;
-  }
+  const LINE_OFFSET = 1;
+  const regex = /<anonymous>:(\d+):(\d+)/g;
   const matches = [...stackTrace.matchAll(regex)].map((x) => {
     const originalLine = consumer.originalPositionFor({
       line: Number(x[1]),
@@ -3067,7 +3572,7 @@ var handleError = (err, code, consumer, traces, variables, lines_executed, curre
       column: Math.min(minColumn, Number(x[2]))
     };
   });
-  const lastLine = ((_a3 = maxBy_default(matches, (x) => x.line ?? 0)) == null ? void 0 : _a3.line) ?? 0;
+  const lastLine = ((_a = maxBy_default(matches, (x) => x.line ?? 0)) == null ? void 0 : _a.line) ?? 0;
   let debugUserCode = "";
   let truncatedCode = "";
   let truncated = false;
@@ -3078,8 +3583,8 @@ var handleError = (err, code, consumer, traces, variables, lines_executed, curre
     }
   };
   for (let i = 0; i < lines.length; i++) {
-    const VM_OFFSET = driver === "isolated-vm" ? 2 : 2;
-    const DISPLAY_OFFSET = driver === "isolated-vm" ? 2 : 0;
+    const VM_OFFSET = 2;
+    const DISPLAY_OFFSET = 0;
     const line = lines[i];
     const correctedStackLineIndex = i + LINE_OFFSET + VM_OFFSET;
     const match = matches.find((x) => x.line + VM_OFFSET === correctedStackLineIndex);
@@ -3129,6 +3634,5 @@ var handleCatch = (err, traces, variables, lines_executed) => {
 };
 
 export {
-  CAN_USE_ISOLATED_VM,
   runAsyncFunction
 };