llmz 0.6.0 → 0.6.2

package/dist/execute-FF7D46TY.js

@@ -1,1109 +0,0 @@
-import {
-  hasTopLevelReturn,
-  runAsyncFunction,
-  warmupVM
-} from "./chunk-YRS7KRKP.js";
-import {
-  Context,
-  ErrorExecutionResult,
-  PartialExecutionResult,
-  Snapshot,
-  SuccessExecutionResult,
-  _CustomModelClient,
-  parseExit
-} from "./chunk-4POZJQXN.js";
-import {
-  StreamingMessageParser,
-  toParsedAssistantResponse
-} from "./chunk-LOX7GOR6.js";
-import "./chunk-UGHFNCPD.js";
-import "./chunk-TDALRNGL.js";
-import "./chunk-GDJTKI7J.js";
-import {
-  AssignmentError,
-  CodeExecutionError,
-  CognitiveError,
-  InvalidCodeError,
-  LoopExceededError,
-  Signals,
-  SnapshotSignal,
-  ThinkSignal
-} from "./chunk-WSVDMGMR.js";
-import {
-  cleanStackTrace
-} from "./chunk-YEAWWJSJ.js";
-import "./chunk-HB2G32AK.js";
-import "./chunk-KWQTYXAT.js";
-import {
-  createJsxComponent
-} from "./chunk-XTEHT2TK.js";
-import {
-  truncateWrappedContent
-} from "./chunk-72ZWBNZV.js";
-import {
-  getErrorMessage,
-  init,
-  stripInvalidIdentifiers
-} from "./chunk-GLXADNTR.js";
-import {
-  clamp_default,
-  isEqual_default
-} from "./chunk-34GJUS6U.js";
-
-// src/runtime/execute.ts
-import { Client } from "@botpress/client";
-import { Cognitive } from "@botpress/cognitive";
-
-// src/abort-signal.ts
-function createJoinedAbortController(signals) {
-  const controller = new AbortController();
-  const validSignals = signals.filter((signal) => signal != null);
-  if (validSignals.length === 0) {
-    return controller;
-  }
-  for (const signal of validSignals) {
-    if (signal.aborted) {
-      controller.abort(signal.reason);
-      return controller;
-    }
-  }
-  const abortListeners = [];
-  for (const signal of validSignals) {
-    const listener = () => {
-      controller.abort(signal.reason);
-      cleanup();
-    };
-    signal.addEventListener("abort", listener);
-    abortListeners.push(() => signal.removeEventListener("abort", listener));
-  }
-  const cleanup = () => {
-    abortListeners.forEach((removeListener) => removeListener());
-  };
-  controller.signal.addEventListener("abort", cleanup, { once: true });
-  return controller;
-}
-
-// src/runtime/generate.ts
-var RESPONSE_LENGTH_BUFFER = {
-  MIN_TOKENS: 1e3,
-  MAX_TOKENS: 16e3,
-  PERCENTAGE: 0.1
-};
-var STREAM_INACTIVITY_TIMEOUT = 6e4;
-var getModelOutputLimit = (inputLength) => clamp_default(
-  RESPONSE_LENGTH_BUFFER.PERCENTAGE * inputLength,
-  RESPONSE_LENGTH_BUFFER.MIN_TOKENS,
-  RESPONSE_LENGTH_BUFFER.MAX_TOKENS
-);
-var LeadingFenceFilter = class {
-  _buffer = "";
-  _done = false;
-  push(text) {
-    if (this._done) {
-      return text;
-    }
-    this._buffer += text;
-    const newline = this._buffer.indexOf("\n");
-    if (newline === -1) {
-      return "";
-    }
-    this._done = true;
-    const firstLine = this._buffer.slice(0, newline);
-    const rest = this._buffer.slice(newline + 1);
-    this._buffer = "";
-    return firstLine.trim().startsWith("```") ? rest : `${firstLine}
-${rest}`;
-  }
-  flush() {
-    if (this._done) {
-      return "";
-    }
-    this._done = true;
-    const buffered = this._buffer;
-    this._buffer = "";
-    return buffered.trim().startsWith("```") ? "" : buffered;
-  }
-};
-var generateCode = async ({
-  iteration,
-  ctx,
-  cognitive,
-  controller,
-  metadata,
-  onSend,
-  onSendDelta,
-  onRunStart,
-  onRunComplete
-}) => {
-  var _a, _b;
-  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 CognitiveError(`Failed to fetch model details for model "${modelRef}": ${getErrorMessage(thrown)}`);
-  });
-  let modelLimit = Math.max(model.input.maxTokens, 8e3);
-  if (ctx.maxTokens) {
-    modelLimit = Math.min(ctx.maxTokens, modelLimit);
-  }
-  const responseLengthBuffer = getModelOutputLimit(modelLimit);
-  if (iteration.tokens) {
-    iteration.tokens.limit = modelLimit;
-  }
-  let messages;
-  try {
-    messages = truncateWrappedContent({
-      messages: iteration.messages,
-      tokenLimit: modelLimit - responseLengthBuffer,
-      throwOnFailure: true
-    }).filter((x) => typeof x.content !== "string" || x.content.trim().length > 0);
-  } catch (thrown) {
-    const cap = ctx.maxTokens ? ` (context window capped at ${modelLimit} tokens by options.maxTokens \u2014 consider raising or removing it)` : ` (model context window: ${modelLimit} tokens)`;
-    throw new CognitiveError(`The prompt does not fit in the context window${cap}: ${getErrorMessage(thrown)}`);
-  }
-  iteration.messages = messages;
-  traces.push({
-    type: "llm_call_started",
-    started_at: startedAt,
-    ended_at: startedAt,
-    model: model.id
-  });
-  const hasAudioParts = messages.some(
-    (message) => Array.isArray(message.content) && message.content.some((part) => part.type === "audio")
-  );
-  const input = {
-    model: iteration.model,
-    temperature: iteration.temperature,
-    responseFormat: "text",
-    reasoningEffort: iteration.reasoningEffort,
-    messages,
-    stopSequences: ctx.version.getStopTokens(),
-    meta: metadata ? { metadata } : void 0,
-    options: hasAudioParts ? { transcriptionModel: ctx.transcriptionModel ?? "fast" } : void 0
-  };
-  let responseMetadata;
-  let raw;
-  let assistantResponse;
-  let timeToFirstToken;
-  let timeToLastToken;
-  const liveItems = /* @__PURE__ */ new Map();
-  const liveContent = /* @__PURE__ */ new Map();
-  let codeGenerationTraced = false;
-  let runCompleted = false;
-  const dispatchSends = async (events) => {
-    for (const event of events) {
-      if (event.type === "item-start") {
-        liveItems.set(event.item.id, event.item);
-        if (event.item.kind === "run" && !codeGenerationTraced) {
-          codeGenerationTraced = true;
-          traces.push({ type: "code_generation_started", started_at: Date.now() });
-          onRunStart == null ? void 0 : onRunStart();
-        }
-      } else if (event.type === "body-delta" && onSendDelta) {
-        const item = liveItems.get(event.itemId);
-        if ((item == null ? void 0 : item.kind) !== "send") {
-          continue;
-        }
-        const content = (liveContent.get(item.id) ?? "") + event.delta;
-        liveContent.set(item.id, content);
-        try {
-          await onSendDelta({
-            id: `${iteration.id}:${item.id}`,
-            component: item.name,
-            props: item.props,
-            delta: event.delta,
-            content
-          });
-        } catch (err) {
-        }
-      } else if (event.type === "item-complete") {
-        if (event.item.kind === "send" && onSend) {
-          await onSend({ name: event.item.name, props: event.item.props, body: event.item.body });
-        } else if (event.item.kind === "run" && event.item.status === "complete" && !runCompleted) {
-          runCompleted = true;
-          onRunComplete == null ? void 0 : onRunComplete((event.item.body ?? "").trim());
-        }
-      }
-    }
-  };
-  if (typeof cognitive.generateTextStream === "function") {
-    const parser = new StreamingMessageParser();
-    const fence = new LeadingFenceFilter();
-    const streamController = createJoinedAbortController([controller.signal]);
-    const requestedAt = Date.now();
-    const stream = cognitive.generateTextStream(
-      {
-        ...input,
-        // Passed through to the cognitive request: fall back to the next
-        // model/provider when the first token takes too long
-        ...ctx.maxTimeToFirstToken ? { options: { ...input.options, maxTimeToFirstToken: ctx.maxTimeToFirstToken } } : {}
-      },
-      { signal: streamController.signal }
-    );
-    const inactivityTimeout = Math.max(STREAM_INACTIVITY_TIMEOUT, ctx.maxTimeToFirstToken ?? 0);
-    const nextChunk = async () => {
-      let timer;
-      const stalled = new Promise((_, reject) => {
-        timer = setTimeout(() => {
-          streamController.abort("LLM stream stalled");
-          reject(new Error(`LLM stream stalled: no data received for ${inactivityTimeout}ms`));
-        }, inactivityTimeout);
-      });
-      try {
-        return await Promise.race([stream.next(), stalled]);
-      } finally {
-        clearTimeout(timer);
-      }
-    };
-    raw = "";
-    while (true) {
-      let chunk;
-      try {
-        chunk = await nextChunk();
-      } catch (thrown) {
-        throw new CognitiveError(`LLM generation failed: ${getErrorMessage(thrown)}`);
-      }
-      if (chunk.done) {
-        break;
-      }
-      if ((_a = chunk.value) == null ? void 0 : _a.metadata) {
-        responseMetadata = chunk.value.metadata;
-      }
-      const delta = (_b = chunk.value) == null ? void 0 : _b.output;
-      if (!delta) {
-        continue;
-      }
-      timeToLastToken = Date.now() - requestedAt;
-      timeToFirstToken ??= timeToLastToken;
-      raw += delta;
-      await dispatchSends(parser.push(fence.push(delta)));
-    }
-    if (!responseMetadata) {
-      throw new CognitiveError("LLM streaming completed without metadata");
-    }
-    const remaining = fence.flush();
-    if (remaining) {
-      await dispatchSends(parser.push(remaining));
-    }
-    await dispatchSends(parser.finish());
-    assistantResponse = toParsedAssistantResponse(parser.items, raw);
-  } else {
-    const response = await cognitive.generateText(input, { signal: controller.signal }).catch((thrown) => {
-      throw new CognitiveError(`LLM generation failed: ${getErrorMessage(thrown)}`);
-    });
-    if (!response.output) {
-      throw new CognitiveError("LLM did not return any text output");
-    }
-    responseMetadata = response.metadata;
-    raw = response.output;
-    assistantResponse = ctx.version.parseAssistantResponse(raw);
-    for (const send of assistantResponse.sends) {
-      await (onSend == null ? void 0 : onSend(send));
-    }
-  }
-  iteration.code = assistantResponse.code;
-  iteration.sends = assistantResponse.sends;
-  iteration.next = assistantResponse.next;
-  const usage = responseMetadata.usage;
-  iteration.llm = {
-    cached: responseMetadata.cached || false,
-    ended_at: Date.now(),
-    started_at: startedAt,
-    status: "success",
-    tokens: usage.inputTokens + usage.outputTokens,
-    spend: responseMetadata.cost ?? usage.inputCost + usage.outputCost,
-    output: assistantResponse.raw,
-    model: `${responseMetadata.provider}:${responseMetadata.model}`,
-    time_to_first_token: timeToFirstToken,
-    time_to_last_token: timeToLastToken,
-    usage: {
-      inputTokens: usage.inputTokens,
-      inputCost: usage.inputCost,
-      outputTokens: usage.outputTokens,
-      outputCost: usage.outputCost
-    }
-  };
-  if (iteration.tokens) {
-    iteration.tokens.input = usage.inputTokens;
-    iteration.tokens.output = usage.outputTokens;
-    iteration.tokens.total = usage.inputTokens + usage.outputTokens;
-  }
-  traces.push({
-    type: "llm_call_success",
-    started_at: startedAt,
-    ended_at: iteration.llm.ended_at,
-    model: model.id,
-    code: iteration.code ?? ""
-  });
-};
-
-// src/runtime/interpret-result.ts
-var interpretVMResult = async ({
-  iteration,
-  result,
-  controller,
-  startedAt,
-  onExit
-}) => {
-  var _a;
-  if (result.error && result.error instanceof InvalidCodeError) {
-    iteration.end({
-      type: "invalid_code_error",
-      invalid_code_error: {
-        message: result.error.message
-      }
-    });
-    return;
-  }
-  iteration.traces.push({
-    type: "code_execution",
-    lines_executed: result.lines_executed ?? 0,
-    started_at: startedAt,
-    ended_at: Date.now()
-  });
-  if (controller.signal.aborted) {
-    iteration.end({
-      type: "aborted",
-      aborted: {
-        reason: controller.signal.reason ?? "The operation was aborted"
-      }
-    });
-    return;
-  }
-  if (result.error && result.error instanceof CodeExecutionError) {
-    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) {
-    iteration.end({
-      type: "execution_error",
-      execution_error: {
-        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) {
-    iteration.end({
-      type: "thinking_requested",
-      thinking_requested: {
-        variables: result.signal.context,
-        reason: result.signal.reason,
-        metadata: result.signal.metadata
-      }
-    });
-    return;
-  }
-  if (result.signal instanceof SnapshotSignal) {
-    iteration.end({
-      type: "callback_requested",
-      callback_requested: {
-        signal: result.signal
-      }
-    });
-    return;
-  }
-  const returnValue = result.return_value;
-  const codeRequestsInspection = hasTopLevelReturn(iteration.code ?? "");
-  if (iteration.next && !codeRequestsInspection) {
-    await applyNextExit({ iteration, controller, onExit });
-    return;
-  }
-  const localVariables = Object.fromEntries(
-    Object.entries(result.variables ?? {}).filter(([, value]) => value !== "[[non-primitive]]")
-  );
-  iteration.end({
-    type: "thinking_requested",
-    thinking_requested: {
-      reason: iteration.next ? `Code execution completed. The \u25A0next=${iteration.next.name} exit was NOT applied because your code returns a value \u2014 inspect it below, then end your next response with \u25A0next.` : "Code execution completed",
-      variables: returnValue !== void 0 ? returnValue : Object.keys(localVariables).length ? localVariables : iteration.variables
-    }
-  });
-};
-var applyNextExit = async ({
-  iteration,
-  controller,
-  onExit
-}) => {
-  const next = iteration.next;
-  if (!next) {
-    throw new Error("applyNextExit called without a \u25A0next block on the iteration");
-  }
-  const attempt = (props) => parseExit(Object.keys(props).length ? { action: next.name, value: props } : { action: next.name }, iteration.exits);
-  let parsedExit = attempt(next.props);
-  const keys = Object.keys(next.props);
-  if (!parsedExit.success && keys.length === 1 && ["props", "value", "data"].includes(keys[0])) {
-    const inner = next.props[keys[0]];
-    if (inner && typeof inner === "object" && !Array.isArray(inner)) {
-      const unwrapped = attempt(inner);
-      if (unwrapped.success) {
-        parsedExit = unwrapped;
-      }
-    }
-  }
-  const returnValue = { action: next.name, value: parsedExit.success ? parsedExit.value : next.props };
-  if (!parsedExit.success) {
-    iteration.end({
-      type: "exit_error",
-      exit_error: {
-        exit: next.name,
-        message: parsedExit.error,
-        return_value: returnValue
-      }
-    });
-    return;
-  }
-  const returnExit = parsedExit.exit;
-  try {
-    await (onExit == null ? void 0 : onExit(
-      {
-        exit: returnExit,
-        result: parsedExit.value
-      },
-      controller
-    ));
-  } catch (err) {
-    iteration.end({
-      type: "exit_error",
-      exit_error: {
-        exit: returnExit.name,
-        message: `Error executing exit ${returnExit.name}: ${getErrorMessage(err)}`,
-        return_value: returnValue
-      }
-    });
-    return;
-  }
-  iteration.end({
-    type: "exit_success",
-    exit_success: {
-      exit_name: returnExit.name,
-      return_value: parsedExit.value
-    }
-  });
-};
-
-// 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);
-  }
-};
-
-// 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 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(originalInput),
-        object,
-        duration: SLOW_TOOL_WARNING
-      }),
-      SLOW_TOOL_WARNING
-    );
-    const toolStart = Date.now();
-    let output;
-    let error;
-    let success = true;
-    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 (err instanceof SnapshotSignal) {
-        err.toolCall = {
-          name: tool.name,
-          inputSchema: tool.input,
-          outputSchema: tool.output,
-          input: originalInput
-        };
-        err.message = Signals.serializeError(err);
-      }
-      if (err instanceof ThinkSignal) {
-        signalToThrow = err;
-        traces.push({
-          type: "think_signal",
-          started_at: Date.now(),
-          line: 0,
-          ended_at: Date.now()
-        });
-        success = true;
-        output = err;
-        const afterRes = await (afterHook == null ? void 0 : afterHook({
-          iteration,
-          tool,
-          input: originalInput,
-          output,
-          controller,
-          object,
-          toolCallId
-        }));
-        if (typeof (afterRes == null ? void 0 : afterRes.output) !== "undefined") {
-          output = afterRes.output;
-        }
-        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;
-      }
-    } catch (err) {
-      if (!await handleSignals(err)) {
-        success = false;
-        error = err;
-      }
-    } finally {
-      clearTimeout(alertSlowTool);
-      pushToolCallTrace();
-    }
-    if (!success) {
-      throw error;
-    }
-    if (signalToThrow) {
-      throw signalToThrow;
-    }
-    return output;
-  };
-}
-
-// 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, _c, _d, _e;
-  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) || _CustomModelClient.isCustomClient(client) ? client : new Cognitive({ client });
-  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,
-    maxTokens: (_c = props.options) == null ? void 0 : _c.maxTokens,
-    maxTimeToFirstToken: (_d = props.options) == null ? void 0 : _d.maxTimeToFirstToken,
-    transcriptionModel: (_e = props.options) == null ? void 0 : _e.transcriptionModel,
-    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, controller });
-        }
-      });
-      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,
-          metadata: props.metadata
-        });
-        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) {
-    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,
-  metadata
-}) => {
-  try {
-    await executeIteration({
-      iteration,
-      ctx,
-      cognitive,
-      controller,
-      onExit,
-      onBeforeExecution,
-      onAfterTool,
-      onBeforeTool,
-      metadata
-    });
-    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
-      });
-      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,
-  metadata
-}) => {
-  var _a, _b;
-  const runCode = (code) => {
-    const vmContext = buildVMContext({ ctx, iteration, controller, onBeforeTool, onAfterTool });
-    return runAsyncFunction(vmContext, code, iteration.traces, controller.signal, ctx.timeout).catch((err) => {
-      return {
-        success: false,
-        error: err instanceof Error ? err : new Error(getErrorMessage(err)),
-        lines_executed: [],
-        traces: [],
-        variables: {}
-      };
-    });
-  };
-  const canExecuteEarly = typeof onBeforeExecution !== "function";
-  let earlyExecution;
-  await generateCode({
-    iteration,
-    ctx,
-    cognitive,
-    controller,
-    metadata,
-    // Pre-warm the VM while the model is still writing the ■run block
-    onRunStart: () => warmupVM(),
-    onRunComplete: canExecuteEarly ? (code) => {
-      if (!code.length || controller.signal.aborted || earlyExecution) {
-        return;
-      }
-      iteration.code = code;
-      earlyExecution = { code, started_at: Date.now(), promise: runCode(code) };
-    } : void 0,
-    onSend: async (send) => {
-      if (!ctx.chat) {
-        return;
-      }
-      const sendStartedAt = Date.now();
-      const component = createJsxComponent({
-        type: send.name,
-        props: send.props,
-        children: send.body ? [send.body] : []
-      });
-      try {
-        await ctx.chat.handler(component);
-      } catch (err) {
-        throw new Error(`Error while sending message (\u25A0send=${send.name}): ${getErrorMessage(err)}`);
-      }
-      iteration.traces.push({ type: "yield", value: component, started_at: sendStartedAt, ended_at: Date.now() });
-    },
-    onSendDelta: ((_a = ctx.chat) == null ? void 0 : _a.onMessageDelta) ? (delta) => ctx.chat.onMessageDelta(delta) : void 0
-  });
-  if (earlyExecution) {
-    iteration.code = earlyExecution.code;
-  }
-  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;
-      }
-      iteration.end({
-        type: "execution_error",
-        execution_error: {
-          message: `Error in onBeforeExecution hook: ${getErrorMessage(err)}`,
-          stack: cleanStackTrace(
-            err instanceof Error ? err.stack ?? "No stack trace available" : "No stack trace available"
-          )
-        }
-      });
-      return;
-    }
-  }
-  const traces = iteration.traces;
-  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;
-  }
-  if (!iteration.code) {
-    if (iteration.next) {
-      await applyNextExit({ iteration, controller, onExit });
-      return;
-    }
-    if (ctx.chat && ((_b = iteration.sends) == null ? void 0 : _b.length)) {
-      iteration.next = { name: "listen", props: {} };
-      await applyNextExit({ iteration, controller, onExit });
-      return;
-    }
-    iteration.end({
-      type: "invalid_code_error",
-      invalid_code_error: {
-        message: "The response did not include a \u25A0run block or a \u25A0next exit. Reply using \u25A0 blocks and end your response with \u25A0run or \u25A0next=<exit>."
-      }
-    });
-    return;
-  }
-  const startedAt = (earlyExecution == null ? void 0 : earlyExecution.started_at) ?? Date.now();
-  const result = earlyExecution ? await earlyExecution.promise : await runCode(iteration.code ?? "");
-  await interpretVMResult({
-    iteration,
-    result,
-    controller,
-    startedAt,
-    onExit
-  });
-};
-export {
-  executeContext
-};