dsh-done-sound 0.1.13 → 0.1.15

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,71 @@ 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).
+
+      // 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.
-      if (liveSnap.streaming === true) {
-        scheduleModuleRetry(delayMs);
-        return;
-      }
+
+      // Every retry window sends "继续" — no waiting on a "streaming" state.
+      // A dropped model leaves the session stuck in running=true (streaming)
+      // with no turn/end event, so waiting on it made the countdown end without
+      // ever sending. The loop only stops on true recovery, a human-approval
+      // wait, a session switch, a config toggle, or the user pressing 终止重试.
+      retryLog('send', 'window fired attempt=' + String(retryState.attempt + 1));
+      sendModuleRetryContinue(sid, delayMs);
+    }
+
+    /** One attempt: send "继续" and schedule the next window regardless of result. */
+    function sendModuleRetryContinue(sid, delayMs) {
       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.
-      const prompt = pluginCtx && pluginCtx.connection && pluginCtx.connection.api && pluginCtx.connection.api.sessions
-        ? pluginCtx.connection.api.sessions.prompt
-        : null;
-      const fail = (why) => {
+      // DSH 0.1.5-rc.2 exposes the sessions service as `ctx.sessions`:
+      // `sessions.binding(sessionId).session.prompt(...)`. The older
+      // `connection.api.sessions.prompt` shape no longer exists there, which is
+      // why retries stopped after arming (prompt-api-unavailable). Support both
+      // so one bundle serves rc.1 and rc.2 hosts.
+      let session = null;
+      let prompt = null;
+      try {
+        const sessions = pluginCtx && pluginCtx.sessions;
+        if (sessions && typeof sessions.binding === 'function') {
+          const binding = sessions.binding(sid);
+          if (binding && binding.session && typeof binding.session.prompt === 'function') {
+            session = binding.session;
+            prompt = (content, mode) => session.prompt(content, mode);
+          }
+        }
+      } catch {
+        // fall through to legacy path
+      }
+      if (typeof prompt !== 'function') {
         try {
-          console.error('[dsh-done-sound] auto-retry could not send "继续":', why);
-          reportLog('error', ['auto-retry could not send "继续":', why]);
+          const legacy = pluginCtx && pluginCtx.connection && pluginCtx.connection.api && pluginCtx.connection.api.sessions;
+          if (legacy && typeof legacy.prompt === 'function') {
+            prompt = (content, mode) => legacy.prompt({ sessionId: sid, mode, content });
+          }
         } catch {
-          // console may be gone during teardown
+          // ignore
         }
-        setConfig({
-          lastEvent: {
-            at: Date.now(),
-            kind: 'retry',
-            reason: 'retry-failed',
-            play: false,
-            retried: true,
-            retryFailed: true,
-            retryAttempt: retryState.attempt,
-          },
-        });
-        retryLater();
-      };
+      }
       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 +494,16 @@ window.__ModuleLoader__.load({
       } catch {
         // keep UTC
       }
-      Promise.resolve(prompt({ sessionId: sid, mode: 'queue', content: [{ type: 'text', text: '继续' }], clientTimeZone: tz }))
+      retryLog('send', '继续 attempt=' + String(retryState.attempt + 1));
+      Promise.resolve(prompt([{ type: 'text', text: '继续' }], 'queue'))
         .then((res) => {
-          const result = res && res.result;
-          if (result && result.ok) {
+          // rc.2 sessions prompt resolves to RemoteResult ({ok} | {ok:false,
+          // error}); the legacy connection API resolves to {result: {...}}.
+          const result = res && res.result ? res.result : res;
+          if (result && result.ok === true) {
             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 +519,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 +533,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);
     }
 
@@ -1352,8 +1399,12 @@ window.__ModuleLoader__.load({
           liveSnap.endTurn = snap.endTurn;
           liveSnap.endReason = snap.endReason;
           if (retryState.active) {
+            // Only a newer turn that closed with `completed` counts as a real
+            // recovery. `aborted`/`blocked` (a dropped model often ends its
+            // retry turn that way) and `error`/`max-tokens` are FAILURES that
+            // must keep the retry loop running until the user stops it.
             const newerClosed = snap.endReason !== null && snap.endTurn > retryState.endTurnAtError;
-            const recovered = newerClosed && snap.endReason !== 'error' && snap.endReason !== 'max-tokens';
+            const recovered = newerClosed && snap.endReason === 'completed';
             const stop =
               snap.sessionId !== retryState.sessionId ||
               snap.pendingCount > 0 ||
@@ -1549,7 +1600,7 @@ if (snap.pendingCount > 0) {
     }
 
     exports.name = 'dsh-done-sound';
-    exports.inject = ['slots', 'remote', 'remote.commands', 'connection'];
+    exports.inject = ['slots', 'sessions', 'remote', 'remote.commands', 'connection'];
     exports.apply = apply;
     // Test seam: `test/retry.test.mjs` loads this bundle with a React stub and
     // drives the module-level retry loop directly, so the "keeps retrying until
@@ -1566,3 +1617,4 @@ if (snap.pendingCount > 0) {
   },
 });
 
+

package/package.json

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