@threadbase-sh/streamer 1.70.0 → 1.70.2

package/dist/index.cjs

@@ -9787,7 +9787,7 @@ var PromptRegistry = class {
     this.maxRecordsPerSession = options.maxRecordsPerSession ?? PROMPT_MAX_RECORDS_PER_SESSION;
   }
   open(draft, adapter, promptId = this.createId()) {
-    this.prune(draft.sessionId);
+    this.sweepExpired(draft.sessionId);
     const held = this.byId.get(promptId);
     if (held && (held.prompt.state === "open" || held.prompt.state === "updated")) {
       throw new Error(`Prompt id already exists: ${promptId}`);
@@ -9877,6 +9877,58 @@ var PromptRegistry = class {
     this.publish(entry);
     return copyPrompt(entry.prompt);
   }
+  /**
+   * The provider's prompt left the screen.
+   *
+   * Distinct from `transition` because the detector cannot tell a teardown it
+   * observed on its own from one OUR OWN write caused. On a screen-scraped gate
+   * the answer keys remove the box, and pty-manager's sendKeys fires the close
+   * synchronously from inside the write — so the close always arrives before
+   * the answer that caused it has settled, and reporting it as a cancel failed
+   * every answer whose bytes had already landed (#720).
+   *
+   * While an answer is writing, the close is deferred and the answer decides:
+   * `resolved` if the write landed, the deferred close if it did not. Success
+   * is the adapter's own result, never the prompt's absence from the screen —
+   * a prompt that does not vanish when answered (a multi-select form) simply
+   * never reaches here, and is settled by the same adapter result (#721).
+   *
+   * ONLY this path defers. `replaced` from a different gate taking the screen,
+   * `unavailable` from invalidateSession and `expired` all still go through
+   * `transition` and still win, because none of them was caused by our write.
+   */
+  providerClosed(promptId, reason) {
+    const entry = this.byId.get(promptId);
+    if (!entry) return null;
+    if (entry.prompt.state !== "open" && entry.prompt.state !== "updated") return null;
+    if (entry.answering) {
+      entry.deferredClose = reason;
+      return null;
+    }
+    return this.transition(promptId, "cancelled", reason);
+  }
+  /**
+   * Run a provider write that may close the prompt as a side effect, so the
+   * close it causes is deferred rather than applied. For callers outside this
+   * class that write without going through `answer()` — the legacy permission
+   * route. `performAnswer` manages the same two fields directly, because it
+   * needs the deferred value in its own control flow.
+   *
+   * The write's own failure needs no unwinding here: pty-manager fires the
+   * close as the last statement of a successful sendKeys, so a throw means no
+   * close was ever deferred and the record is still open for the caller.
+   */
+  whileAnswering(promptId, write) {
+    const entry = this.byId.get(promptId);
+    if (!entry) return write();
+    entry.answering = true;
+    try {
+      return write();
+    } finally {
+      entry.answering = false;
+      entry.deferredClose = void 0;
+    }
+  }
   invalidateSession(sessionId, reason = "session_ended") {
     const transitioned = [];
     for (const entry of this.bySession.get(sessionId)?.values() ?? []) {
@@ -9889,17 +9941,17 @@ var PromptRegistry = class {
   get(promptId) {
     const entry = this.byId.get(promptId);
     if (!entry) return null;
-    this.prune(entry.prompt.sessionId);
+    this.sweepExpired(entry.prompt.sessionId);
     return this.byId.has(promptId) ? copyPrompt(entry.prompt) : null;
   }
   hasActionable(sessionId) {
-    this.prune(sessionId);
+    this.sweepExpired(sessionId);
     return [...this.bySession.get(sessionId)?.values() ?? []].some(
       (entry) => entry.prompt.state === "open" || entry.prompt.state === "updated"
     );
   }
   snapshot(sessionId) {
-    this.prune(sessionId);
+    this.sweepExpired(sessionId);
     return {
       type: "prompt_snapshot",
       schemaVersion: PROMPT_SCHEMA_VERSION,
@@ -9914,7 +9966,7 @@ var PromptRegistry = class {
     for (const entry of this.byId.values()) this.clearExpiration(entry);
   }
   answer(sessionId, answer) {
-    this.prune(sessionId);
+    this.sweepExpired(sessionId);
     const entry = this.byId.get(answer.promptId);
     if (!entry || entry.prompt.sessionId !== sessionId) {
       return Promise.resolve({ ok: false, code: "prompt_not_found" });
@@ -9954,21 +10006,33 @@ var PromptRegistry = class {
     const responseError = this.validateResponses(prompt, answer);
     if (responseError) return { ok: false, code: responseError };
     if (!entry.adapter) return { ok: false, code: "prompt_unavailable" };
+    entry.answering = true;
     let adapterResult;
+    let threw = false;
     try {
       adapterResult = await entry.adapter({ prompt: copyPrompt(prompt), answer });
     } catch {
-      return { ok: false, code: "provider_error" };
+      threw = true;
+      adapterResult = { ok: false, code: "provider_error" };
+    } finally {
+      entry.answering = false;
     }
+    const deferred = entry.deferredClose;
+    entry.deferredClose = void 0;
+    const settle = (outcome) => {
+      if (deferred) this.providerClosed(prompt.promptId, deferred);
+      return outcome;
+    };
+    if (threw) return settle({ ok: false, code: "provider_error" });
     if (entry.prompt.state !== "open" && entry.prompt.state !== "updated") {
-      return { ok: false, code: terminalError(entry.prompt.state) };
+      return settle({ ok: false, code: terminalError(entry.prompt.state) });
     }
     if (entry.prompt.revision !== answer.revision) {
-      return {
+      return settle({
         ok: false,
         code: "prompt_revision_mismatch",
         currentRevision: entry.prompt.revision
-      };
+      });
     }
     if (!adapterResult.ok) {
       if (adapterResult.terminal) {
@@ -9978,7 +10042,7 @@ var PromptRegistry = class {
           adapterResult.terminal.reason
         );
       }
-      return { ok: false, code: adapterResult.code };
+      return settle({ ok: false, code: adapterResult.code });
     }
     return { ok: true, prompt: this.transition(prompt.promptId, "resolved", "answered") };
   }
@@ -10044,7 +10108,7 @@ var PromptRegistry = class {
     if (!entry) throw new Error(`Unknown prompt: ${promptId}`);
     return entry;
   }
-  prune(sessionId) {
+  sweepExpired(sessionId) {
     const now = this.now();
     const session = this.bySession.get(sessionId);
     if (!session) return;
@@ -11068,19 +11132,26 @@ var SessionHandlers = class {
       json(res, 400, { error: "Missing input field" });
       return;
     }
-    this.promptRegistry.hasActionable(sessionId);
+    this.promptRegistry.sweepExpired(sessionId);
     const openPrompt = this.pendingPermission.has(sessionId) ? "permission" : this.pendingQuestions.has(sessionId) ? "question" : null;
     if (openPrompt) {
-      this.log.info(`[input.prompt_pending] ${sessionId.slice(0, 8)} kind=${openPrompt}`, {
-        event: "input.prompt_pending",
-        sessionId,
-        promptKind: openPrompt
-      });
+      const pendingGate = openPrompt === "permission" ? this.pendingPermission.get(sessionId) : void 0;
+      const promptState = pendingGate?.promptId !== void 0 && this.promptRegistry.get(pendingGate.promptId)?.state === "resolved" ? "answered" : "open";
+      this.log.info(
+        `[input.prompt_pending] ${sessionId.slice(0, 8)} kind=${openPrompt} state=${promptState}`,
+        {
+          event: "input.prompt_pending",
+          sessionId,
+          promptKind: openPrompt,
+          promptState
+        }
+      );
       json(res, 409, {
         ok: false,
         reason: "prompt_pending",
         promptKind: openPrompt,
-        error: "A prompt is waiting for an answer; answer or dismiss it before sending text"
+        promptState,
+        error: promptState === "answered" ? "Your answer was sent; wait for the prompt to close before sending text" : "A prompt is waiting for an answer; answer or dismiss it before sending text"
       });
       return;
     }
@@ -11182,10 +11253,7 @@ var SessionHandlers = class {
     if (gate === null) {
       const prior2 = this.pendingPermission.get(sessionId);
       if (!prior2) return;
-      const prompt2 = prior2.promptId ? this.promptRegistry.get(prior2.promptId) : null;
-      if (prompt2?.state === "open" || prompt2?.state === "updated") {
-        this.promptRegistry.transition(prompt2.promptId, "cancelled", "provider_closed");
-      }
+      if (prior2.promptId) this.promptRegistry.providerClosed(prior2.promptId, "provider_closed");
       this.pendingPermission.delete(sessionId);
       this.pendingPermissionKey.delete(sessionId);
       this.broadcastToSession(sessionId, { type: "permission_cancelled", sessionId });
@@ -11410,7 +11478,13 @@ var SessionHandlers = class {
       return;
     }
     try {
-      this.ptyManager.sendKeys(sessionId, option.answerKeys ?? permissionAnswerKeys(option.index));
+      this.promptRegistry.whileAnswering(
+        gate.promptId ?? "",
+        () => this.ptyManager.sendKeys(
+          sessionId,
+          option.answerKeys ?? permissionAnswerKeys(option.index)
+        )
+      );
     } catch (err) {
       const message = err instanceof Error ? err.message : "Failed to send answer";
       json(res, 400, { ok: false, reason: message });