omnius 1.0.857 → 1.0.858

package/dist/index.js

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
 name: package/dist/index.js
-size: 37504153 bytes
-sha256: 72456e9f7b61b67a1cbb984d416fca252b250bce4ed4508b5508c427d960c0ab
+size: 37522251 bytes
+sha256: 5b1ad95c2824b29186cceae690cc07628910ebbe8e1a3d2585756a32e7caf6d0

package/dist/library.js

@@ -345320,6 +345320,25 @@ function compareKeylessInferenceProviders(a, b) {
   return keylessInferenceStage(a) - keylessInferenceStage(b) || Number(b.nativeToolsHint) - Number(a.nativeToolsHint) || Number(b.structuredOutputHint === true) - Number(a.structuredOutputHint === true) || textOrder(a.id, b.id) || textOrder(a.chatUrl, b.chatUrl);
 }
 
+// packages/orchestrator/dist/unread-source-carrier.js
+var proofs2 = /* @__PURE__ */ new WeakMap();
+function markUnreadSourceCarrier(message, proof) {
+  if (message.requiredSourceEvidence)
+    proofs2.set(message.requiredSourceEvidence, proof);
+}
+function isCurrentUnreadSourceCarrier(message) {
+  const evidence = message.requiredSourceEvidence;
+  const proof = evidence && proofs2.get(evidence);
+  return Boolean(proof && message.role === "tool" && message.tool_call_id === proof.callId && message.content === proof.content && evidence?.schema === "omnius.required-source-evidence.v1" && evidence.scope === `unread-web-source:${proof.callId}` && proof.current());
+}
+function restoreUnreadSourceCarrierIdentity(before, after) {
+  for (let index = 0; index < before.length; index++) {
+    const source = before[index], target2 = after[index];
+    if (target2 && isCurrentUnreadSourceCarrier(source) && target2.role === source.role && target2.tool_call_id === source.tool_call_id && target2.content === source.content && target2.requiredSourceEvidence?.schema === source.requiredSourceEvidence?.schema && target2.requiredSourceEvidence?.scope === source.requiredSourceEvidence?.scope)
+      target2.requiredSourceEvidence = source.requiredSourceEvidence;
+  }
+}
+
 // packages/orchestrator/dist/remote-inference-fallback.js
 var completedCapacityRoutes = /* @__PURE__ */ new WeakMap();
 function completedCapacityBinding(request) {
@@ -346420,6 +346439,7 @@ ${line}`).join("");
       responseFormat: prepared.responseFormat,
       response_format: prepared.response_format
     });
+    restoreUnreadSourceCarrierIdentity(prepared.messages, wire.messages);
     const nativeIdle = streamDeadline !== void 0 && (request.nativePlanningStreamIdleTimeoutMs === 9e4 || request.structuredReviewStreamIdleTimeoutMs === 9e4) && this.policy.requestTimeoutMsSource === "default";
     const timeoutMs = nativeIdle ? Math.min(9e4, request.timeoutMs > 0 ? request.timeoutMs : Infinity, Math.max(1, streamDeadline - this.now())) : Math.min(request.timeoutMs, this.policy.requestTimeoutMs);
     const maxTokens = this.remoteOutputTokens(request, route);
@@ -358551,6 +358571,27 @@ var InterruptionLifecycle = class {
   }
 };
 
+// packages/orchestrator/dist/input-wait-interruption.js
+var InputWaitInterruption = class extends Error {
+  constructor() {
+    super("The operator paused inference to provide input.");
+    this.name = "InputWaitInterruption";
+  }
+};
+async function withInputWaitCancellation(signal, operation) {
+  signal.throwIfAborted();
+  let cancel;
+  const interrupted = new Promise((_, reject) => {
+    cancel = () => reject(signal.reason);
+    signal.addEventListener("abort", cancel, { once: true });
+  });
+  try {
+    return await Promise.race([operation(), interrupted]);
+  } finally {
+    signal.removeEventListener("abort", cancel);
+  }
+}
+
 // packages/orchestrator/dist/tool-exposure-policy.js
 import { createHash as createHash71 } from "node:crypto";
 var DEFAULT_MAXIMUM_ALWAYS_VISIBLE_TOOLS = 8;
@@ -387226,7 +387267,12 @@ var AgenticRunner = class _AgenticRunner {
   /** Abort releases process-local pressure even if a remote stream ignores cancellation. */
   _activeInferencePressureLease = null;
   _paused = false;
-  _pauseResolve = null;
+  _pauseWaiters = /* @__PURE__ */ new Set();
+  _inputWaitModelControllers = /* @__PURE__ */ new Set();
+  _inputWaitPaused = false;
+  _inputWaitSequence = 0;
+  _inputWaitPauseReceipt = null;
+  _inputWaitBoundaryController = new AbortController();
   _interruptionMessages = null;
   _interruptionToolCallLog = null;
   _interruptionExplicitGoal = "";
@@ -392598,11 +392644,16 @@ ${read.content}`;
    * model output never select the ownership class.
    */
   async _dispatchInterruptionOwnedModelRequest(backend, request, ownerId, operation = {}) {
+    const admissionInputWaitGeneration = this._modelRequestGeneration;
+    if (this._paused && this._inputWaitPaused)
+      throw new InputWaitInterruption();
     if (this._interruptionMode !== "off" && this._paused) {
       const shouldContinue = await this.waitIfPaused();
       if (!shouldContinue)
         throw new Error("interruption_stop_admitted");
     }
+    if (admissionInputWaitGeneration !== this._modelRequestGeneration)
+      throw new InputWaitInterruption();
     const ticket = this._interruptionLifecycle?.registerOperation({
       kind: "model",
       effect: "read_only",
@@ -392612,6 +392663,8 @@ ${read.content}`;
       throw new Error("interruption_admission_closed:model");
     }
     const failureOwner = { runId: this.currentArtifactRunId(), taskEpoch: this._taskEpoch };
+    const inputWaitController = new AbortController();
+    this._inputWaitModelControllers.add(inputWaitController);
     let successfulRoute;
     if (operation.requiredForRun)
       this._sourceReadContextCapacity = void 0;
@@ -392628,7 +392681,10 @@ ${read.content}`;
         contextLimitSource: limit2.source,
         allowContentCompaction: false
       });
-      if ((preliminary.receipt.decision === "reject" || request.preparedContextCapacity && !this._currentPreparedContextCapacity(request)) && await this._prepareRequestContextCapacity(request, backend.prepareContextCapacity ? backend : this.backend, operation.assertCurrent)) {
+      if ((preliminary.receipt.decision === "reject" || request.preparedContextCapacity && !this._currentPreparedContextCapacity(request)) && await withInputWaitCancellation(inputWaitController.signal, () => this._prepareRequestContextCapacity(request, backend.prepareContextCapacity ? backend : this.backend, () => {
+        inputWaitController.signal.throwIfAborted();
+        operation.assertCurrent?.();
+      }))) {
         limit2 = this._contextAdmissionLimit(request);
         this._refreshCanonicalTransportTrace(request);
       }
@@ -392679,6 +392735,7 @@ ${read.content}`;
         toolOwnerId: this._interruptionOwnerId
       };
       const assertCurrent = () => {
+        inputWaitController.signal.throwIfAborted();
         outbound.assertCurrentAtDispatch?.();
         operation.assertCurrent?.();
         this._abortController.signal.throwIfAborted();
@@ -392714,7 +392771,14 @@ ${read.content}`;
           });
         }
       } : outbound;
