letagents 0.9.0 → 0.10.0

package/dist/mcp/local-state.js

@@ -1,12 +1,16 @@
-import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "fs";
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, statSync, writeFileSync, } from "fs";
+import { randomBytes } from "crypto";
 import { homedir } from "os";
 import { dirname, join } from "path";
 const DEFAULT_STATE_PATH = join(homedir(), ".letagents", "mcp-state.json");
+const STATE_LOCK_WAIT_MS = 25;
+const STATE_LOCK_TIMEOUT_MS = 2_000;
+const STATE_LOCK_STALE_MS = 10_000;
+const STATE_LOCK_SLEEP_BUFFER = new Int32Array(new SharedArrayBuffer(4));
 export function getLocalStatePath() {
     return process.env.LETAGENTS_STATE_PATH || DEFAULT_STATE_PATH;
 }
-export function readLocalState() {
-    const statePath = getLocalStatePath();
+function readLocalStateFromPath(statePath) {
     if (!existsSync(statePath)) {
         return {};
     }
@@ -19,18 +23,76 @@ export function readLocalState() {
         return {};
     }
 }
-export function writeLocalState(state) {
+export function readLocalState() {
+    const statePath = getLocalStatePath();
+    return readLocalStateFromPath(statePath);
+}
+function sleepSync(ms) {
+    if (ms > 0) {
+        Atomics.wait(STATE_LOCK_SLEEP_BUFFER, 0, 0, ms);
+    }
+}
+function writeLocalStateUnlocked(statePath, state) {
+    const tempPath = `${statePath}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`;
+    try {
+        writeFileSync(tempPath, JSON.stringify(state, null, 2) + "\n", "utf-8");
+        renameSync(tempPath, statePath);
+    }
+    finally {
+        rmSync(tempPath, { force: true });
+    }
+}
+function withStateLock(callback) {
     const statePath = getLocalStatePath();
     mkdirSync(dirname(statePath), { recursive: true });
-    const tempPath = `${statePath}.tmp`;
-    writeFileSync(tempPath, JSON.stringify(state, null, 2) + "\n", "utf-8");
-    renameSync(tempPath, statePath);
+    const lockPath = `${statePath}.lock`;
+    const startedAt = Date.now();
+    while (true) {
+        let lockFd = null;
+        try {
+            lockFd = openSync(lockPath, "wx");
+            return callback(statePath);
+        }
+        catch (error) {
+            const err = error;
+            if (err.code !== "EEXIST") {
+                throw error;
+            }
+            try {
+                const stats = statSync(lockPath);
+                if (Date.now() - stats.mtimeMs > STATE_LOCK_STALE_MS) {
+                    rmSync(lockPath, { force: true });
+                    continue;
+                }
+            }
+            catch {
+                continue;
+            }
+            if (Date.now() - startedAt >= STATE_LOCK_TIMEOUT_MS) {
+                throw new Error(`Timed out acquiring local state lock at ${lockPath}`);
+            }
+            sleepSync(STATE_LOCK_WAIT_MS);
+        }
+        finally {
+            if (lockFd !== null) {
+                closeSync(lockFd);
+                rmSync(lockPath, { force: true });
+            }
+        }
+    }
+}
+export function writeLocalState(state) {
+    withStateLock((statePath) => {
+        writeLocalStateUnlocked(statePath, state);
+    });
 }
 export function updateLocalState(updater) {
-    const current = readLocalState();
-    const updated = updater(current) ?? current;
-    writeLocalState(updated);
-    return updated;
+    return withStateLock((statePath) => {
+        const current = readLocalStateFromPath(statePath);
+        const updated = updater(current) ?? current;
+        writeLocalStateUnlocked(statePath, updated);
+        return updated;
+    });
 }
 function isExpired(expiresAt) {
     if (!expiresAt) {

package/dist/mcp/room-id.js

@@ -4,6 +4,9 @@ export function encodeRoomIdPath(roomId) {
         .map((segment) => encodeURIComponent(segment))
         .join("/");
 }
+export function getCanonicalRoomWebPath(roomId) {
+    return `/in/${encodeRoomIdPath(roomId)}`;
+}
 export function looksLikeInviteCode(value) {
     return /^[A-Z0-9]{4}(?:-[A-Z0-9]{4})+$/.test(value.trim().toUpperCase());
 }

package/dist/mcp/server.js

@@ -10,12 +10,12 @@ import { execSync } from "child_process";
 import { SseClient } from "./sse-client.js";
 import { getRoomFromConfig } from "./config-reader.js";
 import { getGitRemoteIdentity } from "./git-remote.js";
-import { clearPendingDeviceAuth, clearStoredAuth, getLocalStatePath, getPendingDeviceAuth, getStoredAgentIdentity, getStoredAuth, getStoredCurrentRoom, getStoredRoomSession, saveRoomSession, setStoredAgentIdentity, setPendingDeviceAuth, setStoredAuth, touchRoomSession, } from "./local-state.js";
-import { encodeRoomIdPath, looksLikeInviteCode, normalizeInviteCode, } from "./room-id.js";
+import { clearPendingDeviceAuth, clearStoredAuth, getLocalStatePath, getPendingDeviceAuth, getStoredAgentIdentity, getStoredAuth, getStoredCurrentRoom, getStoredRoomSession, saveRoomSession, setStoredAgentIdentity, setPendingDeviceAuth, setStoredAuth, touchRoomSession, updateLocalState, } from "./local-state.js";
+import { encodeRoomIdPath, getCanonicalRoomWebPath, looksLikeInviteCode, normalizeInviteCode, } from "./room-id.js";
 import { buildAgentActorLabel, formatOwnerAttribution, inferAgentIdeLabel, toTitleCaseCodename, } from "../shared/agent-identity.js";
-const CURRENT_AGENT_IDENTITY_KEY = getAgentIdentityStorageKey();
 let currentRoom = null;
-let currentAgentIdentity = getStoredAgentIdentity(CURRENT_AGENT_IDENTITY_KEY);
+let currentAgentIdentityKey = "";
+let currentAgentIdentity = null;
 let currentAuthenticatedAccount = undefined;
 let currentAuthenticatedAccountSource = null;
 let currentAuthenticatedEnvToken = null;
@@ -27,6 +27,10 @@ const AGENT_NAME = (process.env.LETAGENTS_AGENT_NAME || process.env.AGENT_NAME |
 const AGENT_DISPLAY_NAME = (process.env.LETAGENTS_AGENT_DISPLAY_NAME || "").trim();
 const AGENT_IDE_LABEL = (process.env.LETAGENTS_AGENT_IDE || process.env.AGENT_IDE || "").trim();
 const AGENT_OWNER_LABEL = (process.env.LETAGENTS_AGENT_OWNER_LABEL || "").trim();
+const EXPLICIT_AGENT_IDENTITY_KEY = getExplicitAgentIdentityStorageKey();
+currentAgentIdentityKey =
+    EXPLICIT_AGENT_IDENTITY_KEY ?? getFallbackAgentIdentityNamespaceKey(detectAgentIdeLabel());
+currentAgentIdentity = getStoredAgentIdentity(currentAgentIdentityKey);
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
@@ -166,7 +170,9 @@ const AGENT_CODENAMES = [
     "wood",
     "wren",
 ];
-function getAgentIdentityStorageKey() {
+const AGENT_CODENAME_SPACE = AGENT_CODENAMES.length * AGENT_CODENAMES.length;
+const AGENT_IDENTITY_SLOT_SUFFIX = ":slot:";
+function getExplicitAgentIdentityStorageKey() {
     const runtimeSignals = [
         process.env.LETAGENTS_AGENT_INSTANCE_ID,
         process.env.CODEX_THREAD_ID && `codex:${process.env.CODEX_THREAD_ID}`,
@@ -177,12 +183,26 @@ function getAgentIdentityStorageKey() {
     if (runtimeSignals.length) {
         return runtimeSignals[0];
     }
-    return `cwd:${process.cwd()}`;
+    return null;
+}
+function getFallbackAgentIdentityNamespaceKey(ideLabel) {
+    return `cwd:${process.cwd()}:ide:${normalizeAgentBaseName(ideLabel)}`;
 }
 function hashStringToIndex(value, modulo) {
     const digest = createHash("sha256").update(value).digest();
     return digest.readUInt16BE(0) % modulo;
 }
+function codenameFromIndex(index) {
+    const normalizedIndex = ((index % AGENT_CODENAME_SPACE) + AGENT_CODENAME_SPACE) % AGENT_CODENAME_SPACE;
+    const firstIndex = Math.floor(normalizedIndex / AGENT_CODENAMES.length);
+    const secondIndex = normalizedIndex % AGENT_CODENAMES.length;
+    const first = AGENT_CODENAMES[firstIndex];
+    const second = AGENT_CODENAMES[secondIndex];
+    return {
+        name: normalizeAgentBaseName(`${first}-${second}`),
+        display_name: `${toTitleCaseCodename(first)} ${toTitleCaseCodename(second)}`,
+    };
+}
 function detectAgentIdeLabel() {
     if (AGENT_IDE_LABEL) {
         return toTitleCaseCodename(AGENT_IDE_LABEL);
@@ -194,6 +214,122 @@ function detectAgentIdeLabel() {
     const inferred = inferAgentIdeLabel(explicitName);
     return inferred || "Agent";
 }
+function getFallbackSlotPrefix(namespaceKey) {
+    return `${namespaceKey}${AGENT_IDENTITY_SLOT_SUFFIX}`;
+}
+function getFallbackSlotKey(namespaceKey, slotIndex) {
+    return `${getFallbackSlotPrefix(namespaceKey)}${slotIndex}`;
+}
+function parseFallbackSlotIndex(identityKey, namespaceKey) {
+    const prefix = getFallbackSlotPrefix(namespaceKey);
+    if (!identityKey.startsWith(prefix)) {
+        return null;
+    }
+    const slotIndex = Number.parseInt(identityKey.slice(prefix.length), 10);
+    return Number.isInteger(slotIndex) && slotIndex >= 0 ? slotIndex : null;
+}
+function isProcessAlive(pid) {
+    if (!pid || !Number.isInteger(pid) || pid <= 0) {
+        return false;
+    }
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        const err = error;
+        return err.code === "EPERM";
+    }
+}
+function claimFallbackIdentityKey(namespaceKey) {
+    let claimedKey = getFallbackSlotKey(namespaceKey, 0);
+    let claimedIdentity = null;
+    const now = new Date().toISOString();
+    updateLocalState((state) => {
+        const identities = state.agent_identities ?? {};
+        const leases = state.agent_identity_leases ?? {};
+        const namespacePrefix = getFallbackSlotPrefix(namespaceKey);
+        for (const [identityKey, lease] of Object.entries(leases)) {
+            if (!identityKey.startsWith(namespacePrefix) || lease.namespace_key !== namespaceKey) {
+                continue;
+            }
+            if (!isProcessAlive(lease.pid)) {
+                delete leases[identityKey];
+            }
+        }
+        const activeLeaseForPid = Object.entries(leases).find(([identityKey, lease]) => identityKey.startsWith(namespacePrefix) &&
+            lease.namespace_key === namespaceKey &&
+            lease.pid === process.pid);
+        if (activeLeaseForPid) {
+            const [identityKey, lease] = activeLeaseForPid;
+            lease.updated_at = now;
+            claimedKey = identityKey;
+            claimedIdentity = identities[identityKey] ?? null;
+            state.agent_identity_leases = leases;
+            return state;
+        }
+        const slotKeys = new Set();
+        for (const identityKey of Object.keys(identities)) {
+            if (identityKey.startsWith(namespacePrefix)) {
+                slotKeys.add(identityKey);
+            }
+        }
+        for (const identityKey of Object.keys(leases)) {
+            if (identityKey.startsWith(namespacePrefix)) {
+                slotKeys.add(identityKey);
+            }
+        }
+        const sortedSlotKeys = [...slotKeys].sort((left, right) => {
+            const leftIndex = parseFallbackSlotIndex(left, namespaceKey) ?? Number.MAX_SAFE_INTEGER;
+            const rightIndex = parseFallbackSlotIndex(right, namespaceKey) ?? Number.MAX_SAFE_INTEGER;
+            return leftIndex - rightIndex;
+        });
+        for (const identityKey of sortedSlotKeys) {
+            if (leases[identityKey]) {
+                continue;
+            }
+            leases[identityKey] = {
+                namespace_key: namespaceKey,
+                pid: process.pid,
+                acquired_at: now,
+                updated_at: now,
+            };
+            claimedKey = identityKey;
+            claimedIdentity = identities[identityKey] ?? null;
+            state.agent_identity_leases = leases;
+            return state;
+        }
+        let nextSlotIndex = 0;
+        while (slotKeys.has(getFallbackSlotKey(namespaceKey, nextSlotIndex))) {
+            nextSlotIndex += 1;
+        }
+        claimedKey = getFallbackSlotKey(namespaceKey, nextSlotIndex);
+        leases[claimedKey] = {
+            namespace_key: namespaceKey,
+            pid: process.pid,
+            acquired_at: now,
+            updated_at: now,
+        };
+        claimedIdentity = identities[claimedKey] ?? null;
+        state.agent_identity_leases = leases;
+        return state;
+    });
+    return {
+        identityKey: claimedKey,
+        identity: claimedIdentity,
+    };
+}
+function ensureAgentIdentityKey(ideLabel) {
+    if (EXPLICIT_AGENT_IDENTITY_KEY) {
+        currentAgentIdentityKey = EXPLICIT_AGENT_IDENTITY_KEY;
+        currentAgentIdentity = getStoredAgentIdentity(currentAgentIdentityKey);
+        return currentAgentIdentityKey;
+    }
+    const claimed = claimFallbackIdentityKey(getFallbackAgentIdentityNamespaceKey(ideLabel));
+    currentAgentIdentityKey = claimed.identityKey;
+    currentAgentIdentity = claimed.identity;
+    return currentAgentIdentityKey;
+}
 async function getAuthenticatedAgentDirectory() {
     try {
         const result = await apiCall("/agents/me");
@@ -213,9 +349,9 @@ async function getAuthenticatedAgentDirectory() {
         return null;
     }
 }
-function shouldReuseStoredIdentity(identity) {
+function shouldReuseStoredIdentity(identity, identityKey) {
     return Boolean(identity &&
-        identity.runtime_key === CURRENT_AGENT_IDENTITY_KEY &&
+        identity.runtime_key === identityKey &&
         identity.display_name?.trim() &&
         identity.ide_label?.trim() &&
         identity.owner_attribution?.trim());
@@ -237,42 +373,38 @@ function resolveExplicitAgentIdentity() {
     return null;
 }
 function pickLocalCodename(runtimeKey, offset = 0) {
-    const index = (hashStringToIndex(runtimeKey, AGENT_CODENAMES.length) + offset) % AGENT_CODENAMES.length;
-    const word = AGENT_CODENAMES[index];
-    return {
-        name: normalizeAgentBaseName(word),
-        display_name: toTitleCaseCodename(word),
-    };
+    const index = hashStringToIndex(runtimeKey, AGENT_CODENAME_SPACE) + offset;
+    return codenameFromIndex(index);
 }
-async function resolveAgentName(authAvailable) {
+async function resolveAgentName(authAvailable, identityKey) {
     const explicit = resolveExplicitAgentIdentity();
     if (explicit) {
         return explicit;
     }
-    if (shouldReuseStoredIdentity(currentAgentIdentity)) {
+    if (shouldReuseStoredIdentity(currentAgentIdentity, identityKey)) {
         return {
             name: currentAgentIdentity.name,
             display_name: currentAgentIdentity.display_name,
         };
     }
     if (!authAvailable) {
-        return pickLocalCodename(CURRENT_AGENT_IDENTITY_KEY);
+        return pickLocalCodename(identityKey);
     }
     const directory = await getAuthenticatedAgentDirectory();
     const existingNames = new Set((directory?.agents ?? [])
         .map((agent) => normalizeAgentBaseName(agent.name || ""))
         .filter(Boolean));
-    for (let offset = 0; offset < AGENT_CODENAMES.length; offset += 1) {
-        const candidate = pickLocalCodename(CURRENT_AGENT_IDENTITY_KEY, offset);
+    for (let offset = 0; offset < AGENT_CODENAME_SPACE; offset += 1) {
+        const candidate = pickLocalCodename(identityKey, offset);
         if (!existingNames.has(candidate.name)) {
             return candidate;
         }
     }
     const fallbackHash = createHash("sha256")
-        .update(CURRENT_AGENT_IDENTITY_KEY)
+        .update(identityKey)
         .digest("hex")
         .slice(0, 4);
-    const fallback = pickLocalCodename(CURRENT_AGENT_IDENTITY_KEY);
+    const fallback = pickLocalCodename(identityKey);
     return {
         name: `${fallback.name}-${fallbackHash}`,
         display_name: `${fallback.display_name} ${fallbackHash.toUpperCase()}`,
@@ -384,8 +516,9 @@ async function ensureAgentIdentity() {
     const owner = await resolveOwnerContext();
     const authAvailable = Boolean(getLetagentsToken());
     const ideLabel = detectAgentIdeLabel();
+    const identityKey = ensureAgentIdentityKey(ideLabel);
     const ownerAttribution = formatOwnerAttribution(owner.label);
-    const { name, display_name: displayName } = await resolveAgentName(authAvailable);
+    const { name, display_name: displayName } = await resolveAgentName(authAvailable, identityKey);
     const actorLabel = buildAgentActorLabel({
         display_name: displayName,
         owner_label: owner.label,
@@ -399,7 +532,7 @@ async function ensureAgentIdentity() {
         ide_label: ideLabel,
         actor_label: actorLabel,
         canonical_key: owner.login ? `${owner.login}/${name}` : null,
-        runtime_key: CURRENT_AGENT_IDENTITY_KEY,
+        runtime_key: identityKey,
         source: "local",
         resolved_at: new Date().toISOString(),
     };
@@ -452,7 +585,7 @@ async function ensureAgentIdentity() {
         currentAgentIdentity = setStoredAgentIdentity({
             ...resolved,
             resolved_at: new Date().toISOString(),
-        }, CURRENT_AGENT_IDENTITY_KEY);
+        }, identityKey);
     }
     return currentAgentIdentity ?? resolved;
 }
@@ -628,22 +761,32 @@ function toRoomState(input) {
         joined_via: input.joined_via,
     };
 }
+function getCanonicalRoomWebUrl(roomId) {
+    return new URL(getCanonicalRoomWebPath(roomId), `${API_URL}/`).toString();
+}
+function withCanonicalRoomLink(roomId, payload) {
+    return {
+        ...payload,
+        room_path: getCanonicalRoomWebPath(roomId),
+        room_url: getCanonicalRoomWebUrl(roomId),
+    };
+}
 function toPublicRoomState(state) {
     if (!state) {
         return null;
     }
-    return {
+    return withCanonicalRoomLink(state.room_id, {
         room_id: state.room_id,
         code: state.code ?? null,
         display_name: state.display_name ?? null,
         joined_via: state.joined_via,
-    };
+    });
 }
 function toPublicStoredRoomSession(session) {
     if (!session) {
         return null;
     }
-    return {
+    return withCanonicalRoomLink(session.room_id, {
         room_id: session.room_id,
         code: session.code ?? null,
         display_name: session.display_name ?? null,
@@ -651,12 +794,12 @@ function toPublicStoredRoomSession(session) {
         joined_at: session.joined_at,
         last_seen_at: session.last_seen_at,
         last_message_id: session.last_message_id ?? null,
-    };
+    });
 }
 function toPublicRoomResponse(response, fallbackRoomId) {
     const { id: _legacyId, project_id: _legacyProjectId, ...rest } = response;
     return {
-        ...rest,
+        ...withCanonicalRoomLink(typeof rest.room_id === "string" ? rest.room_id : fallbackRoomId, rest),
         room_id: typeof rest.room_id === "string" ? rest.room_id : fallbackRoomId,
     };
 }
@@ -868,18 +1011,35 @@ server.resource("room_messages", new ResourceTemplate("letagents://rooms/{room_i
     const normalizedRoomId = String(room_id);
     const storedSession = getStoredRoomSession(normalizedRoomId) ??
         (currentRoom?.room_id === normalizedRoomId ? getStoredCurrentRoom() : null);
-    const result = await roomScopedApiCall({
-        room_id: normalizedRoomId,
-        project_id: storedSession?.project_id ?? null,
-        room_path: (targetRoomId) => `/rooms/${encodeRoomIdPath(targetRoomId)}/messages`,
-        project_path: (projectId) => `/projects/${encodeURIComponent(projectId)}/messages`,
-    });
+    // Paginate through all pages to return full message history
+    const allMessages = [];
+    let afterCursor;
+    for (;;) {
+        const query = new URLSearchParams();
+        if (afterCursor)
+            query.set("after", afterCursor);
+        const qs = query.toString();
+        const result = await roomScopedApiCall({
+            room_id: normalizedRoomId,
+            project_id: storedSession?.project_id ?? null,
+            room_path: (targetRoomId) => `/rooms/${encodeRoomIdPath(targetRoomId)}/messages${qs ? `?${qs}` : ""}`,
+            project_path: (projectId) => `/projects/${encodeURIComponent(projectId)}/messages${qs ? `?${qs}` : ""}`,
+        });
+        const msgs = result.messages ?? [];
+        allMessages.push(...msgs);
+        if (!result.has_more || msgs.length === 0)
+            break;
+        const lastMsg = msgs[msgs.length - 1];
+        if (!lastMsg?.id)
+            break;
+        afterCursor = lastMsg.id;
+    }
     return {
         contents: [
             {
                 uri: uri.href,
                 mimeType: "application/json",
-                text: JSON.stringify(result, null, 2),
+                text: JSON.stringify({ messages: allMessages }, null, 2),
             },
         ],
     };
@@ -972,7 +1132,7 @@ server.tool("get_current_room", "Get information about the currently joined room
                     ? {
                         connected: true,
                         ...toPublicRoomState(currentRoom),
-                        agent_identity: toPublicAgentIdentity(currentAgentIdentity ?? getStoredAgentIdentity(CURRENT_AGENT_IDENTITY_KEY)),
+                        agent_identity: toPublicAgentIdentity(currentAgentIdentity ?? getStoredAgentIdentity(currentAgentIdentityKey)),
                         auth: getStoredAuth()
                             ? {
                                 source: process.env.LETAGENTS_TOKEN ? "env" : "local_state",
@@ -1163,15 +1323,31 @@ server.tool("get_board", "Get the current task board for the room. By default sh
         params.set("status", status);
     if (open_only !== false)
         params.set("open", "true");
-    const qs = params.toString();
-    const result = await roomScopedApiCall({
-        room_id: targetRoomId,
-        project_id: targetProjectId,
-        room_path: (targetRoomId) => `/rooms/${encodeRoomIdPath(targetRoomId)}/tasks${qs ? `?${qs}` : ""}`,
-        project_path: (targetProjectId) => `/projects/${encodeURIComponent(targetProjectId)}/tasks${qs ? `?${qs}` : ""}`,
-    });
+    // Paginate through all pages to return the full board
+    const allTasks = [];
+    let afterCursor;
+    for (;;) {
+        const pageParams = new URLSearchParams(params);
+        if (afterCursor)
+            pageParams.set("after", afterCursor);
+        const qs = pageParams.toString();
+        const result = await roomScopedApiCall({
+            room_id: targetRoomId,
+            project_id: targetProjectId,
+            room_path: (targetRoomId) => `/rooms/${encodeRoomIdPath(targetRoomId)}/tasks${qs ? `?${qs}` : ""}`,
+            project_path: (targetProjectId) => `/projects/${encodeURIComponent(targetProjectId)}/tasks${qs ? `?${qs}` : ""}`,
+        });
+        const tasks = result.tasks ?? [];
+        allTasks.push(...tasks);
+        if (!result.has_more || tasks.length === 0)
+            break;
+        const lastTask = tasks[tasks.length - 1];
+        if (!lastTask?.id)
+            break;
+        afterCursor = lastTask.id;
+    }
     return {
-        content: [{ type: "text", text: JSON.stringify({ success: true, ...result }, null, 2) }],
+        content: [{ type: "text", text: JSON.stringify({ success: true, tasks: allTasks }, null, 2) }],
     };
 });
 server.tool("claim_task", "Claim an accepted task. The task must be in 'accepted' " +
@@ -1497,17 +1673,41 @@ server.tool("read_messages", "Read all messages from a Let Agents Chat room.", {
 }, async ({ room_id }) => {
     const targetRoomId = getTargetRoomId(room_id);
     const targetProjectId = getFallbackProjectId();
-    const result = await roomScopedApiCall({
-        room_id: targetRoomId,
-        project_id: targetProjectId,
-        room_path: (targetRoomId) => `/rooms/${encodeRoomIdPath(targetRoomId)}/messages`,
-        project_path: (targetProjectId) => `/projects/${encodeURIComponent(targetProjectId)}/messages`,
-    });
+    // Paginate through all pages to honor the "read all messages" contract
+    const allMessages = [];
+    let afterCursor;
+    let roomIdFromResponse;
+    for (;;) {
+        const query = new URLSearchParams();
+        if (afterCursor)
+            query.set("after", afterCursor);
+        const qs = query.toString();
+        const result = await roomScopedApiCall({
+            room_id: targetRoomId,
+            project_id: targetProjectId,
+            room_path: (targetRoomId) => `/rooms/${encodeRoomIdPath(targetRoomId)}/messages${qs ? `?${qs}` : ""}`,
+            project_path: (targetProjectId) => `/projects/${encodeURIComponent(targetProjectId)}/messages${qs ? `?${qs}` : ""}`,
+        });
+        roomIdFromResponse = roomIdFromResponse || result.room_id || result.project_id;
+        const msgs = result.messages ?? [];
+        allMessages.push(...msgs);
+        if (!result.has_more || msgs.length === 0)
+            break;
+        // Use the last message ID as the cursor for the next page
+        const lastMsg = msgs[msgs.length - 1];
+        if (!lastMsg?.id)
+            break;
+        afterCursor = lastMsg.id;
+    }
+    const output = { messages: allMessages };
+    if (roomIdFromResponse) {
+        output[targetRoomId ? "room_id" : "project_id"] = roomIdFromResponse;
+    }
     return {
         content: [
             {
                 type: "text",
-                text: JSON.stringify(result, null, 2),
+                text: JSON.stringify(output, null, 2),
             },
         ],
     };
@@ -1535,21 +1735,49 @@ server.tool("wait_for_messages", "Wait for new messages in a Let Agents Chat roo
         params.set("after", after_message_id);
     params.set("timeout", String(serverTimeout));
     const queryString = params.toString();
-    const result = await roomScopedApiCall({
+    const firstResult = await roomScopedApiCall({
         room_id: targetRoomId,
         project_id: targetProjectId,
         room_path: (targetRoomId) => `/rooms/${encodeRoomIdPath(targetRoomId)}/messages/poll?${queryString}`,
         project_path: (targetProjectId) => `/projects/${encodeURIComponent(targetProjectId)}/messages/poll?${queryString}`,
         options: { signal: AbortSignal.timeout(clientTimeout) },
     });
+    const allMessages = [...(firstResult.messages ?? [])];
+    const roomIdFromResponse = firstResult.room_id || firstResult.project_id;
+    // If the immediate response has more pages, paginate through them
+    if (firstResult.has_more && allMessages.length > 0) {
+        let afterCursor = allMessages[allMessages.length - 1]?.id;
+        while (afterCursor) {
+            const pageParams = new URLSearchParams();
+            pageParams.set("after", afterCursor);
+            const qs = pageParams.toString();
+            const page = await roomScopedApiCall({
+                room_id: targetRoomId,
+                project_id: targetProjectId,
+                room_path: (targetRoomId) => `/rooms/${encodeRoomIdPath(targetRoomId)}/messages?${qs}`,
+                project_path: (targetProjectId) => `/projects/${encodeURIComponent(targetProjectId)}/messages?${qs}`,
+            });
+            const msgs = page.messages ?? [];
+            allMessages.push(...msgs);
+            if (!page.has_more || msgs.length === 0)
+                break;
+            afterCursor = msgs[msgs.length - 1]?.id;
+            if (!afterCursor)
+                break;
+        }
+    }
+    const output = { messages: allMessages };
+    if (roomIdFromResponse) {
+        output[targetRoomId ? "room_id" : "project_id"] = roomIdFromResponse;
+    }
     if (targetRoomId) {
-        touchRoomSession(targetRoomId, getLastMessageId(result));
+        touchRoomSession(targetRoomId, getLastMessageId(output));
     }
     return {
         content: [
             {
                 type: "text",
-                text: JSON.stringify(result, null, 2),
+                text: JSON.stringify(output, null, 2),
             },
         ],
     };
@@ -1592,7 +1820,7 @@ server.tool("get_onboarding_status", "Inspect local Let Agents MCP auth and room
                     account: storedAuth?.account ?? null,
                     token_expires_at: storedAuth?.expires_at ?? null,
                     pending_device_auth: pendingAuth,
-                    agent_identity: toPublicAgentIdentity(currentAgentIdentity ?? getStoredAgentIdentity(CURRENT_AGENT_IDENTITY_KEY)),
+                    agent_identity: toPublicAgentIdentity(currentAgentIdentity ?? getStoredAgentIdentity(currentAgentIdentityKey)),
                     current_room: toPublicRoomState(currentRoom),
                     saved_current_room: toPublicStoredRoomSession(savedCurrentRoom),
                     detected_room_from_context: detectedRoom,
@@ -1817,7 +2045,7 @@ server.tool("resume_room_session", "Rejoin the last locally saved room context,
                         rejoined_from_local_state: true,
                         server_session_resumed: false,
                         last_message_id_before_restart: savedRoom.last_message_id ?? null,
-                        room: joined.room,
+                        room: toPublicRoomState(joined.room),
                         agent_identity: toPublicAgentIdentity(agentIdentity),
                     }, null, 2),
                 },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "letagents",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "description": "Let Agents Chat — MCP server for AI agent communication",
   "type": "module",
   "main": "dist/mcp/server.js",