@prestyj/agent 5.29.0 → 5.30.0

package/dist/index.cjs

@@ -904,6 +904,8 @@ async function* agentLoop(messages, options) {
           onContextPrepared: options.onContextPrepared,
           promptCacheKey: options.promptCacheKey,
           serviceTier: options.serviceTier,
+          responsesLite: options.responsesLite,
+          strictTools: options.strictTools,
           supportsImages: options.supportsImages,
           supportsVideo: options.supportsVideo,
           compaction: options.compaction,
@@ -1615,6 +1617,7 @@ async function* agentLoop(messages, options) {
       }
       messages.push({ role: "tool", content: executionResult.toolResults });
       yield { type: "checkpoint", turn };
+      if (executionResult.endRun) break;
       const toolsAborted = executionResult.aborted;
       if (fatalToolArgumentError) {
         if (fatalToolArgumentRecoverable && !toolArgumentAutoContinueUsed) {
@@ -1751,6 +1754,7 @@ async function executeSingleToolCall(toolCall, options, pushEvent) {
   let resultContent;
   let details;
   let isError = false;
+  let endRun = false;
   let invalidArgAttempt;
   const tool = options.toolMap.get(toolCall.name);
   if (tool) {
@@ -1809,6 +1813,7 @@ async function executeSingleToolCall(toolCall, options, pushEvent) {
         hardSignals.length === 1 ? toolTimeout : AbortSignal.any(hardSignals)
       );
       const normalized = normalizeToolResult(raw);
+      endRun = normalized.endRun === true;
       resultContent = (0, import_ai2.redactValue)(normalized.content, toolRedactionOptions());
       details = (0, import_ai2.redactValue)(normalized.details, toolRedactionOptions());
       if (options.transformToolResult) {
@@ -1880,11 +1885,12 @@ ${hints}` : "") + "\nRe-issue the call with each field as the correct type.";
     durationMs,
     ...invalidArgAttempt === void 0 ? {} : { invalidArgAttempt }
   });
-  return { toolCallId: toolCall.id, content: resultContent, isError };
+  return { toolCallId: toolCall.id, content: resultContent, isError, endRun: endRun && !isError };
 }
 function createPreemptTracker(options, eventStream, state, resultsById, dispatchedIds) {
   const running = /* @__PURE__ */ new Map();
   let graceTimer;
+  let endRun = false;
   const preemptSignal = options.preemptSignal;
   const abandon = () => {
     graceTimer = void 0;
@@ -1908,7 +1914,7 @@ function createPreemptTracker(options, eventStream, state, resultsById, dispatch
   preemptSignal?.addEventListener("abort", onPreempt, { once: true });
   return {
     async run(toolCall) {
-      if (options.preemptSignal?.aborted) return;
+      if (endRun || options.preemptSignal?.aborted) return;
       dispatchedIds.add(toolCall.id);
       const interruptible = isInterruptibleTool(options.toolMap.get(toolCall.name), toolCall.name);
       running.set(toolCall.id, { toolCall, interruptible, startedAt: Date.now() });
@@ -1920,15 +1926,15 @@ function createPreemptTracker(options, eventStream, state, resultsById, dispatch
       running.delete(toolCall.id);
       if (resultsById.has(toolCall.id)) return;
       const alreadyMarked = typeof record.content === "string" ? record.content.startsWith(STEER_INTERRUPTED_TEXT) : record.content[0]?.type === "text" && record.content[0].text.startsWith(STEER_INTERRUPTED_TEXT);
-      resultsById.set(
-        toolCall.id,
-        interruptible && preemptSignal?.aborted && !alreadyMarked ? markSteerInterrupted(record) : record
-      );
+      const result = interruptible && preemptSignal?.aborted && !alreadyMarked ? markSteerInterrupted(record) : record;
+      resultsById.set(toolCall.id, result);
+      if (result.endRun && !result.isError) endRun = true;
       if (preemptSignal?.aborted && graceTimer === void 0 && running.size === 0) {
         eventStream.close();
       }
     },
     preempted: () => preemptSignal?.aborted === true,
+    endRun: () => endRun,
     dispose: () => {
       if (graceTimer !== void 0) clearTimeout(graceTimer);
       preemptSignal?.removeEventListener("abort", onPreempt);
@@ -1963,7 +1969,7 @@ async function* executeToolCallsMixed(toolCalls, initialToolResults, options) {
   void (async () => {
     try {
       for (const phase of phases) {
-        if (options.signal?.aborted || options.preemptSignal?.aborted) break;
+        if (options.signal?.aborted || options.preemptSignal?.aborted || tracker.endRun()) break;
         if (phase.sequential) {
           const signature = JSON.stringify([
             phase.sequential.name,
@@ -2001,7 +2007,12 @@ async function* executeToolCallsMixed(toolCalls, initialToolResults, options) {
   const toolResults = buildToolResults(initialToolResults, toolCalls, resultsById, dispatchedIds);
   capToolResults(toolResults, options.maxToolResultChars);
   capTurnToolResults(toolResults, options.maxTurnToolResultChars);
-  return { toolResults, aborted, preempted: !aborted && tracker.preempted() };
+  return {
+    toolResults,
+    aborted,
+    preempted: !aborted && tracker.preempted(),
+    endRun: tracker.endRun()
+  };
 }
 async function* executeToolCallsParallel(toolCalls, initialToolResults, options) {
   const eventStream = new import_ai2.EventStream();
@@ -2035,7 +2046,12 @@ async function* executeToolCallsParallel(toolCalls, initialToolResults, options)
   const toolResults = buildToolResults(initialToolResults, toolCalls, resultsById, dispatchedIds);
   capToolResults(toolResults, options.maxToolResultChars);
   capTurnToolResults(toolResults, options.maxTurnToolResultChars);
-  return { toolResults, aborted, preempted: !aborted && tracker.preempted() };
+  return {
+    toolResults,
+    aborted,
+    preempted: !aborted && tracker.preempted(),
+    endRun: tracker.endRun()
+  };
 }
 function cancelledBeforeStartText(name) {
   return `\`${name}\` was cancelled before it started, so it had no effect. Safe to retry.`;