llmz 0.6.0 → 0.6.2

package/dist/execute-IK6O4SU2.cjs

@@ -1,1109 +0,0 @@
-"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 _class;
-
-
-
-var _chunk3UZKLXADcjs = require('./chunk-3UZKLXAD.cjs');
-
-
-
-
-
-
-
-
-var _chunk5WBNTV42cjs = require('./chunk-5WBNTV42.cjs');
-
-
-
-var _chunkKTDBAJBBcjs = require('./chunk-KTDBAJBB.cjs');
-require('./chunk-RGUG3UMF.cjs');
-require('./chunk-PZE6PIPG.cjs');
-require('./chunk-HMMM32RG.cjs');
-
-
-
-
-
-
-
-
-
-var _chunkPK72FAKDcjs = require('./chunk-PK72FAKD.cjs');
-
-
-var _chunkKIN7Y247cjs = require('./chunk-KIN7Y247.cjs');
-require('./chunk-DDSJTR6Q.cjs');
-require('./chunk-I56MPOVG.cjs');
-
-
-var _chunk5ZF6NTYIcjs = require('./chunk-5ZF6NTYI.cjs');
-
-
-var _chunkHEAQAEFZcjs = require('./chunk-HEAQAEFZ.cjs');
-
-
-
-
-var _chunkGOWPACSKcjs = require('./chunk-GOWPACSK.cjs');
-
-
-
-var _chunkHC2QZTVTcjs = require('./chunk-HC2QZTVT.cjs');
-
-// src/runtime/execute.ts
-var _client = require('@botpress/client');
-var _cognitive = require('@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) => _chunkHC2QZTVTcjs.clamp_default.call(void 0, 
-  RESPONSE_LENGTH_BUFFER.PERCENTAGE * inputLength,
-  RESPONSE_LENGTH_BUFFER.MIN_TOKENS,
-  RESPONSE_LENGTH_BUFFER.MAX_TOKENS
-);
-var LeadingFenceFilter = (_class = class {constructor() { _class.prototype.__init.call(this);_class.prototype.__init2.call(this); }
-  __init() {this._buffer = ""}
-  __init2() {this._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;
-  }
-}, _class);
-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 (0, _chunkPK72FAKDcjs.CognitiveError)(`Failed to fetch model details for model "${modelRef}": ${_chunkGOWPACSKcjs.getErrorMessage.call(void 0, 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 = _chunkHEAQAEFZcjs.truncateWrappedContent.call(void 0, {
-      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 (0, _chunkPK72FAKDcjs.CognitiveError)(`The prompt does not fit in the context window${cap}: ${_chunkGOWPACSKcjs.getErrorMessage.call(void 0, 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: _nullishCoalesce(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 = (_nullishCoalesce(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((_nullishCoalesce(event.item.body, () => ( ""))).trim());
-        }
-      }
-    }
-  };
-  if (typeof cognitive.generateTextStream === "function") {
-    const parser = new (0, _chunkKTDBAJBBcjs.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, _nullishCoalesce(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 (0, _chunkPK72FAKDcjs.CognitiveError)(`LLM generation failed: ${_chunkGOWPACSKcjs.getErrorMessage.call(void 0, 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 (0, _chunkPK72FAKDcjs.CognitiveError)("LLM streaming completed without metadata");
-    }
-    const remaining = fence.flush();
-    if (remaining) {
-      await dispatchSends(parser.push(remaining));
-    }
-    await dispatchSends(parser.finish());
-    assistantResponse = _chunkKTDBAJBBcjs.toParsedAssistantResponse.call(void 0, parser.items, raw);
-  } else {
-    const response = await cognitive.generateText(input, { signal: controller.signal }).catch((thrown) => {
-      throw new (0, _chunkPK72FAKDcjs.CognitiveError)(`LLM generation failed: ${_chunkGOWPACSKcjs.getErrorMessage.call(void 0, thrown)}`);
-    });
-    if (!response.output) {
-      throw new (0, _chunkPK72FAKDcjs.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: _nullishCoalesce(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: _nullishCoalesce(iteration.code, () => ( ""))
-  });
-};
-
-// src/runtime/interpret-result.ts
-var interpretVMResult = async ({
-  iteration,
-  result,
-  controller,
-  startedAt,
-  onExit
-}) => {
-  var _a;
-  if (result.error && result.error instanceof _chunkPK72FAKDcjs.InvalidCodeError) {
-    iteration.end({
-      type: "invalid_code_error",
-      invalid_code_error: {
-        message: result.error.message
-      }
-    });
-    return;
-  }
-  iteration.traces.push({
-    type: "code_execution",
-    lines_executed: _nullishCoalesce(result.lines_executed, () => ( 0)),
-    started_at: startedAt,
-    ended_at: Date.now()
-  });
-  if (controller.signal.aborted) {
-    iteration.end({
-      type: "aborted",
-      aborted: {
-        reason: _nullishCoalesce(controller.signal.reason, () => ( "The operation was aborted"))
-      }
-    });
-    return;
-  }
-  if (result.error && result.error instanceof _chunkPK72FAKDcjs.CodeExecutionError) {
-    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) {
-    iteration.end({
-      type: "execution_error",
-      execution_error: {
-        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) {
-    iteration.end({
-      type: "thinking_requested",
-      thinking_requested: {
-        variables: result.signal.context,
-        reason: result.signal.reason,
-        metadata: result.signal.metadata
-      }
-    });
-    return;
-  }
-  if (result.signal instanceof _chunkPK72FAKDcjs.SnapshotSignal) {
-    iteration.end({
-      type: "callback_requested",
-      callback_requested: {
-        signal: result.signal
-      }
-    });
-    return;
-  }
-  const returnValue = result.return_value;
-  const codeRequestsInspection = _chunk3UZKLXADcjs.hasTopLevelReturn.call(void 0, _nullishCoalesce(iteration.code, () => ( "")));
-  if (iteration.next && !codeRequestsInspection) {
-    await applyNextExit({ iteration, controller, onExit });
-    return;
-  }
-  const localVariables = Object.fromEntries(
-    Object.entries(_nullishCoalesce(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) => _chunk5WBNTV42cjs.parseExit.call(void 0, 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}: ${_chunkGOWPACSKcjs.getErrorMessage.call(void 0, 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
-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 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(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 _chunkPK72FAKDcjs.SnapshotSignal) {
-        err.toolCall = {
-          name: tool.name,
-          inputSchema: tool.input,
-          outputSchema: tool.output,
-          input: originalInput
-        };
-        err.message = _chunkPK72FAKDcjs.Signals.serializeError(err);
-      }
-      if (err instanceof _chunkPK72FAKDcjs.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 = { ..._chunkGOWPACSKcjs.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}: ${_chunkGOWPACSKcjs.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 _chunkGOWPACSKcjs.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, _c, _d, _e;
-  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) || _chunk5WBNTV42cjs._CustomModelClient.isCustomClient(client) ? client : new (0, _cognitive.Cognitive)({ client });
-  const ctx = new (0, _chunk5WBNTV42cjs.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 (0, _chunk5WBNTV42cjs.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, 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: _nullishCoalesce(controller.signal.reason, () => ( "The operation was aborted"))
-              }
-            }
-          });
-          return new (0, _chunk5WBNTV42cjs.ErrorExecutionResult)(ctx, _nullishCoalesce(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 (0, _chunk5WBNTV42cjs.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) {
-    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: ${_chunkGOWPACSKcjs.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,
-  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 _chunkPK72FAKDcjs.CognitiveError)) {
-      await finalizeIteration({
-        iteration,
-        controller,
-        onIterationEnd,
-        status: iteration.status.type === "pending" ? {
-          type: "execution_error",
-          execution_error: {
-            message: "An unexpected error occurred: " + _chunkGOWPACSKcjs.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
-      });
-      return { type: "proceed" };
-    }
-    if (!controller.signal.aborted) {
-      return {
-        type: "return",
-        result: new (0, _chunk5WBNTV42cjs.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, _chunk5WBNTV42cjs.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, _chunk5WBNTV42cjs.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, _chunk5WBNTV42cjs.PartialExecutionResult)(
-        ctx,
-        iteration.status.callback_requested.signal,
-        _chunk5WBNTV42cjs.Snapshot.fromSignal(iteration.status.callback_requested.signal)
-      )
-    };
-  }
-  if (iteration.status.type === "aborted") {
-    return {
-      type: "return",
-      result: new (0, _chunk5WBNTV42cjs.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, _chunk5WBNTV42cjs.ErrorExecutionResult)(ctx, _nullishCoalesce(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 _chunk3UZKLXADcjs.runAsyncFunction.call(void 0, vmContext, code, iteration.traces, controller.signal, ctx.timeout).catch((err) => {
-      return {
-        success: false,
-        error: err instanceof Error ? err : new Error(_chunkGOWPACSKcjs.getErrorMessage.call(void 0, 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: () => _chunk3UZKLXADcjs.warmupVM.call(void 0, ),
-    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 = _chunk5ZF6NTYIcjs.createJsxComponent.call(void 0, {
-        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}): ${_chunkGOWPACSKcjs.getErrorMessage.call(void 0, 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 _chunkPK72FAKDcjs.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: ${_chunkGOWPACSKcjs.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;
-    }
-  }
-  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: _nullishCoalesce(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 = _nullishCoalesce((earlyExecution == null ? void 0 : earlyExecution.started_at), () => ( Date.now()));
-  const result = earlyExecution ? await earlyExecution.promise : await runCode(_nullishCoalesce(iteration.code, () => ( "")));
-  await interpretVMResult({
-    iteration,
-    result,
-    controller,
-    startedAt,
-    onExit
-  });
-};
-
-
-exports.executeContext = executeContext;