llmz 0.1.4 → 0.2.0

package/dist/{execute-22PSGL7P.cjs → execute-BXPFSEVX.cjs}

@@ -1,16 +1,21 @@
-"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(); } }
+"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 _chunkJXD2KJVBcjs = require('./chunk-JXD2KJVB.cjs');
 
 
+var _chunkWWZ2W4WRcjs = require('./chunk-WWZ2W4WR.cjs');
 
 
 
 
 
 
-var _chunkC7T6OJB4cjs = require('./chunk-C7T6OJB4.cjs');
-require('./chunk-BBX2LDZE.cjs');
+
+
+var _chunkIKLFMVSWcjs = require('./chunk-IKLFMVSW.cjs');
+
+
+
+var _chunkYGKQEVQQcjs = require('./chunk-YGKQEVQQ.cjs');
 require('./chunk-WODK7Y4J.cjs');
 require('./chunk-7LMIOS6H.cjs');
 
@@ -27,18 +32,18 @@ var _chunkPK72FAKDcjs = require('./chunk-PK72FAKD.cjs');
 
 var _chunkKIN7Y247cjs = require('./chunk-KIN7Y247.cjs');
 require('./chunk-D6PU5YAS.cjs');
-require('./chunk-CQ3UJW76.cjs');
-require('./chunk-5ZF6NTYI.cjs');
+require('./chunk-I56MPOVG.cjs');
 
 
-var _chunkZPHRTTQXcjs = require('./chunk-ZPHRTTQX.cjs');
+var _chunk5ZF6NTYIcjs = require('./chunk-5ZF6NTYI.cjs');
 
 
+var _chunkYQT5G77Wcjs = require('./chunk-YQT5G77W.cjs');
 
 
-var _chunkFPLSJF4Scjs = require('./chunk-FPLSJF4S.cjs');
 
 
+var _chunkFPLSJF4Scjs = require('./chunk-FPLSJF4S.cjs');
 
 
 
@@ -83,26 +88,78 @@ var RESPONSE_LENGTH_BUFFER = {
   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 generateCode = async ({ iteration, ctx, cognitive, controller, metadata }) => {
-  var _a, _b, _c;
+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, _c, _d;
   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}": ${_chunkFPLSJF4Scjs.getErrorMessage.call(void 0, thrown)}`);
   });
-  const modelLimit = Math.max(model.input.maxTokens, 8e3);
+  let modelLimit = Math.max(model.input.maxTokens, 8e3);
+  if (ctx.maxTokens) {
+    modelLimit = Math.min(ctx.maxTokens, modelLimit);
+  }
   const responseLengthBuffer = getModelOutputLimit(modelLimit);
