letagents 0.8.0 → 0.9.0

package/dist/mcp/local-state.js

@@ -88,6 +88,27 @@ export function clearPendingDeviceAuth() {
         return state;
     });
 }
+export function getStoredAgentIdentity(identityKey) {
+    const state = readLocalState();
+    if (identityKey?.trim()) {
+        const scoped = state.agent_identities?.[identityKey.trim()];
+        if (scoped) {
+            return scoped;
+        }
+    }
+    return state.agent_identity ?? null;
+}
+export function setStoredAgentIdentity(agentIdentity, identityKey) {
+    updateLocalState((state) => {
+        state.agent_identity = agentIdentity;
+        if (identityKey?.trim()) {
+            state.agent_identities = state.agent_identities ?? {};
+            state.agent_identities[identityKey.trim()] = agentIdentity;
+        }
+        return state;
+    });
+    return agentIdentity;
+}
 export function getStoredCurrentRoom() {
     const state = readLocalState();
     return state.current_room ?? null;
@@ -103,6 +124,7 @@ export function saveRoomSession(input) {
         room_id: input.room_id,
         project_id: input.project_id ?? existing?.project_id ?? null,
         code: input.code ?? existing?.code ?? null,
+        display_name: input.display_name ?? existing?.display_name ?? null,
         joined_via: input.joined_via,
         joined_at: existing?.joined_at ?? now,
         last_seen_at: now,

package/dist/mcp/server.js

@@ -2,25 +2,460 @@
 import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
+import { createHash } from "crypto";
 import { writeFileSync, existsSync } from "fs";
+import { userInfo } from "os";
 import { join, dirname } from "path";
 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, getStoredAuth, getStoredCurrentRoom, getStoredRoomSession, saveRoomSession, setPendingDeviceAuth, setStoredAuth, touchRoomSession, } from "./local-state.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 { 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 currentAuthenticatedAccount = undefined;
+let currentAuthenticatedAccountSource = null;
+let currentAuthenticatedEnvToken = null;
 // ---------------------------------------------------------------------------
 // Config
 // ---------------------------------------------------------------------------
 const API_URL = (process.env.LETAGENTS_API_URL || "http://localhost:3001").replace(/\/+$/, "");
 const AGENT_NAME = (process.env.LETAGENTS_AGENT_NAME || process.env.AGENT_NAME || "").trim();
 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();
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
+function readCommandOutput(command, cwd = process.cwd()) {
+    try {
+        const output = execSync(command, {
+            cwd,
+            stdio: ["pipe", "pipe", "pipe"],
+            encoding: "utf-8",
+        }).trim();
+        return output || null;
+    }
+    catch {
+        return null;
+    }
+}
+function normalizeSlugSegment(input, fallback) {
+    const normalized = input
+        .normalize("NFKD")
+        .replace(/[^\x00-\x7F]/g, "")
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .replace(/-{2,}/g, "-");
+    return normalized || fallback;
+}
+function normalizeAgentBaseName(input) {
+    return normalizeSlugSegment(input, "agent").replace(/-agent$/, "") || "agent";
+}
+function isCodexRuntime() {
+    return Boolean(process.env.CODEX_THREAD_ID ||
+        process.env.CODEX_SHELL ||
+        process.env.CODEX_CI ||
+        process.env.CODEX_INTERNAL_ORIGINATOR_OVERRIDE);
+}
+const AGENT_CODENAMES = [
+    "amber",
+    "anchor",
+    "autumn",
+    "badger",
+    "bay",
+    "bear",
+    "brook",
+    "calm",
+    "canyon",
+    "cedar",
+    "clear",
+    "cloud",
+    "comet",
+    "copper",
+    "creek",
+    "crisp",
+    "crest",
+    "dawn",
+    "delta",
+    "dune",
+    "ember",
+    "falcon",
+    "fern",
+    "field",
+    "firefly",
+    "fjord",
+    "forest",
+    "fox",
+    "garden",
+    "glade",
+    "golden",
+    "granite",
+    "grove",
+    "harbor",
+    "hawk",
+    "hollow",
+    "indigo",
+    "ivory",
+    "jade",
+    "juniper",
+    "lagoon",
+    "lake",
+    "lantern",
+    "leaf",
+    "lively",
+    "lunar",
+    "lynx",
+    "maple",
+    "marsh",
+    "meadow",
+    "mesa",
+    "misty",
+    "moon",
+    "morrow",
+    "moss",
+    "noble",
+    "oak",
+    "olive",
+    "opal",
+    "otter",
+    "owl",
+    "peak",
+    "pearl",
+    "pine",
+    "quiet",
+    "raven",
+    "reef",
+    "ridge",
+    "river",
+    "rook",
+    "sage",
+    "scarlet",
+    "shore",
+    "silver",
+    "sky",
+    "solar",
+    "sparrow",
+    "spring",
+    "star",
+    "stone",
+    "storm",
+    "summit",
+    "sun",
+    "sunlit",
+    "swift",
+    "thicket",
+    "tidal",
+    "timber",
+    "trail",
+    "valley",
+    "verdant",
+    "vista",
+    "warm",
+    "wave",
+    "west",
+    "wild",
+    "willow",
+    "wind",
+    "winter",
+    "wolf",
+    "wood",
+    "wren",
+];
+function getAgentIdentityStorageKey() {
+    const runtimeSignals = [
+        process.env.LETAGENTS_AGENT_INSTANCE_ID,
+        process.env.CODEX_THREAD_ID && `codex:${process.env.CODEX_THREAD_ID}`,
+        process.env.ANTIGRAVITY_THREAD_ID && `antigravity:${process.env.ANTIGRAVITY_THREAD_ID}`,
+        process.env.CLAUDECODE_SESSION_ID && `claude:${process.env.CLAUDECODE_SESSION_ID}`,
+        process.env.MCP_SESSION_ID && `mcp:${process.env.MCP_SESSION_ID}`,
+    ].filter((value) => Boolean(value?.trim()));
+    if (runtimeSignals.length) {
+        return runtimeSignals[0];
+    }
+    return `cwd:${process.cwd()}`;
+}
+function hashStringToIndex(value, modulo) {
+    const digest = createHash("sha256").update(value).digest();
+    return digest.readUInt16BE(0) % modulo;
+}
+function detectAgentIdeLabel() {
+    if (AGENT_IDE_LABEL) {
+        return toTitleCaseCodename(AGENT_IDE_LABEL);
+    }
+    if (isCodexRuntime()) {
+        return "Codex";
+    }
+    const explicitName = normalizeAgentBaseName(AGENT_NAME || AGENT_DISPLAY_NAME);
+    const inferred = inferAgentIdeLabel(explicitName);
+    return inferred || "Agent";
+}
+async function getAuthenticatedAgentDirectory() {
+    try {
+        const result = await apiCall("/agents/me");
+        const account = result?.account;
+        if (!account?.login?.trim()) {
+            return null;
+        }
+        currentAuthenticatedAccount = account;
+        currentAuthenticatedAccountSource = process.env.LETAGENTS_TOKEN?.trim() ? "env" : "stored";
+        currentAuthenticatedEnvToken = process.env.LETAGENTS_TOKEN?.trim() || null;
+        return {
+            account,
+            agents: Array.isArray(result?.agents) ? result.agents : [],
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function shouldReuseStoredIdentity(identity) {
+    return Boolean(identity &&
+        identity.runtime_key === CURRENT_AGENT_IDENTITY_KEY &&
+        identity.display_name?.trim() &&
+        identity.ide_label?.trim() &&
+        identity.owner_attribution?.trim());
+}
+function resolveExplicitAgentIdentity() {
+    if (AGENT_NAME) {
+        const name = normalizeAgentBaseName(AGENT_NAME);
+        return {
+            name,
+            display_name: AGENT_DISPLAY_NAME || toTitleCaseCodename(AGENT_NAME),
+        };
+    }
+    if (AGENT_DISPLAY_NAME) {
+        return {
+            name: normalizeAgentBaseName(AGENT_DISPLAY_NAME),
+            display_name: AGENT_DISPLAY_NAME.trim(),
+        };
+    }
+    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),
+    };
+}
+async function resolveAgentName(authAvailable) {
+    const explicit = resolveExplicitAgentIdentity();
+    if (explicit) {
+        return explicit;
+    }
+    if (shouldReuseStoredIdentity(currentAgentIdentity)) {
+        return {
+            name: currentAgentIdentity.name,
+            display_name: currentAgentIdentity.display_name,
+        };
+    }
+    if (!authAvailable) {
+        return pickLocalCodename(CURRENT_AGENT_IDENTITY_KEY);
+    }
+    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);
+        if (!existingNames.has(candidate.name)) {
+            return candidate;
+        }
+    }
+    const fallbackHash = createHash("sha256")
+        .update(CURRENT_AGENT_IDENTITY_KEY)
+        .digest("hex")
+        .slice(0, 4);
+    const fallback = pickLocalCodename(CURRENT_AGENT_IDENTITY_KEY);
+    return {
+        name: `${fallback.name}-${fallbackHash}`,
+        display_name: `${fallback.display_name} ${fallbackHash.toUpperCase()}`,
+    };
+}
+async function getAuthenticatedAccountProfile() {
+    const envToken = (process.env.LETAGENTS_TOKEN || "").trim();
+    if (envToken) {
+        if (currentAuthenticatedAccountSource === "env" &&
+            currentAuthenticatedEnvToken === envToken &&
+            currentAuthenticatedAccount?.login?.trim()) {
+            return currentAuthenticatedAccount;
+        }
+        const directory = await getAuthenticatedAgentDirectory();
+        if (directory?.account?.login?.trim()) {
+            return directory.account;
+        }
+        return null;
+    }
+    const storedAccount = getStoredAuth()?.account;
+    if (storedAccount?.login?.trim()) {
+        currentAuthenticatedAccount = storedAccount;
+        currentAuthenticatedAccountSource = "stored";
+        currentAuthenticatedEnvToken = null;
+        return storedAccount;
+    }
+    if (!getLetagentsToken()) {
+        currentAuthenticatedAccount = undefined;
+        currentAuthenticatedAccountSource = null;
+        currentAuthenticatedEnvToken = null;
+        return null;
+    }
+    if (currentAuthenticatedAccountSource === "stored" &&
+        currentAuthenticatedAccount?.login?.trim()) {
+        return currentAuthenticatedAccount;
+    }
+    const directory = await getAuthenticatedAgentDirectory();
+    if (directory?.account?.login?.trim()) {
+        return directory.account;
+    }
+    return null;
+}
+async function resolveOwnerContext() {
+    const account = await getAuthenticatedAccountProfile();
+    const authLogin = account?.login?.trim() || null;
+    const authLabel = account?.display_name?.trim() || authLogin;
+    if (authLogin || authLabel || AGENT_OWNER_LABEL) {
+        const label = AGENT_OWNER_LABEL || authLabel || authLogin || "Owner";
+        const slug = normalizeSlugSegment(authLogin || label, "owner");
+        return { slug, label, login: authLogin };
+    }
+    const gitUserName = readCommandOutput("git config --get user.name");
+    const gitUserEmail = readCommandOutput("git config --get user.email");
+    const gitIdentity = gitUserName || gitUserEmail?.split("@")[0] || null;
+    if (gitIdentity) {
+        return {
+            slug: normalizeSlugSegment(gitIdentity, "owner"),
+            label: gitIdentity,
+            login: null,
+        };
+    }
+    const osIdentity = process.env.USER ||
+        process.env.LOGNAME ||
+        process.env.USERNAME ||
+        (() => {
+            try {
+                return userInfo().username;
+            }
+            catch {
+                return null;
+            }
+        })() ||
+        "owner";
+    return {
+        slug: normalizeSlugSegment(osIdentity, "owner"),
+        label: osIdentity,
+        login: null,
+    };
+}
+function sameAgentIdentity(left, right) {
+    return Boolean(left &&
+        left.name === right.name &&
+        left.display_name === right.display_name &&
+        left.owner_label === right.owner_label &&
+        left.owner_attribution === right.owner_attribution &&
+        left.ide_label === right.ide_label &&
+        left.actor_label === right.actor_label &&
+        left.canonical_key === right.canonical_key &&
+        left.runtime_key === right.runtime_key &&
+        left.source === right.source);
+}
+function toPublicAgentIdentity(identity) {
+    if (!identity) {
+        return null;
+    }
+    return {
+        name: identity.name,
+        display_name: identity.display_name,
+        owner_label: identity.owner_label,
+        owner_attribution: identity.owner_attribution ?? formatOwnerAttribution(identity.owner_label),
+        ide_label: identity.ide_label ?? inferAgentIdeLabel(identity.display_name) ?? "Agent",
+        actor_label: identity.actor_label,
+        canonical_key: identity.canonical_key ?? null,
+        runtime_key: identity.runtime_key ?? null,
+        source: identity.source,
+    };
+}
+async function ensureAgentIdentity() {
+    const owner = await resolveOwnerContext();
+    const authAvailable = Boolean(getLetagentsToken());
+    const ideLabel = detectAgentIdeLabel();
+    const ownerAttribution = formatOwnerAttribution(owner.label);
+    const { name, display_name: displayName } = await resolveAgentName(authAvailable);
+    const actorLabel = buildAgentActorLabel({
+        display_name: displayName,
+        owner_label: owner.label,
+        ide_label: ideLabel,
+    });
+    let resolved = {
+        name,
+        display_name: displayName,
+        owner_label: owner.label,
+        owner_attribution: ownerAttribution,
+        ide_label: ideLabel,
+        actor_label: actorLabel,
+        canonical_key: owner.login ? `${owner.login}/${name}` : null,
+        runtime_key: CURRENT_AGENT_IDENTITY_KEY,
+        source: "local",
+        resolved_at: new Date().toISOString(),
+    };
+    if (currentAgentIdentity &&
+        currentAgentIdentity.name === resolved.name &&
+        currentAgentIdentity.display_name === resolved.display_name &&
+        currentAgentIdentity.owner_label === resolved.owner_label &&
+        currentAgentIdentity.owner_attribution === resolved.owner_attribution &&
+        currentAgentIdentity.ide_label === resolved.ide_label &&
+        currentAgentIdentity.actor_label === resolved.actor_label &&
+        currentAgentIdentity.runtime_key === resolved.runtime_key &&
+        (!authAvailable || currentAgentIdentity.source === "api")) {
+        return currentAgentIdentity;
+    }
+    if (authAvailable) {
+        try {
+            const registered = await apiCall("/agents", {
+                method: "POST",
+                body: JSON.stringify({
+                    name: resolved.name,
+                    display_name: resolved.display_name,
+                    owner_label: resolved.owner_label,
+                }),
+            });
+            resolved = {
+                ...resolved,
+                canonical_key: typeof registered.canonical_key === "string"
+                    ? registered.canonical_key
+                    : resolved.canonical_key,
+                display_name: typeof registered.display_name === "string"
+                    ? registered.display_name
+                    : resolved.display_name,
+                owner_label: typeof registered.owner_label === "string"
+                    ? registered.owner_label
+                    : resolved.owner_label,
+                source: "api",
+            };
+            resolved.owner_attribution = formatOwnerAttribution(resolved.owner_label);
+            resolved.actor_label = buildAgentActorLabel({
+                display_name: resolved.display_name,
+                owner_label: resolved.owner_label,
+                ide_label: resolved.ide_label,
+            });
+        }
+        catch (error) {
+            console.error("Agent identity registration failed:", error instanceof Error ? error.message : error);
+        }
+    }
+    if (!sameAgentIdentity(currentAgentIdentity, resolved)) {
+        currentAgentIdentity = setStoredAgentIdentity({
+            ...resolved,
+            resolved_at: new Date().toISOString(),
+        }, CURRENT_AGENT_IDENTITY_KEY);
+    }
+    return currentAgentIdentity ?? resolved;
+}
 /**
  * Resolve the root of the git repository containing `dir`.
  * Returns null if `dir` is not inside a git repo.
@@ -64,6 +499,16 @@ class ApiError extends Error {
         this.body = body;
     }
 }
+class RepoRoomAuthRequiredError extends Error {
+    roomId;
+    pendingAuth;
+    constructor(roomId, pendingAuth) {
+        super(`Repo room '${roomId}' requires authentication. Device flow started: open ${pendingAuth.verification_uri} and enter code ${pendingAuth.user_code}, then run poll_device_auth.`);
+        this.name = "RepoRoomAuthRequiredError";
+        this.roomId = roomId;
+        this.pendingAuth = pendingAuth;
+    }
+}
 function getLetagentsToken() {
     return process.env.LETAGENTS_TOKEN || getStoredAuth()?.token || "";
 }
@@ -79,6 +524,34 @@ function isMissingRouteError(error) {
         (error.status === 404 || error.status === 405) &&
         /Cannot (GET|POST|PATCH)|Not Found|Cannot GET \/rooms|Cannot POST \/rooms/i.test(error.body));
 }
+function parseApiErrorPayload(error) {
+    if (!(error instanceof ApiError)) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(error.body);
+        return parsed && typeof parsed === "object" ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function resolveApiPath(urlOrPath) {
+    if (!urlOrPath) {
+        return "/auth/device/start";
+    }
+    try {
+        const parsed = new URL(urlOrPath, `${API_URL}/`);
+        const apiBase = new URL(`${API_URL}/`);
+        if (parsed.origin !== apiBase.origin) {
+            return "/auth/device/start";
+        }
+        return `${parsed.pathname}${parsed.search}`;
+    }
+    catch {
+        return "/auth/device/start";
+    }
+}
 async function apiCall(path, options) {
     const headers = {
         "Content-Type": "application/json",
@@ -98,6 +571,9 @@ async function apiCall(path, options) {
             // Only clear on 401 (invalid/expired credential), NOT on 403
             // (valid credential but insufficient permissions, e.g., private repo access)
             clearStoredAuth();
+            currentAuthenticatedAccount = undefined;
+            currentAuthenticatedAccountSource = null;
+            currentAuthenticatedEnvToken = null;
         }
         throw new ApiError(res.status, body);
     }
@@ -107,11 +583,48 @@ async function apiCall(path, options) {
     }
     return JSON.parse(body);
 }
+async function startPendingDeviceAuth(roomId, deviceFlowUrl) {
+    const existing = getPendingDeviceAuth();
+    if (existing?.suggested_room_id === roomId) {
+        return existing;
+    }
+    const response = await apiCall(resolveApiPath(deviceFlowUrl), {
+        method: "POST",
+    });
+    return setPendingDeviceAuth({
+        request_id: response.request_id,
+        user_code: response.user_code,
+        verification_uri: response.verification_uri,
+        interval_seconds: response.interval,
+        expires_at: new Date(Date.now() + response.expires_in * 1000).toISOString(),
+        started_at: new Date().toISOString(),
+        suggested_room_id: roomId,
+    });
+}
+async function maybeHandleRepoRoomAuthRequired(error, roomId) {
+    const payload = parseApiErrorPayload(error);
+    if (!(error instanceof ApiError) || error.status !== 401 || payload?.error !== "auth_required") {
+        return;
+    }
+    const pendingAuth = await startPendingDeviceAuth(roomId, typeof payload.device_flow_url === "string" ? payload.device_flow_url : undefined);
+    throw new RepoRoomAuthRequiredError(roomId, pendingAuth);
+}
+function toRepoRoomAuthRequiredResult(error) {
+    return {
+        success: false,
+        error: "auth_required",
+        room_id: error.roomId,
+        next_step: "poll_device_auth",
+        pending_device_auth: error.pendingAuth,
+        message: error.message,
+    };
+}
 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,
         joined_via: input.joined_via,
     };
 }
@@ -122,6 +635,7 @@ function toPublicRoomState(state) {
     return {
         room_id: state.room_id,
         code: state.code ?? null,
+        display_name: state.display_name ?? null,
         joined_via: state.joined_via,
     };
 }
@@ -132,6 +646,7 @@ function toPublicStoredRoomSession(session) {
     return {
         room_id: session.room_id,
         code: session.code ?? null,
+        display_name: session.display_name ?? null,
         joined_via: session.joined_via,
         joined_at: session.joined_at,
         last_seen_at: session.last_seen_at,
@@ -145,12 +660,19 @@ function toPublicRoomResponse(response, fallbackRoomId) {
         room_id: typeof rest.room_id === "string" ? rest.room_id : fallbackRoomId,
     };
 }
+async function withAgentIdentity(payload) {
+    return {
+        ...payload,
+        agent_identity: toPublicAgentIdentity(await ensureAgentIdentity()),
+    };
+}
 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,
         joined_via: state.joined_via,
         last_message_id: lastMessageId,
     });
@@ -192,6 +714,7 @@ async function roomScopedApiCall(input) {
             return result;
         }
         catch (error) {
+            await maybeHandleRepoRoomAuthRequired(error, input.room_id);
             if (!input.project_id || !isMissingRouteError(error)) {
                 throw error;
             }
@@ -221,14 +744,21 @@ async function joinRoomIdentifier(identifier, joinedVia) {
                 : looksLikeInviteCode(joinedRoomId)
                     ? joinedRoomId
                     : null,
+            display_name: typeof response.display_name === "string" ? response.display_name : null,
             joined_via: joinedVia,
         }));
+        const agentIdentity = await ensureAgentIdentity();
         return {
             room,
-            response: { ...response, room_id: joinedRoomId },
+            response: {
+                ...response,
+                room_id: joinedRoomId,
+                agent_identity: toPublicAgentIdentity(agentIdentity),
+            },
         };
     }
     catch (error) {
+        await maybeHandleRepoRoomAuthRequired(error, roomId);
         if (!isMissingRouteError(error)) {
             throw error;
         }
@@ -242,14 +772,17 @@ async function joinRoomIdentifier(identifier, joinedVia) {
             room_id: legacyRoomId,
             project_id: typeof project.id === "string" ? project.id : null,
             code: typeof project.code === "string" ? project.code : legacyRoomId,
+            display_name: typeof project.display_name === "string" ? project.display_name : null,
             joined_via: joinedVia,
         }));
+        const agentIdentity = await ensureAgentIdentity();
         return {
             room,
             response: {
                 ...project,
                 room_id: legacyRoomId,
                 project_id: typeof project.id === "string" ? project.id : null,
+                agent_identity: toPublicAgentIdentity(agentIdentity),
             },
         };
     }
@@ -267,14 +800,17 @@ async function joinRoomIdentifier(identifier, joinedVia) {
             : looksLikeInviteCode(legacyRoomId)
                 ? legacyRoomId
                 : null,
+        display_name: typeof project.display_name === "string" ? project.display_name : null,
         joined_via: joinedVia,
     }));
+    const agentIdentity = await ensureAgentIdentity();
     return {
         room,
         response: {
             ...project,
             room_id: legacyRoomId,
             project_id: typeof project.id === "string" ? project.id : null,
+            agent_identity: toPublicAgentIdentity(agentIdentity),
         },
     };
 }
@@ -289,47 +825,31 @@ async function createInviteRoom() {
         room_id: roomId,
         project_id: typeof project.id === "string" ? project.id : null,
         code: typeof project.code === "string" ? project.code : roomId,
+        display_name: typeof project.display_name === "string" ? project.display_name : null,
         joined_via: "join_code",
     }));
-    await autoRegisterAgentIdentity();
+    const agentIdentity = await ensureAgentIdentity();
     return {
         room,
-        response: toPublicRoomResponse(project, roomId),
+        response: {
+            ...toPublicRoomResponse(project, roomId),
+            agent_identity: toPublicAgentIdentity(agentIdentity),
+        },
     };
 }
 async function joinInviteCode(code) {
     const joined = await joinRoomIdentifier(code, "join_code");
-    await autoRegisterAgentIdentity();
-    return {
+    return withAgentIdentity({
         ...toPublicRoomResponse(joined.response, joined.room.room_id),
         joined_via: "join_code",
-    };
+    });
 }
 async function joinNamedRoom(name) {
     const joined = await joinRoomIdentifier(name, "join_room");
-    await autoRegisterAgentIdentity();
-    return {
+    return withAgentIdentity({
         ...toPublicRoomResponse(joined.response, joined.room.room_id),
         joined_via: "join_room",
-    };
-}
-async function autoRegisterAgentIdentity() {
-    if (!AGENT_NAME || !currentRoom) {
-        return;
-    }
-    try {
-        await apiCall("/agents", {
-            method: "POST",
-            body: JSON.stringify({
-                name: AGENT_NAME,
-                display_name: AGENT_DISPLAY_NAME || AGENT_NAME,
-                owner_label: AGENT_OWNER_LABEL || undefined,
-            }),
-        });
-    }
-    catch (error) {
-        console.error("Agent identity registration failed:", error);
-    }
+    });
 }
 // ---------------------------------------------------------------------------
 // MCP Server
@@ -418,42 +938,50 @@ server.tool("join_project", "Legacy alias for join_code. Join an existing room u
 server.tool("join_room", "Join a named room on Let Agents Chat. Creates the room if it doesn't exist. Use this for repo-based room joining.", {
     name: z.string().describe("The room name to join (e.g. 'github.com/owner/repo')"),
 }, async ({ name }) => {
-    return {
-        content: [
-            {
-                type: "text",
-                text: JSON.stringify(await joinNamedRoom(name), null, 2),
-            },
-        ],
-    };
-});
-// -- get_current_room -------------------------------------------------------
-server.tool("get_current_room", "Get information about the currently joined room, including how it was joined.", {}, async () => {
-    if (!currentRoom) {
+    try {
         return {
             content: [
                 {
                     type: "text",
-                    text: JSON.stringify({ connected: false, message: "Not currently in any room" }, null, 2),
+                    text: JSON.stringify(await joinNamedRoom(name), null, 2),
                 },
             ],
         };
     }
+    catch (error) {
+        if (error instanceof RepoRoomAuthRequiredError) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(toRepoRoomAuthRequiredResult(error), null, 2),
+                    },
+                ],
+            };
+        }
+        throw error;
+    }
+});
+// -- get_current_room -------------------------------------------------------
+server.tool("get_current_room", "Get information about the currently joined room, including how it was joined.", {}, async () => {
     return {
         content: [
             {
                 type: "text",
-                text: JSON.stringify({
-                    connected: true,
-                    ...toPublicRoomState(currentRoom),
-                    auth: getStoredAuth()
-                        ? {
-                            source: process.env.LETAGENTS_TOKEN ? "env" : "local_state",
-                            expires_at: getStoredAuth()?.expires_at ?? null,
-                            account: getStoredAuth()?.account ?? null,
-                        }
-                        : null,
-                }, null, 2),
+                text: JSON.stringify(currentRoom
+                    ? {
+                        connected: true,
+                        ...toPublicRoomState(currentRoom),
+                        agent_identity: toPublicAgentIdentity(currentAgentIdentity ?? getStoredAgentIdentity(CURRENT_AGENT_IDENTITY_KEY)),
+                        auth: getStoredAuth()
+                            ? {
+                                source: process.env.LETAGENTS_TOKEN ? "env" : "local_state",
+                                expires_at: getStoredAuth()?.expires_at ?? null,
+                                account: getStoredAuth()?.account ?? null,
+                            }
+                            : null,
+                    }
+                    : { connected: false, message: "Not currently in any room" }, null, 2),
             },
         ],
     };
@@ -508,13 +1036,16 @@ server.tool("post_status", "Broadcast a lightweight status update to the current
     "Use this to let other agents and humans know what you are currently doing, " +
     "e.g. 'reviewing PR #2', 'waiting for tests', 'writing WISHLIST.md'. " +
     "Status updates are distinct from chat messages and can be filtered separately.", {
-    sender: z.string().describe("Name of the agent posting the status (e.g. 'codex-agent')"),
+    sender: z
+        .string()
+        .optional()
+        .describe("Deprecated override. Agent identity is resolved automatically on room entry."),
     status: z.string().describe("Short status description (e.g. 'reviewing PR #2', 'idle', 'thinking...')"),
     room_id: z
         .string()
         .optional()
         .describe("Canonical room ID. Defaults to the current room."),
-}, async ({ sender, status, room_id }) => {
+}, async ({ sender: _sender, status, room_id }) => {
     const targetRoomId = getTargetRoomId(room_id);
     const targetProjectId = getFallbackProjectId();
     if (!targetRoomId && !targetProjectId) {
@@ -533,6 +1064,8 @@ server.tool("post_status", "Broadcast a lightweight status update to the current
     }
     // Status messages use a reserved prefix so the UI (and agents) can distinguish
     // them from normal chat messages without changing the data model.
+    const identity = await ensureAgentIdentity();
+    const sender = identity.actor_label;
     const statusText = `[status] ${status}`;
     const message = await roomScopedApiCall({
         room_id: targetRoomId,
@@ -553,6 +1086,7 @@ server.tool("post_status", "Broadcast a lightweight status update to the current
                     success: true,
                     status_posted: status,
                     sender,
+                    agent_identity: toPublicAgentIdentity(identity),
                     message_id: typeof message.id === "string" ? message.id : null,
                     timestamp: typeof message.timestamp === "string" ? message.timestamp : null,
                 }, null, 2),
@@ -571,10 +1105,13 @@ server.tool("add_task", "Add a new task to the room board. Tasks normally start
     "work that needs to be done.", {
     title: z.string().describe("Short task title, e.g. 'Wire up Jest test runner'"),
     description: z.string().optional().describe("Longer description of what needs to be done"),
-    created_by: z.string().describe("Name of the agent or human creating the task"),
+    created_by: z
+        .string()
+        .optional()
+        .describe("Deprecated override. Agent identity is resolved automatically on room entry."),
     source_message_id: z.string().optional().describe("Optional message ID where task was agreed, e.g. 'msg_42'"),
     room_id: z.string().optional().describe("Canonical room ID. Defaults to current room."),
-}, async ({ title, description, created_by, source_message_id, room_id }) => {
+}, async ({ title, description, created_by: _createdBy, source_message_id, room_id }) => {
     const targetRoomId = getTargetRoomId(room_id);
     const targetProjectId = getFallbackProjectId();
     if (!targetRoomId && !targetProjectId) {
@@ -582,6 +1119,7 @@ server.tool("add_task", "Add a new task to the room board. Tasks normally start
             content: [{ type: "text", text: JSON.stringify({ success: false, error: "Not in a room. Join one first." }) }],
         };
     }
+    const identity = await ensureAgentIdentity();
     const task = await roomScopedApiCall({
         room_id: targetRoomId,
         project_id: targetProjectId,
@@ -589,11 +1127,21 @@ server.tool("add_task", "Add a new task to the room board. Tasks normally start
         project_path: (targetProjectId) => `/projects/${encodeURIComponent(targetProjectId)}/tasks`,
         options: {
             method: "POST",
-            body: JSON.stringify({ title, description, created_by, source_message_id }),
+            body: JSON.stringify({
+                title,
+                description,
+                created_by: identity.actor_label,
+                source_message_id,
+            }),
         },
     });
     return {
-        content: [{ type: "text", text: JSON.stringify({ success: true, task }, null, 2) }],
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify({ success: true, task, agent_identity: toPublicAgentIdentity(identity) }, null, 2),
+            },
+        ],
     };
 });
 server.tool("get_board", "Get the current task board for the room. By default shows only open tasks " +
@@ -630,9 +1178,12 @@ server.tool("claim_task", "Claim an accepted task. The task must be in 'accepted
     "status. This sets the assignee to you and moves the status to 'assigned'. " +
     "Do NOT claim proposed tasks — they need to be accepted first.", {
     task_id: z.string().describe("The task ID to claim, e.g. 'task_1'"),
-    assignee: z.string().describe("Your agent name, e.g. 'antigravity'"),
+    assignee: z
+        .string()
+        .optional()
+        .describe("Deprecated override. Agent identity is resolved automatically on room entry."),
     room_id: z.string().optional().describe("Canonical room ID. Defaults to current room."),
-}, async ({ task_id, assignee, room_id }) => {
+}, async ({ task_id, assignee: _assignee, room_id }) => {
     const targetRoomId = getTargetRoomId(room_id);
     const targetProjectId = getFallbackProjectId();
     if (!targetRoomId && !targetProjectId) {
@@ -641,6 +1192,7 @@ server.tool("claim_task", "Claim an accepted task. The task must be in 'accepted
         };
     }
     try {
+        const identity = await ensureAgentIdentity();
         const updated = await roomScopedApiCall({
             room_id: targetRoomId,
             project_id: targetProjectId,
@@ -648,11 +1200,16 @@ server.tool("claim_task", "Claim an accepted task. The task must be in 'accepted
             project_path: (targetProjectId) => `/projects/${encodeURIComponent(targetProjectId)}/tasks/${encodeURIComponent(task_id)}`,
             options: {
                 method: "PATCH",
-                body: JSON.stringify({ status: "assigned", assignee }),
+                body: JSON.stringify({ status: "assigned", assignee: identity.actor_label }),
             },
         });
         return {
-            content: [{ type: "text", text: JSON.stringify({ success: true, task: updated }, null, 2) }],
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({ success: true, task: updated, agent_identity: toPublicAgentIdentity(identity) }, null, 2),
+                },
+            ],
         };
     }
     catch (error) {
@@ -666,7 +1223,10 @@ server.tool("update_task", "Update a task's status or assignee. Status transitio
     "but NOT proposed → in_progress).", {
     task_id: z.string().describe("The task ID to update"),
     status: z.enum(TASK_STATUSES).optional().describe("New status for the task"),
-    assignee: z.string().optional().describe("New assignee for the task"),
+    assignee: z
+        .string()
+        .optional()
+        .describe("New assignee for the task. Defaults to the current agent when status=assigned."),
     pr_url: z.string().optional().describe("PR URL to link to the task"),
     room_id: z.string().optional().describe("Canonical room ID. Defaults to current room."),
 }, async ({ task_id, status, assignee, pr_url, room_id }) => {
@@ -678,6 +1238,9 @@ server.tool("update_task", "Update a task's status or assignee. Status transitio
         };
     }
     try {
+        const identity = status === "assigned" && !assignee
+            ? await ensureAgentIdentity()
+            : null;
         const updated = await roomScopedApiCall({
             room_id: targetRoomId,
             project_id: targetProjectId,
@@ -685,11 +1248,24 @@ server.tool("update_task", "Update a task's status or assignee. Status transitio
             project_path: (targetProjectId) => `/projects/${encodeURIComponent(targetProjectId)}/tasks/${encodeURIComponent(task_id)}`,
             options: {
                 method: "PATCH",
-                body: JSON.stringify({ status, assignee, pr_url }),
+                body: JSON.stringify({
+                    status,
+                    assignee: assignee ?? identity?.actor_label,
+                    pr_url,
+                }),
             },
         });
         return {
-            content: [{ type: "text", text: JSON.stringify({ success: true, task: updated }, null, 2) }],
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        success: true,
+                        task: updated,
+                        agent_identity: identity ? toPublicAgentIdentity(identity) : null,
+                    }, null, 2),
+                },
+            ],
         };
     }
     catch (error) {
@@ -880,14 +1456,18 @@ server.tool("initialize_repo", "Initialize the current repo for Let Agents Chat
 // -- send_message -----------------------------------------------------------
 server.tool("send_message", "Send a message to a Let Agents Chat room.", {
     room_id: z.string().optional().describe("Canonical room ID. Defaults to the current room."),
-    sender: z.string().describe("Name identifying the sending agent (e.g. 'antigravity-agent')"),
+    sender: z
+        .string()
+        .optional()
+        .describe("Deprecated override. Agent identity is resolved automatically on room entry."),
     text: z.string().describe("The message text to send"),
-}, async ({ room_id, sender, text }) => {
+}, async ({ room_id, sender: _sender, text }) => {
     const targetRoomId = getTargetRoomId(room_id);
     const targetProjectId = getFallbackProjectId();
     if (!targetRoomId && !targetProjectId) {
         throw new Error("No room is currently selected. Join a room first or pass room_id.");
     }
+    const identity = await ensureAgentIdentity();
     const message = await roomScopedApiCall({
         room_id: targetRoomId,
         project_id: targetProjectId,
@@ -895,7 +1475,7 @@ server.tool("send_message", "Send a message to a Let Agents Chat room.", {
         project_path: (targetProjectId) => `/projects/${encodeURIComponent(targetProjectId)}/messages`,
         options: {
             method: "POST",
-            body: JSON.stringify({ sender, text }),
+            body: JSON.stringify({ sender: identity.actor_label, text }),
         },
     });
     touchCurrentRoom(typeof message.id === "string" ? message.id : undefined);
@@ -903,7 +1483,10 @@ server.tool("send_message", "Send a message to a Let Agents Chat room.", {
         content: [
             {
                 type: "text",
-                text: JSON.stringify(message, null, 2),
+                text: JSON.stringify({
+                    ...message,
+                    agent_identity: toPublicAgentIdentity(identity),
+                }, null, 2),
             },
         ],
     };
@@ -1009,6 +1592,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)),
                     current_room: toPublicRoomState(currentRoom),
                     saved_current_room: toPublicStoredRoomSession(savedCurrentRoom),
                     detected_room_from_context: detectedRoom,
@@ -1131,6 +1715,9 @@ server.tool("poll_device_auth", "Poll a pending GitHub Device Flow request. On s
     if (result.status === "denied" || result.status === "expired") {
         clearPendingDeviceAuth();
         clearStoredAuth();
+        currentAuthenticatedAccount = undefined;
+        currentAuthenticatedAccountSource = null;
+        currentAuthenticatedEnvToken = null;
         return {
             content: [
                 {
@@ -1151,6 +1738,9 @@ server.tool("poll_device_auth", "Poll a pending GitHub Device Flow request. On s
         stored_at: new Date().toISOString(),
         source: "device_flow",
     });
+    currentAuthenticatedAccount = storedAuth.account ?? undefined;
+    currentAuthenticatedAccountSource = storedAuth.account ? "stored" : null;
+    currentAuthenticatedEnvToken = null;
     let joinedRoom = null;
     const roomToJoin = room_id ||
         pendingAuth?.suggested_room_id ||
@@ -1161,8 +1751,8 @@ server.tool("poll_device_auth", "Poll a pending GitHub Device Flow request. On s
         const joinedVia = looksLikeInviteCode(roomToJoin) ? "join_code" : "join_room";
         const joined = await joinRoomIdentifier(roomToJoin, joinedVia);
         joinedRoom = joined.room;
-        await autoRegisterAgentIdentity();
     }
+    const agentIdentity = await ensureAgentIdentity();
     return {
         content: [
             {
@@ -1173,6 +1763,7 @@ server.tool("poll_device_auth", "Poll a pending GitHub Device Flow request. On s
                     account: storedAuth.account ?? null,
                     expires_at: storedAuth.expires_at ?? null,
                     auto_joined_room: joinedRoom,
+                    agent_identity: toPublicAgentIdentity(agentIdentity),
                 }, null, 2),
             },
         ],
@@ -1181,6 +1772,9 @@ server.tool("poll_device_auth", "Poll a pending GitHub Device Flow request. On s
 server.tool("clear_saved_auth", "Clear any locally saved LetAgents auth token and pending device auth request.", {}, async () => {
     clearPendingDeviceAuth();
     clearStoredAuth();
+    currentAuthenticatedAccount = undefined;
+    currentAuthenticatedAccountSource = null;
+    currentAuthenticatedEnvToken = null;
     return {
         content: [
             {
@@ -1211,22 +1805,38 @@ server.tool("resume_room_session", "Rejoin the last locally saved room context,
             ],
         };
     }
-    const joined = await joinRoomIdentifier(savedRoom.room_id, savedRoom.joined_via);
-    await autoRegisterAgentIdentity();
-    return {
-        content: [
-            {
-                type: "text",
-                text: JSON.stringify({
-                    success: true,
-                    rejoined_from_local_state: true,
-                    server_session_resumed: false,
-                    last_message_id_before_restart: savedRoom.last_message_id ?? null,
-                    room: joined.room,
-                }, null, 2),
-            },
-        ],
-    };
+    try {
+        const joined = await joinRoomIdentifier(savedRoom.room_id, savedRoom.joined_via);
+        const agentIdentity = await ensureAgentIdentity();
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        success: true,
+                        rejoined_from_local_state: true,
+                        server_session_resumed: false,
+                        last_message_id_before_restart: savedRoom.last_message_id ?? null,
+                        room: joined.room,
+                        agent_identity: toPublicAgentIdentity(agentIdentity),
+                    }, null, 2),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        if (error instanceof RepoRoomAuthRequiredError) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(toRepoRoomAuthRequiredResult(error), null, 2),
+                    },
+                ],
+            };
+        }
+        throw error;
+    }
 });
 // -- check_repo_visibility --------------------------------------------------
 server.tool("check_repo_visibility", "Auto-detect the current repo's git remote and check if it's public or private. Returns the canonical key, provider, visibility, and suggested room type (discoverable for public, invite for private/unknown). Useful for deciding whether to auto-join a discoverable room or create an invite room.", {
@@ -1272,6 +1882,7 @@ async function main() {
         const configRoom = getRoomFromConfig();
         if (configRoom) {
             await joinRoomIdentifier(configRoom, "config");
+            await ensureAgentIdentity();
             console.error(`🏠 Auto-joined room '${configRoom}' (from .letagents.json)`);
             return;
         }
@@ -1279,6 +1890,7 @@ async function main() {
         const gitRoom = getGitRemoteIdentity();
         if (gitRoom) {
             await joinRoomIdentifier(gitRoom, "git-remote");
+            await ensureAgentIdentity();
             console.error(`🏠 Auto-joined room '${gitRoom}' (inferred from git remote — consider adding a .letagents.json)`);
             return;
         }
@@ -1286,6 +1898,7 @@ async function main() {
         const savedCurrentRoom = getStoredCurrentRoom();
         if (savedCurrentRoom) {
             await joinRoomIdentifier(savedCurrentRoom.room_id, savedCurrentRoom.joined_via);
+            await ensureAgentIdentity();
             console.error(`🏠 Rejoined saved room '${savedCurrentRoom.room_id}' (from local state)`);
             return;
         }
@@ -1293,6 +1906,10 @@ async function main() {
         console.error("ℹ️ No .letagents.json, git remote, or saved room found — use create_room, join_code, or join_room to connect.");
     }
     catch (err) {
+        if (err instanceof RepoRoomAuthRequiredError) {
+            console.error(`🔐 Repo room auth required for '${err.roomId}'. Open ${err.pendingAuth.verification_uri} and enter code ${err.pendingAuth.user_code}, then run poll_device_auth.`);
+            return;
+        }
         // Auto-join failure should never block the MCP server
         console.error("⚠️ Auto-join failed (server still running):", err instanceof Error ? err.message : err);
     }

package/dist/shared/agent-identity.js

@@ -0,0 +1,104 @@
+const STRUCTURED_AGENT_LABEL_SEPARATOR = " | ";
+const IDE_LABELS = new Map([
+    ["agent", "Agent"],
+    ["antigravity", "Antigravity"],
+    ["claude", "Claude"],
+    ["codex", "Codex"],
+    ["orchestrator", "Orchestrator"],
+]);
+function normalizeWhitespace(value) {
+    return value.trim().replace(/\s+/g, " ");
+}
+function normalizeIdeLabel(value) {
+    const normalized = normalizeWhitespace(String(value ?? ""))
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+    if (!normalized) {
+        return null;
+    }
+    return IDE_LABELS.get(normalized) ?? toTitleCaseCodename(normalized);
+}
+export function toTitleCaseCodename(value) {
+    const normalized = normalizeWhitespace(value);
+    if (!normalized) {
+        return "";
+    }
+    return normalized
+        .split(/[-\s]+/)
+        .filter(Boolean)
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase())
+        .join(" ");
+}
+export function formatOwnerAttribution(ownerLabel) {
+    const trimmed = normalizeWhitespace(ownerLabel) || "Owner";
+    return /s$/i.test(trimmed) ? `${trimmed}' agent` : `${trimmed}'s agent`;
+}
+export function inferAgentIdeLabel(value) {
+    const normalized = normalizeWhitespace(String(value ?? "")).toLowerCase();
+    if (!normalized) {
+        return null;
+    }
+    if (normalized === "codex" || normalized.startsWith("codex-")) {
+        return "Codex";
+    }
+    if (normalized === "antigravity" || normalized.startsWith("antigravity-")) {
+        return "Antigravity";
+    }
+    if (normalized === "claude" || normalized.startsWith("claude-")) {
+        return "Claude";
+    }
+    if (normalized === "orchestrator" || normalized.startsWith("orchestrator-")) {
+        return "Orchestrator";
+    }
+    return null;
+}
+export function buildAgentActorLabel(input) {
+    const displayName = normalizeWhitespace(input.display_name) || "Agent";
+    const ownerAttribution = formatOwnerAttribution(input.owner_label);
+    const ideLabel = normalizeIdeLabel(input.ide_label) ?? "Agent";
+    return [displayName, ownerAttribution, ideLabel].join(STRUCTURED_AGENT_LABEL_SEPARATOR);
+}
+export function parseAgentActorLabel(value) {
+    const raw = normalizeWhitespace(String(value ?? ""));
+    if (!raw) {
+        return null;
+    }
+    const structuredParts = raw
+        .split(STRUCTURED_AGENT_LABEL_SEPARATOR)
+        .map((part) => normalizeWhitespace(part))
+        .filter(Boolean);
+    if (structuredParts.length === 3 &&
+        /agent$/i.test(structuredParts[1]) &&
+        normalizeIdeLabel(structuredParts[2])) {
+        return {
+            raw,
+            display_name: structuredParts[0],
+            owner_attribution: structuredParts[1],
+            ide_label: normalizeIdeLabel(structuredParts[2]),
+            structured: true,
+        };
+    }
+    const legacyMatch = raw.match(/^(.*?)\s*\(([^)]+agent)\)$/i);
+    if (legacyMatch) {
+        const displayName = normalizeWhitespace(legacyMatch[1] ?? "") || raw;
+        const ownerAttribution = normalizeWhitespace(legacyMatch[2] ?? "") || null;
+        return {
+            raw,
+            display_name: displayName,
+            owner_attribution: ownerAttribution,
+            ide_label: inferAgentIdeLabel(displayName),
+            structured: false,
+        };
+    }
+    return {
+        raw,
+        display_name: raw,
+        owner_attribution: null,
+        ide_label: inferAgentIdeLabel(raw),
+        structured: false,
+    };
+}
+export function getAgentPrimaryLabel(value) {
+    return parseAgentActorLabel(value)?.display_name ?? normalizeWhitespace(String(value ?? ""));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "letagents",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "Let Agents Chat — MCP server for AI agent communication",
   "type": "module",
   "main": "dist/mcp/server.js",
@@ -9,6 +9,7 @@
   },
   "files": [
     "dist/mcp/**",
+    "dist/shared/**",
     "README.md"
   ],
   "scripts": {