letagents 0.12.8 → 0.12.10

package/dist/mcp/server/runtime/messages.js

@@ -0,0 +1,160 @@
+import { normalizeAgentPromptKind } from "../../../shared/room-agent-prompts.js";
+import { dispenseRoomAgentPrompt } from "../../agent-prompt-delivery.js";
+export function getLastMessageId(payload) {
+    if (!payload || typeof payload !== "object") {
+        return undefined;
+    }
+    const messages = payload.messages;
+    const lastMessage = messages?.at(-1);
+    return typeof lastMessage?.id === "string" ? lastMessage.id : undefined;
+}
+export function withJoinRoomAgentPrompt(payload) {
+    return {
+        ...payload,
+        agent_prompt_kind: "join",
+        agent_prompt: dispenseRoomAgentPrompt("join"),
+    };
+}
+function isRecord(value) {
+    return Boolean(value && typeof value === "object");
+}
+function messageId(record) {
+    return typeof record.id === "string" && record.id.trim() ? record.id : null;
+}
+function replyReference(record) {
+    return record.reply_to ?? record.replyTo ?? null;
+}
+function replyReferenceId(record) {
+    const reply = replyReference(record);
+    if (typeof reply === "string" && reply.trim()) {
+        return reply;
+    }
+    if (isRecord(reply) && typeof reply.id === "string" && reply.id.trim()) {
+        return reply.id;
+    }
+    return null;
+}
+function resolveThreadParentId(record, recordsById) {
+    const ownId = messageId(record);
+    const firstReplyId = replyReferenceId(record);
+    if (!firstReplyId) {
+        return ownId;
+    }
+    let parentId = firstReplyId;
+    const seen = new Set(ownId ? [ownId] : []);
+    while (parentId && !seen.has(parentId)) {
+        seen.add(parentId);
+        const parent = recordsById.get(parentId);
+        const nextParentId = parent ? replyReferenceId(parent) : null;
+        if (!nextParentId)
+            break;
+        parentId = nextParentId;
+    }
+    return parentId;
+}
+function explicitThreadRootId(record) {
+    const root = record.thread_root_id ?? record.threadRootId;
+    return typeof root === "string" && root.trim() ? root : null;
+}
+function explicitThreadReplyToId(record) {
+    const replyTo = record.thread_reply_to_id ?? record.threadReplyToId;
+    return typeof replyTo === "string" && replyTo.trim() ? replyTo : null;
+}
+// A message is a thread reply IFF it carries an explicit thread root that differs
+// from its own id. `reply_to` alone is only a quote/chip reference, never proof of
+// thread membership — so a bare quote-reply (explicit root === its own id) stays
+// top-level. Records that carry NO explicit thread_root_id field at all (out-of-band
+// or legacy payloads that never went through the message mappers) fall back to
+// deriving the root from the reply_to chain so genuine threads still survive. The
+// fallback keys on field ABSENCE, never on the value equalling the own id.
+function resolveThreadRootId(record, recordsById) {
+    const explicitRoot = explicitThreadRootId(record);
+    if (explicitRoot) {
+        return explicitRoot;
+    }
+    return resolveThreadParentId(record, recordsById);
+}
+function buildThreadSummaries(records, recordsById) {
+    const summaries = new Map();
+    for (const record of records) {
+        const id = messageId(record);
+        const rootId = resolveThreadRootId(record, recordsById);
+        // Only genuine thread replies (an explicit root different from the message
+        // itself) accrue to a thread. A bare quote-reply roots at itself and must not
+        // inflate the reply count of the message it quotes.
+        if (!id || !rootId || rootId === id)
+            continue;
+        const current = summaries.get(rootId) ?? { count: 0, latestReplyId: null };
+        summaries.set(rootId, {
+            count: current.count + 1,
+            latestReplyId: id,
+        });
+    }
+    return summaries;
+}
+function withThreadMetadata(record, recordsById, summaries) {
+    const ownId = messageId(record);
+    const rootId = resolveThreadRootId(record, recordsById);
+    if (!rootId) {
+        return record;
+    }
+    // The quote/chip reference is preserved regardless of thread membership.
+    const replyToId = explicitThreadReplyToId(record) ?? replyReferenceId(record);
+    const isThreadReply = Boolean(ownId && rootId !== ownId);
+    const summary = summaries.get(rootId) ?? { count: 0, latestReplyId: null };
+    const { thread_parent_id: _threadParentId, thread_root_id: _threadRootId, threadRootId: _threadRootIdCamel, thread_reply_to_id: _threadReplyToId, threadReplyToId: _threadReplyToIdCamel, thread: _thread, ...baseRecord } = record;
+    return {
+        ...baseRecord,
+        ...(isThreadReply
+            ? {
+                thread_parent_id: rootId,
+                thread_root_id: rootId,
+                thread_reply_to_id: replyToId,
+            }
+            : {}),
+        thread: {
+            parent_id: rootId,
+            root_message_id: rootId,
+            reply_to_id: replyToId,
+            is_thread_reply: isThreadReply,
+            reply_count_in_result: summary.count,
+            latest_reply_id_in_result: summary.latestReplyId,
+        },
+    };
+}
+function toAgentReadableMessage(message, recordsById, summaries) {
+    if (!message || typeof message !== "object") {
+        return message;
+    }
+    const record = withThreadMetadata(message, recordsById, summaries);
+    const kind = normalizeAgentPromptKind(record.agent_prompt_kind);
+    const text = typeof record.text === "string" ? record.text : null;
+    if (!kind || text === null) {
+        return record;
+    }
+    return {
+        ...record,
+        visible_text: text,
+        agent_prompt: dispenseRoomAgentPrompt(kind),
+        prompt_injected: kind === "inline",
+    };
+}
+export function toAgentReadableMessages(messages, contextMessages = []) {
+    const records = (messages ?? []).filter(isRecord);
+    const contextRecords = contextMessages.filter(isRecord);
+    const recordsById = new Map();
+    for (const record of [...contextRecords, ...records]) {
+        const id = messageId(record);
+        if (id)
+            recordsById.set(id, record);
+    }
+    const summaries = buildThreadSummaries(records, recordsById);
+    return (messages ?? []).map((message) => toAgentReadableMessage(message, recordsById, summaries));
+}
+export function appendIncludePromptOnly(path) {
+    return `${path}${path.includes("?") ? "&" : "?"}include_prompt_only=1`;
+}
+export function normalizeOptionalToolString(value) {
+    const trimmed = value?.trim();
+    return trimmed ? trimmed : undefined;
+}

