llmz 0.0.82 → 0.0.84

package/dist/{llmz-2HD6WKIP.cjs → execute-2BVFYTJT.cjs}

@@ -1,6 +1,6 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
 
-var _chunkGFZCNSYWcjs = require('./chunk-GFZCNSYW.cjs');
+var _chunkJXD2KJVBcjs = require('./chunk-JXD2KJVB.cjs');
 
 
 
@@ -8,11 +8,10 @@ var _chunkGFZCNSYWcjs = require('./chunk-GFZCNSYW.cjs');
 
 
 
-var _chunkX24YFCFYcjs = require('./chunk-X24YFCFY.cjs');
-require('./chunk-5X5TDCMX.cjs');
-require('./chunk-H5LCBNN6.cjs');
-require('./chunk-BXPPMP5X.cjs');
-
+var _chunkPQGZQQA6cjs = require('./chunk-PQGZQQA6.cjs');
+require('./chunk-BBX2LDZE.cjs');
+require('./chunk-WODK7Y4J.cjs');
+require('./chunk-7LMIOS6H.cjs');
 
 
 
@@ -26,33 +25,27 @@ var _chunkPK72FAKDcjs = require('./chunk-PK72FAKD.cjs');
 
 
 var _chunkKIN7Y247cjs = require('./chunk-KIN7Y247.cjs');
-require('./chunk-DLV5FJ42.cjs');
-require('./chunk-VXQ2CZ7B.cjs');
-require('./chunk-OX3Y2Z5K.cjs');
-
-
-var _chunkTB6TCWEBcjs = require('./chunk-TB6TCWEB.cjs');
-
+require('./chunk-D6PU5YAS.cjs');
+require('./chunk-CQ3UJW76.cjs');
+require('./chunk-5ZF6NTYI.cjs');
 
 
-var _chunkFQ4QCUTIcjs = require('./chunk-FQ4QCUTI.cjs');
+var _chunkZPHRTTQXcjs = require('./chunk-ZPHRTTQX.cjs');
 
 
 
 
+var _chunkFPLSJF4Scjs = require('./chunk-FPLSJF4S.cjs');
 
-var _chunk7XVBJQ53cjs = require('./chunk-7XVBJQ53.cjs');
 
-// src/llmz.ts
-var _client = require('@botpress/client');
 
 
 
+var _chunkHC2QZTVTcjs = require('./chunk-HC2QZTVT.cjs');
 
+// src/runtime/execute.ts
+var _client = require('@botpress/client');
 var _cognitive = require('@botpress/cognitive');
