@markmnl/fmsg-mcp 0.1.3 → 0.1.4

package/dist/client/message-id.d.ts

@@ -6,6 +6,7 @@
 /** Validate and normalise an id (number or digit string) to its decimal string form. */
 export declare function normalizeMessageId(value: unknown, label?: string): string;
 export declare function compareMessageIds(a: string, b: string): number;
+export declare function minMessageId(ids: Iterable<string>): string | undefined;
 export declare function maxMessageId(ids: Iterable<string>): string | undefined;
 /**
  * Parse fmsg JSON, converting id fields to exact decimal strings using the

package/dist/client/message-id.js

@@ -27,6 +27,13 @@ export function compareMessageIds(a, b) {
     const y = BigInt(b);
     return x < y ? -1 : x > y ? 1 : 0;
 }
+export function minMessageId(ids) {
+    let best;
+    for (const id of ids)
+        if (best === undefined || compareMessageIds(id, best) < 0)
+            best = id;
+    return best;
+}
 export function maxMessageId(ids) {
     let best;
     for (const id of ids)

package/dist/tools/wait.js

@@ -30,6 +30,8 @@ export const registerWaitTools = (server, deps) => {
             reply_target_id: z.string().nullable().describe("newest message of the batch; reply to this one"),
             messages: z.array(messageItem.extend({ body: z.string().nullable() })),
             pending_other_threads: z.array(z.object({ id: z.string(), from: z.string(), root_id: z.string().nullable() })),
+            skipped: z.array(z.object({ id: z.string(), reason: z.enum(["own", "reaction", "no_reply", "from_mismatch", "other_thread"]) })).describe("messages deliberately passed over; after_id has advanced past them"),
+            unclassified: z.array(z.object({ id: z.string(), from: z.string(), error: z.string() })).describe("messages whose thread could not be determined; after_id is held before them, call again to retry"),
             transport: z.enum(["websocket", "poll"]),
             note: z.string().nullable(),
         }),
@@ -62,6 +64,8 @@ export const registerWaitTools = (server, deps) => {
             reply_target_id: newest?.id ?? null,
             messages,
             pending_other_threads: result.pending_other_threads,
+            skipped: result.skipped,
+            unclassified: result.unclassified,
             transport: result.transport,
             note: result.note,
         };
@@ -75,6 +79,9 @@ export const registerWaitTools = (server, deps) => {
         if (result.pending_other_threads.length) {
             lines.push(`Also waiting on other threads: ${result.pending_other_threads.map((p) => `${p.id} from ${p.from}`).join(", ")}`);
         }
+        if (result.unclassified.length) {
+            lines.push(`Could not classify ${result.unclassified.map((u) => `${u.id} from ${u.from}`).join(", ")}; after_id is held before them, call again to retry.`);
+        }
         if (result.note)
             lines.push(`Note: ${result.note}`);
         if (include_thread && newest) {

package/dist/wait.d.ts

@@ -21,12 +21,26 @@ export type Pending = {
     from: string;
     root_id: string | null;
 };
+export type SkipReason = "own" | "reaction" | "no_reply" | "from_mismatch" | "other_thread";
+export type Skipped = {
+    id: string;
+    reason: SkipReason;
+};
+export type Unclassified = {
+    id: string;
+    from: string;
+    error: string;
+};
 export type WaitResult = {
     status: "message" | "timeout";
     after_id: string;
     thread_root_id: string | null;
     messages: FmsgMessage[];
     pending_other_threads: Pending[];
+    /** Messages deliberately passed over (the cursor advances past these). */
+    skipped: Skipped[];
+    /** Messages whose thread could not be determined; the cursor never advances past these. */
+    unclassified: Unclassified[];
     transport: "websocket" | "poll";
     note: string | null;
 };

package/dist/wait.js

