@yeaft/webchat-agent 0.1.505 → 0.1.506

package/connection/message-router.js

@@ -25,7 +25,7 @@ import { sendToServer, flushMessageBuffer } from './buffer.js';
 import { handleRestartAgent, handleUpgradeAgent } from './upgrade.js';
 import { loadMcpServers, updateMcpConfig } from '../mcp.js';
 import { getLlmConfig, updateLlmConfig, getUnifySettings, updateUnifySettings } from '../unify/config-api.js';
-import { handleUnifyChat, handleUnifyModeSwitch, handleUnifyModelSwitch, resetUnifySession, handleUnifyLoadHistory, handleUnifyMergeThread, handleUnifyForkThread } from '../unify/web-bridge.js';
+import { handleUnifyChat, handleUnifyModeSwitch, handleUnifyModelSwitch, resetUnifySession, handleUnifyLoadHistory, handleUnifyMergeThread, handleUnifyForkThread, handleUnifyAbortThread, handleUnifyAbortAll } from '../unify/web-bridge.js';
 
 export async function handleMessage(msg) {
   switch (msg.type) {
@@ -373,6 +373,19 @@ export async function handleMessage(msg) {
       handleUnifyForkThread(msg);
       break;
 
+    case 'unify_abort_thread':
+      // task-325c: user-initiated abort of a single thread's in-flight
+      // query. Payload `{ threadId }`. Silent no-op when the thread has
+      // no in-flight controller.
+      handleUnifyAbortThread(msg);
+      break;
+
+    case 'unify_abort_all':
+      // task-325c: user-initiated abort of ALL in-flight queries across
+      // every thread. Always emits `unify_aborted` ack.
+      handleUnifyAbortAll();
+      break;
+
     // Expert roles definition (for ExpertPanel detail view)
     case 'get_expert_roles': {
       const { getExpertRolesDefinition } = await import('../expert-roles.js');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "0.1.505",
+  "version": "0.1.506",
   "description": "Remote agent for Yeaft WebChat — connects worker machines to the central server",
   "main": "index.js",
   "type": "module",

package/unify/session.js

@@ -269,5 +269,13 @@ export async function loadSession(options = {}) {
     threadStore: getThreadStore(),
     status,
     shutdown,
+    // task-325c: user-initiated abort API. Delegates to web-bridge which
+    // owns the per-thread AbortController registry (`abortByThread`).
+    // Lazy-imported to avoid a hard cycle with web-bridge.js (which already
+    // imports this module to call loadSession).
+    async abort(opts = {}) {
+      const { abortUnifySession } = await import('./web-bridge.js');
+      return abortUnifySession(opts);
+    },
   };
 }

package/unify/web-bridge.js

@@ -848,6 +848,90 @@ export async function handleUnifyChat(msg) {
   }
 }
 
+/**
+ * task-325c: user-initiated abort of an in-flight Unify query on ONE thread.
+ *
+ * Cancels the AbortController registered for `msg.threadId` (if any). Silent
+ * no-op when the thread has no in-flight round — users clicking Stop on an
+ * already-idle thread should not trigger an error bubble. Emits an
+ * `unify_aborted` event for UI acknowledgement and a fresh
+ * `thread_list_updated` so inflight pills clear immediately.
+ *
+ * Red line (PM): the `thread_list_updated` event name is preserved; no
+ * new per-thread abort signal leaks into `Engine.abort()`'s signature.
+ *
+ * @param {{ threadId?: string }} msg
+ * @returns {{ aborted: string[], all: boolean }}
+ */
+export function handleUnifyAbortThread(msg = {}) {
+  const aborted = [];
+  const threadId = msg && msg.threadId;
+  if (threadId) {
+    const ctrl = abortByThread.get(threadId);
+    if (ctrl) {
+      try { ctrl.abort(); } catch { /* best-effort */ }
+      abortByThread.delete(threadId);
+      aborted.push(threadId);
+    }
+  }
+  sendUnifyEvent({ type: 'unify_aborted', aborted, all: false });
+  sendThreadListUpdate();
+  return { aborted, all: false };
+}
+
+/**
+ * task-325c: user-initiated abort of ALL in-flight Unify queries.
+ *
+ * Iterates every registered controller, aborts it, then clears the map.
+ * Always emits `unify_aborted` with `all:true` (even when nothing was
+ * running) so the UI can confirm the click landed.
+ *
+ * @returns {{ aborted: string[], all: boolean }}
+ */
+export function handleUnifyAbortAll() {
+  const aborted = [];
+  for (const [threadId, ctrl] of abortByThread.entries()) {
+    try { ctrl.abort(); } catch { /* best-effort */ }
+    aborted.push(threadId);
+  }
+  abortByThread.clear();
+  sendUnifyEvent({ type: 'unify_aborted', aborted, all: true });
+  sendThreadListUpdate();
+  return { aborted, all: true };
+}
+
+/**
+ * Unified dispatcher bound onto `session.abort({ threadId?, all? })`.
+ * Routes to {@link handleUnifyAbortThread} or {@link handleUnifyAbortAll}
+ * per input. Kept exported so message-router and tests can call it too.
+ *
+ * @param {{ threadId?: string, all?: boolean }} [opts]
+ */
+export function abortUnifySession(opts = {}) {
+  if (opts && opts.all) return handleUnifyAbortAll();
+  if (opts && opts.threadId) return handleUnifyAbortThread({ threadId: opts.threadId });
+  // No payload — conservative default: abort nothing, just emit ack so
+  // callers see the no-op round-trip. Matches PM "don't accidentally
+  // nuke everything on a bare click".
+  sendUnifyEvent({ type: 'unify_aborted', aborted: [], all: false });
+  return { aborted: [], all: false };
+}
+
+/**
+ * Test-only: seed / inspect the abort registry without spinning up a
+ * full session. Never use from production code — the prod registry is
+ * managed by handleUnifyChat's per-query controller lifecycle.
+ * @private
+ */
+export function __testSeedAbortController(threadId, ctrl) {
+  abortByThread.set(threadId, ctrl);
+}
+
+/** Test-only: returns the set of thread ids currently registered. */
+export function __testGetRegisteredThreadIds() {
+  return [...abortByThread.keys()];
+}
+
 /**
  * Handle mode switch from the web UI.
  * DEPRECATED (task-297): Unify no longer has chat/work mode distinction.