@luckydraw/cumulus 1.0.10 → 1.0.12

package/dist/gateway/server.js

@@ -41,6 +41,37 @@ import { isAutomatedSender } from './senders.js';
 import { validateTranscriptFlush, ingestTranscriptFlush } from './transcript-ingest.js';
 const threadQueues = new Map();
 const threadBusy = new Map();
+// ─── Thread activity notification (task 146) ─────────────────────────────────
+// The sidebar shows a thread as working, including threads the viewer has not
+// opened. That needs a push, and `markThreadBusy` is the only place worth
+// hanging it on: task 100 made it the point EVERY transport lands on, so one
+// notification here covers WS turns, agent injects, scheduled triggers, job
+// completions and queue drains without a second notion of "busy" to drift.
+//
+// Registered by the webchat adapter (only it can reach the sockets), same shape
+// as `setUserQueueDelivery` — this module must not import the adapter.
+let threadActivityListener = null;
+export function setThreadActivityListener(fn) {
+    threadActivityListener = fn;
+}
+/**
+ * Announce a change in whether a thread is running a turn.
+ *
+ * Transition-only: callers mark busy repeatedly (an inject re-marks a thread
+ * that is already working), and a listener that re-broadcast every call would
+ * fan out a socket write per no-op. A never-throw wrapper because this is a
+ * cosmetic signal — it must never be able to fail a turn.
+ */
+function notifyThreadActivity(threadName, busy) {
+    if (!threadActivityListener)
+        return;
+    try {
+        threadActivityListener(threadName, busy);
+    }
+    catch (err) {
+        console.error(`[Gateway] thread activity listener failed for "${threadName}": ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
 const userQueues = new Map();
 let userQueueDelivery;
 export function setUserQueueDelivery(fn) {
@@ -183,6 +214,21 @@ let federationRouter;
  * server, so later mutations (e.g. broadcastToThread wiring) are visible here.
  */
 let agentPipelineOpts;
+/**
+ * THE only writer of `threadBusy`.
+ *
+ * Every mutation goes through here so the activity notification (task 146)
+ * cannot be missed: `markThreadBusy` is the drain point, but the queue-drain and
+ * direct-inject paths mark a thread busy by hand on their way into `sendMessage`,
+ * and a notification hung only on the exported function would report those turns
+ * as never having started.
+ */
+function setBusyState(threadName, busy) {
+    const was = !!threadBusy.get(threadName);
+    threadBusy.set(threadName, busy);
+    if (was !== busy)
+        notifyThreadActivity(threadName, busy);
+}
 /**
  * Mark a thread as busy/idle from any transport (SSE turns, webchat adapter,
  * agent injects). Busy→idle is THE drain point for queued agent messages —
@@ -191,12 +237,12 @@ let agentPipelineOpts;
  */
 export function markThreadBusy(threadName, busy) {
     if (busy) {
-        threadBusy.set(threadName, true);
+        setBusyState(threadName, true);
         return;
     }
     // Only clear if still marked — another path may have set it busy again
     if (threadBusy.get(threadName)) {
-        threadBusy.set(threadName, false);
+        setBusyState(threadName, false);
     }
     // User-queued messages take priority: their drain pass toggles busy and
     // lands back here when the user queue is empty.
@@ -279,7 +325,7 @@ async function drainQueue(threadName, opts) {
     const queue = threadQueues.get(threadName);
     if (!queue || queue.length === 0)
         return;
-    threadBusy.set(threadName, true);
+    setBusyState(threadName, true);
     const item = queue.shift();
     try {
         await processMessage(threadName, item, opts);
@@ -365,6 +411,8 @@ async function processMessage(threadName, item, opts) {
             gatewayAgentsConfig: opts.gatewayAgentsConfig,
             hfApiKey: opts.hfApiKey,
             openaiApiKey: opts.openaiApiKey,
+            // Custom OpenAI-compatible endpoints + their own credentials (task 147).
+            customProviders: opts.customProviders,
             // Catalog: lets the spawn resolve non-Claude provider + context window (task 118).
             models: opts.models,
             // Config-driven Claude sub-model default (task 113). Read per turn, so a live
@@ -422,6 +470,7 @@ async function handleWebhook(type, name, req, res, pipelineOpts, hooksConfig) {
         broadcastToThread: pipelineOpts.broadcastToThread,
         hfApiKey: pipelineOpts.hfApiKey,
         openaiApiKey: pipelineOpts.openaiApiKey,
+        customProviders: pipelineOpts.customProviders,
         models: pipelineOpts.models,
         claudeModels: pipelineOpts.claudeModels,
     };
@@ -669,7 +718,7 @@ async function handleAgentInject(req, res, pipelineOpts, scope) {
             // Ensure thread exists
             await getOrCreateThread(targetName);
             // Send as a message through the pipeline (fire-and-forget)
-            threadBusy.set(targetName, true);
+            setBusyState(targetName, true);
             const broadcast = pipelineOpts.broadcastToThread;
             sendMessage({
                 threadName: targetName,
@@ -678,6 +727,7 @@ async function handleAgentInject(req, res, pipelineOpts, scope) {
                 claudePath: pipelineOpts.claudePath,
                 hfApiKey: pipelineOpts.hfApiKey,
                 openaiApiKey: pipelineOpts.openaiApiKey,
+                customProviders: pipelineOpts.customProviders,
                 models: pipelineOpts.models,
                 sharedMcpPort: pipelineOpts.sharedMcpPort,
                 projectRoot: pipelineOpts.projectRoot,
@@ -865,7 +915,7 @@ function drainAgentQueue(threadName, pipelineOpts) {
         formatted = formatAgentBatch(queue);
     }
     // Fire-and-forget: send the batched message as a new turn
-    threadBusy.set(threadName, true);
+    setBusyState(threadName, true);
     const broadcast = pipelineOpts.broadcastToThread;
     sendMessage({
         threadName,
@@ -878,6 +928,7 @@ function drainAgentQueue(threadName, pipelineOpts) {
         gatewayAgentsConfig: pipelineOpts.gatewayAgentsConfig,
         hfApiKey: pipelineOpts.hfApiKey,
         openaiApiKey: pipelineOpts.openaiApiKey,
+        customProviders: pipelineOpts.customProviders,
         models: pipelineOpts.models,
         // Config-driven Claude sub-model default (task 113) — the drained turn must
         // resolve the same model the live turn would have.
@@ -1082,6 +1133,12 @@ async function handleListThreads(res, scopeNs, namespaces) {
                 messageCount: lineCount,
                 lastActivity: stat.mtime.toISOString(),
             };
+            // Whether a turn is running right now (task 146). Present on BOTH listings
+            // — a tab that opens mid-turn must render the activity indicator without
+            // waiting for the next transition, which may be minutes away.
+            if (threadBusy.get(name)) {
+                entry.busy = true;
+            }
             if (tc.projectDir) {
                 entry.projectDir = tc.projectDir;
             }
@@ -2637,7 +2694,16 @@ export async function startGatewayServer(options) {
                 if (claudeModels.length > 0 && !claudeModels.some(m => m.default)) {
                     claudeModels[0].default = true;
                 }
-                jsonResponse(res, 200, { models, claudeModels });
+                // Custom providers, for the dropdown's provider label (task 147).
+                // ONLY id + label: this endpoint accepts any valid key, including a
+                // namespace-scoped key that ships in a public app's HTML (097 P7), and
+                // baseUrl is private infrastructure. The admin-only /api/config serves
+                // baseUrl + the masked credential.
+                const customProviders = (pipelineOpts.customProviders || []).map(p => ({
+                    id: p.id,
+                    label: p.label,
+                }));
+                jsonResponse(res, 200, { models, claudeModels, customProviders });
                 return;
             }
             // GET/PUT /api/config — gateway-level settings are ADMIN-ONLY (task 128).
@@ -2660,6 +2726,7 @@ export async function startGatewayServer(options) {
                         model: pipelineOpts.model,
                         hfApiKey: pipelineOpts.hfApiKey,
                         openaiApiKey: pipelineOpts.openaiApiKey,
+                        customProviders: pipelineOpts.customProviders,
                         licenseKey: storedLicenseKey,
                     }),
                     license: licenseView(),
@@ -2695,6 +2762,8 @@ export async function startGatewayServer(options) {
                         pipelineOpts.hfApiKey = applied.hfApiKey;
                     if (patch.openaiApiKey !== undefined)
                         pipelineOpts.openaiApiKey = applied.openaiApiKey;
+                    if (patch.customProviders !== undefined)
+                        pipelineOpts.customProviders = applied.customProviders;
                     // Task 129: licence key is persist-ONLY — track the stored value for
                     // display, but never rewire enforcement (licenseStatus stays as
                     // verified at startup; a reload is what applies it — task 127).
@@ -2709,6 +2778,7 @@ export async function startGatewayServer(options) {
                             model: pipelineOpts.model,
                             hfApiKey: pipelineOpts.hfApiKey,
                             openaiApiKey: pipelineOpts.openaiApiKey,
+                            customProviders: pipelineOpts.customProviders,
                             licenseKey: storedLicenseKey,
                         }),
                         license: licenseView(),