package/dist/mcp/server/runtime/presence.js

@@ -0,0 +1,52 @@
+import { getRoomIdentityPresenceCacheKey } from "../../agent-presence.js";
+import { encodeRoomIdPath } from "../../room-id.js";
+import { isLocalRoomStorageEnabled, resolveLocalRoomStorageIdentifiers, touchRoomSession, } from "../../local-state.js";
+import { apiCall, isMissingRouteError } from "./api.js";
+import { agentSessionCredentials, identityFromAgentSession } from "./agent-sessions.js";
+import { getSessionLivenessRegistration } from "./identity.js";
+const roomPresenceByIdentity = new Map();
+export function getRememberedRoomPresence(roomId, identity) {
+    if (!roomId || !identity) {
+        return { status: "idle", status_text: null };
+    }
+    return (roomPresenceByIdentity.get(getRoomIdentityPresenceCacheKey(roomId, identity.actor_label)) ?? { status: "idle", status_text: null });
+}
+export async function syncRoomPresence(roomId, identity, presence, agentSession) {
+    const resolvedIdentity = agentSession ? identityFromAgentSession(agentSession) : identity;
+    if (!roomId || !resolvedIdentity || !agentSession) {
+        return;
+    }
+    roomPresenceByIdentity.set(getRoomIdentityPresenceCacheKey(roomId, resolvedIdentity.actor_label), presence);
+    const { localRoomId, cloudRoomId } = await resolveLocalRoomStorageIdentifiers(roomId);
+    if (await isLocalRoomStorageEnabled(roomId)) {
+        touchRoomSession(localRoomId || roomId);
+        return;
+    }
+    const apiRoomId = cloudRoomId || roomId;
+    try {
+        await apiCall(`/rooms/${encodeRoomIdPath(apiRoomId)}/presence`, {
+            method: "POST",
+            body: JSON.stringify({
+                actor_label: resolvedIdentity.actor_label,
+                agent_key: resolvedIdentity.canonical_key,
+                display_name: resolvedIdentity.display_name,
+                owner_label: resolvedIdentity.owner_label,
+                ide_label: resolvedIdentity.ide_label,
+                status: presence.status,
+                status_text: presence.status_text,
+                liveness_observation: getSessionLivenessRegistration(),
+                ...agentSessionCredentials(agentSession),
+            }),
+        });
+        touchRoomSession(apiRoomId);
+    }
+    catch (error) {
+        if (isMissingRouteError(error)) {
+            return;
+        }
+        throw error;
+    }
+}
+export async function heartbeatRoomPresence(roomId, identity) {
+    await syncRoomPresence(roomId, identity, getRememberedRoomPresence(roomId, identity));
+}