-      const response = await backend.chatCompletion(dispatchRequest);
+      const ownedRequest = { ...dispatchRequest, signal: AbortSignal.any([
+        inputWaitController.signal,
+        this._abortController.signal,
+        this._turnAbortController.signal,
+        ...dispatchRequest.signal ? [dispatchRequest.signal] : []
+      ]) };
+      const response = await withInputWaitCancellation(inputWaitController.signal, () => backend.chatCompletion(ownedRequest));
+      inputWaitController.signal.throwIfAborted();
       if (ticket && !this._interruptionLifecycle?.canCommit(ticket)) {
         throw new Error("interruption_stale_model_result");
       }
@@ -392722,6 +392786,8 @@ ${read.content}`;
         this._successfulPrimaryInferenceRoutes.set(request, successfulRoute);
       return response;
     } catch (error) {
+      if (inputWaitController.signal.reason instanceof InputWaitInterruption)
+        throw inputWaitController.signal.reason;
       const failure = error;
       if (operation.requiredForRun && !this.aborted && failureOwner.runId === this.currentArtifactRunId() && failureOwner.taskEpoch === this._taskEpoch && failure?.fatal === true && failure.retryable === false && (failure.code === "remote_inference_unavailable" || failure.code === "inference_stream_interrupted" || failure.code === "fallback_approval_required" || failure.code === "fallback_declined")) {
         this._terminalRuntimeFailure = {
@@ -392735,8 +392801,9 @@ ${read.content}`;
       }
       throw error;
     } finally {
+      this._inputWaitModelControllers.delete(inputWaitController);
       if (ticket) {
-        this._interruptionLifecycle?.acknowledgeOperation(ticket, this.aborted ? "cancelled" : "completed");
+        this._interruptionLifecycle?.acknowledgeOperation(ticket, this.aborted || inputWaitController.signal.aborted ? "cancelled" : "completed");
       }
     }
   }
