fmsg-mcp

Send new fmsg message

send_message

Destructive

Send a new immutable message immediately to start a thread with Markdown body and optional attachments; use reply to continue an existing conversation.

Instructions

Send a new message immediately, starting a new thread. fmsg messages are immutable: once sent they cannot be edited or recalled. Send within the user's requested task or authorized automation. Recipients may be full @user@domain addresses or resolvable short names. The body is Markdown by default. Secrets are redacted. If the host rejects the message its reason is returned verbatim. To continue an existing conversation use reply instead. Files: data_text for text, data_base64 for small files; add sha256 when you can. Send files as they are; fmsg compresses them.

Input Schema

TableJSON Schema

Name	Required	Description	Default
`to`	Yes	recipient addresses (@user@domain) or short names
`body`	Yes	message body; Markdown unless type says otherwise
`type`	No	body media type	text/markdown; charset=utf-8
`topic`	Yes	thread topic (subject) — immutable once sent
`no_reply`	No	ask recipients (and their agents) not to reply
`important`	No	mark as important for recipients
`attachments`	No	files

Output Schema

TableJSON Schema

Name	Required	Description
`id`	Yes
`to`	Yes
`from`	Yes
`hint`	No	for you, not the user: a better way to do this next time
`time`	Yes
`topic`	Yes
`redacted`	No	the kinds of secret replaced, such as github_token; empty when none
`resolved`	No	short names and how they resolved, when any were given; confirm with the user if an address looks wrong
`warnings`	Yes	things to tell the user, such as redacted secrets or resolved short names
`parent_id`	Yes
`redactions`	Yes	secrets replaced with placeholders before sending
`attachments`	Yes	sorted by filename, the same order in every tool
`thread_topic`	No	the thread's topic: the topic sent for a new message; for a reply, the thread root's topic, or null when the root is not visible

Schema Changelog

Changes observed during successful MCP inspections.

Changed20 schema fields changedv1.1.0Oct 15, 2026

addedInput schema / additionalProperties
```
Added value: +false
```
addedInput schema / properties / attachments / description
```
Added value: +"files"
```
addedInput schema / properties / attachments / items / additionalProperties
```
Added value: +false
```
addedInput schema / properties / attachments / items / properties / content_type / description
```
Added value: +"inferred from the filename when omitted"
```
addedInput schema / properties / attachments / items / properties / data_base64 / description
```
Added value: +"base64 file contents, for small files. The host sets the size limit"
```
removedInput schema / properties / attachments / items / properties / data_base64 / minLength
```
Removed value: -1
```

addedInput schema / properties / attachments / items / properties / data_text

Added value: +{
+  "description": "text file contents, sent as UTF-8 bytes; use instead of data_base64 for text",
+  "type": "string"
+}

addedInput schema / properties / attachments / items / properties / filename / description
```
Added value: +"file name"
```

addedInput schema / properties / attachments / items / properties / sha256

Added value: +{
+  "description": "hex sha256 of the file; the attachment is refused, and nothing sent, if the bytes differ. Give it when you can compute it",
+  "pattern": "^[0-9A-Fa-f]{64}$",
+  "type": "string"
+}

changedInput schema / properties / attachments / items / required

Previous value: -[
-  "filename",
-  "data_base64"
-]New value: +[
+  "filename"
+]

addedInput schema / properties / important / description
```
Added value: +"mark as important for recipients"
```
changedOutput schema / additionalProperties
```
Previous value: -falseNew value: +{}
```

addedOutput schema / properties / attachments / description

Added value: +"sorted by filename, the same order in every tool"

changedOutput schema / properties / attachments / items / additionalProperties
```
Previous value: -falseNew value: +{}
```

addedOutput schema / properties / attachments / items / properties / type

Added value: +{
+  "description": "media type; inferred from the filename when the host records none",
+  "type": "string"
+}

addedOutput schema / properties / hint

Added value: +{
+  "description": "for you, not the user: a better way to do this next time",
+  "type": "string"
+}

addedOutput schema / properties / redacted

Added value: +{
+  "description": "the kinds of secret replaced, such as github_token; empty when none",
+  "items": {
+    "type": "string"
+  },
+  "type": "array"
+}

addedOutput schema / properties / resolved

Added value: +{
+  "description": "short names and how they resolved, when any were given; confirm with the user if an address looks wrong",
+  "items": {
+    "additionalProperties": {},
+    "properties": {
+      "address": {
+        "type": "string"
+      },
+      "input": {
+        "type": "string"
+      }
+    },
+    "type": "object"
+  },
+  "type": "array"
+}

addedOutput schema / properties / thread_topic

Added value: +{
+  "description": "the thread's topic: the topic sent for a new message; for a reply, the thread root's topic, or null when the root is not visible",
+  "type": [
+    "string",
+    "null"
+  ]
+}

addedOutput schema / properties / warnings / description

Added value: +"things to tell the user, such as redacted secrets or resolved short names"

First observedv0.1.3Sep 5, 2026

TDQS

A4.9/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare destructiveHint=true, idempotentHint=false and openWorldHint=true, but the description goes well beyond them: messages are immutable and cannot be edited or recalled, secrets are redacted, and host rejections are returned verbatim. The immutability and redaction notes are exactly the kind of consequence detail the hints cannot convey.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Six sentences, each carrying distinct information — immutability, authorization scope, addressing, body format, redaction, rejection behavior, sibling routing, and attachment handling. The core action and its irreversibility are front-loaded with no filler.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

An output schema exists, so return values and delivery errors need no explanation here. Combined with full schema coverage and strong annotations, the description supplies everything an agent needs: irreversibility, the sha256 abort condition, addressing flexibility, and the routing rule to reply.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, so the baseline is 3, but the description adds real operational meaning: recipients may be short names, body is Markdown by default, use data_text vs data_base64 by size, and supply sha256 when computable because mismatched bytes abort the whole send. It also notes fmsg compresses files, so callers need not pre-compress, which the schema does not say.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource ('Send a new message immediately, starting a new thread') and explicitly distinguishes itself from the sibling tool that handles continuations ('To continue an existing conversation use reply instead'). An agent can differentiate send_message from reply, send_draft, and create_draft without opening any schema.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Gives an explicit authorization boundary ('Send within the user's requested task or authorized automation') and names the alternative with the condition that selects it ('To continue an existing conversation use reply instead'). This is the when/when-not/alternative pattern at full strength.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Deploy Server