dsh-done-sound 0.1.13 → 0.1.14

package/lib/client.js

@@ -370,6 +370,7 @@ window.__ModuleLoader__.load({
       deadline: 0,
       timer: null,
       delayMs: 60000,
+      streamingSince: null, // when the loop first saw the session stuck streaming
     };
     // Latest session view, refreshed by the detector on every snapshot change,
     // so this module-level timer can decide without reaching into React state.
@@ -380,13 +381,22 @@ window.__ModuleLoader__.load({
         retryState.timer = null;
       }
     }
-    function cancelModuleRetry() {
+    function cancelModuleRetry(why) {
+      if (retryState.active || retryState.timer !== null) {
+        try {
+          console.info('[dsh-done-sound] retry: cancel', why || 'stop');
+          reportLog('info', ['retry: cancel', why || 'stop']);
+        } catch {
+          // ignore
+        }
+      }
       clearRetryTimer();
       retryState.active = false;
       retryState.sessionId = null;
       retryState.endTurnAtError = 0;
       retryState.attempt = 0;
       retryState.deadline = 0;
+      retryState.streamingSince = null;
     }
     /** Queue the next attempt and publish the countdown deadline. */
     function scheduleModuleRetry(delayMs) {
@@ -410,70 +420,61 @@ window.__ModuleLoader__.load({
       if (!retryState.active) return;
       const sid = retryState.sessionId;
       const delayMs = retryState.delayMs;
-      // Stop the loop once the situation it was armed for is gone: another
-      // session, a human-approval wait, or a newer turn that closed normally
-      // (i.e. the retry worked).
+      const now = Date.now();
+
+      // Stop the loop only when the session truly recovered: a newer turn
+      // closed normally (`completed`). Aborts / blocks / errors are FAILURES
+      // from the user's point of view (a dropped model often ends the retry
+      // turn as `aborted`) — those must keep retrying until the user stops it.
       const recovered =
         liveSnap.endReason !== null &&
         liveSnap.endTurn > retryState.endTurnAtError &&
-        liveSnap.endReason !== 'error' &&
-        liveSnap.endReason !== 'max-tokens';
+        liveSnap.endReason === 'completed';
       if (liveSnap.sessionId !== sid || liveSnap.pendingCount > 0 || recovered) {
-        cancelModuleRetry();
+        retryLog('stop', 'liveSnap=' + String(liveSnap.sessionId) + '/' + (liveSnap.endReason || 'idle') + '/' + (liveSnap.pendingCount || 0));
+        cancelModuleRetry('recovered-or-stale');
         setConfig({ retryCooldownUntil: null });
         return;
       }
-      // The agent is generating again: wait for that turn instead of stacking
-      // another "继续" on top of it.
+
+      // The agent is generating again. Wait for that turn to close instead of
+      // stacking another "继续" on top of it — UNLESS it has been "streaming"
+      // without ever closing for a suspiciously long time. A dropped model can
+      // leave the session stuck in running=true with no turn/end event, which
+      // would otherwise make the loop wait forever silently (the "only one
+      // retry" symptom). In that case treat it as hung and force another send.
       if (liveSnap.streaming === true) {
-        scheduleModuleRetry(delayMs);
+        if (retryState.streamingSince === null) retryState.streamingSince = now;
+        const stuckCap = Math.max(delayMs, 60000);
+        if (now - retryState.streamingSince < stuckCap) {
+          retryLog('wait', 'streaming ' + String(Math.round((now - retryState.streamingSince) / 1000)) + 's');
+          scheduleModuleRetry(delayMs);
+          return;
+        }
+        retryLog('force', 'streaming stuck ' + String(Math.round((now - retryState.streamingSince) / 1000)) + 's — sending anyway');
+        retryState.streamingSince = null;
+        sendModuleRetryContinue(sid, delayMs);
         return;
       }
-      const retryLater = () => {
-        if (retryState.active) scheduleModuleRetry(delayMs);
-      };
-      // Real send path: the browser→host RPC client (same route the composer's
-      // "send" uses). ctx.connection is provided by @deepseek-ai/dsh-client-connection;
-      // its api.sessions.prompt carries an RpcResponse whose `.result` is {ok} |
-      // {ok:false,error}. Failures are surfaced (console + settings-card row) —
-      // the old remote.sessions guess was silently skipped because no such
-      // namespace exists on the client context.
+
+      retryState.streamingSince = null;
+      sendModuleRetryContinue(sid, delayMs);
+    }
+
+    /** One attempt: send "继续" and schedule the next window regardless of result. */
+    function sendModuleRetryContinue(sid, delayMs) {
       const prompt = pluginCtx && pluginCtx.connection && pluginCtx.connection.api && pluginCtx.connection.api.sessions
         ? pluginCtx.connection.api.sessions.prompt
         : null;
-      const fail = (why) => {
-        try {
-          console.error('[dsh-done-sound] auto-retry could not send "继续":', why);
-          reportLog('error', ['auto-retry could not send "继续":', why]);
-        } catch {
-          // console may be gone during teardown
-        }
-        setConfig({
-          lastEvent: {
-            at: Date.now(),
-            kind: 'retry',
-            reason: 'retry-failed',
-            play: false,
-            retried: true,
-            retryFailed: true,
-            retryAttempt: retryState.attempt,
-          },
-        });
-        retryLater();
+      const retryLater = () => {
+        if (retryState.active) scheduleModuleRetry(delayMs);
       };
       if (typeof prompt !== 'function') {
         // Nothing to retry with — stop instead of spinning a useless timer.
-        cancelModuleRetry();
+        cancelModuleRetry('prompt-api-unavailable');
         setConfig({
           retryCooldownUntil: null,
-          lastEvent: {
-            at: Date.now(),
-            kind: 'retry',
-            reason: 'retry-failed',
-            play: false,
-            retried: true,
-            retryFailed: true,
-          },
+          lastEvent: { at: Date.now(), kind: 'retry', reason: 'retry-failed', play: false, retried: true, retryFailed: true },
         });
         return;
       }
@@ -483,13 +484,14 @@ window.__ModuleLoader__.load({
       } catch {
         // keep UTC
       }
+      retryLog('send', '继续 attempt=' + String(retryState.attempt + 1));
       Promise.resolve(prompt({ sessionId: sid, mode: 'queue', content: [{ type: 'text', text: '继续' }], clientTimeZone: tz }))
         .then((res) => {
           const result = res && res.result;
           if (result && result.ok) {
             try {
               console.log('[dsh-done-sound] auto-retry sent "继续" to session', sid);
-              reportLog('info', ['auto-retry sent "继续" to session', sid]);
+              reportLog('info', ['auto-retry sent "继续" to session', sid, 'attempt', retryState.attempt + 1]);
             } catch {
               // ignore
             }
@@ -505,6 +507,9 @@ window.__ModuleLoader__.load({
               // never let a playback error break the retry flow
             }
             retryState.attempt += 1;
+            // A send that the host accepted but that revived nothing must still
+            // keep the loop alive — the next window sends "继续" again.
+            retryState.streamingSince = null;
             setConfig({
               lastEvent: {
                 at: Date.now(),
@@ -516,22 +521,52 @@ window.__ModuleLoader__.load({
                 retryAttempt: retryState.attempt,
               },
             });
-            // Keep the loop alive: if this attempt did not revive the session,
-            // the next tick sends "继续" again until the user stops it.
             retryLater();
           } else {
             const err = result && result.error ? result.error.message : JSON.stringify(result);
-            fail(err || 'prompt not accepted');
+            sendRetryFail(err || 'prompt not accepted', delayMs);
           }
         })
-        .catch((err) => fail(err && err.message ? err.message : String(err)));
+        .catch((err) => sendRetryFail(err && err.message ? err.message : String(err), delayMs));
+    }
+
+    function sendRetryFail(why, delayMs) {
+      try {
+        console.error('[dsh-done-sound] auto-retry could not send "继续":', why);
+        reportLog('error', ['auto-retry could not send "继续":', why]);
+      } catch {
+        // console may be gone during teardown
+      }
+      setConfig({
+        lastEvent: {
+          at: Date.now(),
+          kind: 'retry',
+          reason: 'retry-failed',
+          play: false,
+          retried: true,
+          retryFailed: true,
+          retryAttempt: retryState.attempt,
+        },
+      });
+      if (retryState.active) scheduleModuleRetry(delayMs);
     }
+
+    function retryLog(action, detail) {
+      try {
+        console.info('[dsh-done-sound] retry:', action, detail || '');
+        reportLog('info', ['retry:', action, detail || '']);
+      } catch {
+        // ignore — logging must never break the loop
+      }
+    }
+
     function startModuleRetry(sessionId, endTurnAtError, delayMs) {
-      cancelModuleRetry();
+      cancelModuleRetry('re-arm');
       retryState.active = true;
       retryState.sessionId = sessionId;
       retryState.endTurnAtError = endTurnAtError;
       retryState.attempt = 0;
+      retryState.streamingSince = null;
       scheduleModuleRetry(delayMs);
     }
 
@@ -1566,3 +1601,4 @@ if (snap.pendingCount > 0) {
   },
 });
 
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-done-sound",
-  "version": "0.1.13",
+  "version": "0.1.14",
   "description": "Play a user-chosen sound whenever a conversation finishes in the DeepSeek Harness web GUI",
   "license": "MIT",
   "type": "module",