-var _zui = require('@bpinternal/zui');
-var _ms = require('ms'); var _ms2 = _interopRequireDefault(_ms);
-var _ulid = require('ulid');
 
 // src/abort-signal.ts
 function createJoinedAbortController(signals) {
@@ -83,172 +76,32 @@ function createJoinedAbortController(signals) {
   return controller;
 }
 
-// src/llmz.ts
-var getErrorMessage = (err) => err instanceof Error ? err.message : JSON.stringify(err);
-var SLOW_TOOL_WARNING = _ms2.default.call(void 0, "15s");
+// src/runtime/generate.ts
 var RESPONSE_LENGTH_BUFFER = {
   MIN_TOKENS: 1e3,
   MAX_TOKENS: 16e3,
   PERCENTAGE: 0.1
 };
-var getModelOutputLimit = (inputLength) => _chunk7XVBJQ53cjs.clamp_default.call(void 0, 
+var getModelOutputLimit = (inputLength) => _chunkHC2QZTVTcjs.clamp_default.call(void 0, 
   RESPONSE_LENGTH_BUFFER.PERCENTAGE * inputLength,
   RESPONSE_LENGTH_BUFFER.MIN_TOKENS,
   RESPONSE_LENGTH_BUFFER.MAX_TOKENS
 );
-var executeContext = async (props) => {
-  var _a, _b;
-  await _chunkFQ4QCUTIcjs.init.call(void 0, );
-  const result = await _executeContext(props);
-  try {
-    (_b = (_a = result.context.chat) == null ? void 0 : _a.onExecutionDone) == null ? void 0 : _b.call(_a, result);
-  } catch (e) {
-  }
-  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 = _nullishCoalesce(props.client, () => ( new (0, _client.Client)()));
-  const cognitive = _cognitive.Cognitive.isCognitiveClient(client) ? client : _cognitive.CognitiveBeta.isBetaClient(client) ? _cognitive.cognitiveFromBeta.call(void 0, client) : new (0, _cognitive.Cognitive)({ client, __experimental_beta: true });
-  const cleanups = [];
-  const ctx = new (0, _chunkX24YFCFYcjs.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 (0, _chunkX24YFCFYcjs.ErrorExecutionResult)(ctx, new (0, _chunkPK72FAKDcjs.LoopExceededError)());
-      }
-      const iteration = await ctx.nextIteration();
-      try {
-        await executeOnIterationStartHook({
-          iteration,
-          ctx,
-          onIterationStart,
-          controller,
-          onIterationEnd
-        });
-      } catch (err) {
-        if (err instanceof _chunkPK72FAKDcjs.ThinkSignal) {
-          continue;
-        }
-      }
-      if (controller.signal.aborted) {
-        iteration.end({
-          type: "aborted",
-          aborted: {
-            reason: _nullishCoalesce(controller.signal.reason, () => ( "The operation was aborted"))
-          }
-        });
-        return new (0, _chunkX24YFCFYcjs.ErrorExecutionResult)(ctx, _nullishCoalesce(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 _chunkPK72FAKDcjs.CognitiveError) {
-          return new (0, _chunkX24YFCFYcjs.ErrorExecutionResult)(ctx, err);
-        }
-        iteration.end({
-          type: "execution_error",
-          execution_error: {
-            message: "An unexpected error occurred: " + getErrorMessage(err),
-            stack: _chunkKIN7Y247cjs.cleanStackTrace.call(void 0, _nullishCoalesce(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 (0, _chunkX24YFCFYcjs.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 (0, _chunkX24YFCFYcjs.PartialExecutionResult)(
-          ctx,
-          iteration.status.callback_requested.signal,
-          _chunkX24YFCFYcjs.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 (0, _chunkX24YFCFYcjs.ErrorExecutionResult)(ctx, _nullishCoalesce(iteration.error, () => ( `Unknown error. Status: ${iteration.status.type}`)));
-    }
-  } catch (error) {
-    return new (0, _chunkX24YFCFYcjs.ErrorExecutionResult)(ctx, _nullishCoalesce(error, () => ( "Unknown error")));
-  } finally {
-    for (const cleanup of cleanups) {
-      try {
-        cleanup();
-      } catch (e2) {
-      }
-    }
-  }
-};
-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) => {
-    throw new (0, _chunkPK72FAKDcjs.CognitiveError)(`Failed to fetch model details for model "${modelRef}": ${getErrorMessage(thrown)}`);
+    throw new (0, _chunkPK72FAKDcjs.CognitiveError)(`Failed to fetch model details for model "${modelRef}": ${_chunkFPLSJF4Scjs.getErrorMessage.call(void 0, thrown)}`);
   });
   const modelLimit = Math.max(model.input.maxTokens, 8e3);
   const responseLengthBuffer = getModelOutputLimit(modelLimit);
-  const messages = _chunkTB6TCWEBcjs.truncateWrappedContent.call(void 0, {
+  const messages = _chunkZPHRTTQXcjs.truncateWrappedContent.call(void 0, {
     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",
@@ -259,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",
@@ -268,7 +119,7 @@ var executeIteration = async ({
     messages: messages.filter((x) => x.role !== "system"),
     stopSequences: ctx.version.getStopTokens()
   }).catch((thrown) => {
-    throw new (0, _chunkPK72FAKDcjs.CognitiveError)(`LLM generation failed: ${getErrorMessage(thrown)}`);
+    throw new (0, _chunkPK72FAKDcjs.CognitiveError)(`LLM generation failed: ${_chunkFPLSJF4Scjs.getErrorMessage.call(void 0, thrown)}`);
   });
   const out = typeof ((_c = (_b = output.output.choices) == null ? void 0 : _b[0]) == null ? void 0 : _c.content) === "string" ? output.output.choices[0].content : null;
   if (!out) {
@@ -276,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 _chunkPK72FAKDcjs.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: _chunkKIN7Y247cjs.cleanStackTrace.call(void 0, _nullishCoalesce(err.stack, () => ( "No stack trace available")))
-        }
-      });
-    }
-  }
   iteration.llm = {
     cached: output.meta.cached || false,
     ended_at: Date.now(),
@@ -319,149 +145,63 @@ var executeIteration = async ({
     model: model.ref,
     code: iteration.code
   });
-  const vmContext = { ..._chunkFQ4QCUTIcjs.stripInvalidIdentifiers.call(void 0, iteration.variables) };
-  for (const obj of iteration.objects) {
-    const internalValues = {};
-    const instance = {};
-    for (const { name, value, writable, type } of _nullishCoalesce(obj.properties, () => ( []))) {
-      internalValues[name] = value;
-      const initialValue = value;
-      const schema = _nullishCoalesce(type, () => ( _zui.z.any()));
-      Object.defineProperty(instance, name, {
-        enumerable: true,
-        configurable: true,
-        get() {
-          return internalValues[name];
-        },
-        set(value2) {
-          if (_chunk7XVBJQ53cjs.isEqual_default.call(void 0, value2, internalValues[name])) {
-            return;
-          }
-          if (!writable) {
-            throw new (0, _chunkPK72FAKDcjs.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 (0, _chunkPK72FAKDcjs.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 _nullishCoalesce(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, ..._nullishCoalesce(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: _nullishCoalesce(controller.signal.reason, () => ( "The operation was aborted"))
-      }
-    });
-  }
-  startedAt = Date.now();
-  const result = await _chunkGFZCNSYWcjs.runAsyncFunction.call(void 0, 
-    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 _chunkPK72FAKDcjs.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: _nullishCoalesce(result.lines_executed, () => ( 0)),
     started_at: startedAt,
     ended_at: Date.now()
   });
   if (controller.signal.aborted) {
-    return iteration.end({
+    iteration.end({
       type: "aborted",
       aborted: {
         reason: _nullishCoalesce(controller.signal.reason, () => ( "The operation was aborted"))
       }
     });
+    return;
   }
   if (result.error && result.error instanceof _chunkPK72FAKDcjs.CodeExecutionError) {
-    return iteration.end({
+    iteration.end({
       type: "execution_error",
       execution_error: {
         message: result.error.message,
         stack: _chunkKIN7Y247cjs.cleanStackTrace.call(void 0, _nullishCoalesce(_nullishCoalesce(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: _nullishCoalesce(((_d = result == null ? void 0 : result.error) == null ? void 0 : _d.message), () => ( "Unknown error occurred")),
+        message: _nullishCoalesce(((_a = result == null ? void 0 : result.error) == null ? void 0 : _a.message), () => ( "Unknown error occurred")),
         stack: _chunkKIN7Y247cjs.cleanStackTrace.call(void 0, _nullishCoalesce(result.error.stack, () => ( "No stack trace available")))
       }
     });
+    return;
   }
   if (result.signal instanceof _chunkPK72FAKDcjs.ThinkSignal) {
-    return iteration.end({
+    iteration.end({
       type: "thinking_requested",
       thinking_requested: {
         variables: result.signal.context,
@@ -469,39 +209,43 @@ var executeIteration = async ({
         metadata: result.signal.metadata
       }
     });
+    return;
   }
   if (result.signal instanceof _chunkPK72FAKDcjs.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 = _chunk7XVBJQ53cjs.omit_default.call(void 0, _nullishCoalesce(returnValue, () => ( {})), "action");
-    if (_chunk7XVBJQ53cjs.isPlainObject_default.call(void 0, variables) && Object.keys(variables).length > 0) {
-      return iteration.end({
+    const variables = _chunkHC2QZTVTcjs.omit_default.call(void 0, _nullishCoalesce(returnValue, () => ( {})), "action");
+    if (_chunkHC2QZTVTcjs.isPlainObject_default.call(void 0, variables) && Object.keys(variables).length > 0) {
+      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 = _chunkX24YFCFYcjs.parseExit.call(void 0, returnValue, iteration.exits);
+  const parsedExit = _chunkPQGZQQA6cjs.parseExit.call(void 0, returnValue, iteration.exits);
   if (!parsedExit.success) {
-    return iteration.end({
+    iteration.end({
       type: "exit_error",
       exit_error: {
         exit: _nullishCoalesce((returnValue == null ? void 0 : returnValue.action), () => ( "n/a")),
@@ -509,6 +253,7 @@ var executeIteration = async ({
         return_value: returnValue
       }
     });
+    return;
   }
   const returnExit = parsedExit.exit;
   returnValue = { action: returnExit.name, value: parsedExit.value };
@@ -518,58 +263,109 @@ 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,
-        message: `Error executing exit ${returnExit.name}: ${getErrorMessage(err)}`,
+        message: `Error executing exit ${returnExit.name}: ${_chunkFPLSJF4Scjs.getErrorMessage.call(void 0, err)}`,
         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
+var _zui = require('@bpinternal/zui');
+
+// src/runtime/tool-wrapper.ts
+var _ms = require('ms'); var _ms2 = _interopRequireDefault(_ms);
+var _ulid = require('ulid');
+var SLOW_TOOL_WARNING = _ms2.default.call(void 0, "15s");
+function wrapTool({
+  chat,
+  tool,
+  traces,
+  object,
+  iteration,
+  beforeHook,
+  afterHook,
+  controller
+}) {
   const getToolInput = (input) => _nullishCoalesce(tool.zInput.safeParse(input).data, () => ( input));
-  return function(input) {
+  return async function(input) {
     const toolCallId = `tcall_${_ulid.ulid.call(void 0, )}`;
+    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 _chunkPK72FAKDcjs.SnapshotSignal) {
-        error2.toolCall = {
+      if (err instanceof _chunkPK72FAKDcjs.SnapshotSignal) {
+        err.toolCall = {
           name: tool.name,
           inputSchema: tool.input,
           outputSchema: tool.output,
-          input
+          input: originalInput
         };
-        error2.message = _chunkPK72FAKDcjs.Signals.serializeError(error2);
+        err.message = _chunkPK72FAKDcjs.Signals.serializeError(err);
       }
-      if (error2 instanceof _chunkPK72FAKDcjs.ThinkSignal) {
+      if (err instanceof _chunkPK72FAKDcjs.ThinkSignal) {
+        signalToThrow = err;
         traces.push({
           type: "think_signal",
           started_at: Date.now(),
@@ -577,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;
       }
-      success = true;
-      output = result;
-    } catch (err) {
-      if (!handleSignals(err)) {
-        success = false;
+      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;
+      }
+    } catch (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 _chunkPK72FAKDcjs.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 = { ..._chunkFPLSJF4Scjs.stripInvalidIdentifiers.call(void 0, iteration.variables) };
+  for (const obj of iteration.objects) {
+    const internalValues = {};
+    const instance = {};
+    for (const { name, value, writable, type } of _nullishCoalesce(obj.properties, () => ( []))) {
+      internalValues[name] = value;
+      const initialValue = value;
+      const schema = _nullishCoalesce(type, () => ( _zui.z.any()));
+      Object.defineProperty(instance, name, {
+        enumerable: true,
+        configurable: true,
+        get() {
+          return internalValues[name];
+        },
+        set(value2) {
+          if (_chunkHC2QZTVTcjs.isEqual_default.call(void 0, value2, internalValues[name])) {
+            return;
+          }
+          if (!writable) {
+            throw new (0, _chunkPK72FAKDcjs.AssignmentError)(`Property ${obj.name}.${name} is read-only and cannot be modified`);
+          }
+          const parsed = schema.safeParse(value2);
+          if (!parsed.success) {
+            throw new (0, _chunkPK72FAKDcjs.AssignmentError)(
+              `Invalid value for Object property ${obj.name}.${name}: ${_chunkFPLSJF4Scjs.getErrorMessage.call(void 0, 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 _nullishCoalesce(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, ..._nullishCoalesce(tool.aliases, () => ( []))]) {
+      vmContext[key] = wrapped;
+    }
+  }
+  return vmContext;
+};
+
+// src/runtime/execute.ts
+var executeContext = async (props) => {
+  var _a, _b;
+  await _chunkFPLSJF4Scjs.init.call(void 0, );
+  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 = _nullishCoalesce(props.client, () => ( new (0, _client.Client)()));
+  const cognitive = _cognitive.Cognitive.isCognitiveClient(client) ? client : _cognitive.CognitiveBeta.isBetaClient(client) ? _cognitive.cognitiveFromBeta.call(void 0, client) : new (0, _cognitive.Cognitive)({ client, __experimental_beta: true });
+  const ctx = new (0, _chunkPQGZQQA6cjs.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 (0, _chunkPQGZQQA6cjs.ErrorExecutionResult)(ctx, new (0, _chunkPK72FAKDcjs.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: _nullishCoalesce(controller.signal.reason, () => ( "The operation was aborted"))
+              }
+            }
+          });
+          return new (0, _chunkPQGZQQA6cjs.ErrorExecutionResult)(ctx, _nullishCoalesce(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 (0, _chunkPQGZQQA6cjs.ErrorExecutionResult)(ctx, _nullishCoalesce(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 _chunkPK72FAKDcjs.ThinkSignal) {
-      iteration.end({
+    await finalizeIteration({
+      iteration,
+      controller,
+      onIterationEnd,
+      status: err instanceof _chunkPK72FAKDcjs.ThinkSignal ? {
         type: "thinking_requested",
         thinking_requested: {
           variables: err.context,
           reason: err.reason
         }
+      } : {
+        type: "execution_error",
+        execution_error: {
+          message: `Error in onIterationStart hook: ${_chunkFPLSJF4Scjs.getErrorMessage.call(void 0, err)}`,
+          stack: _chunkKIN7Y247cjs.cleanStackTrace.call(void 0, 
+            err instanceof Error ? _nullishCoalesce(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 _chunkPK72FAKDcjs.CognitiveError)) {
+      await finalizeIteration({
+        iteration,
+        controller,
+        onIterationEnd,
+        status: iteration.status.type === "pending" ? {
+          type: "execution_error",
+          execution_error: {
+            message: "An unexpected error occurred: " + _chunkFPLSJF4Scjs.getErrorMessage.call(void 0, err),
+            stack: _chunkKIN7Y247cjs.cleanStackTrace.call(void 0, 
+              err instanceof Error ? _nullishCoalesce(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 (0, _chunkPQGZQQA6cjs.ErrorExecutionResult)(ctx, err)
+      };
+    }
+    await finalizeIteration({
+      iteration,
+      controller,
+      onIterationEnd,
+      status: iteration.status.type === "pending" ? {
+        type: "aborted",
+        aborted: {
+          reason: _nullishCoalesce(controller.signal.reason, () => ( "The operation was aborted"))
+        }
+      } : void 0
+    });
+    return {
+      type: "return",
+      result: new (0, _chunkPQGZQQA6cjs.ErrorExecutionResult)(ctx, _nullishCoalesce(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 (0, _chunkPQGZQQA6cjs.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 (0, _chunkPQGZQQA6cjs.PartialExecutionResult)(
+        ctx,
+        iteration.status.callback_requested.signal,
+        _chunkPQGZQQA6cjs.Snapshot.fromSignal(iteration.status.callback_requested.signal)
+      )
+    };
+  }
+  if (iteration.status.type === "aborted") {
+    return {
+      type: "return",
+      result: new (0, _chunkPQGZQQA6cjs.ErrorExecutionResult)(ctx, _nullishCoalesce(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 (0, _chunkPQGZQQA6cjs.ErrorExecutionResult)(ctx, _nullishCoalesce(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 _chunkPK72FAKDcjs.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: _chunkKIN7Y247cjs.cleanStackTrace.call(void 0, _nullishCoalesce(err.stack, () => ( "No stack trace available")))
+          message: `Error in onBeforeExecution hook: ${_chunkFPLSJF4Scjs.getErrorMessage.call(void 0, err)}`,
+          stack: _chunkKIN7Y247cjs.cleanStackTrace.call(void 0, 
+            err instanceof Error ? _nullishCoalesce(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: _nullishCoalesce(controller.signal.reason, () => ( "The operation was aborted"))
+      }
+    });
+    return;
+  }
+  const startedAt = Date.now();
+  const result = await _chunkJXD2KJVBcjs.runAsyncFunction.call(void 0, 
+    vmContext,
+    _nullishCoalesce(iteration.code, () => ( "")),
+    traces,
+    controller.signal,
+    ctx.timeout
+  ).catch((err) => {
+    return {
+      success: false,
+      error: err instanceof Error ? err : new Error(_chunkFPLSJF4Scjs.getErrorMessage.call(void 0, err)),
+      lines_executed: [],
+      traces: [],
+      variables: {}
+    };
+  });
+  await interpretVMResult({
+    iteration,
+    result,
+    controller,
+    startedAt,
+    onExit
+  });
 };
 
 
-
-exports._executeContext = _executeContext; exports.executeContext = executeContext;
+exports.executeContext = executeContext;