@seawork/server 1.0.20 → 1.0.21-rc.2

package/dist/server/server/agent/providers/codex-app-server-agent.js

@@ -20,6 +20,12 @@ import { buildCodexFeatures, codexModelSupportsFastMode } from "./codex-feature-
 import { formatDiagnosticStatus, formatProviderDiagnostic, formatProviderDiagnosticError, resolveBinaryVersion, toDiagnosticErrorMessage, } from "./diagnostic-utils.js";
 const DEFAULT_TIMEOUT_MS = 14 * 24 * 60 * 60 * 1000;
 const TURN_START_TIMEOUT_MS = 90 * 1000;
+// issue #259: window after turn/interrupt during which the next turn/start
+// gets a sentinel reminder prepended to its input.
+const CANCEL_REMINDER_WINDOW_MS = 60 * 1000;
+const CANCEL_REMINDER_TEXT = "[seawork system note] The user canceled the previous turn before it finished. " +
+    "Ignore any prior user message that did not receive a complete answer. " +
+    "Only respond to the message below.";
 const CODEX_EXTERNAL_MIGRATION_MIN_VERSION = "0.128.0";
 const CODEX_PROVIDER = "codex";
 const CODEX_SEAWORK_PROVIDER_ID = "seawork";
@@ -2092,6 +2098,10 @@ class CodexAppServerAgentSession {
         this.capabilities = CODEX_APP_SERVER_CAPABILITIES;
         this.currentThreadId = null;
         this.currentTurnId = null;
+        // issue #259: codex thread is append-only and turn/interrupt does not retract
+        // the canceled user message. Track when interrupt completed so the next
+        // turn/start can warn the model to ignore the prior prompt.
+        this.lastCanceledAt = null;
         this.client = null;
         this.subscribers = new Set();
         this.nextTurnOrdinal = 0;
@@ -2280,8 +2290,29 @@ class CodexAppServerAgentSession {
         }
         this.planModeEnabled = value;
         this.refreshResolvedCollaborationMode();
+        // collaborationMode switches may bring in a different settings.model
+        // (when config.model is unset and plan/code modes carry different model
+        // hints). Mirror setModel()'s fast-tier guard so we don't ship
+        // serviceTier:"fast" to a model that doesn't support it.
+        if (this.serviceTier && !codexModelSupportsFastMode(this.effectiveTurnModel())) {
+            // Clear both runtime and persisted state — the constructor restores
+            // serviceTier from config.featureValues.fast_mode on session reload,
+            // so leaving the persisted flag true would bring the invalid state back.
+            this.serviceTier = null;
+            this.config.featureValues = {
+                ...(this.config.featureValues ?? {}),
+                fast_mode: false,
+            };
+        }
         this.cachedRuntimeInfo = null;
     }
