aegis-desktop 0.8.13 → 0.8.15

package/vendor/aegis.js

@@ -65,6 +65,50 @@ function envIdleMs(name) {
   return Number.isFinite(n) && n > 0 ? n : 0;
 }
 
+/**
+ * DeepSeek's chat template wraps tool calls and turn boundaries in special
+ * tokens — fullwidth pipe (U+FF5C) delimiting an identifier that uses ▁
+ * (U+2581) as its word separator, e.g. ｜tool▁calls▁begin｜, ｜tool▁call▁end｜,
+ * ｜Assistant｜, ｜begin▁of▁sentence｜. These are chat-template internals, never
+ * user-facing text; when the provider's streaming tool-call path leaks them
+ * into `delta.content` they used to reach the screen verbatim — reported as
+ * the pasted "｜｜DSML｜｜" envelope on Windows/macOS. Returns a per-stream
+ * stripper closure with a short lookback buffer so a token split across two
+ * SSE chunks isn't half-rendered before its closing pipe arrives.
+ */
+const DEEPSEEK_ENVELOPE_RE = /｜[A-Za-z][A-Za-z0-9]*(?:▁[A-Za-z0-9]+)*｜/g;
+function makeDeepSeekEnvelopeStripper() {
+  let buf = '';
+  const strip = (chunk) => {
+    buf += chunk;
+    buf = buf.replace(DEEPSEEK_ENVELOPE_RE, '');
+    const openIdx = buf.lastIndexOf('｜');
+    if (openIdx !== -1) {
+      const tail = buf.slice(openIdx);
+      // Held back only while the tail still looks like an in-progress token
+      // (no closing pipe yet); a bare '｜' or genuine prose flushes normally.
+      if (tail.length <= 60 && /^｜[A-Za-z0-9▁]*$/.test(tail)) {
+        const out = buf.slice(0, openIdx);
+        buf = tail;
+        return out;
+      }
+    }
+    const out = buf;
+    buf = '';
+    return out;
+  };
+  // Unconditional release of whatever is left buffered — called once the
+  // stream is fully drained, when a held-back '｜…' is known to never close
+  // (dropped connection, or it was real prose all along) rather than an
+  // in-progress token.
+  strip.flush = () => {
+    const out = buf;
+    buf = '';
+    return out;
+  };
+  return strip;
+}
+
 /**
  * UUID v4 that works everywhere: Web Crypto first (browsers, Node ≥ 19),
  * then Node's CJS crypto module (Node < 19), then a Math.random fallback for
@@ -221,10 +265,26 @@ function createClient(opts = {}) {
       }
       throw err;
     } finally {
+      // The timeout is time-to-*headers* only, so it is cleared the moment the
+      // response resolves: a long generation must never be cut off by it.
       if (timer) clearTimeout(timer);
-      if (controller && callerSignal && typeof callerSignal.removeEventListener === 'function') {
-        callerSignal.removeEventListener('abort', onAbort);
-      }
+      // …but the caller's abort bridge is deliberately NOT removed here.
+      //
+      // `fetch` resolves at the status line, while the RESPONSE BODY is still
+      // bound to `controller.signal` and keeps being read long after this
+      // function has returned. Unhooking the caller's signal at that point
+      // detached Stop/Escape from the stream it was supposed to stop: the
+      // engine's own controller really did abort — `engine.cancel()` answered
+      // `{ ok: true }`, so the right controller was found and `abort()` was
+      // really called — and nothing happened, because the only thing wired to
+      // the live body had already been told to stop listening. The turn then
+      // streamed to completion while the UI sat on "stopping…", never settled,
+      // and never produced the salvaged bubble, because no error ever reached
+      // the caller's catch.
+      //
+      // `once: true` plus one signal per turn bounds the cost of leaving it
+      // attached to a single listener per turn — a far smaller price than a
+      // cancel button that does nothing.
     }
   }
 
@@ -838,6 +898,15 @@ function createClient(opts = {}) {
     // resolve with text only and the caller could never see the calls.
     const toolCallsByIndex = new Map();
     let finishReason = null;
+    // `fullText` above stays RAW (it is also the `seen` cursor the snapshot
+    // reconciliation below compares against the provider's own un-stripped
+    // snapshots); `cleanText` is what the caller actually receives — the same
+    // stream, with DeepSeek's chat-template envelope removed — and is what the
+    // final `message.content` below is built from, so a non-streaming caller
+    // reading the resolved result sees the same clean text a streaming caller
+    // already saw via `onStream`.
+    let cleanText = '';
+    const stripEnvelope = makeDeepSeekEnvelopeStripper();
 
     // Idle watchdog: if the server holds the connection open without ever
     // sending another byte (a stuck upstream call, a proxy that swallows the
@@ -863,6 +932,7 @@ function createClient(opts = {}) {
     let keepAlives = 0;
     async function readWithIdleTimeout() {
       let timer;
+      let onAbort = null;
       const remaining = Math.max(0, idleMs - (Date.now() - lastPayloadAt));
       const timeout = new Promise((_, reject) => {
         timer = setTimeout(() => {
@@ -873,10 +943,37 @@ function createClient(opts = {}) {
           ));
         }, remaining);
       });
+      // The caller's abort, raced against the read directly rather than trusted
+      // to propagate through the body stream.
+      //
+      // Whether an abort of the caller's signal reaches a response body that is
+      // already being read is a property of `boundedFetch`, not of this loop —
+      // and it is not a property this loop can observe. Racing here makes "the
+      // caller stopped" a fact the read loop establishes for itself, so Stop
+      // and Escape end the turn at the next chunk boundary regardless of how
+      // the request's signal was assembled. Without it an aborted turn kept
+      // consuming a stream nobody wanted and `chat()` never settled at all.
+      const aborted = signal && typeof signal.addEventListener === 'function'
+        ? new Promise((_, reject) => {
+            onAbort = () => {
+              const e = new Error('The turn was stopped.');
+              e.name = 'AbortError';
+              e.code = 'ABORT_ERR';
+              reject(e);
+            };
+            if (signal.aborted) onAbort();
+            else signal.addEventListener('abort', onAbort, { once: true });
+          })
+        : null;
       try {
-        return await Promise.race([reader.read(), timeout]);
+        return await (aborted
+          ? Promise.race([reader.read(), timeout, aborted])
+          : Promise.race([reader.read(), timeout]));
       } finally {
         clearTimeout(timer);
+        if (signal && onAbort && typeof signal.removeEventListener === 'function') {
+          signal.removeEventListener('abort', onAbort);
+        }
       }
     }
 
@@ -969,7 +1066,13 @@ function createClient(opts = {}) {
           choice && choice.delta && choice.delta.content,
           choice && choice.message && choice.message.content,
           fullText,
-          (chunk) => onStream({ delta: chunk })
+          (chunk) => {
+            const clean = stripEnvelope(chunk);
+            if (clean) {
+              cleanText += clean;
+              onStream({ delta: clean });
+            }
+          }
         );
         const fragments =
           (choice && choice.delta && choice.delta.tool_calls) ||
@@ -999,13 +1102,22 @@ function createClient(opts = {}) {
       throw err;
     }
 
+    // A trailing '｜…' that never closed (stream ended right after it, or it
+    // was real prose all along) is real content, not an unfinished envelope
+    // token — release it rather than dropping it silently.
+    const strayTail = stripEnvelope.flush();
+    if (strayTail) {
+      cleanText += strayTail;
+      onStream({ delta: strayTail });
+    }
+
     // An id-less fragment stream still yields usable calls, but the caller
     // needs *an* id to pair results back, so synthesize one.
     const toolCalls = [...toolCallsByIndex.entries()]
       .sort((a, b) => a[0] - b[0])
       .map(([idx, c]) => ({ ...c, id: c.id || `call_${idx}` }));
 
-    const message = { content: fullText };
+    const message = { content: cleanText };
     if (toolCalls.length) message.tool_calls = toolCalls;
     const result = {
       model: resultModel,