lattice-talk 0.1.2 → 0.1.3

package/dist/index.js

@@ -53317,6 +53317,7 @@ var PRESENCE_TTL_MIN_SECONDS = 5;
 var PRESENCE_TTL_MAX_SECONDS = 86400;
 var STREAM_MAXLEN_MIN = 10;
 var STREAM_MAXLEN_MAX = 1e6;
+var PULL_WAIT_MAX_MS = 3e4;
 
 // src/core/config.ts
 function parseOtelHeaders(raw) {
@@ -53450,6 +53451,7 @@ init_esm_shims();
 
 // src/core/memory-store.ts
 init_esm_shims();
+import { EventEmitter } from "events";
 
 // src/core/keys.ts
 init_esm_shims();
@@ -53504,9 +53506,55 @@ var keys = {
   },
   memoryMeta(ns, sid, key) {
     return `lattice:${ns}:memory:${sessionTag(sid)}:meta:${key}`;
+  },
+  /**
+   * Pub/sub wake-up channels. Payloads are small hints only — streams remain
+   * the source of truth, so a missed notify only delays a waiter until its
+   * timeout or next poll.
+   */
+  notifyRoom(ns, sid, rid) {
+    return `lattice:${ns}:notify:${sessionTag(sid)}:room:${rid}`;
+  },
+  /** DM delivery channel — one per recipient agent. */
+  notifyDm(ns, sid, agentId) {
+    return `lattice:${ns}:notify:${sessionTag(sid)}:dm:${agentId}`;
+  },
+  /** Session roster/room-list changes (join, leave, room create/delete). */
+  notifyMeta(ns, sid) {
+    return `lattice:${ns}:notify:${sessionTag(sid)}:meta`;
   }
 };
 
