@imenam/mcp-messenger 1.0.6 → 1.0.8

package/dist/src/mcp/tools.js

@@ -25,24 +25,37 @@ export const TOOLS = [
         },
     },
     {
-        name: "set_label",
-        description: "Give a plain-language name to this mailbox, or to a thread. Ids are opaque: a name is what makes a mailbox or a conversation recognisable later, both for the other agents and for the user reading the web console. Without thread_id it names this mailbox ('Développement des tests unitaires du parser'); with thread_id it names that thread ('Le test échoue sur un bug applicatif'). A thread has a single shared name: renaming it changes it for every participant, and the last caller wins.",
+        name: "rename_mailbox",
+        description: "Give a plain-language name to this mailbox, or change it: what this session is working on, e.g. 'Développement des tests unitaires du parser'. Addresses are opaque: the name is what makes this session recognisable later, both for the other agents (list_agents) and for the user reading the web console. It does not touch the agent name, which says where the agent comes from (its project) and is set by the configuration.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                name: { type: "string", description: "Short name, one line. Say what the work is about, not who does it." },
+                description: { type: "string", description: "Optional longer explanation of what this mailbox is for." },
+            },
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "rename_thread",
+        description: "Give a plain-language name to a thread, or change it, e.g. 'Le test échoue sur un bug applicatif'. A thread has a single shared name: renaming it changes it for every participant, and the last caller wins. Use it when a thread was opened without a name, or when the discussion has drifted away from its original name.",
         inputSchema: {
             type: "object",
             properties: {
-                label: { type: "string", description: "Short name, one line. Say what the work is about, not who does it." },
-                description: { type: "string", description: "Optional longer explanation of the mailbox or the thread." },
                 thread_id: {
                     type: "string",
-                    description: "Thread to name. Omit to name this mailbox instead. You must be a participant of the thread.",
+                    description: "Thread to rename. You must be a participant of the thread.",
                 },
+                name: { type: "string", description: "Short name, one line. Say what the thread is about." },
+                description: { type: "string", description: "Optional longer explanation of the thread." },
             },
+            required: ["thread_id"],
             additionalProperties: false,
         },
     },
     {
         name: "list_threads",
-        description: "List the conversations visible from this mailbox, most recently active first, with their name, participants and unread count. This is the readable map of the ongoing work: prefer it over list_messages when you want to know what is being discussed rather than what arrived last. A thread with no name falls back to the subject of its opening message — name it with set_label.",
+        description: "List the conversations visible from this mailbox, most recently active first, with their name, participants and unread count. This is the readable map of the ongoing work: prefer it over list_messages when you want to know what is being discussed rather than what arrived last. A thread with no name falls back to the subject of its opening message — name it with rename_thread.",
         inputSchema: {
             type: "object",
             properties: {
@@ -55,29 +68,26 @@ export const TOOLS = [
     },
     {
         name: "list_agents",
-        description: "List the agents known to the mailbox server, most recently active first, with their name and description. Use it to find the address of the agent you want to write to.",
+        description: "List the other agents known to the mailbox server, most recently active first, with their name and description. Your own mailbox is never listed — you cannot write to yourself. Use it to find the address of the agent you want to write to.",
         inputSchema: { type: "object", properties: {}, additionalProperties: false },
     },
     {
         name: "send_message",
-        description: "Send a message to one or more agents, identified by their mailbox address. Set reply_to to answer an existing message and keep the thread together.",
+        description: "Send a message to one agent, identified by its mailbox address. A message has a single recipient: to reach several agents, send each one its own message. Set reply_to to answer an existing message and keep the thread together. Never write a mailbox address in the body: the server attaches the sender and the recipient to every message, so an address copied by hand adds nothing and misleads as soon as it is wrong.",
         inputSchema: {
             type: "object",
             properties: {
-                to: {
-                    type: "array",
-                    items: { type: "string" },
-                    minItems: 1,
-                    description: "Recipient agent ids (mailbox addresses).",
-                },
-                cc: { type: "array", items: { type: "string" }, description: "Agents to keep in copy." },
+                to: { type: "string", description: "Recipient agent id (mailbox address). Exactly one recipient." },
                 subject: { type: "string", description: "Short subject line." },
-                body: { type: "string", description: "Message body, plain text or markdown." },
+                body: {
+                    type: "string",
+                    description: "Message body, plain text or markdown. Do not restate your own address or the recipient's here.",
+                },
                 priority: { type: "string", enum: [...PRIORITIES], description: "Defaults to normal." },
                 reply_to: { type: "string", description: "Id of the message being answered; the reply joins its thread." },
-                thread_title: {
+                thread_name: {
                     type: "string",
-                    description: "Plain-language name of the conversation, e.g. 'Résolution de l'échec du test de parsing'. Name the thread when you open it — you already know what it is about. On a reply it renames the thread for everyone, which is what you want when the discussion has drifted.",
+                    description: "Plain-language name of the conversation, e.g. 'Résolution de l'échec du test de parsing'. Name the thread when you open it — you already know what it is about. On a reply it renames the thread for everyone (same effect as rename_thread).",
                 },
                 thread_description: { type: "string", description: "Optional longer description of the thread." },
             },
@@ -210,13 +220,12 @@ export const TOOLS = [
 ];
 const schemas = {
     send_message: z.object({
-        to: z.union([z.string(), z.array(z.string()).min(1)]),
-        cc: z.union([z.string(), z.array(z.string())]).optional(),
+        to: z.string().min(1),
         subject: z.string().min(1),
         body: z.string().min(1),
         priority: z.enum(PRIORITIES).optional(),
         reply_to: z.string().optional(),
-        thread_title: z.string().trim().min(1).max(200).optional(),
+        thread_name: z.string().trim().min(1).max(200).optional(),
         thread_description: z.string().trim().min(1).max(2000).optional(),
     }),
     list_messages: z.object({
@@ -238,6 +247,24 @@ const schemas = {
     move_messages: z.object({ message_ids: z.array(z.string().min(1)).min(1), folder: z.string().min(1) }),
     delete_messages: z.object({ message_ids: z.array(z.string().min(1)).min(1), permanent: z.boolean().optional() }),
     attach_to_mailbox: z.object({ mailbox_id: z.string().trim().min(1).optional() }),
+    rename_mailbox: z
+        .object({
+        name: z.string().trim().min(1).max(200).optional(),
+        description: z.string().trim().min(1).max(2000).optional(),
+    })
+        .refine((v) => v.name !== undefined || v.description !== undefined, {
+        message: "provide `name` and/or `description`",
+    }),
+    rename_thread: z
+        .object({
+        thread_id: z.string().trim().min(1),
+        name: z.string().trim().min(1).max(200).optional(),
+        description: z.string().trim().min(1).max(2000).optional(),
+    })
+        .refine((v) => v.name !== undefined || v.description !== undefined, {
+        message: "provide `name` and/or `description`",
+    }),
+    // Ancien outil `set_label` : une seule entrée pour la boîte et le fil, `label` au lieu de `name`.
     set_label: z
         .object({
         label: z.string().trim().min(1).max(200).optional(),
@@ -273,9 +300,15 @@ export async function callTool(client, name, rawArgs) {
             const lines = [
                 `Mailbox address: ${client.agentId}`,
                 "  ↳ give this address to another agent so it can write to you.",
+                self?.agent_name
+                    ? `Agent: ${self.agent_name}`
+                    : "Agent: unnamed (set MESSENGER_AGENT_NAME in the MCP configuration)",
+                // Le nom vient de la configuration : toutes les sessions du projet le portent. Le
+                // dire ici évite qu'un agent prenne une session homonyme pour la sienne.
+                "  ↳ this name is shared with every session of the same project; only the address above identifies you.",
                 self?.display_name
                     ? `Mailbox name: ${self.display_name}`
-                    : "Mailbox name: none — call set_label so the user can tell this session apart from the others.",
+                    : "Mailbox name: none — call rename_mailbox so the user can tell this session apart from the others.",
             ];
             if (client.isAttachedElsewhere) {
                 lines.push(`Attached to another mailbox. This session's own mailbox is ${client.sessionAgentId}.`);
@@ -303,8 +336,9 @@ export async function callTool(client, name, rawArgs) {
             client.setAgentId(target.id);
             const attachedStats = await client.stats();
             return [
-                `Attached to mailbox ${target.id}${target.display_name ? ` (${target.display_name})` : ""}.`,
-                target.description ? `Description: ${target.description}` : null,
+                `Attached to mailbox ${target.id}${formatAgentNames(target) ? ` (${formatAgentNames(target)})` : ""}.`,
+                target.agent_description ? `Agent: ${target.agent_description}` : null,
+                target.description ? `Mailbox: ${target.description}` : null,
                 `Unread (excluding trash): ${attachedStats.unread_total}`,
                 client.sessionAgentId && client.sessionAgentId !== target.id
                     ? `This session's own mailbox remains ${client.sessionAgentId} — attach_to_mailbox with no argument goes back to it.`
@@ -313,29 +347,24 @@ export async function callTool(client, name, rawArgs) {
                 .filter(Boolean)
                 .join("\n");
         }
-        // `set_mailbox_label` n'est plus publié, mais reste accepté : une session en cours
-        // peut l'avoir appris avant la mise à jour du serveur.
+        case "rename_mailbox": {
+            const input = schemas.rename_mailbox.parse(args);
+            return renameMailbox(client, input.name ?? null, input.description ?? null);
+        }
+        case "rename_thread": {
+            const input = schemas.rename_thread.parse(args);
+            return renameThread(client, input.thread_id, input.name ?? null, input.description ?? null);
+        }
+        // `set_label` et `set_mailbox_label` ne sont plus publiés, mais restent acceptés : une
+        // session en cours peut les avoir appris avant la mise à jour du serveur. Le mot « label »
+        // faisait penser à une étiquette, alors qu'il s'agissait du nom.
         case "set_mailbox_label":
         case "set_label": {
             const input = schemas.set_label.parse(args);
             if (input.thread_id) {
-                const thread = await client.setThreadLabel(input.thread_id, {
-                    title: input.label ?? null,
-                    description: input.description ?? null,
-                });
-                return [
-                    `Thread ${thread.thread_id} is now named "${thread.title}".`,
-                    thread.description ? `Description: ${thread.description}` : null,
-                    "Every participant of the thread sees this name.",
-                ]
-                    .filter(Boolean)
-                    .join("\n");
+                return renameThread(client, input.thread_id, input.label ?? null, input.description ?? null);
             }
-            const agent = await client.updateProfile({
-                display_name: input.label ?? null,
-                description: input.description ?? null,
-            });
-            return `Mailbox ${agent.id} named "${agent.display_name}".`;
+            return renameMailbox(client, input.label ?? null, input.description ?? null);
         }
         case "list_threads": {
             const input = schemas.list_threads.parse(args);
@@ -347,41 +376,54 @@ export async function callTool(client, name, rawArgs) {
         case "list_agents": {
             const agents = await client.listAgents();
             if (agents.length === 0)
-                return "No agent registered yet on this server.";
-            return agents
+                return "No other agent on this server yet.";
+            const directory = agents
                 .map((agent) => {
-                const flags = [agent.id === client.agentId ? "you" : null, agent.registered ? null : "never connected"]
-                    .filter(Boolean)
-                    .join(", ");
-                const title = agent.display_name ? `${agent.id} — ${agent.display_name}` : agent.id;
+                const flags = agent.registered ? "" : "never connected";
+                const names = formatAgentNames(agent);
+                const title = names ? `${agent.id} — ${names}` : agent.id;
                 // L'annuaire est classé par cette date : l'afficher rend l'ordre lisible.
                 const seen = agent.last_activity_at ? `last active ${agent.last_activity_at}` : "never active";
-                return [`• ${title}${flags ? ` (${flags})` : ""}`, `  ${agent.description ?? "no description"}`, `  ${seen}`].join("\n");
+                return [
+                    `• ${title}${flags ? ` (${flags})` : ""}`,
+                    `  ${agent.agent_description ?? agent.description ?? "no description"}`,
+                    `  ${seen}`,
+                ].join("\n");
             })
                 .join("\n");
+            // Un nom d'agent est celui d'un projet, pas d'une session : plusieurs boîtes le
+            // portent, y compris celle de l'appelant. Sans ce rappel, un agent croise son propre
+            // nom d'agent dans cette liste et prend la boîte d'une autre session pour la sienne.
+            return [
+                directory,
+                "",
+                "Addresses identify sessions; agent names do not. Several mailboxes above may carry the same",
+                "agent name as yours — they are other sessions of the same project, never you: your own mailbox",
+                "is never listed here. Always write to an address taken from this list, never to a name.",
+            ].join("\n");
         }
         case "send_message": {
             const input = schemas.send_message.parse(args);
             const result = await client.sendMessage({
-                to: asArray(input.to),
-                cc: asArray(input.cc),
+                to: input.to,
                 subject: input.subject,
                 body: input.body,
                 priority: input.priority,
                 reply_to: input.reply_to ?? null,
-                thread_title: input.thread_title ?? null,
+                // Le protocole HTTP et le stockage gardent `thread_title` ; seul l'outil dit `thread_name`.
+                thread_title: input.thread_name ?? null,
                 thread_description: input.thread_description ?? null,
             });
             const lines = [
                 `Message sent: ${result.message_id}`,
                 `Thread: ${formatThreadRef(result.thread_title, result.thread_id)}`,
-                `Delivered to: ${result.delivered_to.join(", ")}`,
+                `Delivered to: ${result.delivered_to}`,
             ];
             if (!result.thread_title && !input.reply_to) {
-                lines.push("This thread has no name yet — set_label with its thread_id makes it readable for everyone.");
+                lines.push("This thread has no name yet — rename_thread with its thread_id makes it readable for everyone.");
             }
-            if (result.unknown_recipients.length > 0) {
-                lines.push(`Warning — never connected to this server, the message will wait in their mailbox: ${result.unknown_recipients.join(", ")}`);
+            if (result.unknown_recipient) {
+                lines.push(`Warning — ${result.delivered_to} has never connected to this server, the message will wait in their mailbox.`);
             }
             return lines.join("\n");
         }
@@ -497,10 +539,28 @@ export async function callTool(client, name, rawArgs) {
             throw new Error(`Unknown tool: ${name}`);
     }
 }
-function asArray(value) {
-    if (value === undefined)
-        return [];
-    return Array.isArray(value) ? value : [value];
+async function renameMailbox(client, name, description) {
+    const agent = await client.updateProfile({ display_name: name, description });
+    return [
+        `Mailbox ${agent.id} named "${agent.display_name}".`,
+        agent.agent_name ? `The agent name stays "${agent.agent_name}"; both are shown together.` : null,
+    ]
+        .filter(Boolean)
+        .join("\n");
+}
+/** `Agent · Boîte` : l'agent dit d'où l'on écrit, la boîte de quoi il est question. */
+function formatAgentNames(agent) {
+    return [agent.agent_name, agent.display_name].filter(Boolean).join(" · ");
+}
+async function renameThread(client, threadId, name, description) {
+    const thread = await client.setThreadLabel(threadId, { title: name, description });
+    return [
+        `Thread ${thread.thread_id} is now named "${thread.title}".`,
+        thread.description ? `Description: ${thread.description}` : null,
+        "Every participant of the thread sees this name.",
+    ]
+        .filter(Boolean)
+        .join("\n");
 }
 /** `titre (id)`, ou l'id seul tant que le fil n'a pas été nommé. */
 function formatThreadRef(title, threadId) {
@@ -523,7 +583,7 @@ function formatSummary(message) {
     const priority = message.priority === "normal" ? "" : ` [${message.priority}]`;
     return [
         `${flags} ${message.subject}${priority}`,
-        `   from ${message.from} to ${message.to.join(", ") || "—"}${message.cc.length ? ` (cc ${message.cc.join(", ")})` : ""} · ${message.created_at}`,
+        `   from ${message.from} to ${message.to || "—"} · ${message.created_at}`,
         `   ${message.preview}`,
         `   id ${message.message_id} · thread ${formatThreadRef(message.thread_title, message.thread_id)}`,
     ].join("\n");
@@ -532,8 +592,7 @@ function formatMessage(message) {
     const header = [
         `Subject: ${message.subject}`,
         `From: ${message.from}`,
-        `To: ${message.to.join(", ") || "—"}`,
-        message.cc.length ? `Cc: ${message.cc.join(", ")}` : null,
+        `To: ${message.to || "—"}`,
         `Date: ${message.created_at}`,
         `Priority: ${message.priority}`,
         `Folder: ${message.folder}${message.read ? "" : " (unread)"}${message.starred ? " ★" : ""}`,

package/dist/src/server/app.js

@@ -14,15 +14,20 @@ import { logger } from "../logger.js";
 const UI_DIR = path.join(path.dirname(fileURLToPath(import.meta.url)), "ui");
 const agentIdSchema = z.string().trim().min(1).max(128);
 const idListSchema = z.array(z.string().trim().min(1)).min(1).max(200);
-const registerSchema = z.object({
+/** Nom et description de la boîte : ce que l'agent pose lui-même sur sa session. */
+const mailboxProfileSchema = z.object({
     display_name: z.string().trim().max(200).nullish(),
     description: z.string().trim().max(2000).nullish(),
+});
+const registerSchema = mailboxProfileSchema.extend({
+    /** Identité de l'agent (le projet, typiquement) : vient de la configuration, pas de l'agent. */
+    agent_name: z.string().trim().max(200).nullish(),
+    agent_description: z.string().trim().max(2000).nullish(),
     /** true = l'adresse doit être inconnue du serveur (allocation d'une boîte neuve). */
     fresh: z.boolean().optional(),
 });
 const sendSchema = z.object({
-    to: z.union([agentIdSchema, z.array(agentIdSchema).min(1)]),
-    cc: z.union([agentIdSchema, z.array(agentIdSchema)]).optional(),
+    to: agentIdSchema,
     subject: z.string().min(1).max(500),
     body: z.string().min(1).max(200_000),
     priority: z.enum(PRIORITIES).optional(),
@@ -191,16 +196,21 @@ export function createApp({ store, config }) {
         }
         const agent = store.ensureAgent(req.agentId, {
             registered: true,
+            agent_name: input.agent_name ?? null,
+            agent_description: input.agent_description ?? null,
+            // Un client antérieur à la séparation agent / boîte n'envoie que ces deux-là.
             display_name: input.display_name ?? null,
             description: input.description ?? null,
         });
         res.json({ agent });
     });
-    api.get("/agents", (_req, res) => {
-        res.json({ agents: store.listAgents() });
+    // L'agent ne se voit pas dans son propre annuaire : sa boîte est la seule interdite d'envoi.
+    api.get("/agents", (req, res) => {
+        res.json({ agents: store.listAgents(req.agentId) });
     });
+    // Ne touche qu'à la boîte : l'identité de l'agent ne se renomme pas depuis une session.
     api.patch("/agents/me", (req, res) => {
-        const input = registerSchema.parse(req.body ?? {});
+        const input = mailboxProfileSchema.parse(req.body ?? {});
         res.json({
             agent: store.ensureAgent(req.agentId, {
                 registered: true,
@@ -222,8 +232,7 @@ export function createApp({ store, config }) {
         const input = sendSchema.parse(req.body ?? {});
         const result = store.sendMessage({
             from: req.agentId,
-            to: toArray(input.to),
-            cc: toArray(input.cc),
+            to: input.to,
             subject: input.subject,
             body: input.body,
             priority: input.priority,
@@ -231,7 +240,7 @@ export function createApp({ store, config }) {
             thread_title: input.thread_title ?? null,
             thread_description: input.thread_description ?? null,
         });
-        logger.info(`message ${result.message_id}: ${req.agentId} -> ${result.delivered_to.join(", ")}`);
+        logger.info(`message ${result.message_id}: ${req.agentId} -> ${result.delivered_to}`);
         res.status(201).json(result);
     });
     api.get("/messages", (req, res) => {
@@ -337,11 +346,6 @@ export function createApp({ store, config }) {
     });
     return app;
 }
-function toArray(value) {
-    if (value === undefined)
-        return [];
-    return Array.isArray(value) ? value : [value];
-}
 /**
  * Exige un jeton connu du serveur sur toute requête entrante.
  *