@@ -392826,7 +392893,7 @@ ${read.content}`;
       const pending = this._currentUnreadWebSourceCarrier(message), callId = message.tool_call_id;
       if (!pending || !callId || typeof message.content !== "string")
         continue;
-      _unreadWebSourceCarrierProofs.set(message, {
+      markUnreadSourceCarrier(message, {
         content: message.content,
         callId,
         current: () => this._currentUnreadWebSourceView(callId) === pending
@@ -393022,6 +393089,7 @@ ${read.content}`;
         const exactRequest = { ...value, messages: value.messages.map((message) => ({ ...message })) };
         this._toolPromotionLastDispatchedTurn = turn;
         const result = await (streaming ? this.streamingRequest(value, turn, textProtocol) : this.backend.chatCompletion(value));
+        value.signal?.throwIfAborted();
         if (!this.aborted && readOwner.scopeId === this._sessionId && readOwner.runId === this.currentArtifactRunId() && readOwner.taskEpoch === this._taskEpoch && readOwner.toolOwnerId === this._interruptionOwnerId && result.choices.some((choice) => Boolean(choice.message.content?.trim() || choice.message.toolCalls?.length))) {
           await this._confirmCorpusReadsInSuccessfulRequest(exactRequest);
           this._confirmUnreadWebSourcesInSuccessfulRequest(exactRequest);
@@ -405949,10 +406017,7 @@ The previous reviewer response failed exact candidate-quote serialization. Host
     if (shellTool && typeof shellTool.killAll === "function") {
       shellTool.killAll();
     }
-    if (this._pauseResolve) {
-      this._pauseResolve();
-      this._pauseResolve = null;
-    }
+    this._releasePauseWaiters();
     return transition;
   }
   /** Get the current abort signal for passing to fetch/spawn */
@@ -407651,6 +407716,48 @@ Only the exact pending declared read tickets may execute. Old-plan mutations and
     this._paused = true;
     return transition;
   }
