@mulmobridge/chat-service 1.3.0 → 1.3.2

package/dist/relay.d.ts

@@ -34,6 +34,8 @@ export interface RelayDeps {
     getRole: (roleId: string) => Role;
     defaultRoleId: string;
     logger: Logger;
+    /** Monotonic milliseconds for the reply limit. Defaults to `performance.now()`. */
+    now?: () => number;
 }
 export declare function createRelay(deps: RelayDeps): RelayFn;
 export declare function resolveDefaultRole(bridgeOptions: Readonly<Record<string, string | number | boolean>> | undefined, getRole: (roleId: string) => Role, fallbackRoleId: string, logger: Logger, transportId: string): string;

package/dist/relay.js

@@ -8,6 +8,8 @@
 // host.
 import { EVENT_TYPES, resolveReplyTimeoutMs } from "@mulmobridge/protocol";
 import { createKeyedSerializer } from "./keyed-serializer.js";
+import { remainingReplyMs } from "./reply-deadline.js";
+import { startChatWhenIdle } from "./start-when-idle.js";
 // ── Factory ──────────────────────────────────────────────────
 export function createRelay(deps) {
     const serialize = createKeyedSerializer();
@@ -17,10 +19,19 @@ export function createRelay(deps) {
         // sessions, and split the conversation across them (#1878). The
         // JSON pair is an unambiguous composite key for the two ids.
         const key = JSON.stringify([params.transportId, params.externalChatId]);
-        return serialize.run(key, () => processRelayMessage(deps, params));
+        const budget = {
+            receivedAtMs: clockOf(deps)(),
+            replyTimeoutMs: resolveBridgeReplyTimeout(params.bridgeOptions, deps.logger, params.transportId),
+        };
+        return serialize.run(key, () => processRelayMessage(deps, params, budget));
     };
 }
