llmz 0.0.81 → 0.0.83

package/dist/{llmz-BSI7Y6YH.js → execute-CJVHUFYI.js}

@@ -1,6 +1,6 @@
 import {
   runAsyncFunction
-} from "./chunk-22DGAZXC.js";
+} from "./chunk-EFEF2AL7.js";
 import {
   Context,
   ErrorExecutionResult,
@@ -8,10 +8,10 @@ import {
   Snapshot,
   SuccessExecutionResult,
   parseExit
-} from "./chunk-2UM7PFM3.js";
-import "./chunk-HP3T6PF4.js";
-import "./chunk-HBKQKO3R.js";
-import "./chunk-DO7DN4FZ.js";
+} from "./chunk-VDTORFBP.js";
+import "./chunk-I2CZYEMH.js";
+import "./chunk-5Z2SJOGS.js";
+import "./chunk-NPVV3PHY.js";
 import {
   AssignmentError,
   CodeExecutionError,
@@ -20,35 +20,32 @@ import {
   LoopExceededError,
   Signals,
   SnapshotSignal,
-  ThinkSignal,
-  VMSignal
+  ThinkSignal
 } from "./chunk-WSVDMGMR.js";
 import {
   cleanStackTrace
 } from "./chunk-YEAWWJSJ.js";
-import "./chunk-E74GBCTT.js";
-import "./chunk-EQ4JDBE5.js";
-import "./chunk-E6UFMAW7.js";
+import "./chunk-VLJA22PB.js";
+import "./chunk-3T5IU7OU.js";
+import "./chunk-XTEHT2TK.js";
 import {
   truncateWrappedContent
-} from "./chunk-YFG53MRF.js";
+} from "./chunk-MM2FLD3J.js";
 import {
+  getErrorMessage,
   init,
   stripInvalidIdentifiers
-} from "./chunk-3NVOHQVY.js";
+} from "./chunk-5MAFEI2A.js";
 import {
   clamp_default,
   isEqual_default,
   isPlainObject_default,
   omit_default
-} from "./chunk-BJMZIH3M.js";
+} from "./chunk-34GJUS6U.js";
 
-// src/llmz.ts
+// src/runtime/execute.ts
 import { Client } from "@botpress/client";