package/dist/mcp/server/runtime/room-api.js

@@ -0,0 +1,42 @@
+import { resolveLocalRoomStorageIdentifiers, touchRoomSession, } from "../../local-state.js";
+import { LETAGENTS_ORIGIN_ROOM_ID_HEADER } from "../../../shared/request-headers.js";
+import { apiCall, isMissingRouteError, } from "./api.js";
+import { maybeHandleRepoRoomAuthRequired } from "./device-auth.js";
+import { getLastMessageId } from "./messages.js";
+import { currentRoom } from "./room-state.js";
+export async function roomScopedApiCall(input) {
+    const headers = {
+        ...input.options?.headers,
+    };
+    if (currentRoom?.room_id &&
+        !Object.keys(headers).some((key) => key.toLowerCase() === LETAGENTS_ORIGIN_ROOM_ID_HEADER.toLowerCase())) {
+        headers[LETAGENTS_ORIGIN_ROOM_ID_HEADER] = currentRoom.room_id;
+    }
+    const options = {
+        ...input.options,
+        headers,
+    };
+    if (input.room_id) {
+        const { cloudRoomId } = await resolveLocalRoomStorageIdentifiers(input.room_id);
+        const apiRoomId = cloudRoomId || input.room_id;
+        try {
+            const result = await apiCall(input.room_path(apiRoomId), options);
+            touchRoomSession(input.room_id, input.preserve_session_cursor ? undefined : getLastMessageId(result));
+            return result;
+        }
+        catch (error) {
+            await maybeHandleRepoRoomAuthRequired(error, apiRoomId);
+            if (!input.project_id || !isMissingRouteError(error)) {
+                throw error;
+            }
+        }
+    }
+    if (!input.project_id) {
+        throw new Error("No room is available for this request.");
+    }
+    const result = await apiCall(input.project_path(input.project_id), options);
+    if (input.room_id) {
+        touchRoomSession(input.room_id, input.preserve_session_cursor ? undefined : getLastMessageId(result));
+    }
+    return result;
+}

package/dist/mcp/server/runtime/room-state.js