-async function processRelayMessage(deps, params) {
+// Neutral about the cause: a queue behind an earlier message, or slow setup on an idle chat.
+const EXPIRED_BEFORE_START_REPLY = "The request timed out before the agent could start on it. Please send it again.";
+// Monotonic by default, so a wall-clock step between receipt and processing cannot move the limit.
+const clockOf = (deps) => deps.now ?? (() => performance.now());
+const remainingOf = (budget, deps) => remainingReplyMs(budget.receivedAtMs, budget.replyTimeoutMs, clockOf(deps)());
+async function processRelayMessage(deps, params, budget) {
     const { store, handleCommand, startChat, onSessionEvent, getRole, defaultRoleId, logger } = deps;
     const { transportId, externalChatId, attachments, bridgeOptions } = params;
     let { text } = params;
@@ -60,7 +71,14 @@ async function processRelayMessage(deps, params) {
             chatState = commandResult.nextState;
         text = commandResult.forwardAs;
     }
-    const result = await startChat({
+    // Checked here, not on entry: a command above still runs and answers at once, but an agent turn
+    // started after the limit would produce a reply nobody is waiting for.
+    if (remainingOf(budget, deps) === 0) {
+        logger.info("chat-service", "message expired before its turn started", { transportId, externalChatId });
+        return { kind: "ok", reply: EXPIRED_BEFORE_START_REPLY };
+    }
+    const idleStartDeps = { startChat, onSessionEvent, remainingMs: () => remainingOf(budget, deps) };
+    const result = await startChatWhenIdle(idleStartDeps, {
         message: text,
         roleId: chatState.roleId,
         chatSessionId: chatState.sessionId,
@@ -70,18 +88,12 @@ async function processRelayMessage(deps, params) {
         // we forward the whole bag untouched.
         bridgeOptions,
     });
+    if (result.kind === "expired") {
+        logger.info("chat-service", "message expired waiting for the session to finish", { transportId, externalChatId });
+        return { kind: "ok", reply: EXPIRED_BEFORE_START_REPLY };
+    }
     if (result.kind === "error") {
         const status = result.status ?? 500;
-        if (status === 409) {
-            // Session busy — tell the bridge to retry. Keep the HTTP
-            // response shape the old handler returned (status 409 on
-            // the HTTP side, "ok" reply text on the socket side — both
-            // layers decide how to serialise).
-            return {
-                kind: "ok",
-                reply: "A previous message is still being processed. Please wait.",
-            };
-        }
         logger.error("chat-service", "startChat failed", {
             transportId,
             externalChatId,
@@ -94,8 +106,7 @@ async function processRelayMessage(deps, params) {
         };
     }
     try {
-        const replyTimeoutMs = resolveBridgeReplyTimeout(bridgeOptions, logger, transportId);
-        const reply = await collectAgentReply(onSessionEvent, chatState.sessionId, replyTimeoutMs, params.onChunk);
+        const reply = await collectAgentReply(onSessionEvent, chatState.sessionId, remainingOf(budget, deps), params.onChunk);
         await store.setChatState(transportId, {
             ...chatState,
             updatedAt: new Date().toISOString(),

package/dist/reply-deadline.d.ts

@@ -0,0 +1,2 @@
+/** Milliseconds of the reply limit still left at `nowMs`; never negative. */
+export declare function remainingReplyMs(receivedAtMs: number, replyTimeoutMs: number, nowMs: number): number;

package/dist/reply-deadline.js

@@ -0,0 +1,9 @@
+// A turn's reply limit is counted from when the relay RECEIVED the message,
+// not from when the turn reached the front of its chat's queue. The bridge
+// client starts its ack timer when it sends, so a limit counted from the start
+// of collection let a queued or slow-to-start turn outlive the client's wait
+// and have its reply dropped (#3312).
+/** Milliseconds of the reply limit still left at `nowMs`; never negative. */
+export function remainingReplyMs(receivedAtMs, replyTimeoutMs, nowMs) {
+    return Math.max(0, receivedAtMs + replyTimeoutMs - nowMs);
+}

package/dist/start-when-idle.d.ts

@@ -0,0 +1,11 @@
+import type { OnSessionEventFn, StartChatFn, StartChatParams, StartChatResult } from "./types.js";
+export type IdleStartResult = StartChatResult | {
+    kind: "expired";
+};
+export interface IdleStartDeps {
+    startChat: StartChatFn;
+    onSessionEvent: OnSessionEventFn;
+    /** Milliseconds this message may still wait; 0 once its limit has passed. */
+    remainingMs: () => number;
+}
+export declare function startChatWhenIdle(deps: IdleStartDeps, params: StartChatParams): Promise<IdleStartResult>;

package/dist/start-when-idle.js

@@ -0,0 +1,52 @@
+// Start a bridge turn even when the session is still busy with an earlier run.
+//
+// A turn cut off at its reply limit leaves its agent running, so the next
+// turn's `startChat()` used to get 409 and the message was dropped with
+// "please wait" (#3320). Instead, wait for that run to finish — within the
+// message's own remaining time — and start then.
+import { EVENT_TYPES } from "@mulmobridge/protocol";
+// `startChat()` answers 409 before it saves or broadcasts anything, so trying again is safe.
+const isBusy = (result) => result.kind === "error" && result.status === 409;
+function waitForSessionFinished(onSessionEvent, sessionId, timeoutMs) {
+    const handles = {};
+    const finished = new Promise((resolve) => {
+        handles.settle = (value) => {
+            handles.done = true;
+            clearTimeout(handles.timer);
+            handles.unsubscribe?.();
+            resolve(value);
+        };
+    });
+    const settle = (value) => handles.settle?.(value);
+    handles.timer = setTimeout(() => settle(false), timeoutMs);
+    handles.unsubscribe = onSessionEvent(sessionId, (event) => {
+        if (event.type === EVENT_TYPES.sessionFinished)
+            settle(true);
+    });
+    // A listener fired during subscription settled before `unsubscribe` existed.
+    if (handles.done)
+        handles.unsubscribe();
+    // A cancelled wait still settles, so nothing is left pending behind it.
+    return { finished, cancel: () => settle(false) };
+}
+async function retryWhenFinished(deps, params) {
+    const remainingMs = deps.remainingMs();
+    if (remainingMs === 0)
+        return { kind: "expired" };
+    // Subscribe BEFORE trying again: a run that ends between the 409 and the
+    // subscription would otherwise never be seen, and this would wait out the limit.
+    const wait = waitForSessionFinished(deps.onSessionEvent, params.chatSessionId, remainingMs);
+    const retried = await deps.startChat(params).catch((err) => {
+        wait.cancel();
+        throw err;
+    });
+    if (!isBusy(retried)) {
+        wait.cancel();
+        return retried;
+    }
+    return (await wait.finished) ? retryWhenFinished(deps, params) : { kind: "expired" };
+}
+export async function startChatWhenIdle(deps, params) {
+    const first = await deps.startChat(params);
+    return isBusy(first) ? retryWhenFinished(deps, params) : first;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mulmobridge/chat-service",
-  "version": "1.3.0",
+  "version": "1.3.2",
   "description": "Server-side chat service for MulmoBridge — socket.io + REST bridge to Claude Code agents",
   "type": "module",
   "main": "./dist/index.js",