@vellumai/assistant 0.8.10 → 0.8.11-staging.1

package/src/plugins/defaults/compaction/window-manager.ts

@@ -24,7 +24,11 @@ import {
   runAssistantDrivenCompaction,
   runEmergencyCompaction,
 } from "../../../context/compactor.js";
-import { estimatePromptTokens } from "../../../context/token-estimator.js";
+import {
+  estimatePromptTokens,
+  estimateToolsTokens,
+} from "../../../context/token-estimator.js";
+import type { InjectionMode } from "../../../daemon/conversation-runtime-assembly.js";
 import type {
   ContentBlock,
   Message,
@@ -33,6 +37,15 @@ import type {
 } from "../../../providers/types.js";
 import type { TrustClass } from "../../../runtime/actor-trust-resolver.js";
 import { getLogger } from "../../../util/logger.js";
+import {
+  createInitialReducerState,
+  reduceContextOverflow,
+  type ReducerConfig,
+  type ReducerState,
+  type ReducerStepResult,
+} from "./context-overflow-reducer.js";
+import { computeCorrectedOverflowTarget } from "./corrected-target.js";
+import { resolveOverflowAction } from "./overflow-policy.js";
 
 const log = getLogger("context-window");
 
@@ -85,6 +98,23 @@ export interface ContextWindowResult {
    * compactions that did clear the threshold.
    */
   exhausted?: boolean;
+  /**
+   * Runtime-injection volume the overflow reduction ladder settled on for the
+   * next provider call. The injection-downgrade rung lowers this to
+   * `"minimal"`; every other rung leaves it `"full"`. The agent loop forwards
+   * it to the post-compaction re-injection so the reduced prompt keeps the
+   * volume the ladder chose. Omitted on the ordinary (non-overflow) compaction
+   * path, where re-injection always runs at `"full"`.
+   */
+  injectionMode?: InjectionMode;
+  /**
+   * Set when the overflow reduction ladder applied its terminal
+   * auto-compress-latest-turn rung. The agent loop reads it to classify the
+   * terminal exit when recovery is exhausted: a still-too-large turn after
+   * auto-compress ran is a `budget_yield_unrecovered`, without it a
+   * `context_too_large`. Omitted on the ordinary compaction path.
+   */
+  autoCompressApplied?: boolean;
 }
 
 export interface ShouldCompactResult {
@@ -135,6 +165,52 @@ export interface EmergencyCompactOptions {
   overrideProfile?: string | null;
 }
 
+/**
+ * Turn-specific inputs for {@link ContextWindowManager.reduceOverflowOneRung}.
+ * The manager owns everything the reduction ladder derives from its own state
+ * (provider, system prompt, token budgets, conversation id, config, and the
+ * running reducer state); the caller supplies only what is specific to the
+ * overflow that triggered recovery.
+ */
+export interface OverflowRecoveryRungOptions {
+  /**
+   * Provider-reported token count from the overflow rejection, or `null` when
+   * it could not be parsed. Lowers the compaction target in proportion to the
+   * estimator's under-count so the reduced history lands under the provider's
+   * true ceiling rather than the under-counted estimate.
+   */
+  actualTokens: number | null;
+  /**
+   * Whether the terminal auto-compress-latest-turn rung is permitted. The
+   * caller resolves this from the overflow policy; the manager never makes the
+   * policy call itself.
+   */
+  allowAutoCompressLatestTurn: boolean;
+  /** Per-conversation inference-profile override for the summary call. */
+  overrideProfile?: string | null;
+  /** Trust class of the actor whose turn triggered overflow recovery. */
+  actorTrustClass?: TrustClass;
+}
+
+export interface OverflowRecoveryOptions {
+  /**
+   * Provider-reported token count from the overflow rejection, or `null` when
+   * it could not be parsed. Forwarded to the reduction ladder to correct the
+   * compaction target against the estimator's under-count.
+   */
+  actualTokens: number | null;
+  /**
+   * Whether a human is present this turn. The manager resolves the
+   * auto-compress-latest-turn permission from the overflow policy using this
+   * flag, so callers signal interactivity rather than the policy verdict.
+   */
+  isInteractive: boolean;
+  /** Per-conversation inference-profile override for the summary call. */
+  overrideProfile?: string | null;
+  /** Trust class of the actor whose turn triggered overflow recovery. */
+  actorTrustClass?: TrustClass;
+}
+
 export interface ContextWindowManagerOptions {
   provider: Provider;
   systemPrompt: string | (() => string);
@@ -218,6 +294,26 @@ export class ContextWindowManager {
    */
   private _nonPersistedPrefixCount = 0;
   private _resolvedSystemPrompt: string | undefined;
+  /**
+   * Reducer state for the in-progress overflow-recovery ladder, held across
+   * the successive {@link reduceOverflowOneRung} calls of a single turn so the
+   * ladder advances one rung per call. Reset to `undefined` at each turn
+   * boundary via {@link resetOverflowRecovery} so a new turn starts the ladder
+   * from the emergency rung.
+   */
+  private _overflowReducerState: ReducerState | undefined;
+  /**
+   * The corrected compaction target and the prompt-token estimate it was
+   * derived from, computed once against the overflowing prompt on the first
+   * rung of a turn and reused across that turn's later rungs. The correction
+   * captures the estimator error the provider's actual token count revealed at
+   * the moment of overflow; re-deriving it against an already-reduced prompt
+   * would divide the original actual-token count by a smaller estimate and
+   * drive the target ever lower. Reset with {@link resetOverflowRecovery}.
+   */
+  private _overflowTurnTarget:
+    | { targetTokens: number; estimatedInputTokens: number }
+    | undefined;
 
   constructor(options: ContextWindowManagerOptions) {
     this.provider = options.provider;
@@ -232,6 +328,16 @@ export class ContextWindowManager {
     this.config = config;
   }
 
+  /**
+   * Clear the overflow-recovery ladder so the next {@link reduceOverflowOneRung}
+   * call starts a fresh ladder from the emergency rung. Called at the turn
+   * boundary.
+   */
+  resetOverflowRecovery(): void {
+    this._overflowReducerState = undefined;
+    this._overflowTurnTarget = undefined;
+  }
+
   /** Leading non-persisted inherited-context messages the compactor preserves. */
   get nonPersistedPrefixCount(): number {
     return this._nonPersistedPrefixCount;
@@ -325,6 +431,202 @@ export class ContextWindowManager {
     }
   }
 
+  /**
+   * Advance the context-overflow reduction ladder by one rung against
+   * `messages`, holding the reducer state across the successive calls of a
+   * single turn (reset via {@link resetOverflowRecovery}). The compaction
+   * target is the manager's overflow preflight budget, lowered in proportion
+   * to the estimator error the provider's actual token count reveals, so the
+   * reduced history lands under the provider's true ceiling rather than the
+   * under-counted estimate.
+   */
+  async reduceOverflowOneRung(
+    messages: Message[],
+    options: OverflowRecoveryRungOptions,
+    signal?: AbortSignal,
+  ): Promise<ReducerStepResult> {
+    try {
+      return await this._reduceOverflowOneRung(messages, options, signal);
+    } finally {
+      this.clearSystemPromptCache();
+    }
+  }
+
+  /**
+   * Drive the context-overflow reduction ladder one rung against `messages`
+   * and adapt the rung into a {@link ContextWindowResult} the agent loop's
+   * compaction path consumes. Resolves the auto-compress-latest-turn
+   * permission from the overflow policy — the manager owns that policy call,
+   * the ladder never makes it — and surfaces the rung's injection mode,
+   * terminal auto-compress flag, and exhaustion so the loop can re-inject at
+   * the chosen volume and classify the terminal exit when recovery runs out.
+   */
+  async recoverContextOverflow(
+    messages: Message[],
+    options: OverflowRecoveryOptions,
+    signal?: AbortSignal,
+  ): Promise<ContextWindowResult> {
+    const allowAutoCompressLatestTurn =
+      resolveOverflowAction({
+        overflowRecovery: this.config.overflowRecovery,
+        isInteractive: options.isInteractive,
+      }) === "auto_compress_latest_turn";
+    const step = await this.reduceOverflowOneRung(
+      messages,
+      {
+        actualTokens: options.actualTokens,
+        allowAutoCompressLatestTurn,
+        overrideProfile: options.overrideProfile,
+        actorTrustClass: options.actorTrustClass,
+      },
+      signal,
+    );
+    return this.overflowStepToResult(step, messages);
+  }
+
+  /**
+   * Adapt a reduction-ladder {@link ReducerStepResult} into the
+   * {@link ContextWindowResult} shape the agent loop's compaction path
+   * consumes. A summary rung carries a full compaction result (with the
+   * durable-commit and circuit-breaker fields); the non-summary rungs
+   * (truncation / media stubbing / injection downgrade) only transform the
+   * in-memory history, so they map to a no-op result that still propagates the
+   * reduced messages. Both forward the ladder's injection mode, exhaustion, and
+   * whether the terminal auto-compress rung was applied.
+   */
+  private overflowStepToResult(
+    step: ReducerStepResult,
+    basis: Message[],
+  ): ContextWindowResult {
+    const autoCompressApplied = step.state.appliedTiers.includes(
+      "auto_compress_latest_turn",
+    );
+    const base =
+      step.compactionResult ??
+      noopResult(step.messages, step.estimatedTokens, {
+        maxInputTokens: this.config.maxInputTokens,
+        thresholdTokens: Math.floor(
+          this.config.maxInputTokens *
+            this.resolveCompactionConfig().autoThreshold,
+        ),
+        reason: `overflow recovery: ${step.tier}`,
+      });
+    return {
+      ...base,
+      messages: step.messages,
+      estimatedInputTokens: step.estimatedTokens,
+      previousEstimatedInputTokens: this.estimateInputTokens(basis),
+      injectionMode: step.state.injectionMode,
+      autoCompressApplied,
+      exhausted: step.state.exhausted,
+    };
+  }
+
+  private async _reduceOverflowOneRung(
+    messages: Message[],
+    options: OverflowRecoveryRungOptions,
+    signal?: AbortSignal,
+  ): Promise<ReducerStepResult> {
+    if (this.conversationId == null) {
+      throw new Error(
+        "ContextWindowManager has no conversationId — cannot run overflow recovery",
+      );
+    }
+    if (!this._overflowReducerState) {
+      this._overflowReducerState = createInitialReducerState();
+      this._overflowTurnTarget = this.deriveOverflowTurnTarget(
+        messages,
+        options.actualTokens,
+      );
+    }
+    const { targetTokens, estimatedInputTokens } = this._overflowTurnTarget!;
+
+    const config: ReducerConfig = {
+      providerName: this.estimationProviderName,
+      systemPrompt: this.systemPrompt,
+      contextWindow: this.config,
+      targetTokens,
+      toolTokenBudget: this.resolveTurnToolTokenBudget(),
+      conversationId: this.conversationId,
+      overrideProfile: options.overrideProfile ?? null,
+      actorTrustClass: options.actorTrustClass,
+      previousEstimatedInputTokens: estimatedInputTokens,
+      maxMiddleTierAttempts: this.config.overflowRecovery.maxAttempts,
+      allowAutoCompressLatestTurn: options.allowAutoCompressLatestTurn,
+    };
+
+    const step = await reduceContextOverflow(
+      messages,
+      config,
+      this._overflowReducerState,
+      signal,
+    );
+    this._overflowReducerState = step.state;
+    return step;
+  }
+
+  /**
+   * Compute the corrected compaction target for a turn's overflow recovery:
+   * the overflow preflight budget lowered in proportion to the estimator error
+   * the provider's actual token count reveals, so the reduced history lands
+   * under the provider's true ceiling rather than the under-counted estimate.
+   */
+  private deriveOverflowTurnTarget(
+    messages: Message[],
+    actualTokens: number | null,
+  ): { targetTokens: number; estimatedInputTokens: number } {
+    const estimatedInputTokens = estimatePromptTokens(
+      messages,
+      this.systemPrompt,
+      {
+        providerName: this.estimationProviderName,
+        toolTokenBudget: this.resolveTurnToolTokenBudget(),
+      },
+    );
+    const { targetTokens, estimationErrorRatio } =
+      computeCorrectedOverflowTarget({
+        preflightBudget: this.resolveOverflowPreflightBudget(messages.length),
+        actualTokens,
+        estimatedTokens: estimatedInputTokens,
+      });
+    if (estimationErrorRatio != null) {
+      log.warn(
+        {
+          actualTokens,
+          estimatedTokens: estimatedInputTokens,
+          estimationErrorRatio: estimationErrorRatio.toFixed(2),
+          targetTokens,
+        },
+        "Adjusting overflow compaction target based on observed estimation error",
+      );
+    }
+    return { targetTokens, estimatedInputTokens };
+  }
+
+  /**
+   * Tool-token budget for the current turn's overflow recovery. Prefers the
+   * live tool set resolved for the turn — matching what the loop sends to the
+   * provider — and falls back to the constructor-time snapshot when no
+   * resolver is wired (legacy test paths, ad-hoc instantiation).
+   */
+  private resolveTurnToolTokenBudget(): number {
+    const tools = this.resolveTools?.();
+    return tools ? estimateToolsTokens(tools) : this.toolTokenBudget;
+  }
+
+  /**
+   * The token budget overflow recovery compacts below, derived from the
+   * manager's configured max-input cap and overflow-recovery safety margin.
+   * Long histories (> 50 messages) get a wider margin so the reduced prompt
+   * keeps clearance under the provider's true ceiling.
+   */
+  private resolveOverflowPreflightBudget(messageCount: number): number {
+    const baseSafetyMargin = this.config.overflowRecovery.safetyMarginRatio;
+    const safetyMargin =
+      messageCount > 50 ? Math.max(baseSafetyMargin, 0.15) : baseSafetyMargin;
+    return Math.floor(this.config.maxInputTokens * (1 - safetyMargin));
+  }
+
   private async _maybeCompact(
     messages: Message[],
     signal?: AbortSignal,

package/src/plugins/defaults/empty-response/hooks/post-model-call.ts

@@ -0,0 +1,173 @@
+/**
+ * Default `post-model-call` hook: when the model yields a turn with no tool
+ * calls, decide whether to let the turn end, rewrite it for the user, or
+ * re-query the model.
+ *
+ * Two cases warrant intervention:
+ *
+ * 1. **Refusal stop.** The provider returned `stopReason === "refusal"` with no
+ *    visible text (Anthropic's safety classifier zeroed the response) and no
+ *    earlier turn this run already delivered visible text. The hook rewrites
+ *    the turn into a plain-text apology (`REFUSAL_FALLBACK_TEXT`) by replacing
+ *    {@link PostModelCallContext.content} and lets the turn end. A retry is
+ *    deliberately not attempted: a safety-classifier refusal re-fires on a
+ *    re-query, so the canned message is the intended terminal response.
+ * 2. **Empty turn after tool use.** The turn produced no visible text, follows
+ *    at least one prior assistant turn this run, and no earlier turn this run
+ *    already delivered visible text. The hook re-queries the model with
+ *    `NUDGE_TEXT` (a tool trail exists to summarize, so a retry can recover a
+ *    real answer). The retry is bounded to one pass per run by a one-shot
+ *    per-conversation mark this hook sets; the sibling `stop` hook (see
+ *    `./stop.ts`) clears it when the turn terminates, so the next run nudges
+ *    afresh.
+ *
+ * Every other case leaves the decision at `"stop"` (the model said its piece,
+ * or there is nothing to act on).
+ *
+ * Both prior-turn signals are derived from the current response cycle — the
+ * messages after the last genuine user prompt (a user turn that isn't purely
+ * tool results). Scoping this way keeps prior conversation turns from polluting
+ * the signals, and deriving the boundary from history content rather than an
+ * index means mid-run compaction (which rewrites the array in place) can't
+ * invalidate it. A prior assistant turn this cycle implies a completed tool-use
+ * iteration (an empty turn nudges-and-continues without pushing an assistant
+ * message), so "a prior assistant turn exists" is the equivalent of "this is
+ * not the first model call".
+ *
+ * Defaults register before any user plugin, so this hook runs at the front of
+ * the `post-model-call` chain — later hooks see (and may override) its
+ * decision.
+ *
+ * Only a finalized, no-tool reply is actionable. A provider rejection carries
+ * no turn content to assess (a recovery hook like history-repair owns that),
+ * and a tool-bearing turn continues naturally — the loop runs the tools and
+ * ignores the decision — so the hook returns early for both.
+ */
+
+import type { PluginHookFn, PostModelCallContext } from "@vellumai/plugin-api";
+
+import type { ContentBlock, Message } from "../../../../providers/types.js";
+import {
+  isEmptyResponseNudged,
+  markEmptyResponseNudged,
+} from "../nudge-state-store.js";
+
+/**
+ * Canonical nudge text for an empty turn after tool use. Must stay verbatim so
+ * a plugin that wraps the default sees a stable string.
+ *
+ * Wire-compat note: this is shown to the LLM, not the user. Edits here affect
+ * model behavior but not end-user UX directly.
+ */
+export const NUDGE_TEXT =
+  "<system_notice>Your previous response was empty. You must respond to the user with a summary of what you found or did. Do not use any tools — just respond with text.</system_notice>";
+
+/**
+ * User-facing text a refusal turn is rewritten into. Used when the provider
+ * stops with `"refusal"` and no visible text — i.e. the safety classifier
+ * zeroed the response. Unlike `NUDGE_TEXT` (shown only to the model), this is
+ * the message the user actually reads in place of an empty assistant bubble.
+ */
+export const REFUSAL_FALLBACK_TEXT =
+  "Sorry — I wasn't able to generate a response to that. Please try rephrasing or asking in a different way.";
+
+function hasVisibleText(content: ReadonlyArray<ContentBlock>): boolean {
+  return content.some(
+    (block) => block.type === "text" && block.text.trim().length > 0,
+  );
+}
+
+function hasToolUse(content: ReadonlyArray<ContentBlock>): boolean {
+  return content.some((block) => block.type === "tool_use");
+}
+
+function isAssistantTurn(message: Message): boolean {
+  return message.role === "assistant";
+}
+
+/** A user-role message carrying only tool results, not a fresh prompt. */
+function isToolResultMessage(message: Message): boolean {
+  return (
+    message.role === "user" &&
+    message.content.length > 0 &&
+    message.content.every((block) => block.type === "tool_result")
+  );
+}
+
+/**
+ * Messages belonging to the current response cycle: everything after the last
+ * genuine user prompt. Falls back to the whole history when none is found.
+ */
+function currentCycleMessages(
+  messages: ReadonlyArray<Message>,
+): ReadonlyArray<Message> {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const message = messages[i];
+    if (message.role === "user" && !isToolResultMessage(message)) {
+      return messages.slice(i + 1);
+    }
+  }
+  return messages;
+}
+
+const postModelCall: PluginHookFn<PostModelCallContext> = async (ctx) => {
+  // A provider rejection carries no turn content to assess (a recovery hook
+  // owns the rejection); the sibling `stop` hook clears the mark when the turn
+  // terminates.
+  if (ctx.error) return;
+  // A tool-bearing turn continues mid-run — the loop runs the tools — so leave
+  // the mark intact to keep the one-nudge-per-run bound across tool iterations.
+  if (hasToolUse(ctx.content)) return;
+
+  const turnHasVisibleText = hasVisibleText(ctx.content);
+
+  const cycleMessages = currentCycleMessages(ctx.messages);
+  const priorAssistantTurns = cycleMessages.filter(isAssistantTurn);
+  const hadPriorAssistantTurn = priorAssistantTurns.length > 0;
+  const priorAssistantHadVisibleText = priorAssistantTurns.some((message) =>
+    hasVisibleText(message.content),
+  );
+
+  // Refusal stop: rewrite the empty turn into a user-facing apology and let it
+  // end. Skipped when an earlier turn this run already replied, so the apology
+  // never lands beneath a real answer.
+  if (
+    ctx.stopReason === "refusal" &&
+    !turnHasVisibleText &&
+    !priorAssistantHadVisibleText
+  ) {
+    ctx.content = [{ type: "text", text: REFUSAL_FALLBACK_TEXT }];
+    return;
+  }
+
+  const isEmptyTurnAfterTools =
+    !turnHasVisibleText &&
+    hadPriorAssistantTurn &&
+    !priorAssistantHadVisibleText;
+
+  if (isEmptyTurnAfterTools) {
+    // Re-query once to recover a real answer. The one-shot per-conversation
+    // mark makes the hook self-limiting: a second empty turn this run finds the
+    // mark already set and lets the turn end rather than nudging again.
+    if (!isEmptyResponseNudged(ctx.conversationId)) {
+      markEmptyResponseNudged(ctx.conversationId);
+      ctx.messages.push({
+        role: "user",
+        content: [{ type: "text", text: NUDGE_TEXT }],
+      });
+      ctx.decision = "continue";
+      ctx.logger.warn(
+        { plugin: "empty-response", conversationId: ctx.conversationId },
+        "Model returned empty response after tool results — retrying",
+      );
+      return;
+    }
+
+    ctx.logger.error(
+      { plugin: "empty-response", conversationId: ctx.conversationId },
+      "Model returned empty response after tool results — retries exhausted",
+    );
+  }
+};
+
+export default postModelCall;

package/src/plugins/defaults/empty-response/hooks/stop.ts

@@ -1,126 +1,22 @@
 /**
- * Default `stop` hook: when the model yields a turn with no tool calls, decide
- * whether to let the turn end or re-query the model with a nudge.
+ * Default `stop` hook: clears the per-conversation empty-response nudge bound
+ * when a turn terminates.
  *
- * Two cases warrant a nudge:
- *
- * 1. **Refusal stop.** The provider returned `stopReason === "refusal"` with no
- *    visible text (Anthropic's safety classifier zeroed the response). Nudged
- *    even on the first model call of the run — a refusal there guarantees no
- *    organic text exists yet, so without intervening the loop would persist an
- *    empty assistant bubble to the user. Uses `REFUSAL_NUDGE_TEXT`.
- * 2. **Empty turn after tool use.** The turn produced no visible text, follows
- *    at least one prior assistant turn this run, and no earlier turn this run
- *    already delivered visible text. Uses `NUDGE_TEXT`.
- *
- * Every other case leaves the decision at `"stop"` (the model said its piece,
- * or there is nothing to nudge about). The retry cap is owned by the agent
- * loop: this hook always asks to continue when a nudge is warranted, and the
- * loop stops anyway once the run's nudge budget is spent.
- *
- * Both prior-turn signals are derived from the current response cycle — the
- * messages after the last genuine user prompt (a user turn that isn't purely
- * tool results). Scoping this way keeps prior conversation turns from polluting
- * the signals, and deriving the boundary from history content rather than an
- * index means mid-run compaction (which rewrites the array in place) can't
- * invalidate it. A prior assistant turn this cycle implies a completed tool-use
- * iteration (an empty turn nudges-and-continues without pushing an assistant
- * message), so "a prior assistant turn exists" is the equivalent of "this is
- * not the first model call".
- *
- * Defaults register before any user plugin, so this hook runs at the front of
- * the `stop` chain — later hooks see (and may override) its decision.
+ * The `post-model-call` hook (see `./post-model-call.ts`) marks the bound when
+ * it re-queries the model after an empty turn. `stop` is the definitive
+ * terminal hook — it fires exactly once when the turn is truly ending, after
+ * every retry decision has been made — so clearing the bound here
+ * unconditionally guarantees the next run nudges afresh, no matter how the turn
+ * ended (a finalized reply, an abort, or a retry the loop's per-run backstop
+ * refused).
  */
 
 import type { PluginHookFn, StopContext } from "@vellumai/plugin-api";
 
-import type { ContentBlock, Message } from "../../../../providers/types.js";
-
-/**
- * Canonical nudge text for an empty turn after tool use. Must stay verbatim so
- * a plugin that wraps the default sees a stable string.
- *
- * Wire-compat note: this is shown to the LLM, not the user. Edits here affect
- * model behavior but not end-user UX directly.
- */
-export const NUDGE_TEXT =
-  "<system_notice>Your previous response was empty. You must respond to the user with a summary of what you found or did. Do not use any tools — just respond with text.</system_notice>";
-
-/**
- * Refusal-specific nudge. Used when the provider stops with `"refusal"` and no
- * visible text — i.e. the safety classifier zeroed the response. Kept distinct
- * from `NUDGE_TEXT` so the model gets context-appropriate guidance (no "summary
- * of what you found or did" — there is no tool trail to summarize on a refusal).
- *
- * Wire-compat note: this is shown to the LLM, not the user. Edits here affect
- * retry behavior but not end-user UX directly.
- */
-export const REFUSAL_NUDGE_TEXT =
-  '<system_notice>Your previous response was empty because the upstream provider returned stop_reason="refusal". Please answer the user\'s last message directly with a plain-text response. Do not use any tools — just respond with text.</system_notice>';
-
-function hasVisibleText(content: ReadonlyArray<ContentBlock>): boolean {
-  return content.some(
-    (block) => block.type === "text" && block.text.trim().length > 0,
-  );
-}
-
-function isAssistantTurn(message: Message): boolean {
-  return message.role === "assistant";
-}
-
-/** A user-role message carrying only tool results, not a fresh prompt. */
-function isToolResultMessage(message: Message): boolean {
-  return (
-    message.role === "user" &&
-    message.content.length > 0 &&
-    message.content.every((block) => block.type === "tool_result")
-  );
-}
-
-/**
- * Messages belonging to the current response cycle: everything after the last
- * genuine user prompt. Falls back to the whole history when none is found.
- */
-function currentCycleMessages(
-  messages: ReadonlyArray<Message>,
-): ReadonlyArray<Message> {
-  for (let i = messages.length - 1; i >= 0; i--) {
-    const message = messages[i];
-    if (message.role === "user" && !isToolResultMessage(message)) {
-      return messages.slice(i + 1);
-    }
-  }
-  return messages;
-}
+import { clearEmptyResponseNudged } from "../nudge-state-store.js";
 
 const stop: PluginHookFn<StopContext> = async (ctx) => {
-  const turnHasVisibleText = hasVisibleText(ctx.responseContent);
-
-  const appendNudge = (text: string): void => {
-    ctx.messages.push({ role: "user", content: [{ type: "text", text }] });
-    ctx.decision = "continue";
-  };
-
-  if (ctx.stopReason === "refusal" && !turnHasVisibleText) {
-    appendNudge(REFUSAL_NUDGE_TEXT);
-    return;
-  }
-
-  const cycleMessages = currentCycleMessages(ctx.messages);
-  const priorAssistantTurns = cycleMessages.filter(isAssistantTurn);
-  const hadPriorAssistantTurn = priorAssistantTurns.length > 0;
-  const priorAssistantHadVisibleText = priorAssistantTurns.some((message) =>
-    hasVisibleText(message.content),
-  );
-
-  const isEmptyTurnAfterTools =
-    !turnHasVisibleText &&
-    hadPriorAssistantTurn &&
-    !priorAssistantHadVisibleText;
-
-  if (isEmptyTurnAfterTools) {
-    appendNudge(NUDGE_TEXT);
-  }
+  clearEmptyResponseNudged(ctx.conversationId);
 };
 
 export default stop;