+  /** Operator input wait: cancel unfinished inference and retain owned work. */
+  pauseForInput() {
+    const receipt = this.pause();
+    if (receipt?.accepted === false)
+      return receipt;
+    this._inputWaitPauseReceipt = receipt;
+    ++this._inputWaitSequence;
+    if (!this._inputWaitPaused) {
+      this._inputWaitPaused = true;
+      ++this._modelRequestGeneration;
+      this._inputWaitBoundaryController.abort(new InputWaitInterruption());
+      this._pendingStreamAssistantText = null;
+      this._pendingPausedStreamTerminal = null;
+      for (const controller of this._inputWaitModelControllers)
+        controller.abort(new InputWaitInterruption());
+    }
+    return receipt;
+  }
+  /** A typed instruction resumes only after the exact atomic owners settle. */
+  async resumeAfterInput() {
+    const sequence = this._inputWaitSequence;
+    const pauseReceipt = this._inputWaitPauseReceipt;
+    const lifecycle = this._interruptionLifecycle;
+    const runId = this.currentArtifactRunId();
+    while (!this.aborted && sequence === this._inputWaitSequence && lifecycle === this._interruptionLifecycle && runId === this.currentArtifactRunId() && lifecycle?.snapshot().phase === "pausing") {
+      await new Promise((resolve38) => setTimeout(resolve38, 20));
+    }
+    if (sequence !== this._inputWaitSequence || lifecycle !== this._interruptionLifecycle || runId !== this.currentArtifactRunId()) {
+      return pauseReceipt ? {
+        ...pauseReceipt,
+        accepted: false,
+        action: "resume",
+        reason: "Resume superseded by a newer input-wait request."
+      } : null;
+    }
+    return this.resume();
+  }
+  _releasePauseWaiters() {
+    for (const release of this._pauseWaiters)
+      release();
+    this._pauseWaiters.clear();
+  }
   /**
    * Resume a paused task. The run loop continues from where it left off.
    */
@@ -407662,10 +407769,9 @@ Only the exact pending declared read tickets may execute. Old-plan mutations and
     if (resumed && !resumed.accepted)
       return resumed;
     this._paused = false;
-    if (this._pauseResolve) {
-      this._pauseResolve();
-      this._pauseResolve = null;
-    }
+    this._inputWaitPaused = false;
+    this._inputWaitBoundaryController = new AbortController();
+    this._releasePauseWaiters();
     return resumed;
   }
   /** Whether the runner is currently paused */
@@ -407878,7 +407984,7 @@ Earlier host presentation and its quoted source/history bytes are retained lossl
     } catch {
     }
     await new Promise((resolve38) => {
-      this._pauseResolve = resolve38;
+      this._pauseWaiters.add(resolve38);
     });
     return !this.aborted;
   }
@@ -410107,7 +410213,7 @@ Respond with the assessment and take the selected evidence-backed action.`;
     try {
       this.aborted = false;
       this._paused = false;
-      this._pauseResolve = null;
+      this._pauseWaiters.clear();
       this._abortController = new AbortController();
       this._turnAbortController = new AbortController();
       this._taskEpoch = 1;
@@ -410405,6 +410511,9 @@ Respond with the assessment and take the selected evidence-backed action.`;
     this._abortController = new AbortController();
     this._turnAbortController = new AbortController();
     this._paused = false;
+    this._inputWaitPaused = false;
+    this._inputWaitBoundaryController = new AbortController();
+    this._inputWaitModelControllers.clear();
     this._interruptionMessages = null;
     this._interruptionToolCallLog = null;
     this._taskProcedureExperience = null;
@@ -410784,7 +410893,7 @@ Respond with the assessment and take the selected evidence-backed action.`;
     } catch {
     }
     this._loadResolutionMemory();
-    this._pauseResolve = null;
+    this._pauseWaiters.clear();
     this._prepareSteeringInputsForRun();
     const persistentTaskGoal = cleanForStorage(actualUserGoal || "") || cleanedTask;
     const userGoal = persistentTaskGoal;
@@ -415709,6 +415818,7 @@ Then use file_read on individual FILES inside it.`);
       return boundExecuteSingle;
     };
     for (let turn = 0; turn < turnCap + durableProgressTurnCredits; turn++) {
+      const inputWaitGeneration = this._modelRequestGeneration;
       if (this._completionIncompleteVerification)
         break;
       this._currentTurn = turn;
@@ -417403,9 +417513,21 @@ ${diagnosis}` : diagnosis;
         }
       }
       let response;
+      if (inputWaitGeneration !== this._modelRequestGeneration) {
+        if (!await this.waitIfPaused())
+          break;
+        --turn;
+        continue;
+      }
       try {
         response = await this._dispatchCanonicalRequest(chatRequest, turn);
       } catch (reqErr) {
+        if (reqErr instanceof InputWaitInterruption || inputWaitGeneration !== this._modelRequestGeneration) {
+          if (!await this.waitIfPaused())
+            break;
+          --turn;
+          continue;
+        }
         if (isTerminalInferenceFailure(reqErr)) {
           nonRetryableBackendFailure = true;
         }
@@ -417460,6 +417582,12 @@ ${diagnosis}` : diagnosis;
           try {
             response = await this._dispatchCanonicalRequest(chatRequest, turn);
           } catch (retryErr) {
+            if (retryErr instanceof InputWaitInterruption || inputWaitGeneration !== this._modelRequestGeneration) {
+              if (!await this.waitIfPaused())
+                break;
+              --turn;
+              continue;
+            }
             if (isTerminalInferenceFailure(retryErr)) {
               nonRetryableBackendFailure = true;
             }
@@ -417485,6 +417613,12 @@ ${diagnosis}` : diagnosis;
           try {
             response = await this._dispatchCanonicalRequest(chatRequest, turn);
           } catch (retryErr) {
+            if (retryErr instanceof InputWaitInterruption || inputWaitGeneration !== this._modelRequestGeneration) {
+              if (!await this.waitIfPaused())
+                break;
+              --turn;
+              continue;
+            }
             if (isTerminalInferenceFailure(retryErr)) {
               nonRetryableBackendFailure = true;
             }
@@ -417509,6 +417643,12 @@ ${diagnosis}` : diagnosis;
             nonRetryableBackendFailure = true;
             reqErr = terminalError;
           });