-  const messages = _chunkZPHRTTQXcjs.truncateWrappedContent.call(void 0, {
-    messages: iteration.messages,
-    tokenLimit: modelLimit - responseLengthBuffer,
-    throwOnFailure: true
-  }).filter((x) => typeof x.content !== "string" || x.content.trim().length > 0);
+  if (iteration.tokens) {
+    iteration.tokens.limit = modelLimit;
+  }
+  let messages;
+  try {
+    messages = _chunkYQT5G77Wcjs.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}: ${_chunkFPLSJF4Scjs.getErrorMessage.call(void 0, thrown)}`);
+  }
   iteration.messages = messages;
   traces.push({
     type: "llm_call_started",
@@ -110,7 +167,7 @@ var generateCode = async ({ iteration, ctx, cognitive, controller, metadata }) =
     ended_at: startedAt,
     model: model.ref
   });
-  const output = await cognitive.generateContent({
+  const input = {
     signal: controller.signal,
     systemPrompt: (_a = messages.find((x) => x.role === "system")) == null ? void 0 : _a.content,
     model: iteration.model,
@@ -120,15 +177,123 @@ var generateCode = async ({ iteration, ctx, cognitive, controller, metadata }) =
     messages: messages.filter((x) => x.role !== "system"),
     stopSequences: ctx.version.getStopTokens(),
     meta: metadata ? { metadata } : void 0
-  }).catch((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) {
-    throw new (0, _chunkPK72FAKDcjs.CognitiveError)("LLM did not return any text output");
+  };
+  let output;
+  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.generateContentStream === "function") {
+    const parser = new (0, _chunkYGKQEVQQcjs.StreamingMessageParser)();
+    const fence = new LeadingFenceFilter();
+    const streamController = createJoinedAbortController([controller.signal]);
+    const requestedAt = Date.now();
+    const stream = cognitive.generateContentStream({
+      ...input,
+      signal: streamController.signal,
+      // Passed through to the cognitive v2 request: fall back to the next
+      // model/provider when the first token takes too long
+      ...ctx.maxTimeToFirstToken ? { options: { maxTimeToFirstToken: ctx.maxTimeToFirstToken } } : {}
+    });
+    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: ${_chunkFPLSJF4Scjs.getErrorMessage.call(void 0, thrown)}`);
+      }
+      if (chunk.done) {
+        output = chunk.value;
+        break;
+      }
+      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)));
+    }
+    const remaining = fence.flush();
+    if (remaining) {
+      await dispatchSends(parser.push(remaining));
+    }
+    await dispatchSends(parser.finish());
+    assistantResponse = _chunkYGKQEVQQcjs.toParsedAssistantResponse.call(void 0, parser.items, raw);
+  } else {
+    output = await cognitive.generateContent(input).catch((thrown) => {
+      throw new (0, _chunkPK72FAKDcjs.CognitiveError)(`LLM generation failed: ${_chunkFPLSJF4Scjs.getErrorMessage.call(void 0, thrown)}`);
+    });
+    const out = typeof ((_d = (_c = output.output.choices) == null ? void 0 : _c[0]) == null ? void 0 : _d.content) === "string" ? output.output.choices[0].content : null;
+    if (!out) {
+      throw new (0, _chunkPK72FAKDcjs.CognitiveError)("LLM did not return any text output");
+    }
+    raw = out;
+    assistantResponse = ctx.version.parseAssistantResponse(out);
+    for (const send of assistantResponse.sends) {
+      await (onSend == null ? void 0 : onSend(send));
+    }
   }
-  const assistantResponse = ctx.version.parseAssistantResponse(out);
-  iteration.code = assistantResponse.code.trim();
+  iteration.code = assistantResponse.code;
+  iteration.sends = assistantResponse.sends;
+  iteration.next = assistantResponse.next;
   iteration.llm = {
     cached: output.meta.cached || false,
     ended_at: Date.now(),
@@ -138,14 +303,21 @@ var generateCode = async ({ iteration, ctx, cognitive, controller, metadata }) =
     spend: output.meta.cost.input + output.meta.cost.output,
     output: assistantResponse.raw,
     model: `${output.meta.model.integration}:${output.meta.model.model}`,
+    time_to_first_token: timeToFirstToken,
+    time_to_last_token: timeToLastToken,
     usage: output.output.usage
   };
+  if (iteration.tokens) {
+    iteration.tokens.input = output.meta.tokens.input;
+    iteration.tokens.output = output.meta.tokens.output;
+    iteration.tokens.total = output.meta.tokens.input + output.meta.tokens.output;
+  }
   traces.push({
     type: "llm_call_success",
     started_at: startedAt,
     ended_at: iteration.llm.ended_at,
     model: model.ref,
-    code: iteration.code
+    code: _nullishCoalesce(iteration.code, () => ( ""))
   });
 };
 
@@ -222,35 +394,50 @@ var interpretVMResult = async ({
     });
     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 = _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;
+  const returnValue = result.return_value;
+  const codeRequestsInspection = _chunkWWZ2W4WRcjs.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
     }
-    iteration.end({
-      type: "thinking_requested",
-      thinking_requested: {
-        reason: "Thinking requested",
-        variables: 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) => _chunkIKLFMVSWcjs.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;
       }
-    });
-    return;
+    }
   }