@@ -0,0 +1,122 @@
+import { SseClient } from "../../sse-client.js";
+import { getStoredAgentIdentity, saveRoomSession, touchRoomSession, } from "../../local-state.js";
+import { getCanonicalRoomWebPath, } from "../../room-id.js";
+import { API_URL, getLetagentsToken } from "./api.js";
+import { AGENT_INSTANCE_UUID, currentAgentIdentity, currentAgentIdentityKey, } from "./identity.js";
+let mcpServer = null;
+let sseClient = null;
+export let currentRoom = null;
+export function attachMcpServer(server) {
+    mcpServer = server;
+}
+export function shutdownRuntime() {
+    sseClient?.unsubscribeAll();
+}
+function getSseClient() {
+    sseClient ??= new SseClient(API_URL, () => getLetagentsToken());
+    return sseClient;
+}
+function getCurrentStreamAgentIdentity() {
+    const identity = currentAgentIdentity ?? getStoredAgentIdentity(currentAgentIdentityKey);
+    if (!identity?.actor_label || !identity.canonical_key) {
+        return null;
+    }
+    return {
+        actorLabel: identity.actor_label,
+        actorKey: identity.canonical_key,
+        actorInstanceId: AGENT_INSTANCE_UUID,
+    };
+}
+export function toRoomState(input) {
+    return {
+        room_id: input.room_id,
+        project_id: input.project_id ?? null,
+        code: input.code ?? null,
+        display_name: input.display_name ?? null,
+        git_room: input.git_room ?? null,
+        joined_via: input.joined_via,
+        is_local: input.is_local ?? false,
+    };
+}
+function getCanonicalRoomWebUrl(roomId) {
+    return new URL(getCanonicalRoomWebPath(roomId), `${API_URL}/`).toString();
+}
+export function withCanonicalRoomLink(roomId, payload) {
+    return {
+        ...payload,
+        room_path: getCanonicalRoomWebPath(roomId),
+        room_url: getCanonicalRoomWebUrl(roomId),
+    };
+}
+export function toPublicRoomState(state) {
+    if (!state) {
+        return null;
+    }
+    return withCanonicalRoomLink(state.room_id, {
+        room_id: state.room_id,
+        code: state.code ?? null,
+        display_name: state.display_name ?? null,
+        git_room: state.git_room ?? null,
+        joined_via: state.joined_via,
+        is_local: state.is_local ?? false,
+    });
+}
+export function toPublicStoredRoomSession(session) {
+    if (!session) {
+        return null;
+    }
+    return withCanonicalRoomLink(session.room_id, {
+        room_id: session.room_id,
+        code: session.code ?? null,
+        display_name: session.display_name ?? null,
+        git_room: session.git_room ?? null,
+        joined_via: session.joined_via,
+        joined_at: session.joined_at,
+        last_seen_at: session.last_seen_at,
+        last_message_id: session.last_message_id ?? null,
+    });
+}
+export function toPublicRoomResponse(response, fallbackRoomId) {
+    const { id: _legacyId, project_id: _legacyProjectId, ...rest } = response;
+    return {
+        ...withCanonicalRoomLink(typeof rest.room_id === "string" ? rest.room_id : fallbackRoomId, rest),
+        room_id: typeof rest.room_id === "string" ? rest.room_id : fallbackRoomId,
+    };
+}
+export function rememberRoom(state, lastMessageId) {
+    currentRoom = state;
+    saveRoomSession({
+        room_id: state.room_id,
+        project_id: state.project_id ?? null,
+        code: state.code ?? null,
+        display_name: state.display_name ?? null,
+        git_room: state.git_room ?? null,
+        joined_via: state.joined_via,
+        last_message_id: lastMessageId,
+    });
+    getSseClient().unsubscribeAll();
+    if (state.is_local) {
+        return state;
+    }
+    getSseClient().subscribe({
+        roomId: state.room_id,
+        projectId: state.project_id ?? null,
+        agentIdentity: getCurrentStreamAgentIdentity(),
+    }, (_message) => {
+        touchRoomSession(state.room_id);
+        mcpServer?.server.sendResourceListChanged();
+    });
+    return state;
+}
+export function touchCurrentRoom(lastMessageId) {
+    if (!currentRoom) {
+        return;
+    }
+    touchRoomSession(currentRoom.room_id, lastMessageId);
+}
+export function getTargetRoomId(roomId) {
+    return roomId || currentRoom?.room_id || null;
+}
+export function getFallbackProjectId() {
+    return currentRoom?.project_id ?? null;
+}