@mulmobridge/chat-service 0.1.4 → 0.1.6

package/dist/chat-state.d.ts

@@ -11,7 +11,15 @@ export interface ChatStateStore {
     getChatState(transportId: string, externalChatId: string): Promise<TransportChatState | null>;
     setChatState(transportId: string, state: TransportChatState): Promise<void>;
     resetChatState(transportId: string, externalChatId: string, roleId: string): Promise<TransportChatState>;
-    connectSession(transportId: string, externalChatId: string, chatSessionId: string): Promise<TransportChatState | null>;
+    /** Repoint the persisted chat state at another session. `roleId` is
+     *  optional: when omitted, the existing state's roleId is preserved
+     *  (the old default, kept for HTTP `/connect` callers that only know
+     *  the session ID). Callers that DO know the target session's role —
+     *  notably the `/switch` command, which already has `SessionSummary.roleId`
+     *  from `/sessions` — MUST pass it, otherwise the file-backed state
+     *  drifts into a stale-role / new-session pair and the next relay's
+     *  `startChat` uses the mismatched pair (issue #1888). */
+    connectSession(transportId: string, externalChatId: string, chatSessionId: string, roleId?: string): Promise<TransportChatState | null>;
     generateSessionId(transportId: string, externalChatId: string): string;
 }
 export declare function createChatStateStore(opts: {

package/dist/chat-state.js

@@ -57,13 +57,18 @@ export function createChatStateStore(opts) {
         });
         return state;
     };
-    const connectSession = async (transportId, externalChatId, chatSessionId) => {
+    const connectSession = async (transportId, externalChatId, chatSessionId, roleId) => {
         const existing = await getChatState(transportId, externalChatId);
         if (!existing)
             return null;
         const updated = {
             ...existing,
             sessionId: chatSessionId,
+            // A missing `roleId` arg means "preserve the current role" (that's
+            // the HTTP `/connect` route, which doesn't know the target's role);
+            // when the caller passes one (`/switch`), take theirs so state and
+            // downstream `startChat` agree on which role runs the resumed session.
+            ...(roleId !== undefined ? { roleId } : {}),
             updatedAt: new Date().toISOString(),
         };
         await setChatState(transportId, updated);
@@ -71,6 +76,7 @@ export function createChatStateStore(opts) {
             transportId,
             externalChatId,
             sessionId: chatSessionId,
+            roleId: updated.roleId,
         });
         return updated;
     };

package/dist/commands.js

@@ -211,7 +211,12 @@ export function createCommandHandler(opts) {
                 };
             }
         }
-        const updated = await connectSession(transportId, chatState.externalChatId, target.id);
+        // Pass `target.roleId` so the persisted state's role tracks the session
+        // we just repointed at. Without this, `connectSession` would swap the
+        // sessionId but leave the previous role in place, and the next relay's
+        // `startChat` would run the resumed session under the wrong role
+        // (issue #1888).
+        const updated = await connectSession(transportId, chatState.externalChatId, target.id, target.roleId);
         if (!updated) {
             return { reply: "Failed to switch session." };
         }

package/dist/index.js

@@ -97,7 +97,31 @@ export function createChatService(deps) {
             badRequest(res, "chatSessionId is required");
             return;
         }
-        const updated = await store.connectSession(transportId, externalChatId, chatSessionId);
+        // Resolve the target session's role BEFORE calling connectSession so the
+        // persisted state's `roleId` tracks the new session's role — otherwise the
+        // next relay's `startChat` would resume the new session under the previous
+        // role (#1888 / #1894). Three fallback paths all treated as "preserve
+        // existing role":
+        //   1. No `getSessionRole` wired at all (backward compat for older hosts).
+        //   2. Resolver returns null (unknown / corrupt session metadata).
+        //   3. Resolver throws (host bug / timeout / IO error) — catch here so
+        //      the route can never bubble the failure as a 500 to the API caller
+        //      (codex review on #1895; the MulmoClaude host's resolver is
+        //      hardened but the DI contract doesn't require hosts to be).
+        let resolvedRole = null;
+        if (deps.getSessionRole) {
+            try {
+                resolvedRole = await deps.getSessionRole(chatSessionId);
+            }
+            catch (err) {
+                logger.warn("chat-service", "getSessionRole threw; falling back to preserving existing role", {
+                    chatSessionId,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+                resolvedRole = null;
+            }
+        }
+        const updated = await store.connectSession(transportId, externalChatId, chatSessionId, resolvedRole ?? undefined);
         if (!updated) {
             notFound(res, "No chat state found for this transport");
             return;

package/dist/types.d.ts

@@ -122,6 +122,17 @@ export interface ChatServiceDeps {
         }>;
         total: number;
     }>;
+    /**
+     * Resolve the roleId a given session was started with. Used by the HTTP
+     * `/connect` route so the persisted bridge state's role tracks the target
+     * session's role after a repoint — same drift-fix as bridge `/switch`
+     * (issue #1888 / #1894), but for API callers that only supply a session ID.
+     * Returns null when the session isn't found OR when its role isn't known;
+     * on null the route falls back to the previous "preserve current role"
+     * behaviour (safe default). Omit this dep entirely to keep the old
+     * session-id-only semantics.
+     */
+    getSessionRole?: (sessionId: string) => Promise<string | null>;
     /**
      * Return the skills the bridge command handler should expose. The
      * handler uses the result for two things:

package/package.json

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