+    effectiveTurnModel() {
+        const collabModel = this.resolvedCollaborationMode?.settings?.model;
+        if (typeof collabModel === "string" && collabModel.length > 0) {
+            return collabModel;
+        }
+        return this.config.model;
+    }
     rememberPlanResult(item) {
         if (item.detail.type !== "plan") {
             return;
@@ -2317,14 +2348,16 @@ class CodexAppServerAgentSession {
         this.emitEvent({ type: "permission_requested", provider: CODEX_PROVIDER, request });
     }
     /**
-     * Prepare the session for plan implementation by disabling plan/fast mode
-     * and returning the implementation prompt. The caller is responsible for
-     * starting the turn through the normal streamAgent path.
+     * Prepare the session for plan implementation by disabling plan mode (so the
+     * next turn runs in `code` collaboration mode instead of generating another
+     * plan) and returning the implementation prompt. fast_mode is intentionally
+     * preserved — it only controls the inference tier and is orthogonal to the
+     * plan→implement transition. The caller is responsible for starting the
+     * turn through the normal streamAgent path.
      */
     preparePlanImplementation(params) {
         const planText = typeof params.planText === "string" ? normalizePlanMarkdown(params.planText) : "";
         this.applyFeatureValue("plan_mode", false);
-        this.applyFeatureValue("fast_mode", false);
         return buildCodexPlanImplementationPrompt(planText);
     }
     registerRequestHandlers() {
@@ -2558,7 +2591,7 @@ class CodexAppServerAgentSession {
         else {
             await this.ensureThread();
         }
-        const input = await this.buildUserInput(effectivePrompt);
+        const input = this.maybePrependCancelReminder(await this.buildUserInput(effectivePrompt));
         const preset = MODE_PRESETS[this.currentMode] ?? MODE_PRESETS[DEFAULT_CODEX_MODE_ID];
         const approvalPolicy = this.config.approvalPolicy ?? preset.approvalPolicy;
         const sandboxPolicyType = this.config.sandboxMode ?? preset.sandbox;
@@ -2612,6 +2645,11 @@ class CodexAppServerAgentSession {
             throw error;
         }
         this.logger.info({ turnId, elapsedMs: Date.now() - turnStartT0 }, "[timing] codex turn/start acknowledged");
+        // issue #259: do NOT consume `lastCanceledAt` here. The sentinel is only
+        // cleared once we see turn/completed with status "completed" — a
+        // turn/start ack can still race with turn/completed: failed, in which
+        // case the orphaned prompt is still in the thread and the next retry
+        // must carry the reminder (PR #273 review #3).
         return { turnId };
     }
     subscribe(callback) {
@@ -2835,6 +2873,12 @@ class CodexAppServerAgentSession {
                 threadId: this.currentThreadId,
                 turnId: this.currentTurnId,
             });
+            // issue #259: codex protocol has no thread-truncate RPC, so a canceled
+            // user prompt stays in the thread. The sentinel timestamp is set on the
+            // turn/completed `interrupted` event below (not here), because a
+            // successful turn/interrupt RPC can race with normal completion — if
+            // the model already finished, the prompt has a paired assistant reply
+            // and the next turn must NOT prepend the sentinel.
         }
         catch (error) {
             this.logger.warn({ error }, "Failed to interrupt Codex turn");
@@ -2948,6 +2992,27 @@ class CodexAppServerAgentSession {
         const blocks = prompt;
         return await codexAppServerTurnInputFromPrompt(blocks, this.logger);
     }
+    // issue #259: if the previous turn was canceled via turn/interrupt and the
+    // user resends a prompt within the window, prepend a one-shot sentinel so
+    // the model knows to ignore the orphaned user message that codex's
+    // append-only thread cannot retract. Sentinel lifecycle is owned by
+    // turn/completed: it is only cleared on a "completed" status. We do NOT
+    // clear it here on a successful turn/start ack, because that turn could
+    // still end as turn/completed: failed, in which case the orphaned prompt
+    // remains in the thread and the next retry must still carry the reminder
+    // (PR #273 review #3). The only side-effect here is eagerly dropping a
+    // stale timestamp that fell outside the window — no turn/completed is
+    // expected to arrive for it.
+    maybePrependCancelReminder(input) {
+        if (this.lastCanceledAt === null)
+            return input;
+        const elapsed = Date.now() - this.lastCanceledAt;
+        if (elapsed >= CANCEL_REMINDER_WINDOW_MS) {
+            this.lastCanceledAt = null;
+            return input;
+        }
+        return [{ type: "text", text: CANCEL_REMINDER_TEXT }, ...input];
+    }
     emitEvent(event) {
         if (event.type === "timeline") {
             if (event.item.type === "assistant_message") {
@@ -3004,9 +3069,22 @@ class CodexAppServerAgentSession {
                 });
             }
             else if (parsed.status === "interrupted") {
+                // issue #259: the user prompt for this turn is now orphaned in the
+                // append-only thread. Record the moment so the next turn/start can
+                // prepend a sentinel telling the model to ignore it.
+                this.lastCanceledAt = Date.now();
                 this.emitEvent({ type: "turn_canceled", provider: CODEX_PROVIDER, reason: "interrupted" });
             }
             else {
+                // issue #259: a normal `completed` turn means the prior user prompt
+                // has a paired assistant reply — clear any pending sentinel (e.g.
+                // from a turn/interrupt that raced with normal completion) so we
+                // don't tell the model to ignore valid history. Unknown future
+                // statuses leave `lastCanceledAt` untouched: we don't know whether
+                // the prompt was answered or orphaned, so we keep current state.
+                if (parsed.status === "completed") {
+                    this.lastCanceledAt = null;
+                }
                 if (this.planModeEnabled && this.latestPlanResult?.text) {
                     this.emitSyntheticPlanApprovalRequest(this.latestPlanResult.text);
                 }