+          if (inputWaitGeneration !== this._modelRequestGeneration) {
+            if (!await this.waitIfPaused())
+              break;
+            --turn;
+            continue;
+          }
           if (!recovered2) {
             if (this.aborted)
               break;
@@ -417542,6 +417682,12 @@ ${diagnosis}` : diagnosis;
                   const imgRetry = await this._dispatchCanonicalRequest(chatRequest, turn);
                   response = imgRetry;
                 } catch (imgRetryErr) {
+                  if (imgRetryErr instanceof InputWaitInterruption || inputWaitGeneration !== this._modelRequestGeneration) {
+                    if (!await this.waitIfPaused())
+                      break;
+                    --turn;
+                    continue;
+                  }
                   if (isTerminalInferenceFailure(imgRetryErr)) {
                     nonRetryableBackendFailure = true;
                   }
@@ -417589,6 +417735,12 @@ ${diagnosis}` : diagnosis;
                 response = await this._dispatchCanonicalRequest(chatRequest, turn, true, "json");
                 imageRecovered = true;
               } catch (retryErr2) {
+                if (retryErr2 instanceof InputWaitInterruption || inputWaitGeneration !== this._modelRequestGeneration) {
+                  if (!await this.waitIfPaused())
+                    break;
+                  --turn;
+                  continue;
+                }
                 if (isTerminalInferenceFailure(retryErr2)) {
                   nonRetryableBackendFailure = true;
                 }
@@ -417632,11 +417784,21 @@ ${transportFailure2}` : transportFailure2;
           response = recovered2 ?? response;
         }
       }
+      if (inputWaitGeneration !== this._modelRequestGeneration) {
+        if (!await this.waitIfPaused())
+          break;
+        --turn;
+        continue;
+      }
       if (this._interruptionMode !== "off" && this._paused) {
         const shouldContinue = await this.waitIfPaused();
         if (!shouldContinue)
           break;
       }
+      if (inputWaitGeneration !== this._modelRequestGeneration) {
+        --turn;
+        continue;
+      }
       this.flushPendingPausedStreamTerminal();
       this.flushPendingStreamAssistantText();
       totalTokens += response.usage?.totalTokens || (response.usage?.promptEvalCount ?? response.usage?.promptTokens ?? 0) + (response.usage?.completionTokens ?? 0);
@@ -417980,7 +418142,10 @@ ${transportFailure2}` : transportFailure2;
           for (const sr of streamResults) {
             const resolvedStreamTool = this.lookupRegisteredTool(sr.name);
             const admittedFullRead = (resolvedStreamTool?.name ?? sr.name) === "file_read" && sr.result.success && !sr.result.branchEvidence;
-            if (!admittedFullRead) {
+            const unread = this._currentUnreadWebSourceView(sr.id);
+            const sourceCall = unread && rawToolCalls.find((call2) => call2.id === sr.id);
+            const admittedWebSource = sr.result.success === true && unread && sourceCall && resolvedStreamTool?.tool === unread.tool && this._buildExactArgsKey(sourceCall.arguments) === unread.argsKey && (sr.result.llmContent ?? sr.result.output) === unread.carrier;
+            if (!admittedFullRead && !admittedWebSource) {
               sr.result = this.applyRegisteredToolResultTriage(sr.result, resolvedStreamTool?.name ?? sr.name, resolvedStreamTool?.tool);
             }
           }
@@ -418710,6 +418875,7 @@ ${this.options.maxTurns && this.options.maxTurns > 0 ? `You have ${this.options.
       }
       const restartTurnCap = this.options.maxTurns && this.options.maxTurns > 0 ? this.options.maxTurns : Number.MAX_SAFE_INTEGER;
       for (let turn = 0; turn < restartTurnCap; turn++) {
+        const inputWaitGeneration = this._modelRequestGeneration;
         if (this._completionIncompleteVerification)
           break;
         this._maybeApplyThinkGuard();
@@ -418880,9 +419046,21 @@ ${diagnosis}` : diagnosis;
           break;
         }
         let response;
+        if (inputWaitGeneration !== this._modelRequestGeneration) {
+          if (!await this.waitIfPaused())
+            break;
+          --turn;
+          continue;
+        }
         try {
           response = await this._dispatchCanonicalRequest(chatRequest, turn);
         } catch (reqErr) {
+          if (reqErr instanceof InputWaitInterruption || inputWaitGeneration !== this._modelRequestGeneration) {
+            if (!await this.waitIfPaused())
+              break;
+            --turn;
+            continue;
+          }
           if (isTerminalInferenceFailure(reqErr)) {
             nonRetryableBackendFailure = true;
           }
@@ -418931,6 +419109,12 @@ ${diagnosis}` : diagnosis;
             try {
               response = await this._dispatchCanonicalRequest(chatRequest, turn);
             } catch (retryErr) {
+              if (retryErr instanceof InputWaitInterruption || inputWaitGeneration !== this._modelRequestGeneration) {
+                if (!await this.waitIfPaused())
+                  break;
+                --turn;
+                continue;
+              }
               if (isTerminalInferenceFailure(retryErr)) {
                 nonRetryableBackendFailure = true;
               }
@@ -418956,6 +419140,12 @@ ${diagnosis}` : diagnosis;
             try {
               response = await this._dispatchCanonicalRequest(chatRequest, turn);
             } catch (retryErr) {
+              if (retryErr instanceof InputWaitInterruption || inputWaitGeneration !== this._modelRequestGeneration) {
+                if (!await this.waitIfPaused())
+                  break;
+                --turn;
+                continue;
+              }
               if (isTerminalInferenceFailure(retryErr)) {
                 nonRetryableBackendFailure = true;
               }
@@ -418980,6 +419170,12 @@ ${diagnosis}` : diagnosis;
               nonRetryableBackendFailure = true;
               reqErr = terminalError;
             });
+            if (inputWaitGeneration !== this._modelRequestGeneration) {
+              if (!await this.waitIfPaused())
+                break;
+              --turn;
+              continue;
+            }
             if (!recovered2) {
               if (this.aborted)
                 break;
@@ -419006,11 +419202,21 @@ ${diagnosis}` : diagnosis;
             response = recovered2;
           }
         }
+        if (inputWaitGeneration !== this._modelRequestGeneration) {
+          if (!await this.waitIfPaused())
+            break;
+          --turn;
+          continue;
+        }
         if (this._interruptionMode !== "off" && this._paused) {
           const shouldContinue = await this.waitIfPaused();
           if (!shouldContinue)
             break;
         }
+        if (inputWaitGeneration !== this._modelRequestGeneration) {
+          --turn;
+          continue;
+        }
         this.flushPendingPausedStreamTerminal();
         this.flushPendingStreamAssistantText();
         totalTokens += response.usage?.totalTokens || (response.usage?.promptEvalCount ?? response.usage?.promptTokens ?? 0) + (response.usage?.completionTokens ?? 0);
@@ -426277,7 +426483,8 @@ ${description}`
   async waitForTransientRetry(delayMs) {
     const signals = [
       this._abortController.signal,
-      this._turnAbortController.signal
+      this._turnAbortController.signal,
+      this._inputWaitBoundaryController.signal
     ];
     if (signals.some((signal) => signal.aborted))
       return;
@@ -426301,7 +426508,8 @@ ${description}`
     });
   }
   async retryOnTransient(initialErr, chatRequest, turn, onTerminalFailure) {
-    if (this.aborted || this._pendingSteeringPreemption)
+    const inputWaitGeneration = this._modelRequestGeneration;
+    if (this.aborted || this._pendingSteeringPreemption || this._inputWaitPaused)
       return null;
     if (!this.isTransientError(initialErr))
       return null;
@@ -426328,7 +426536,7 @@ ${description}`
     const backend = this.backend;
     let attempt = 1;
     while (attempt <= (maxRetries === Infinity ? Number.MAX_SAFE_INTEGER : maxRetries)) {
-      if (this.aborted || this._pendingSteeringPreemption)
+      if (this.aborted || this._pendingSteeringPreemption || this._inputWaitPaused || inputWaitGeneration !== this._modelRequestGeneration)
         return null;
       if (foregroundCanWait && isStalledBackend(currentErr)) {
         const stall = stallBudget.recordStall();
@@ -426420,7 +426628,7 @@ ${description}`
         });
       }
       await this.waitForTransientRetry(effectiveDelay);
