letagents 0.12.10 → 0.12.11

package/dist/mcp/server/tools/agent-sessions.js

@@ -2,7 +2,9 @@ import { z } from "zod";
 import { scheduleCodexRuntimeStreamBridgeBind, } from "../../codex-session.js";
 import { getManagedAgentProvider, toManagedAgentStartResponse, } from "../../managed-agent-providers.js";
 import { encodeRoomIdPath, looksLikeInviteCode, normalizeInviteCode } from "../../room-id.js";
-import { AGENT_INSTANCE_UUID, RepoRoomAuthRequiredError, apiCall, agentSessionCredentials, currentRoom, detectAgentIdeLabel, detectAgentRuntimeLabel, endStoredAgentSession, ensureAgentIdentity, getSessionLivenessRegistration, getAgentSessionRepoBranch, getStoredAgentSession, getTargetRoomId, ensureLocalWorkerAgentSession, isLocalRoomStorageEnabled, joinRoomIdentifier, resolveLocalRoomStorageIdentifiers, saveAgentSession, toPublicAgentSession, toPublicRoomState, toRepoRoomAuthRequiredResult, withAgentIdentity, } from "../runtime.js";
+import { AGENT_INSTANCE_UUID, RepoRoomAuthRequiredError, apiCall, agentSessionCredentials, currentRoom, detectAgentIdeLabel, detectAgentRuntimeLabel, endStoredAgentSession, ensureAgentIdentity, getSessionLivenessRegistration, getAgentSessionRepoBranch, getStoredAgentSession, getTargetRoomId, ensureLocalWorkerAgentSession, isLocalRoomStorageEnabled, joinRoomIdentifier, resolveLocalRoomStorageIdentifiers, saveAgentSession, toPublicAgentSession, toPublicRoomState, toRepoRoomAuthRequiredResult, withAgentIdentity, resolveWorkerToolIdentity, } from "../runtime.js";
+import { requireValidWorkerBearerRuntime, workerModeDisabledToolResult, } from "../runtime/worker-bearer.js";
+import { bindSupervisedWorkerSession } from "../runtime/supervisor-bridge.js";
 export function registerAgentSessionTools(server) {
     // -- register_agent_session -------------------------------------------------
     server.tool("register_agent_session", "Register this MCP client as an explicit room agent session. Unregistered MCP traffic is treated as controller traffic and stays out of the connected-agent roster.", {
@@ -66,6 +68,28 @@ export function registerAgentSessionTools(server) {
                 ],
             };
         }
+        const { cloudRoomId } = await resolveLocalRoomStorageIdentifiers(targetRoomId);
+        const apiRoomId = cloudRoomId || targetRoomId;
+        if (requireValidWorkerBearerRuntime().mode === "worker") {
+            // The supplied bearer is issued for an existing server-side agent
+            // session. Do not call the owner-only registration endpoint or write
+            // any session credential to local storage.
+            const { agentSession } = await resolveWorkerToolIdentity({ roomId: apiRoomId });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            success: true,
+                            worker_bearer_mode: true,
+                            agent_session: toPublicAgentSession(agentSession),
+                            agent_session_id: agentSession.session_id,
+                            use_agent_session_id: "This local worker-bearer session marker may be passed to room tools. The supplied bearer remains the only server credential.",
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
         const identity = await ensureAgentIdentity();
         if (!identity.canonical_key) {
             return {
@@ -80,8 +104,6 @@ export function registerAgentSessionTools(server) {
                 ],
             };
         }
-        const { cloudRoomId } = await resolveLocalRoomStorageIdentifiers(targetRoomId);
-        const apiRoomId = cloudRoomId || targetRoomId;
         const created = await apiCall(`/rooms/${encodeRoomIdPath(apiRoomId)}/agent-sessions`, {
             method: "POST",
             body: JSON.stringify({
@@ -124,6 +146,7 @@ export function registerAgentSessionTools(server) {
             last_seen_at: typeof created.last_seen_at === "string" ? created.last_seen_at : new Date().toISOString(),
             ended_at: typeof created.ended_at === "string" ? created.ended_at : null,
         });
+        await bindSupervisedWorkerSession(session);
         scheduleCodexRuntimeStreamBridgeBind(session);
         return {
             content: [
@@ -258,6 +281,12 @@ export function registerAgentSessionTools(server) {
             .optional()
             .describe("Optional hard stop in minutes. Defaults to 0, which means run until stopped."),
     }, async ({ room, cwd, stop_phrase, max_minutes }) => {
+        const disabled = workerModeDisabledToolResult("Local Codex session orchestration");
+        if (disabled) {
+            return {
+                content: [{ type: "text", text: JSON.stringify(disabled, null, 2) }],
+            };
+        }
         const joinedVia = looksLikeInviteCode(room) ? "join_code" : "join_room";
         try {
             const joined = await joinRoomIdentifier(room, joinedVia);
@@ -305,6 +334,12 @@ export function registerAgentSessionTools(server) {
             .optional()
             .describe("Optional session id. Defaults to the current local Codex live session."),
     }, async ({ session_id }) => {
+        const disabled = workerModeDisabledToolResult("Local Codex session orchestration");
+        if (disabled) {
+            return {
+                content: [{ type: "text", text: JSON.stringify(disabled, null, 2) }],
+            };
+        }
         const provider = getManagedAgentProvider("codex");
         const status = await provider.inspectLocalSession(session_id, currentRoom?.room_id);
         if (!status) {
@@ -343,6 +378,12 @@ export function registerAgentSessionTools(server) {
             .optional()
             .describe("If true, also terminate the spawned codex app-server process when possible."),
     }, async ({ session_id, shutdown_server }) => {
+        const disabled = workerModeDisabledToolResult("Local Codex session orchestration");
+        if (disabled) {
+            return {
+                content: [{ type: "text", text: JSON.stringify(disabled, null, 2) }],
+            };
+        }
         const provider = getManagedAgentProvider("codex");
         const stopped = await provider.stopLocalSession({
             session_id,

package/dist/mcp/server/tools/messages/message-lookup.js

@@ -0,0 +1,75 @@
+import { encodeRoomIdPath } from "../../../room-id.js";
+import { ApiError, appendIncludePromptOnly, getLocalChatMessages, isMissingRouteError, roomScopedApiCall, } from "../../runtime.js";
+function isRecord(value) {
+    return Boolean(value && typeof value === "object");
+}
+export async function findLocalMessageById(roomId, messageId) {
+    let afterCursor;
+    for (;;) {
+        const result = await getLocalChatMessages(roomId, {
+            after: afterCursor,
+            include_prompt_only: true,
+        });
+        const messages = (result.messages ?? []).filter(isRecord);
+        const match = messages.find((message) => message.id === messageId);
+        if (match)
+            return match;
+        if (!result.has_more || messages.length === 0)
+            return null;
+        const lastMessage = messages[messages.length - 1];
+        afterCursor = typeof lastMessage?.id === "string" ? lastMessage.id : undefined;
+        if (!afterCursor)
+            return null;
+    }
+}
+export async function findRemoteMessageById(input) {
+    if (input.roomId) {
+        try {
+            const result = await roomScopedApiCall({
+                room_id: input.roomId,
+                room_path: (roomId) => appendIncludePromptOnly(`/rooms/${encodeRoomIdPath(roomId)}/messages/${encodeURIComponent(input.messageId)}`),
+                project_path: () => "",
+                // Context lookups must not advance the room session cursor.
+                preserve_session_cursor: true,
+            });
+            return isRecord(result.message) ? result.message : null;
+        }
+        catch (error) {
+            if (isMissingRouteError(error)) {
+                // Older API without the by-id route: fall back to scanning history.
+            }
+            else if (error instanceof ApiError && error.status === 404) {
+                return null;
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+    return scanRemoteMessageHistoryById(input);
+}
+async function scanRemoteMessageHistoryById(input) {
+    let afterCursor;
+    for (;;) {
+        const query = new URLSearchParams();
+        if (afterCursor)
+            query.set("after", afterCursor);
+        const qs = query.toString();
+        const result = await roomScopedApiCall({
+            room_id: input.roomId,
+            project_id: input.projectId,
+            room_path: (roomId) => appendIncludePromptOnly(`/rooms/${encodeRoomIdPath(roomId)}/messages${qs ? `?${qs}` : ""}`),
+            project_path: (projectId) => appendIncludePromptOnly(`/projects/${encodeURIComponent(projectId)}/messages${qs ? `?${qs}` : ""}`),
+        });
+        const messages = (result.messages ?? []).filter(isRecord);
+        const match = messages.find((message) => message.id === input.messageId);
+        if (match)
+            return match;
+        if (!result.has_more || messages.length === 0)
+            return null;
+        const lastMessage = messages[messages.length - 1];
+        afterCursor = typeof lastMessage?.id === "string" ? lastMessage.id : undefined;
+        if (!afterCursor)
+            return null;
+    }
+}

package/dist/mcp/server/tools/messages/read-tool.js

@@ -24,7 +24,7 @@ function withRecencyTelemetry(output, selection) {
 }
 // Fetch the most recent messages by paging BACKWARDS from the tail
 // (before=latest), so a limited read never walks the full room history.
-async function fetchRecentRemoteMessages(input) {
+export async function fetchRecentRemoteMessages(input) {
     const collected = [];
     let beforeCursor = "latest";
     let truncated = false;

package/dist/mcp/server/tools/messages/send-tool.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { encodeRoomIdPath } from "../../../room-id.js";
-import { agentSessionCredentials, addLocalChatMessage, appendIncludePromptOnly, currentRoom, getFallbackProjectId, getLocalChatMessages, getRememberedRoomPresence, getTargetRoomId, isLocalRoomStorageEnabled, resolveLocalRoomStorageIdentifiers, resolveWorkerToolIdentity, roomScopedApiCall, syncRoomPresence, toPublicAgentIdentity, touchCurrentRoom, } from "../../runtime.js";
+import { agentSessionCredentials, addLocalChatMessage, currentRoom, getFallbackProjectId, getRememberedRoomPresence, getTargetRoomId, isLocalRoomStorageEnabled, resolveLocalRoomStorageIdentifiers, resolveWorkerToolIdentity, roomScopedApiCall, syncRoomPresence, toPublicAgentIdentity, touchCurrentRoom, } from "../../runtime.js";
+import { findLocalMessageById, findRemoteMessageById } from "./message-lookup.js";
 import { jsonToolResponse } from "./response.js";
 export function buildSendMessageRequestBody(input) {
     return {
@@ -22,50 +23,6 @@ function explicitThreadRootId(message) {
     }
     return null;
 }
-async function findLocalMessageById(roomId, messageId) {
-    let afterCursor;
-    for (;;) {
-        const result = await getLocalChatMessages(roomId, {
-            after: afterCursor,
-            include_prompt_only: true,
-        });
-        const messages = (result.messages ?? []);
-        const match = messages.find((message) => message.id === messageId);
-        if (match)
-            return match;
-        if (!result.has_more || messages.length === 0)
-            return null;
-        const lastMessage = messages[messages.length - 1];
-        afterCursor = typeof lastMessage?.id === "string" ? lastMessage.id : undefined;
-        if (!afterCursor)
-            return null;
-    }
-}
-async function findRemoteMessageById(input) {
-    let afterCursor;
-    for (;;) {
-        const query = new URLSearchParams();
-        if (afterCursor)
-            query.set("after", afterCursor);
-        const qs = query.toString();
-        const result = await roomScopedApiCall({
-            room_id: input.roomId,
-            project_id: input.projectId,
-            room_path: (roomId) => appendIncludePromptOnly(`/rooms/${encodeRoomIdPath(roomId)}/messages${qs ? `?${qs}` : ""}`),
-            project_path: (projectId) => appendIncludePromptOnly(`/projects/${encodeURIComponent(projectId)}/messages${qs ? `?${qs}` : ""}`),
-        });
-        const messages = result.messages ?? [];
-        const match = messages.find((message) => message.id === input.messageId);
-        if (match)
-            return match;
-        if (!result.has_more || messages.length === 0)
-            return null;
-        const lastMessage = messages[messages.length - 1];
-        afterCursor = typeof lastMessage?.id === "string" ? lastMessage.id : undefined;
-        if (!afterCursor)
-            return null;
-    }
-}
 async function findMessageById(input) {
     if (input.localRoomId && await isLocalRoomStorageEnabled(input.localRoomId)) {
         const { localRoomId } = await resolveLocalRoomStorageIdentifiers(input.localRoomId);

package/dist/mcp/server/tools/messages/wait-tool.js

@@ -1,10 +1,30 @@
 import { z } from "zod";
 import { getPollTimeoutCapMs } from "../../../../shared/poll-timeout-cap.js";
 import { encodeRoomIdPath } from "../../../room-id.js";
-import { appendIncludePromptOnly, buildAgentDeliveryHeaders, currentRoom, ensureAgentIdentity, getFallbackProjectId, getLocalChatMessages, getLastMessageId, getRememberedRoomPresence, getTargetRoomId, identityFromAgentSession, isLocalRoomStorageEnabled, listLocalTasks, resolveLocalRoomStorageIdentifiers, resolveAgentSession, roomScopedApiCall, syncRoomPresence, toAgentReadableMessages, touchRoomSession, waitForLocalChatMessages, } from "../../runtime.js";
+import { appendIncludePromptOnly, buildAgentDeliveryHeaders, currentRoom, ensureAgentIdentity, getFallbackProjectId, getLatestLocalChatMessages, getLocalChatMessages, getLastMessageId, getRememberedRoomPresence, getTargetRoomId, identityFromAgentSession, isLocalRoomStorageEnabled, listLocalTasks, resolveLocalRoomStorageIdentifiers, resolveAgentSession, roomScopedApiCall, syncRoomPresence, toAgentReadableMessages, touchRoomSession, WORKER_BEARER_AGENT_SESSION_ID, waitForLocalChatMessages, } from "../../runtime.js";
+import { requireValidWorkerBearerRuntime } from "../../runtime/worker-bearer.js";
 import { attachAgentMessageActivations } from "../../../../shared/activation-routing.js";
+import { findLocalMessageById, findRemoteMessageById } from "./message-lookup.js";
+import { fetchRecentRemoteMessages } from "./read-tool.js";
 import { jsonToolResponse } from "./response.js";
 const DEFAULT_POLL_TIMEOUT_MS = 30000;
+// When wait_for_messages is called WITHOUT an after_message_id cursor, it must
+// catch up on only the most RECENT messages instead of replaying the entire
+// room history (busy rooms archive millions of characters, which blows the
+// tool's token budget). This bounds that no-cursor catch-up to a recent tail.
+export const DEFAULT_WAIT_CATCHUP_LIMIT = 100;
+// Decide how the initial fetch should behave. With a cursor we return
+// everything after it (genuine "new since I last polled", already bounded);
+// without one we fetch only the bounded recent tail.
+export function planWaitForMessagesFetch(input) {
+    if (input.effectiveAfterMessageId) {
+        return { mode: "after_cursor", after: input.effectiveAfterMessageId };
+    }
+    return {
+        mode: "catch_up_tail",
+        limit: input.catchupLimit ?? DEFAULT_WAIT_CATCHUP_LIMIT,
+    };
+}
 const LOCAL_TASK_OWNER_STATUSES = new Set(["assigned", "in_progress", "blocked", "in_review"]);
 export function buildWaitForMessagesRequestOptions(input) {
     return {
@@ -88,6 +108,10 @@ function addActivationRoutingTelemetry(output, routing) {
     return output;
 }
 export function resolveWaitAgentSession(roomId, agentSessionId) {
+    if (requireValidWorkerBearerRuntime().mode === "worker" &&
+        (!agentSessionId?.trim() || agentSessionId === WORKER_BEARER_AGENT_SESSION_ID)) {
+        return null;
+    }
     if (!agentSessionId?.trim()) {
         return null;
     }
@@ -130,57 +154,53 @@ async function attachLocalActivationMetadata(roomId, messages, agentSession, opt
         session_kind: agentSession.session_kind,
     }, activationContext);
 }
-async function findLocalMessageById(roomId, targetMessageId) {
-    let afterCursor;
-    for (;;) {
-        const result = await getLocalChatMessages(roomId, {
-            after: afterCursor,
-            include_prompt_only: true,
-        });
-        const messages = (result.messages ?? []).filter(isRecord);
-        const match = messages.find((message) => message.id === targetMessageId);
-        if (match)
-            return match;
-        if (!result.has_more || messages.length === 0)
-            return null;
-        const lastMessage = messages[messages.length - 1];
-        afterCursor = messageId(lastMessage) ?? undefined;
-        if (!afterCursor)
-            return null;
-    }
+// Resolving an out-of-window parent costs a lookup (a by-id fetch, or a
+// page-by-page history scan against older APIs), so resolved (and observed)
+// messages are cached per process to keep repeat polls from re-resolving the
+// same thread roots. Message ids are
+// room-scoped, so the key includes the room scope. Message records are treated
+// as immutable once posted; a bounded insertion-ordered map keeps memory flat
+// for long-running workers.
+const THREAD_CONTEXT_CACHE_MAX = 500;
+const threadContextCache = new Map();
+function threadContextCacheKey(scopeId, targetMessageId) {
+    return `${scopeId}:${targetMessageId}`;
 }
-async function findRemoteMessageById(input) {
-    let afterCursor;
-    for (;;) {
-        const params = new URLSearchParams();
-        if (afterCursor)
-            params.set("after", afterCursor);
-        const queryString = params.toString();
-        const result = await roomScopedApiCall({
-            room_id: input.roomId,
-            project_id: input.projectId,
-            room_path: (roomId) => appendIncludePromptOnly(`/rooms/${encodeRoomIdPath(roomId)}/messages${queryString ? `?${queryString}` : ""}`),
-            project_path: (projectId) => appendIncludePromptOnly(`/projects/${encodeURIComponent(projectId)}/messages${queryString ? `?${queryString}` : ""}`),
-        });
-        const messages = (result.messages ?? []).filter(isRecord);
-        const match = messages.find((message) => message.id === input.targetMessageId);
-        if (match)
-            return match;
-        if (!result.has_more || messages.length === 0)
-            return null;
-        const lastMessage = messages[messages.length - 1];
-        afterCursor = messageId(lastMessage) ?? undefined;
-        if (!afterCursor)
-            return null;
+export function rememberThreadContextMessages(scopeId, records) {
+    for (const record of records) {
+        if (!isRecord(record))
+            continue;
+        const id = messageId(record);
+        if (!id)
+            continue;
+        const key = threadContextCacheKey(scopeId, id);
+        threadContextCache.delete(key);
+        threadContextCache.set(key, record);
+    }
+    while (threadContextCache.size > THREAD_CONTEXT_CACHE_MAX) {
+        const oldest = threadContextCache.keys().next().value;
+        if (oldest === undefined)
+            break;
+        threadContextCache.delete(oldest);
     }
 }
-async function collectThreadContextMessages(input) {
+export function resetThreadContextCacheForTests() {
+    threadContextCache.clear();
+}
+export async function collectThreadContextMessages(input) {
     const records = input.messages.filter(isRecord);
     const knownIds = new Set(records.map(messageId).filter((id) => Boolean(id)));
     const seenIds = new Set(knownIds);
     const pendingIds = records
         .map(replyReferenceId)
         .filter((id) => Boolean(id && !knownIds.has(id)));
+    const scopeId = input.roomId ?? input.localRoomId ?? input.projectId ?? "";
+    rememberThreadContextMessages(scopeId, records);
+    if (pendingIds.length === 0) {
+        // Nothing quotes an out-of-window message (idle polls land here), so skip
+        // storage-mode resolution entirely.
+        return [];
+    }
     const contextMessages = [];
     const useLocalStorage = Boolean(input.localRoomId && await isLocalRoomStorageEnabled(input.localRoomId));
     const localIdentifiers = useLocalStorage
@@ -192,15 +212,20 @@ async function collectThreadContextMessages(input) {
         if (!nextId || seenIds.has(nextId))
             continue;
         seenIds.add(nextId);
-        const message = useLocalStorage && input.localRoomId
-            ? await findLocalMessageById(sqliteRoomId || input.localRoomId, nextId)
-            : await findRemoteMessageById({
-                roomId: input.roomId,
-                projectId: input.projectId,
-                targetMessageId: nextId,
-            });
+        const cached = threadContextCache.get(threadContextCacheKey(scopeId, nextId));
+        const message = cached
+            ?? (useLocalStorage && input.localRoomId
+                ? await findLocalMessageById(sqliteRoomId || input.localRoomId, nextId)
+                : await findRemoteMessageById({
+                    roomId: input.roomId,
+                    projectId: input.projectId,
+                    messageId: nextId,
+                }));
         if (!message)
             continue;
+        if (!cached) {
+            rememberThreadContextMessages(scopeId, [message]);
+        }
         contextMessages.push(message);
         const parentId = replyReferenceId(message);
         if (parentId && !seenIds.has(parentId)) {
@@ -215,7 +240,7 @@ export function registerWaitForMessagesTool(server) {
         after_message_id: z
             .string()
             .optional()
-            .describe("Only return messages after this message ID (e.g. 'msg_3'). If omitted, returns all existing messages immediately."),
+            .describe(`Only return messages after this message ID (e.g. 'msg_3'). If omitted, returns just the most recent ${DEFAULT_WAIT_CATCHUP_LIMIT} messages (bounded recent tail) instead of the full room history, and advances the session cursor to the newest message.`),
         timeout: z
             .number()
             .optional()
@@ -239,10 +264,19 @@ export function registerWaitForMessagesTool(server) {
             const effectiveAfterMessageId = resolveEffectiveAfterMessageId({
                 requestedAfterMessageId: after_message_id,
             });
-            const existing = await getLocalChatMessages(effectiveLocalRoomId, {
-                after: effectiveAfterMessageId,
-                include_prompt_only: true,
-            });
+            const fetchPlan = planWaitForMessagesFetch({ effectiveAfterMessageId });
+            // Without a cursor, page BACKWARDS from the tail (getLatest…) so we
+            // return the most-recent messages, not the oldest N; with a cursor we
+            // keep the unchanged forward "everything after the cursor" behavior.
+            const existing = fetchPlan.mode === "catch_up_tail"
+                ? await getLatestLocalChatMessages(effectiveLocalRoomId, {
+                    limit: fetchPlan.limit,
+                    include_prompt_only: true,
+                })
+                : await getLocalChatMessages(effectiveLocalRoomId, {
+                    after: effectiveAfterMessageId,
+                    include_prompt_only: true,
+                });
             const replayingExistingMessages = existing.messages.length > 0;
             const result = replayingExistingMessages
                 ? existing
@@ -271,45 +305,81 @@ export function registerWaitForMessagesTool(server) {
         }
         await syncRoomPresence(targetRoomId ?? currentRoom?.room_id ?? null, identity, getRememberedRoomPresence(targetRoomId ?? currentRoom?.room_id ?? null, agentSession ? identityFromAgentSession(agentSession) : identity), agentSession);
         const clientTimeout = serverTimeout + (serverTimeout > 120_000 ? 120_000 : 5_000);
-        const params = new URLSearchParams();
         const effectiveAfterMessageId = resolveEffectiveAfterMessageId({
             requestedAfterMessageId: after_message_id,
         });
-        if (effectiveAfterMessageId)
-            params.set("after", effectiveAfterMessageId);
-        params.set("timeout", String(serverTimeout));
-        const queryString = params.toString();
+        const fetchPlan = planWaitForMessagesFetch({ effectiveAfterMessageId });
         const deliveryHeaders = buildAgentDeliveryHeaders(agentSession);
-        const firstResult = await roomScopedApiCall({
-            room_id: targetRoomId,
-            project_id: targetProjectId,
-            room_path: (targetRoomId) => appendIncludePromptOnly(`/rooms/${encodeRoomIdPath(targetRoomId)}/messages/poll?${queryString}`),
-            project_path: (targetProjectId) => appendIncludePromptOnly(`/projects/${encodeURIComponent(targetProjectId)}/messages/poll?${queryString}`),
-            options: buildWaitForMessagesRequestOptions({
-                deliveryHeaders,
-                signal: AbortSignal.timeout(clientTimeout),
-            }),
-        });
-        const allMessages = [...(firstResult.messages ?? [])];
-        const roomIdFromResponse = firstResult.room_id || firstResult.project_id;
-        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(buildWaitForMessagesHistoryPageRequest({
-                    targetRoomId,
-                    targetProjectId,
-                    queryString: qs,
+        const allMessages = [];
+        let roomIdFromResponse;
+        // Long-poll the server (blocks up to serverTimeout for new messages),
+        // optionally seeded with a cursor. Shared by the cursor path and by the
+        // no-cursor empty-tail fallback so a quiet room still blocks instead of
+        // busy-spinning. When `after` is provided this also catches up any backlog
+        // after the cursor via forward pagination.
+        const longPollFromCursor = async (after) => {
+            const params = new URLSearchParams();
+            if (after)
+                params.set("after", after);
+            params.set("timeout", String(serverTimeout));
+            const queryString = params.toString();
+            const firstResult = await roomScopedApiCall({
+                room_id: targetRoomId,
+                project_id: targetProjectId,
+                room_path: (targetRoomId) => appendIncludePromptOnly(`/rooms/${encodeRoomIdPath(targetRoomId)}/messages/poll?${queryString}`),
+                project_path: (targetProjectId) => appendIncludePromptOnly(`/projects/${encodeURIComponent(targetProjectId)}/messages/poll?${queryString}`),
+                options: buildWaitForMessagesRequestOptions({
                     deliveryHeaders,
-                }));
-                const msgs = page.messages ?? [];
-                allMessages.push(...msgs);
-                if (!page.has_more || msgs.length === 0)
-                    break;
-                afterCursor = msgs[msgs.length - 1]?.id;
+                    signal: AbortSignal.timeout(clientTimeout),
+                }),
+            });
+            allMessages.push(...(firstResult.messages ?? []));
+            roomIdFromResponse = roomIdFromResponse || firstResult.room_id || firstResult.project_id;
+            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(buildWaitForMessagesHistoryPageRequest({
+                        targetRoomId,
+                        targetProjectId,
+                        queryString: qs,
+                        deliveryHeaders,
+                    }));
+                    const msgs = page.messages ?? [];
+                    allMessages.push(...msgs);
+                    if (!page.has_more || msgs.length === 0)
+                        break;
+                    afterCursor = msgs[msgs.length - 1]?.id;
+                }
             }
+        };
+        if (fetchPlan.mode === "catch_up_tail") {
+            // No cursor: catch up on only the bounded recent tail. Mirror
+            // read_messages by paging BACKWARDS from the tail (before=latest) so we
+            // return the newest N and never walk the full room history. This also
+            // advances the session cursor to the newest message returned.
+            const recent = await fetchRecentRemoteMessages({
+                targetRoomId,
+                targetProjectId,
+                limit: fetchPlan.limit,
+            });
+            if (recent.messages.length > 0) {
+                allMessages.push(...recent.messages);
+                roomIdFromResponse = recent.roomIdFromResponse;
+            }
+            else {
+                // Empty tail => the room is effectively empty, so there is nothing to
+                // dump. Fall through to the long-poll (no cursor) so a worker looping
+                // in a quiet room blocks up to the timeout instead of busy-spinning,
+                // exactly as the local path does via waitForLocalChatMessages.
+                roomIdFromResponse = recent.roomIdFromResponse;
+                await longPollFromCursor();
+            }
+        }
+        else {
+            await longPollFromCursor(fetchPlan.after);
         }
         const routing = filterSilentActivationMessages(allMessages);
         const threadContext = await collectThreadContextMessages({

package/dist/mcp/server/tools/onboarding/device-auth-tools.js

@@ -3,6 +3,7 @@ import { getRoomFromConfig } from "../../../config-reader.js";
 import { looksLikeInviteCode } from "../../../room-id.js";
 import { apiCall, clearAuthenticatedAccountCache, clearPendingDeviceAuth, clearStoredAuth, currentRoom, ensureAgentIdentity, getPendingDeviceAuth, joinRoomIdentifierWithoutImplicitGitRefCreate, setAuthenticatedAccountCache, setPendingDeviceAuth, setStoredAuth, toPublicAgentIdentity, withCanonicalRoomLink, } from "../../runtime.js";
 import { jsonTextResponse } from "./responses.js";
+import { workerModeDisabledToolResult } from "../../runtime/worker-bearer.js";
 export function registerDeviceAuthTools(server) {
     registerStartDeviceAuthTool(server);
     registerPollDeviceAuthTool(server);
@@ -19,6 +20,9 @@ function registerStartDeviceAuthTool(server) {
             .optional()
             .describe("If true, replaces any existing pending device auth request."),
     }, async ({ room_id, force }) => {
+        const disabled = workerModeDisabledToolResult();
+        if (disabled)
+            return jsonTextResponse(disabled);
         const existing = getPendingDeviceAuth();
         if (existing && !force) {
             return jsonTextResponse({
@@ -60,6 +64,9 @@ function registerPollDeviceAuthTool(server) {
             .optional()
             .describe("If true, tries to join the room immediately after the auth succeeds."),
     }, async ({ request_id, room_id, auto_join }) => {
+        const disabled = workerModeDisabledToolResult();
+        if (disabled)
+            return jsonTextResponse(disabled);
         const pendingAuth = request_id
             ? getPendingDeviceAuth()?.request_id === request_id
                 ? getPendingDeviceAuth()
@@ -137,6 +144,9 @@ function registerPollDeviceAuthTool(server) {
 }
 function registerClearSavedAuthTool(server) {
     server.tool("clear_saved_auth", "Clear any locally saved LetAgents auth token and pending device auth request.", {}, async () => {
+        const disabled = workerModeDisabledToolResult();
+        if (disabled)
+            return jsonTextResponse(disabled);
         clearPendingDeviceAuth();
         clearStoredAuth();
         clearAuthenticatedAccountCache();

package/dist/mcp/server/tools/onboarding/name-tool.js

@@ -3,6 +3,7 @@ import { buildAgentActorLabel, formatOwnerAttribution } from "../../../../shared
 import { normalizeAgentBaseName } from "../../../../shared/codenames.js";
 import { apiCall, currentAgentIdentity, currentAgentIdentityKey, detectAgentIdeLabel, getConversationIdentity, getLetagentsToken, resolveOwnerContext, setConversationIdentity, storeCurrentAgentIdentity, toPublicAgentIdentity, } from "../../runtime.js";
 import { jsonTextResponse } from "./responses.js";
+import { workerModeDisabledToolResult } from "../../runtime/worker-bearer.js";
 export function registerSetAgentNameTool(server) {
     server.tool("set_agent_name", "Set or change the agent's display name. The agent will be known by this name in the room. Use this to pick a custom name instead of the auto-generated codename.", {
         name: z
@@ -15,6 +16,9 @@ export function registerSetAgentNameTool(server) {
             .optional()
             .describe("Optional conversation ID to scope this name change. When provided, only this conversation uses the new name; other conversations keep their own identity."),
     }, async ({ name: desiredName, conversation_id }) => {
+        const disabled = workerModeDisabledToolResult();
+        if (disabled)
+            return jsonTextResponse(disabled);
         const trimmedName = desiredName.trim();
         if (trimmedName.length < 2 || trimmedName.length > 64) {
             return jsonTextResponse({
@@ -22,7 +26,7 @@ export function registerSetAgentNameTool(server) {
                 error: "Name must be between 2 and 64 characters.",
             });
         }
-        const authAvailable = Boolean(getLetagentsToken());
+        const authAvailable = Boolean(await getLetagentsToken());
         if (!authAvailable) {
             return jsonTextResponse({
                 success: false,