-  const parsedExit = _chunkC7T6OJB4cjs.parseExit.call(void 0, returnValue, iteration.exits);
+  const returnValue = { action: next.name, value: parsedExit.success ? parsedExit.value : next.props };
   if (!parsedExit.success) {
     iteration.end({
       type: "exit_error",
       exit_error: {
-        exit: _nullishCoalesce((returnValue == null ? void 0 : returnValue.action), () => ( "n/a")),
+        exit: next.name,
         message: parsedExit.error,
         return_value: returnValue
       }
@@ -258,12 +445,14 @@ var interpretVMResult = async ({
     return;
   }
   const returnExit = parsedExit.exit;
-  returnValue = { action: returnExit.name, value: parsedExit.value };
   try {
-    await (onExit == null ? void 0 : onExit({
-      exit: returnExit,
-      result: returnValue == null ? void 0 : returnValue.value
-    }));
+    await (onExit == null ? void 0 : onExit(
+      {
+        exit: returnExit,
+        result: parsedExit.value
+      },
+      controller
+    ));
   } catch (err) {
     iteration.end({
       type: "exit_error",
@@ -279,10 +468,9 @@ var interpretVMResult = async ({
     type: "exit_success",
     exit_success: {
       exit_name: returnExit.name,
-      return_value: returnValue == null ? void 0 : returnValue.value
+      return_value: parsedExit.value
     }
   });
-  return;
 };
 
 // src/runtime/utils.ts
@@ -535,18 +723,20 @@ var executeContext = async (props) => {
   return result;
 };
 var executeContextInternal = async (props) => {
-  var _a, _b;
+  var _a, _b, _c, _d;
   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) || _chunkC7T6OJB4cjs._CustomModelClient.isCustomClient(client) ? client : _cognitive.CognitiveBeta.isBetaClient(client) ? _cognitive.cognitiveFromBeta.call(void 0, client) : new (0, _cognitive.Cognitive)({ client, __experimental_beta: true });
-  const ctx = new (0, _chunkC7T6OJB4cjs.Context)({
+  const cognitive = _cognitive.Cognitive.isCognitiveClient(client) || _chunkIKLFMVSWcjs._CustomModelClient.isCustomClient(client) ? client : _cognitive.CognitiveBeta.isBetaClient(client) ? _cognitive.cognitiveFromBeta.call(void 0, client) : new (0, _cognitive.Cognitive)({ client, __experimental_beta: true });
+  const ctx = new (0, _chunkIKLFMVSWcjs.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,
     exits: props.exits,
     snapshot: props.snapshot,
     model: props.model,
@@ -556,12 +746,12 @@ var executeContextInternal = async (props) => {
   try {
     while (true) {
       if (ctx.iterations.length >= ctx.loop) {
-        return new (0, _chunkC7T6OJB4cjs.ErrorExecutionResult)(ctx, new (0, _chunkPK72FAKDcjs.LoopExceededError)());
+        return new (0, _chunkIKLFMVSWcjs.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 });
+          onTrace == null ? void 0 : onTrace({ trace, iteration: ctx.iterations.length, controller });
         }
       });
       try {
@@ -587,7 +777,7 @@ var executeContextInternal = async (props) => {
               }
             }
           });
-          return new (0, _chunkC7T6OJB4cjs.ErrorExecutionResult)(ctx, _nullishCoalesce(controller.signal.reason, () => ( "The operation was aborted")));
+          return new (0, _chunkIKLFMVSWcjs.ErrorExecutionResult)(ctx, _nullishCoalesce(controller.signal.reason, () => ( "The operation was aborted")));
         }
         const iterationResult = await executeIterationWithErrorHandling({
           iteration,
@@ -617,7 +807,7 @@ var executeContextInternal = async (props) => {
       }
     }
   } catch (error) {
-    return new (0, _chunkC7T6OJB4cjs.ErrorExecutionResult)(ctx, _nullishCoalesce(error, () => ( "Unknown error")));
+    return new (0, _chunkIKLFMVSWcjs.ErrorExecutionResult)(ctx, _nullishCoalesce(error, () => ( "Unknown error")));
   }
 };
 var executeIterationStartHook = async ({
@@ -704,7 +894,7 @@ var executeIterationWithErrorHandling = async ({
     if (!controller.signal.aborted) {
       return {
         type: "return",
-        result: new (0, _chunkC7T6OJB4cjs.ErrorExecutionResult)(ctx, err)
+        result: new (0, _chunkIKLFMVSWcjs.ErrorExecutionResult)(ctx, err)
       };
     }
     await finalizeIteration({
@@ -720,7 +910,7 @@ var executeIterationWithErrorHandling = async ({
     });
     return {
       type: "return",
-      result: new (0, _chunkC7T6OJB4cjs.ErrorExecutionResult)(ctx, _nullishCoalesce(controller.signal.reason, () => ( "The operation was aborted")))
+      result: new (0, _chunkIKLFMVSWcjs.ErrorExecutionResult)(ctx, _nullishCoalesce(controller.signal.reason, () => ( "The operation was aborted")))
     };
   }
 };
@@ -732,7 +922,7 @@ var transformIterationResult = ({
     const exitName = iteration.status.exit_success.exit_name;
     return {
       type: "return",
-      result: new (0, _chunkC7T6OJB4cjs.SuccessExecutionResult)(ctx, {
+      result: new (0, _chunkIKLFMVSWcjs.SuccessExecutionResult)(ctx, {
         exit: iteration.exits.find((x) => x.name === exitName),
         result: iteration.status.exit_success.return_value
       })
@@ -741,17 +931,17 @@ var transformIterationResult = ({
   if (iteration.status.type === "callback_requested") {
     return {
       type: "return",
-      result: new (0, _chunkC7T6OJB4cjs.PartialExecutionResult)(
+      result: new (0, _chunkIKLFMVSWcjs.PartialExecutionResult)(
         ctx,
         iteration.status.callback_requested.signal,
-        _chunkC7T6OJB4cjs.Snapshot.fromSignal(iteration.status.callback_requested.signal)
+        _chunkIKLFMVSWcjs.Snapshot.fromSignal(iteration.status.callback_requested.signal)
       )
     };
   }
   if (iteration.status.type === "aborted") {
     return {
       type: "return",
-      result: new (0, _chunkC7T6OJB4cjs.ErrorExecutionResult)(ctx, _nullishCoalesce(iteration.error, () => ( "The operation was aborted")))
+      result: new (0, _chunkIKLFMVSWcjs.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") {
@@ -759,7 +949,7 @@ var transformIterationResult = ({
   }
   return {
     type: "return",
-    result: new (0, _chunkC7T6OJB4cjs.ErrorExecutionResult)(ctx, _nullishCoalesce(iteration.error, () => ( `Unknown error. Status: ${iteration.status.type}`)))
+    result: new (0, _chunkIKLFMVSWcjs.ErrorExecutionResult)(ctx, _nullishCoalesce(iteration.error, () => ( `Unknown error. Status: ${iteration.status.type}`)))
   };
 };
 var executeIteration = async ({
@@ -773,7 +963,58 @@ var executeIteration = async ({
   onAfterTool,
   metadata
 }) => {
-  await generateCode({ iteration, ctx, cognitive, controller, metadata });
+  var _a, _b;
+  const runCode = (code) => {
+    const vmContext = buildVMContext({ ctx, iteration, controller, onBeforeTool, onAfterTool });
+    return _chunkWWZ2W4WRcjs.runAsyncFunction.call(void 0, vmContext, code, iteration.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: {}
+      };
+    });
+  };
+  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: () => _chunkWWZ2W4WRcjs.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}): ${_chunkFPLSJF4Scjs.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);
@@ -804,7 +1045,6 @@ var executeIteration = async ({
     }
   }
   const traces = iteration.traces;
-  const vmContext = buildVMContext({ ctx, iteration, controller, onBeforeTool, onAfterTool });
   if (controller.signal.aborted) {
     traces.push({
       type: "abort_signal",
@@ -819,22 +1059,26 @@ var executeIteration = async ({
     });
     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: {}
-    };
-  });
+  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,