-import { Cognitive } from "@botpress/cognitive";
-import { z } from "@bpinternal/zui";
-import ms from "ms";
-import { ulid } from "ulid";
+import { Cognitive, CognitiveBeta, cognitiveFromBeta } from "@botpress/cognitive";
 
 // src/abort-signal.ts
 function createJoinedAbortController(signals) {
@@ -79,9 +76,7 @@ function createJoinedAbortController(signals) {
   return controller;
 }
 
-// src/llmz.ts
-var getErrorMessage = (err) => err instanceof Error ? err.message : JSON.stringify(err);
-var SLOW_TOOL_WARNING = ms("15s");
+// src/runtime/generate.ts
 var RESPONSE_LENGTH_BUFFER = {
   MIN_TOKENS: 1e3,
   MAX_TOKENS: 16e3,
@@ -92,141 +87,9 @@ var getModelOutputLimit = (inputLength) => clamp_default(
   RESPONSE_LENGTH_BUFFER.MIN_TOKENS,
   RESPONSE_LENGTH_BUFFER.MAX_TOKENS
 );
-var executeContext = async (props) => {
-  var _a, _b;
-  await init();
-  const result = await _executeContext(props);
-  try {
-    (_b = (_a = result.context.chat) == null ? void 0 : _a.onExecutionDone) == null ? void 0 : _b.call(_a, result);
-  } catch {
-  }
-  return result;
-};
-var _executeContext = async (props) => {
-  var _a, _b;
-  const controller = createJoinedAbortController([props.signal]);
-  const { onIterationStart, onIterationEnd, onTrace, onExit, onBeforeExecution, onAfterTool, onBeforeTool } = props;
-  const client = props.client ?? new Client();
-  const cognitive = Cognitive.isCognitiveClient(client) ? client : new Cognitive({ client, __experimental_beta: true });
-  const cleanups = [];
-  const ctx = new Context({
-    chat: props.chat,
-    instructions: props.instructions,
-    objects: props.objects,
-    tools: props.tools,
-    loop: (_a = props.options) == null ? void 0 : _a.loop,
-    timeout: (_b = props.options) == null ? void 0 : _b.timeout,
-    exits: props.exits,
-    snapshot: props.snapshot,
-    model: props.model,
-    temperature: props.temperature,
-    reasoningEffort: props.reasoningEffort
-  });
-  try {
-    while (true) {
-      if (ctx.iterations.length >= ctx.loop) {
-        return new ErrorExecutionResult(ctx, new LoopExceededError());
-      }
-      const iteration = await ctx.nextIteration();
-      try {
-        await executeOnIterationStartHook({
-          iteration,
-          ctx,
-          onIterationStart,
-          controller,
-          onIterationEnd
-        });
-      } catch (err) {
-        if (err instanceof ThinkSignal) {
-          continue;
-        }
-      }
-      if (controller.signal.aborted) {
-        iteration.end({
-          type: "aborted",
-          aborted: {
-            reason: controller.signal.reason ?? "The operation was aborted"
-          }
-        });
-        return new ErrorExecutionResult(ctx, controller.signal.reason ?? "The operation was aborted");
-      }
-      cleanups.push(
-        iteration.traces.onPush((traces) => {
-          for (const trace of traces) {
-            onTrace == null ? void 0 : onTrace({ trace, iteration: ctx.iterations.length });
-          }
-        })
-      );
-      try {
-        await executeIteration({
-          iteration,
-          ctx,
-          cognitive,
-          controller,
-          onExit,
-          onBeforeExecution,
-          onAfterTool,
-          onBeforeTool
-        });
-      } catch (err) {
-        if (err instanceof CognitiveError) {
-          return new ErrorExecutionResult(ctx, err);
-        }
-        iteration.end({
-          type: "execution_error",
-          execution_error: {
-            message: "An unexpected error occurred: " + getErrorMessage(err),
-            stack: cleanStackTrace(err.stack ?? "No stack trace available")
-          }
-        });
-      }
-      try {
-        await (onIterationEnd == null ? void 0 : onIterationEnd(iteration, controller));
-      } catch (err) {
-        console.error(err);
-      }
-      if (iteration.status.type === "exit_success") {
-        const exitName = iteration.status.exit_success.exit_name;
-        return new SuccessExecutionResult(ctx, {
-          exit: iteration.exits.find((x) => x.name === exitName),
-          result: iteration.status.exit_success.return_value
-        });
-      }
-      if (iteration.status.type === "callback_requested") {
-        return new PartialExecutionResult(
-          ctx,
-          iteration.status.callback_requested.signal,
-          Snapshot.fromSignal(iteration.status.callback_requested.signal)
-        );
-      }
-      if (iteration.status.type === "thinking_requested" || iteration.status.type === "exit_error" || iteration.status.type === "execution_error" || iteration.status.type === "invalid_code_error") {
-        continue;
-      }
-      return new ErrorExecutionResult(ctx, iteration.error ?? `Unknown error. Status: ${iteration.status.type}`);
-    }
-  } catch (error) {
-    return new ErrorExecutionResult(ctx, error ?? "Unknown error");
-  } finally {
-    for (const cleanup of cleanups) {
-      try {
-        cleanup();
-      } catch {
-      }
-    }
-  }
-};
-var executeIteration = async ({
-  iteration,
-  ctx,
-  cognitive,
-  controller,
-  onExit,
-  onBeforeExecution,
-  onBeforeTool,
-  onAfterTool
-}) => {
-  var _a, _b, _c, _d;
-  let startedAt = Date.now();
+var generateCode = async ({ iteration, ctx, cognitive, controller }) => {
+  var _a, _b, _c;
+  const startedAt = Date.now();
   const traces = iteration.traces;
   const modelRef = Array.isArray(iteration.model) ? iteration.model[0] : iteration.model;
   const model = await cognitive.getModelDetails(modelRef).catch((thrown) => {
@@ -238,13 +101,7 @@ var executeIteration = async ({
     messages: iteration.messages,
     tokenLimit: modelLimit - responseLengthBuffer,
     throwOnFailure: true
-  }).filter(
-    (x) => (
-      // Filter out empty messages, as they are not valid inputs for the LLM
-      // This can happen when a message is truncated and the content is empty
-      typeof x.content !== "string" || x.content.trim().length > 0
-    )
-  );
+  }).filter((x) => typeof x.content !== "string" || x.content.trim().length > 0);
   iteration.messages = messages;
   traces.push({
     type: "llm_call_started",
@@ -255,8 +112,6 @@ var executeIteration = async ({
   const output = await cognitive.generateContent({
     signal: controller.signal,
     systemPrompt: (_a = messages.find((x) => x.role === "system")) == null ? void 0 : _a.content,
-    // Validated upstream in Context (see context.ts isValidModel). Cast narrows
-    // Models' `({} & string)` escape hatch down to cognitive's stricter InputModel.
     model: iteration.model,
     temperature: iteration.temperature,
     responseFormat: "text",
@@ -272,31 +127,6 @@ var executeIteration = async ({
   }
   const assistantResponse = ctx.version.parseAssistantResponse(out);
   iteration.code = assistantResponse.code.trim();
-  if (typeof onBeforeExecution === "function") {
-    try {
-      const hookRes = await onBeforeExecution(iteration, controller);
-      if (typeof (hookRes == null ? void 0 : hookRes.code) === "string" && hookRes.code.trim().length > 0) {
-        iteration.code = hookRes.code.trim();
-      }
-    } catch (err) {
-      if (err instanceof ThinkSignal) {
-        return iteration.end({
-          type: "thinking_requested",
-          thinking_requested: {
-            variables: err.context,
-            reason: err.reason
-          }
-        });
-      }
-      return iteration.end({
-        type: "execution_error",
-        execution_error: {
-          message: `Error in onBeforeExecution hook: ${getErrorMessage(err)}`,
-          stack: cleanStackTrace(err.stack ?? "No stack trace available")
-        }
-      });
-    }
-  }
   iteration.llm = {
     cached: output.meta.cached || false,
     ended_at: Date.now(),
@@ -315,149 +145,63 @@ var executeIteration = async ({
     model: model.ref,
     code: iteration.code
   });
-  const vmContext = { ...stripInvalidIdentifiers(iteration.variables) };
-  for (const obj of iteration.objects) {
-    const internalValues = {};
-    const instance = {};
-    for (const { name, value, writable, type } of obj.properties ?? []) {
-      internalValues[name] = value;
-      const initialValue = value;
-      const schema = type ?? z.any();
-      Object.defineProperty(instance, name, {
-        enumerable: true,
-        configurable: true,
-        get() {
-          return internalValues[name];
-        },
-        set(value2) {
-          if (isEqual_default(value2, internalValues[name])) {
-            return;
-          }
-          if (!writable) {
-            throw new AssignmentError(`Property ${obj.name}.${name} is read-only and cannot be modified`);
-          }
-          if (value2 === internalValues[name]) {
-            return;
-          }
-          const parsed = schema.safeParse(value2);
-          if (!parsed.success) {
-            throw new AssignmentError(
-              `Invalid value for Object property ${obj.name}.${name}: ${getErrorMessage(parsed.error)}`
-            );
-          }
-          internalValues[name] = parsed.data;
-          traces.push({
-            type: "property",
-            started_at: Date.now(),
-            object: obj.name,
-            property: name,
-            value: parsed.data
-          });
-          iteration.trackMutation({ object: obj.name, property: name, before: initialValue, after: parsed.data });
-        }
-      });
-    }
-    for (const tool of obj.tools ?? []) {
-      instance[tool.name] = wrapTool({
-        chat: ctx.chat,
-        tool,
-        traces,
-        object: obj.name,
-        iteration,
-        beforeHook: onBeforeTool,
-        afterHook: onAfterTool,
-        controller
-      });
-    }
-    Object.preventExtensions(instance);
-    Object.seal(instance);
-    vmContext[obj.name] = instance;
-  }
-  for (const tool of iteration.tools) {
-    const wrapped = wrapTool({
-      chat: ctx.chat,
-      tool,
-      traces,
-      iteration,
-      beforeHook: onBeforeTool,
-      afterHook: onAfterTool,
-      controller
-    });
-    for (const key of [tool.name, ...tool.aliases ?? []]) {
-      vmContext[key] = wrapped;
-    }
-  }
-  if (controller.signal.aborted) {
-    traces.push({
-      type: "abort_signal",
-      started_at: Date.now(),
-      reason: "The operation was aborted by user."
-    });
-    return iteration.end({
-      type: "aborted",
-      aborted: {
-        reason: controller.signal.reason ?? "The operation was aborted"
-      }
-    });
-  }
-  startedAt = Date.now();
-  const result = await runAsyncFunction(
-    vmContext,
-    iteration.code,
-    traces,
-    controller.signal,
-    ctx.timeout
-  ).catch((err) => {
-    return {
-      success: false,
-      error: err,
-      lines_executed: [],
-      traces: [],
-      variables: {}
-    };
-  });
+};
+
+// src/runtime/interpret-result.ts
+var interpretVMResult = async ({
+  iteration,
+  result,
+  controller,
+  startedAt,
+  onExit
+}) => {
+  var _a;
   if (result.error && result.error instanceof InvalidCodeError) {
-    return iteration.end({
+    iteration.end({
       type: "invalid_code_error",
       invalid_code_error: {
         message: result.error.message
       }
     });
+    return;
   }
-  traces.push({
+  iteration.traces.push({
     type: "code_execution",
     lines_executed: result.lines_executed ?? 0,
     started_at: startedAt,
     ended_at: Date.now()
   });
   if (controller.signal.aborted) {
-    return iteration.end({
+    iteration.end({
       type: "aborted",
       aborted: {
         reason: controller.signal.reason ?? "The operation was aborted"
       }
     });
+    return;
   }
   if (result.error && result.error instanceof CodeExecutionError) {
-    return iteration.end({
+    iteration.end({
       type: "execution_error",
       execution_error: {
         message: result.error.message,
         stack: cleanStackTrace(result.error.stacktrace ?? result.error.stack ?? "No stack trace available")
       }
     });
+    return;
   }
   if (!result.success) {
-    return iteration.end({
+    iteration.end({
       type: "execution_error",
       execution_error: {
-        message: ((_d = result == null ? void 0 : result.error) == null ? void 0 : _d.message) ?? "Unknown error occurred",
+        message: ((_a = result == null ? void 0 : result.error) == null ? void 0 : _a.message) ?? "Unknown error occurred",
         stack: cleanStackTrace(result.error.stack ?? "No stack trace available")
       }
     });
+    return;
   }
   if (result.signal instanceof ThinkSignal) {
-    return iteration.end({
+    iteration.end({
       type: "thinking_requested",
       thinking_requested: {
         variables: result.signal.context,
@@ -465,39 +209,43 @@ var executeIteration = async ({
         metadata: result.signal.metadata
       }
     });
+    return;
   }
   if (result.signal instanceof SnapshotSignal) {
-    return iteration.end({
+    iteration.end({
       type: "callback_requested",
       callback_requested: {
         signal: result.signal
       }
     });
+    return;
   }
   let returnValue = result.success && result.return_value ? result.return_value : null;
   const returnAction = returnValue == null ? void 0 : returnValue.action;
   if (returnAction === "think") {
     const variables = omit_default(returnValue ?? {}, "action");
     if (isPlainObject_default(variables) && Object.keys(variables).length > 0) {
-      return iteration.end({
+      iteration.end({
         type: "thinking_requested",
         thinking_requested: {
           variables,
           reason: "Thinking requested"
         }
       });
+      return;
     }
-    return iteration.end({
+    iteration.end({
       type: "thinking_requested",
       thinking_requested: {
         reason: "Thinking requested",
         variables: iteration.variables
       }
     });
+    return;
   }
   const parsedExit = parseExit(returnValue, iteration.exits);
   if (!parsedExit.success) {
-    return iteration.end({
+    iteration.end({
       type: "exit_error",
       exit_error: {
         exit: (returnValue == null ? void 0 : returnValue.action) ?? "n/a",
@@ -505,6 +253,7 @@ var executeIteration = async ({
         return_value: returnValue
       }
     });
+    return;
   }
   const returnExit = parsedExit.exit;
   returnValue = { action: returnExit.name, value: parsedExit.value };
@@ -514,7 +263,7 @@ var executeIteration = async ({
       result: returnValue == null ? void 0 : returnValue.value
     }));
   } catch (err) {
-    return iteration.end({
+    iteration.end({
       type: "exit_error",
       exit_error: {
         exit: returnExit.name,
@@ -522,50 +271,101 @@ var executeIteration = async ({
         return_value: returnValue
       }
     });
+    return;
   }
-  return iteration.end({
+  iteration.end({
     type: "exit_success",
     exit_success: {
       exit_name: returnExit.name,
       return_value: returnValue == null ? void 0 : returnValue.value
     }
   });
+  return;
+};
+
+// src/runtime/utils.ts
+var finalizeIteration = async ({ iteration, status, controller, onIterationEnd }) => {
+  if (status) {
+    iteration.end(status);
+  }
+  if (iteration.status.type === "pending") {
+    return;
+  }
+  try {
+    await (onIterationEnd == null ? void 0 : onIterationEnd(iteration, controller));
+  } catch (err) {
+    console.error(err);
+  }
 };
-function wrapTool({ chat, tool, traces, object, iteration, beforeHook, afterHook, controller }) {
+
+// src/runtime/vm-context.ts
+import { z } from "@bpinternal/zui";
+
+// src/runtime/tool-wrapper.ts
+import ms from "ms";
+import { ulid } from "ulid";
+var SLOW_TOOL_WARNING = ms("15s");
+function wrapTool({
+  chat,
+  tool,
+  traces,
+  object,
+  iteration,
+  beforeHook,
+  afterHook,
+  controller
+}) {
   const getToolInput = (input) => tool.zInput.safeParse(input).data ?? input;
-  return function(input) {
+  return async function(input) {
     const toolCallId = `tcall_${ulid()}`;
+    const originalInput = input;
+    let effectiveInput = input;
     const alertSlowTool = setTimeout(
       () => traces.push({
         type: "tool_slow",
         tool_name: tool.name,
         tool_call_id: toolCallId,
         started_at: Date.now(),
-        input: getToolInput(input),
+        input: getToolInput(originalInput),
         object,
         duration: SLOW_TOOL_WARNING
       }),
       SLOW_TOOL_WARNING
     );
-    const cancelSlowTool = () => clearTimeout(alertSlowTool);
     const toolStart = Date.now();
     let output;
     let error;
     let success = true;
-    const handleSignals = (error2) => {
-      if (output === error2) {
+    let signalToThrow;
+    const pushToolCallTrace = () => {
+      traces.push({
+        type: "tool_call",
+        tool_call_id: toolCallId,
+        started_at: toolStart,
+        ended_at: Date.now(),
+        tool_name: tool.name,
+        object,
+        input: getToolInput(originalInput),
+        output,
+        error,
+        success
+      });
+    };
+    const handleSignals = async (err) => {
+      if (output === err) {
         return true;
       }
-      if (error2 instanceof SnapshotSignal) {
-        error2.toolCall = {
+      if (err instanceof SnapshotSignal) {
+        err.toolCall = {
           name: tool.name,
           inputSchema: tool.input,
           outputSchema: tool.output,
-          input
+          input: originalInput
         };
-        error2.message = Signals.serializeError(error2);
+        err.message = Signals.serializeError(err);
       }
-      if (error2 instanceof ThinkSignal) {
+      if (err instanceof ThinkSignal) {
+        signalToThrow = err;
         traces.push({
           type: "think_signal",
           started_at: Date.now(),
@@ -573,150 +373,470 @@ function wrapTool({ chat, tool, traces, object, iteration, beforeHook, afterHook
           ended_at: Date.now()
         });
         success = true;
-        output = error2;
-        return true;
-      }
-      return false;
-    };
-    try {
-      const withHooks = async (input2) => {
-        const beforeRes = await (beforeHook == null ? void 0 : beforeHook({
-          iteration,
-          tool,
-          input: input2,
-          controller,
-          object,
-          toolCallId
-        }));
-        if (typeof (beforeRes == null ? void 0 : beforeRes.input) !== "undefined") {
-          input2 = beforeRes.input;
-        }
-        let output2 = await tool.execute(
-          input2,
-          {
-            callId: toolCallId
-          },
-          chat
-        );
+        output = err;
         const afterRes = await (afterHook == null ? void 0 : afterHook({
           iteration,
           tool,
-          input: input2,
-          output: output2,
+          input: originalInput,
+          output,
           controller,
           object,
           toolCallId
         }));
         if (typeof (afterRes == null ? void 0 : afterRes.output) !== "undefined") {
-          output2 = afterRes.output;
+          output = afterRes.output;
         }
-        return output2;
-      };
-      const result = withHooks(input);
-      if (result instanceof Promise || (result == null ? void 0 : result.then) && (result == null ? void 0 : result.catch)) {
-        return result.then((res) => {
-          output = res;
-          success = true;
-          return res;
-        }).catch(async (err) => {
-          if (!handleSignals(err)) {
-            success = false;
-            error = err;
-          } else {
-            const afterRes = await (afterHook == null ? void 0 : afterHook({
-              iteration,
-              tool,
-              input,
-              output,
-              controller,
-              object,
-              toolCallId
-            }));
-            if (typeof (afterRes == null ? void 0 : afterRes.output) !== "undefined") {
-              output = afterRes.output;
-            }
-          }
-          throw err;
-        }).finally(() => {
-          cancelSlowTool();
-          traces.push({
-            type: "tool_call",
-            tool_call_id: toolCallId,
-            started_at: toolStart,
-            ended_at: Date.now(),
-            tool_name: tool.name,
-            object,
-            input: getToolInput(input),
-            output,
-            error,
-            success
-          });
-        });
+        return true;
+      }
+      return false;
+    };
+    try {
+      const beforeRes = await (beforeHook == null ? void 0 : beforeHook({
+        iteration,
+        tool,
+        input: effectiveInput,
+        controller,
+        object,
+        toolCallId
+      }));
+      if (typeof (beforeRes == null ? void 0 : beforeRes.input) !== "undefined") {
+        effectiveInput = beforeRes.input;
+      }
+      output = await tool.execute(
+        effectiveInput,
+        {
+          callId: toolCallId
+        },
+        chat
+      );
+      const afterRes = await (afterHook == null ? void 0 : afterHook({
+        iteration,
+        tool,
+        input: effectiveInput,
+        output,
+        controller,
+        object,
+        toolCallId
+      }));
+      if (typeof (afterRes == null ? void 0 : afterRes.output) !== "undefined") {
+        output = afterRes.output;
       }
-      success = true;
-      output = result;
     } catch (err) {
-      if (!handleSignals(err)) {
+      if (!await handleSignals(err)) {
         success = false;
         error = err;
       }
+    } finally {
+      clearTimeout(alertSlowTool);
+      pushToolCallTrace();
     }
-    cancelSlowTool();
-    traces.push({
-      type: "tool_call",
-      tool_call_id: toolCallId,
-      started_at: toolStart,
-      ended_at: Date.now(),
-      tool_name: tool.name,
-      object,
-      input: getToolInput(input),
-      output,
-      error,
-      success
-    });
     if (!success) {
       throw error;
     }
-    if (output instanceof VMSignal) {
-      throw output;
+    if (signalToThrow) {
+      throw signalToThrow;
     }
     return output;
   };
 }
-var executeOnIterationStartHook = async (props) => {
-  const { iteration, ctx, onIterationStart, controller, onIterationEnd } = props;
+
+// src/runtime/vm-context.ts
+var buildVMContext = ({
+  ctx,
+  iteration,
+  controller,
+  onBeforeTool,
+  onAfterTool
+}) => {
+  const traces = iteration.traces;
+  const vmContext = { ...stripInvalidIdentifiers(iteration.variables) };
+  for (const obj of iteration.objects) {
+    const internalValues = {};
+    const instance = {};
+    for (const { name, value, writable, type } of obj.properties ?? []) {
+      internalValues[name] = value;
+      const initialValue = value;
+      const schema = type ?? z.any();
+      Object.defineProperty(instance, name, {
+        enumerable: true,
+        configurable: true,
+        get() {
+          return internalValues[name];
+        },
+        set(value2) {
+          if (isEqual_default(value2, internalValues[name])) {
+            return;
+          }
+          if (!writable) {
+            throw new AssignmentError(`Property ${obj.name}.${name} is read-only and cannot be modified`);
+          }
+          const parsed = schema.safeParse(value2);
+          if (!parsed.success) {
+            throw new AssignmentError(
+              `Invalid value for Object property ${obj.name}.${name}: ${getErrorMessage(parsed.error)}`
+            );
+          }
+          internalValues[name] = parsed.data;
+          traces.push({
+            type: "property",
+            started_at: Date.now(),
+            object: obj.name,
+            property: name,
+            value: parsed.data
+          });
+          iteration.trackMutation({ object: obj.name, property: name, before: initialValue, after: parsed.data });
+        }
+      });
+    }
+    for (const tool of obj.tools ?? []) {
+      instance[tool.name] = wrapTool({
+        chat: ctx.chat,
+        tool,
+        traces,
+        object: obj.name,
+        iteration,
+        beforeHook: onBeforeTool,
+        afterHook: onAfterTool,
+        controller
+      });
+    }
+    Object.preventExtensions(instance);
+    Object.seal(instance);
+    vmContext[obj.name] = instance;
+  }
+  for (const tool of iteration.tools) {
+    const wrapped = wrapTool({
+      chat: ctx.chat,
+      tool,
+      traces,
+      iteration,
+      beforeHook: onBeforeTool,
+      afterHook: onAfterTool,
+      controller
+    });
+    for (const key of [tool.name, ...tool.aliases ?? []]) {
+      vmContext[key] = wrapped;
+    }
+  }
+  return vmContext;
+};
+
+// src/runtime/execute.ts
+var executeContext = async (props) => {
+  var _a, _b;
+  await init();
+  const result = await executeContextInternal(props);
+  try {
+    (_b = (_a = result.context.chat) == null ? void 0 : _a.onExecutionDone) == null ? void 0 : _b.call(_a, result);
+  } catch (err) {
+  }
+  return result;
+};
+var executeContextInternal = async (props) => {
+  var _a, _b;
+  const controller = createJoinedAbortController([props.signal]);
+  const { onIterationStart, onIterationEnd, onTrace, onExit, onBeforeExecution, onAfterTool, onBeforeTool } = props;
+  const client = props.client ?? new Client();
+  const cognitive = Cognitive.isCognitiveClient(client) ? client : CognitiveBeta.isBetaClient(client) ? cognitiveFromBeta(client) : new Cognitive({ client, __experimental_beta: true });
+  const ctx = new Context({
+    chat: props.chat,
+    instructions: props.instructions,
+    objects: props.objects,
+    tools: props.tools,
+    loop: (_a = props.options) == null ? void 0 : _a.loop,
+    timeout: (_b = props.options) == null ? void 0 : _b.timeout,
+    exits: props.exits,
+    snapshot: props.snapshot,
+    model: props.model,
+    temperature: props.temperature,
+    reasoningEffort: props.reasoningEffort
+  });
+  try {
+    while (true) {
+      if (ctx.iterations.length >= ctx.loop) {
+        return new ErrorExecutionResult(ctx, new LoopExceededError());
+      }
+      const iteration = await ctx.nextIteration();
+      const unsubscribeTrace = iteration.traces.onPush((traces) => {
+        for (const trace of traces) {
+          onTrace == null ? void 0 : onTrace({ trace, iteration: ctx.iterations.length });
+        }
+      });
+      try {
+        const startHookResult = await executeIterationStartHook({
+          ctx,
+          iteration,
+          controller,
+          onIterationStart,
+          onIterationEnd
+        });
+        if (startHookResult.type === "continue") {
+          continue;
+        }
+        if (controller.signal.aborted) {
+          await finalizeIteration({
+            iteration,
+            controller,
+            onIterationEnd,
+            status: {
+              type: "aborted",
+              aborted: {
+                reason: controller.signal.reason ?? "The operation was aborted"
+              }
+            }
+          });
+          return new ErrorExecutionResult(ctx, controller.signal.reason ?? "The operation was aborted");
+        }
+        const iterationResult = await executeIterationWithErrorHandling({
+          iteration,
+          ctx,
+          cognitive,
+          controller,
+          onExit,
+          onBeforeExecution,
+          onAfterTool,
+          onBeforeTool,
+          onIterationEnd
+        });
+        if (iterationResult.type === "return") {
+          return iterationResult.result;
+        }
+        const selectedResult = transformIterationResult({ ctx, iteration });
+        if (selectedResult.type === "continue") {
+          continue;
+        }
+        return selectedResult.result;
+      } finally {
+        try {
+          unsubscribeTrace();
+        } catch (err) {
+        }
+      }
+    }
+  } catch (error) {
+    return new ErrorExecutionResult(ctx, error ?? "Unknown error");
+  }
+};
+var executeIterationStartHook = async ({
+  ctx,
+  iteration,
+  controller,
+  onIterationStart,
+  onIterationEnd
+}) => {
   try {
     const hookRes = await (onIterationStart == null ? void 0 : onIterationStart(iteration, controller, ctx));
     if (hookRes) {
       Object.assign(iteration, hookRes);
     }
+    return { type: "proceed" };
   } catch (err) {
-    if (err instanceof ThinkSignal) {
-      iteration.end({
+    await finalizeIteration({
+      iteration,
+      controller,
+      onIterationEnd,
+      status: err instanceof ThinkSignal ? {
         type: "thinking_requested",
         thinking_requested: {
           variables: err.context,
           reason: err.reason
         }
+      } : {
+        type: "execution_error",
+        execution_error: {
+          message: `Error in onIterationStart hook: ${getErrorMessage(err)}`,
+          stack: cleanStackTrace(
+            err instanceof Error ? err.stack ?? "No stack trace available" : "No stack trace available"
+          )
+        }
+      }
+    });
+    return { type: "continue" };
+  }
+};
+var executeIterationWithErrorHandling = async ({
+  iteration,
+  ctx,
+  cognitive,
+  controller,
+  onExit,
+  onBeforeExecution,
+  onAfterTool,
+  onBeforeTool,
+  onIterationEnd
+}) => {
+  try {
+    await executeIteration({
+      iteration,
+      ctx,
+      cognitive,
+      controller,
+      onExit,
+      onBeforeExecution,
+      onAfterTool,
+      onBeforeTool
+    });
+    await finalizeIteration({ iteration, controller, onIterationEnd });
+    return { type: "proceed" };
+  } catch (err) {
+    if (!(err instanceof CognitiveError)) {
+      await finalizeIteration({
+        iteration,
+        controller,
+        onIterationEnd,
+        status: iteration.status.type === "pending" ? {
+          type: "execution_error",
+          execution_error: {
+            message: "An unexpected error occurred: " + getErrorMessage(err),
+            stack: cleanStackTrace(
+              err instanceof Error ? err.stack ?? "No stack trace available" : "No stack trace available"
+            )
+          }
+        } : void 0
       });
-      try {
-        await (onIterationEnd == null ? void 0 : onIterationEnd(iteration, controller));
-      } catch (err2) {
-        console.error(err2);
+      return { type: "proceed" };
+    }
+    if (!controller.signal.aborted) {
+      return {
+        type: "return",
+        result: new ErrorExecutionResult(ctx, err)
+      };
+    }
+    await finalizeIteration({
+      iteration,
+      controller,
+      onIterationEnd,
+      status: iteration.status.type === "pending" ? {
+        type: "aborted",
+        aborted: {
+          reason: controller.signal.reason ?? "The operation was aborted"
+        }
+      } : void 0
+    });
+    return {
+      type: "return",
+      result: new ErrorExecutionResult(ctx, controller.signal.reason ?? "The operation was aborted")
+    };
+  }
+};
+var transformIterationResult = ({
+  ctx,
+  iteration
+}) => {
+  if (iteration.status.type === "exit_success") {
+    const exitName = iteration.status.exit_success.exit_name;
+    return {
+      type: "return",
+      result: new SuccessExecutionResult(ctx, {
+        exit: iteration.exits.find((x) => x.name === exitName),
+        result: iteration.status.exit_success.return_value
+      })
+    };
+  }
+  if (iteration.status.type === "callback_requested") {
+    return {
+      type: "return",
+      result: new PartialExecutionResult(
+        ctx,
+        iteration.status.callback_requested.signal,
+        Snapshot.fromSignal(iteration.status.callback_requested.signal)
+      )
+    };
+  }
+  if (iteration.status.type === "aborted") {
+    return {
+      type: "return",
+      result: new ErrorExecutionResult(ctx, iteration.error ?? "The operation was aborted")
+    };
+  }
+  if (iteration.status.type === "thinking_requested" || iteration.status.type === "exit_error" || iteration.status.type === "execution_error" || iteration.status.type === "invalid_code_error") {
+    return { type: "continue" };
+  }
+  return {
+    type: "return",
+    result: new ErrorExecutionResult(ctx, iteration.error ?? `Unknown error. Status: ${iteration.status.type}`)
+  };
+};
+var executeIteration = async ({
+  iteration,
+  ctx,
+  cognitive,
+  controller,
+  onExit,
+  onBeforeExecution,
+  onBeforeTool,
+  onAfterTool
+}) => {
+  await generateCode({ iteration, ctx, cognitive, controller });
+  if (typeof onBeforeExecution === "function") {
+    try {
+      const hookRes = await onBeforeExecution(iteration, controller);
+      if (typeof (hookRes == null ? void 0 : hookRes.code) === "string" && hookRes.code.trim().length > 0) {
+        iteration.code = hookRes.code.trim();
+      }
+    } catch (err) {
+      if (err instanceof ThinkSignal) {
+        iteration.end({
+          type: "thinking_requested",
+          thinking_requested: {
+            variables: err.context,
+            reason: err.reason
+          }
+        });
+        return;
       }
-    } else {
       iteration.end({
         type: "execution_error",
         execution_error: {
-          message: `Error in onIterationStart hook: ${getErrorMessage(err)}`,
-          stack: cleanStackTrace(err.stack ?? "No stack trace available")
+          message: `Error in onBeforeExecution hook: ${getErrorMessage(err)}`,
+          stack: cleanStackTrace(
+            err instanceof Error ? err.stack ?? "No stack trace available" : "No stack trace available"
+          )
         }
       });
+      return;
     }
-    throw err;
   }
+  const traces = iteration.traces;
+  const vmContext = buildVMContext({ ctx, iteration, controller, onBeforeTool, onAfterTool });
+  if (controller.signal.aborted) {
+    traces.push({
+      type: "abort_signal",
+      started_at: Date.now(),
+      reason: "The operation was aborted by user."
+    });
+    iteration.end({
+      type: "aborted",
+      aborted: {
+        reason: controller.signal.reason ?? "The operation was aborted"
+      }
+    });
+    return;
+  }
+  const startedAt = Date.now();
+  const result = await runAsyncFunction(
+    vmContext,
+    iteration.code ?? "",
+    traces,
+    controller.signal,
+    ctx.timeout
+  ).catch((err) => {
+    return {
+      success: false,
+      error: err instanceof Error ? err : new Error(getErrorMessage(err)),
+      lines_executed: [],
+      traces: [],
+      variables: {}
+    };
+  });
+  await interpretVMResult({
+    iteration,
+    result,
+    controller,
+    startedAt,
+    onExit
+  });
 };
 export {
-  _executeContext,
   executeContext
 };