@@ -1,4 +1,4 @@
-import { compareMessageIds, maxMessageId } from "./client/message-id.js";
+import { compareMessageIds, maxMessageId, minMessageId } from "./client/message-id.js";
 import { openFmsgWebSocket, parseWsEvent } from "./client/ws.js";
 /**
  * Block until the next qualifying inbound message (plus any that arrive on the
@@ -18,47 +18,73 @@ export async function waitForMessage(client, self, options, signal, deps = {}) {
         floor = newest?.id ?? "0";
     }
     let skippedMax = floor;
+    let finished = false;
     const rootCache = new Map();
-    const rootOf = async (id) => {
-        if (rootCache.has(id))
-            return rootCache.get(id);
-        let root = null;
+    const lookupRoot = async (id) => {
         try {
-            root = (await client.getThreadMessages(id, signal)).root_id;
+            return (await client.getThreadMessages(id, signal)).root_id;
         }
-        catch {
-            // Fall back to a bounded pid walk.
+        catch (error) {
+            // Fall back to a bounded pid walk; any failure here propagates as "unknown".
+            let cur = id;
+            for (let i = 0; i < 100; i++) {
+                const m = await client.getMessage(cur, signal);
+                if (!m.pid)
+                    return m.id;
+                cur = m.pid;
+            }
+            throw error;
+        }
+    };
+    /**
+     * Resolve a message's thread root. A lookup can fail transiently (the host's
+     * WebSocket announces a message slightly before it is readable), so retry a
+     * few times; if it still fails, throw rather than guess: a message whose
+     * thread is unknown must never be mistaken for one on another thread.
+     */
+    const rootOf = async (id, attempts = 3) => {
+        const cached = rootCache.get(id);
+        if (cached !== undefined)
+            return cached;
+        let lastError;
+        for (let i = 0; i < attempts; i++) {
+            if (signal?.aborted || finished)
+                break;
             try {
-                let cur = id;
-                for (let i = 0; i < 100; i++) {
-                    const m = await client.getMessage(cur, signal);
-                    if (!m.pid) {
-                        root = m.id;
-                        break;
-                    }
-                    cur = m.pid;
-                }
+                const root = await lookupRoot(id);
+                rootCache.set(id, root);
+                return root;
             }
-            catch {
-                root = null;
+            catch (error) {
+                lastError = error;
+                if (i + 1 < attempts)
+                    await new Promise((r) => setTimeout(r, 400 * (i + 1)));
             }
         }
-        rootCache.set(id, root);
-        return root;
+        throw lastError instanceof Error ? lastError : new Error(String(lastError));
     };
-    const targetRoot = options.threadOf ? await rootOf(options.threadOf) : undefined;
-    if (options.threadOf && targetRoot === null)
-        throw new Error(`could not determine the thread of message ${options.threadOf}`);
+    let targetRoot;
+    if (options.threadOf) {
+        try {
+            targetRoot = await rootOf(options.threadOf, 1);
+        }
+        catch {
+            throw new Error(`could not determine the thread of message ${options.threadOf}`);
+        }
+    }
     const seen = new Set();
     const batch = [];
     const pending = [];
+    const skipped = [];
+    const unclassified = [];
+    /** Messages whose thread lookup is still running; if the call ends first they count as unclassified. */
+    const inflight = new Map();
     let batchRoot = null;
     let transport = "websocket";
     let note = null;
     let socket;
     let pollTimer;
     let settleTimer;
-    let finished = false;
     return new Promise((resolve, reject) => {
         const cleanup = () => {
             finished = true;
@@ -81,13 +107,28 @@ export async function waitForMessage(client, self, options, signal, deps = {}) {
             if (finished)
                 return;
             cleanup();
+            for (const [id, from] of inflight)
+                unclassified.push({ id, from, error: "thread lookup did not complete before the call returned" });
+            inflight.clear();
             const ids = batch.map((m) => m.id);
+            // The cursor advances only over messages returned or deliberately skipped,
+            // and never past a message whose thread could not be determined.
+            let afterId = maxMessageId([...ids, skippedMax, floor]);
+            const firstUnknown = unclassified.length ? minMessageId(unclassified.map((u) => u.id)) : undefined;
+            if (firstUnknown !== undefined && compareMessageIds(afterId, firstUnknown) >= 0) {
+                const before = (BigInt(firstUnknown) - 1n).toString();
+                afterId = compareMessageIds(before, floor) > 0 ? before : floor;
+                const held = `cursor held at ${afterId}: could not determine the thread of ${unclassified.map((u) => u.id).join(", ")}; call again to retry`;
+                note = note ? `${note}; ${held}` : held;
+            }
             resolve({
                 status: batch.length ? "message" : "timeout",
-                after_id: batch.length ? maxMessageId(ids) : skippedMax,
+                after_id: afterId,
                 thread_root_id: batchRoot,
                 messages: [...batch].sort((a, b) => compareMessageIds(a.id, b.id)),
                 pending_other_threads: pending,
+                skipped: [...skipped].sort((a, b) => compareMessageIds(a.id, b.id)),
+                unclassified: [...unclassified].sort((a, b) => compareMessageIds(a.id, b.id)),
                 transport,
                 note,
             });
@@ -117,23 +158,36 @@ export async function waitForMessage(client, self, options, signal, deps = {}) {
             seen.add(m.id);
             if (compareMessageIds(m.id, floor) <= 0)
                 return;
-            const disqualified = m.from.toLowerCase() === me ||
-                (m.reaction !== null && m.reaction !== undefined) ||
-                m.no_reply === true ||
-                (wantFrom !== undefined && m.from.toLowerCase() !== wantFrom);
-            if (disqualified) {
+            const skip = (reason) => {
+                skipped.push({ id: m.id, reason });
                 if (compareMessageIds(m.id, skippedMax) > 0)
                     skippedMax = m.id;
+            };
+            if (m.from.toLowerCase() === me)
+                return skip("own");
+            if (m.reaction !== null && m.reaction !== undefined)
+                return skip("reaction");
+            if (m.no_reply === true)
+                return skip("no_reply");
+            if (wantFrom !== undefined && m.from.toLowerCase() !== wantFrom)
+                return skip("from_mismatch");
+            let root;
+            inflight.set(m.id, m.from);
+            try {
+                root = await rootOf(m.id);
+            }
+            catch (error) {
+                if (!finished)
+                    unclassified.push({ id: m.id, from: m.from, error: error instanceof Error ? error.message : String(error) });
                 return;
             }
-            const root = await rootOf(m.id);
+            finally {
+                inflight.delete(m.id);
+            }
             if (finished)
                 return;
-            if (targetRoot !== undefined && root !== targetRoot) {
-                if (compareMessageIds(m.id, skippedMax) > 0)
-                    skippedMax = m.id;
-                return;
-            }
+            if (targetRoot !== undefined && root !== targetRoot)
+                return skip("other_thread");
             if (batch.length === 0) {
                 batchRoot = root;
                 batch.push(m);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@markmnl/fmsg-mcp",
   "mcpName": "io.github.markmnl/fmsg-mcp",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "MCP server for fmsg: send and receive federated messages from any AI agent via a deployed fmsg Web API",
   "type": "module",
   "license": "MIT",

package/server.json

@@ -6,13 +6,13 @@
     "url": "https://github.com/markmnl/fmsg-mcp",
     "source": "github"
   },
-  "version": "0.1.3",
+  "version": "0.1.4",
   "packages": [
     {
       "registryType": "npm",
       "registryBaseUrl": "https://registry.npmjs.org",
       "identifier": "@markmnl/fmsg-mcp",
-      "version": "0.1.3",
+      "version": "0.1.4",
       "transport": {
         "type": "stdio"
       },