-      if (this.aborted || this._pendingSteeringPreemption)
+      if (this.aborted || this._pendingSteeringPreemption || this._inputWaitPaused || inputWaitGeneration !== this._modelRequestGeneration)
         return null;
       try {
         if (!isBrokerQueueDeadline) {
@@ -426514,6 +426722,7 @@ ${description}`
       }
     }
     for await (const chunk of backend.chatCompletionStream(request)) {
+      request.signal?.throwIfAborted();
       if (this.aborted || this._pendingSteeringPreemption)
         break;
       if (chunk.type === "finish" && chunk.responseDiagnostics)
@@ -426671,6 +426880,7 @@ arguments=` : ""}` + (chunk.toolCallArgs ?? "");
         lastFinalizedIdx = idx;
       }
     }
+    request.signal?.throwIfAborted();
     if (toolCallAccumulators.size > 0) {
       for (const [, acc] of toolCallAccumulators) {
         if (acc.name && !["completed", "failed", "yielded", "executing"].includes(this._streamingExecutor.getStates().get(acc.id) ?? "")) {
@@ -426993,7 +427203,6 @@ function computeEffectiveThink(params) {
   return params.defaultThink;
 }
 var _corpusExactCarrierProofs = /* @__PURE__ */ new WeakMap();
-var _unreadWebSourceCarrierProofs = /* @__PURE__ */ new WeakMap();
 function sanitizeHistoryThink(messages2, options = {}) {
   const referencedToolCallIds = /* @__PURE__ */ new Set();
   for (const message of messages2) {
@@ -427002,8 +427211,7 @@ function sanitizeHistoryThink(messages2, options = {}) {
     }
   }
   const stripped = messages2.map((m) => {
-    const unread = _unreadWebSourceCarrierProofs.get(m);
-    if (unread && m.role === "tool" && m.tool_call_id === unread.callId && m.content === unread.content && m.requiredSourceEvidence?.schema === "omnius.required-source-evidence.v1" && m.requiredSourceEvidence.scope === `unread-web-source:${unread.callId}` && unread.current())
+    if (isCurrentUnreadSourceCarrier(m))
       return m;
     const carrier = _corpusExactCarrierProofs.get(m);
     if (carrier && m.role === "tool" && m.tool_call_id === carrier.callId && m.content === carrier.content && m.requiredSourceEvidence?.schema === "omnius.required-source-evidence.v1" && m.requiredSourceEvidence.scope === `corpus-input:${carrier.callId}` && carrier.current())