+// src/core/notify.ts
+init_esm_shims();
+async function publishNotify(store, channel, payload) {
+  try {
+    await store.publish(channel, JSON.stringify(payload));
+  } catch {
+  }
+}
+async function waitForNotify(store, channels, timeoutMs, recheck) {
+  if (channels.length === 0 || timeoutMs <= 0) return false;
+  let wake;
+  const woke = new Promise((resolve) => {
+    wake = resolve;
+  });
+  let unsub;
+  try {
+    unsub = await store.subscribe(channels, () => wake());
+  } catch {
+    return false;
+  }
+  try {
+    if (recheck && await recheck()) return true;
+    const timer = new Promise((resolve) => setTimeout(() => resolve(false), timeoutMs));
+    const hit = await Promise.race([woke.then(() => true), timer]);
+    return hit;
+  } finally {
+    await unsub();
+  }
+}
+
 // src/core/stream.ts
 init_esm_shims();
 function compareStreamIds(a, b) {
@@ -53531,6 +53579,7 @@ var MemoryStore = class {
   constructor(ns, clock = Date.now) {
     this.ns = ns;
     this.clock = clock;
+    this.events.setMaxListeners(0);
   }
   ns;
   clock;
@@ -53540,6 +53589,7 @@ var MemoryStore = class {
   strings = /* @__PURE__ */ new Map();
   streams = /* @__PURE__ */ new Map();
   streamSeq = /* @__PURE__ */ new Map();
+  events = new EventEmitter();
   now() {
     return this.clock();
   }
@@ -53701,6 +53751,10 @@ var MemoryStore = class {
       const rid = key.slice(cursorPrefix.length).split(":").slice(1).join(":");
       if (rid === roomId) this.strings.delete(key);
     }
+    await publishNotify(this, keys.notifyMeta(this.ns, sessionId), {
+      type: "rooms",
+      room_id: roomId
+    });
   }
   async getRoomMeta(sessionId, roomId) {
     const h = this.hashes.get(keys.roomMeta(this.ns, sessionId, roomId));
@@ -53805,7 +53859,23 @@ var MemoryStore = class {
   async ping() {
     return true;
   }
+  async publish(channel, payload) {
+    this.events.emit(channel, payload);
+  }
+  async subscribe(channels, onMessage) {
+    const listeners = channels.map((channel) => {
+      const handler = (payload) => onMessage(channel, payload);
+      this.events.on(channel, handler);
+      return { channel, handler };
+    });
+    return async () => {
+      for (const { channel, handler } of listeners) {
+        this.events.off(channel, handler);
+      }
+    };
+  }
   async close() {
+    this.events.removeAllListeners();
     this.hashes.clear();
     this.sets.clear();
     this.strings.clear();
@@ -53939,6 +54009,9 @@ var RedisStore = class _RedisStore {
   redis;
   ns;
   kind = "redis";
+  // A connection in subscriber mode can run no other commands, so it is a
+  // dedicated duplicate created on first subscribe.
+  subClient;
   static connect(config2) {
     return new _RedisStore(createRedisClient(config2), config2.namespace);
   }
@@ -54072,6 +54145,10 @@ var RedisStore = class _RedisStore {
       }
     }
     await pipeline.exec();
+    await publishNotify(this, keys.notifyMeta(this.ns, sessionId), {
+      type: "rooms",
+      room_id: roomId
+    });
   }
   async getRoomMeta(sessionId, roomId) {
     const data = await this.redis.hgetall(keys.roomMeta(this.ns, sessionId, roomId));
@@ -54184,7 +54261,39 @@ var RedisStore = class _RedisStore {
       return false;
     }
   }
+  async publish(channel, payload) {
+    await this.redis.publish(channel, payload);
+  }
+  async subscribe(channels, onMessage) {
+    if (channels.length === 0) return async () => {
+    };
+    if (!this.subClient) {
+      this.subClient = this.redis.duplicate();
+      this.subClient.on("error", (err2) => {
+        log("redis sub error", err2.message);
+      });
+    }
+    const sub = this.subClient;
+    sub.on("message", onMessage);
+    await sub.subscribe(...channels);
+    return async () => {
+      sub.off("message", onMessage);
+      try {
+        await sub.unsubscribe(...channels);
+      } catch {
+      }
+    };
+  }
   async close() {
+    const sub = this.subClient;
+    this.subClient = void 0;
+    if (sub) {
+      try {
+        await sub.quit();
+      } catch {
+        sub.disconnect();
+      }
+    }
     try {
       await this.redis.quit();
     } catch {
@@ -55527,7 +55636,7 @@ init_esm_shims();
 // package.json
 var package_default = {
   name: "lattice-talk",
-  version: "0.1.2",
+  version: "0.1.3",
   description: "Lattice \u2014 Cross-Harness MCP Session Bus. Shared sessions, DMs, rooms, memory, and OpenTelemetry for agents across Claude Code, Cursor, Codex, and custom harnesses.",
   type: "module",
   main: "./dist/index.js",
@@ -56042,6 +56151,12 @@ async function ensureRoom(deps, sessionId, roomId, createdBy, displayName) {
   };
   const created = await deps.store.addRoom(sessionId, rid, meta3);
   const finalMeta = await deps.store.getRoomMeta(sessionId, rid) ?? meta3;
+  if (created) {
+    await publishNotify(deps.store, keys.notifyMeta(deps.config.namespace, sessionId), {
+      type: "rooms",
+      room_id: rid
+    });
+  }
   return { created, meta: finalMeta };
 }
 async function ensureMainRoom(deps, sessionId, agentId) {
@@ -56069,6 +56184,10 @@ async function joinRoom(deps, input2) {
   }
   await deps.store.addRoomMember(sessionId, roomId, agentId);
   const members2 = await deps.store.listRoomMembers(sessionId, roomId);
+  await publishNotify(deps.store, keys.notifyMeta(deps.config.namespace, sessionId), {
+    type: "rooms",
+    room_id: roomId
+  });
   return { room_id: roomId, members: members2.length, session_id: sessionId };
 }
 
@@ -56082,6 +56201,11 @@ function clampPullLimit(limit) {
   if (!Number.isFinite(n)) return PULL_DEFAULT_LIMIT;
   return Math.min(PULL_MAX_LIMIT, Math.max(1, Math.floor(n)));
 }
+function clampWaitMs(waitMs) {
+  const n = waitMs ?? 0;
+  if (!Number.isFinite(n) || n <= 0) return 0;
+  return Math.min(PULL_WAIT_MAX_MS, Math.floor(n));
+}
 function truncateBody(body, max = BODY_TRUNCATE_CHARS) {
   if (body.length <= max) return { body, truncated: false };
   return { body: body.slice(0, max), truncated: true };
@@ -56154,6 +56278,12 @@ async function tellRoom(deps, input2) {
     fields,
     deps.config.streamMaxLen
   );
+  await publishNotify(deps.store, keys.notifyRoom(deps.config.namespace, sessionId, roomId), {
+    type: "message",
+    room_id: roomId,
+    id: messageId,
+    from: agentId
+  });
   return { message_id: messageId, room_id: roomId, session_id: sessionId };
 }
 async function tellAgent(deps, input2) {
@@ -56182,6 +56312,12 @@ async function tellAgent(deps, input2) {
     fields,
     deps.config.streamMaxLen
   );
+  await publishNotify(deps.store, keys.notifyDm(deps.config.namespace, sessionId, to), {
+    type: "dm",
+    pair,
+    id: messageId,
+    from
+  });
   return { message_id: messageId, pair, session_id: sessionId };
 }
 async function pullOneStream(deps, sessionId, agentId, rid, streamKey, limit) {
@@ -56200,11 +56336,43 @@ async function pullOneStream(deps, sessionId, agentId, rid, streamKey, limit) {
 async function pullMessages(deps, input2) {
   const { sessionId, agentId } = await requireJoinedSession(deps, input2.session_id);
   const limit = clampPullLimit(input2.limit);
+  const waitMs = clampWaitMs(input2.wait_ms);
   const inbox = input2.inbox === true || input2.room_id === "inbox" || Boolean(input2.other_agent_id);
   if (inbox) {
-    return pullInbox(deps, sessionId, agentId, input2.other_agent_id, limit);
+    const channels2 = [keys.notifyDm(deps.config.namespace, sessionId, agentId)];
+    return pullWithWait(
+      deps,
+      waitMs,
+      channels2,
+      () => pullInbox(deps, sessionId, agentId, input2.other_agent_id, limit)
+    );
   }
   const roomId = assertId(input2.room_id?.trim() || DEFAULT_ROOM, "room_id");
+  const channels = [keys.notifyRoom(deps.config.namespace, sessionId, roomId)];
+  return pullWithWait(
+    deps,
+    waitMs,
+    channels,
+    () => pullRoomStream(deps, sessionId, agentId, roomId, limit)
+  );
+}
+async function pullWithWait(deps, waitMs, channels, pullNow) {
+  const first = await pullNow();
+  if (waitMs <= 0 || first.messages.length > 0) return first;
+  let buffered;
+  const notified = await waitForNotify(deps.store, channels, waitMs, async () => {
+    const recheck = await pullNow();
+    if (recheck.messages.length > 0) {
+      buffered = recheck;
+      return true;
+    }
+    return false;
+  });
+  if (buffered) return buffered;
+  if (!notified) return first;
+  return pullNow();
+}
+async function pullRoomStream(deps, sessionId, agentId, roomId, limit) {
   const meta3 = await deps.store.getRoomMeta(sessionId, roomId);
   if (!meta3) {
     throw new UserError(`Room ${roomId} does not exist. Create it with create_room first.`);
@@ -56451,6 +56619,10 @@ async function joinSession(deps, input2) {
   await ensureMainRoom(deps, sessionId, agent.agent_id);
   await refreshPresence(deps, sessionId, agent.agent_id);
   deps.ctx.rememberJoin(sessionId, agent);
+  await publishNotify(deps.store, keys.notifyMeta(deps.config.namespace, sessionId), {
+    type: "agents",
+    agent_id: agent.agent_id
+  });
   const peers = await listPeers(deps, { session_id: sessionId });
   return {
     session_id: sessionId,
@@ -56468,6 +56640,10 @@ async function leaveSession(deps, input2 = {}) {
   await deps.store.clearAgentState(sessionId, agentId);
   await deps.store.removeAgent(sessionId, agentId);
   deps.ctx.clearIf(sessionId, agentId);
+  await publishNotify(deps.store, keys.notifyMeta(deps.config.namespace, sessionId), {
+    type: "agents",
+    agent_id: agentId
+  });
   return { left: true, session_id: sessionId, agent_id: agentId };
 }
 async function listPeers(deps, input2 = {}) {
@@ -56797,7 +56973,10 @@ var pullMessagesSchema = external_exports.object({
   room_id: external_exports.string().max(128).regex(OPTIONAL_ID_PATTERN).optional().describe("Room to read (default main). Caller must be a member. Use inbox to pull DMs instead."),
   inbox: external_exports.boolean().optional().describe("If true, pull this process's DM inbox (all pair streams, or one if other_agent_id is set)."),
   other_agent_id: external_exports.string().max(128).regex(ID_PATTERN).optional().describe("When pulling inbox, only this DM pair. Does not change who is reading."),
-  limit: external_exports.coerce.number().int().min(1).max(200).optional().describe("Max messages to return. Default 50, max 200.")
+  limit: external_exports.coerce.number().int().min(1).max(200).optional().describe("Max messages to return. Default 50, max 200."),
+  wait_ms: external_exports.coerce.number().int().min(0).max(3e4).optional().describe(
+    "Block up to this many ms waiting for a new message (push wake-up, not polling). 0 or omitted returns immediately. Max 30000."
+  )
 });
 var createRoomSchema = external_exports.object({
   session_id: joinedSessionField,
@@ -57057,7 +57236,7 @@ function registerMessagingTools(server, deps) {
   server.registerTool(
     "tell_room",
     {
-      description: "Broadcast a message from this joined process to a session room (default main). Caller must be a room member. Other agents see it on pull_messages after idle.",
+      description: "Broadcast a message from this joined process to a session room (default main). Caller must be a room member. Room members waiting on pull_messages with wait_ms are woken immediately.",
       inputSchema: tellRoomSchema,
       outputSchema: tellRoomOutputSchema,
       annotations: write("Tell room")
@@ -57076,7 +57255,7 @@ function registerMessagingTools(server, deps) {
   server.registerTool(
     "pull_messages",
     {
-      description: "Read new messages since this process's cursor, then advance the cursor and refresh presence. Pass room_id for a room (must be a member), or inbox=true (optionally other_agent_id) for this process's DMs. Bodies longer than ~2k chars are truncated.",
+      description: "Read new messages since this process's cursor, then advance the cursor and refresh presence. Pass room_id for a room (must be a member), or inbox=true (optionally other_agent_id) for this process's DMs. Set wait_ms (max 30000) to block until a new message arrives via push wake-up instead of polling. Bodies longer than ~2k chars are truncated.",
       inputSchema: pullMessagesSchema,
       outputSchema: pullMessagesOutputSchema,
       annotations: write("Pull messages")