Update messages

PATCH /v1/team/messages/{id}

Team → · All API references → · Get started →


Address	`https://api.hanzo.ai/v1/team/messages/{id}`
Method	`PATCH`
Operation	`patch_team_messages_by_id`
Auth	`Authorization: Bearer $HANZO_API_KEY`

Rewrites what a message says. Only its author may edit it.

The edit is an ordinary update of the message document through the Team client's own write path, stamped with editedOn, so an open client shows the new text and the "edited" mark live. Somebody the new text mentions for the first time is notified.

Request

4 fields, body application/json (required).

Field	In	Type	Required	Description
`id`	path	string	yes	ID is the message, from the path.
`id`	body	string	—	ID is the message, from the path.
`space`	body	string	—	Space names the space holding it.
`text`	body	string	—	Text is the message's new text, with the same `<@account-uuid>` mentions a new message takes.

Response

Status	Body	Meaning
`200`	team.teamMessage	ok
`default`	problem-details	refused

200 body — 21 fields.

Field	In	Type	Always	Description
`author`	body	string	—	Author is the team account uuid that wrote it.
`createdOn`	body	integer (int64)	—	CreatedOn is unix MILLIseconds, which is what the platform stamps.
`doc`	body	string	—	Doc is the document this message is a comment on.
`editedOn`	body	integer (int64)	—	EditedOn is when the author last edited the message, unix milliseconds.
`files`	body	team.teamFile[]	—	Files are the files attached to the message.
`files[].file`	body	string	—	File is the blob id, readable at GET /v1/team/files/{space}/{name}?file={file}.
`files[].id`	body	string	—	ID is the attachment document's own id.
`files[].name`	body	string	—	Name is the file's name as the person uploaded it.
`files[].size`	body	integer (int64)	—	Size is the file's length in bytes, as the uploader stated it.
`files[].type`	body	string	—	Type is the media type the uploader declared.
`id`	body	string	—	ID is the message document's own id.
`lastReply`	body	integer (int64)	—	LastReply is when the thread was last answered, unix milliseconds.
`mentions`	body	string[]	—	Mentions are the account uuids the message @-mentions — exactly the people notify.go told they were mentioned.
`reactions`	body	team.teamReaction[]	—	Reactions are the emoji people reacted with, one entry per emoji, in the order each emoji was first used.
`reactions[].accounts`	body	string[]	—	Accounts are the account uuids that reacted with it, earliest first.
`reactions[].count`	body	integer (int64)	—	Count is how many people reacted with it.
`reactions[].emoji`	body	string	—	Emoji is the reaction itself, as the person picked it.
`replies`	body	integer (int64)	—	Replies is how many replies the message's thread holds.
`room`	body	string	—	Room is the room it was said in — the same id the room listing answers with, so a caller holding a message can name its room without a second read.
`text`	body	string	—	Text is the message as PLAIN TEXT.
`thread`	body	string	—	Thread is the message this one replies to.

Failure carries the platform error shape — see Errors.

Examples

hanzo has no subcommand for this operation — the CLI serves only what cloud's live route table confirms. Use HTTP or an SDK.

import { Configuration, TeamApi } from 'hanzoai';

const api = new TeamApi(new Configuration({ accessToken: process.env.HANZO_API_KEY }));
const { data } = await api.patchTeamMessagesById({ id: 'id', id: "<id>", space: "<space>" });

from hanzoai.cloud import ApiClient, Configuration
from hanzoai.cloud.api import TeamApi

client = ApiClient(Configuration(access_token=os.environ["HANZO_API_KEY"]))
result = TeamApi(client).patch_team_messages_by_id(id='id', id="<id>", space="<space>")

cfg := hanzoai.NewConfiguration()
cfg.AddDefaultHeader("Authorization", "Bearer "+os.Getenv("HANZO_API_KEY"))
client := hanzoai.NewAPIClient(cfg)

resp, _, err := client.TeamAPI.PatchTeamMessagesById(context.Background()).Execute()
if err != nil {
	return err
}

use hanzo_client::apis::{configuration::Configuration, team_api};

let mut cfg = Configuration::new();
cfg.bearer_access_token = std::env::var("HANZO_API_KEY").ok();

let result = team_api::patch_team_messages_by_id(&cfg, Default::default()).await?;

import ai.hanzo.cloud.ApiClient;
import ai.hanzo.cloud.api.TeamApi;

ApiClient client = new ApiClient();
client.setBearerToken(System.getenv("HANZO_API_KEY"));

var result = new TeamApi(client).patchTeamMessagesById();

The method above is the one at the current release of the document. [email protected] (npm) and [email protected] (PyPI) were generated from an earlier release, where this operation carried a different id, so it spells the method differently — regenerating the clients is what makes the two agree. SDKs →

curl -X PATCH https://api.hanzo.ai/v1/team/messages/<id> \
  -H "Authorization: Bearer $HANZO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
       "id": "<id>",
       "space": "<space>"
     }'

MCP reaches team through the team tool, which names its 18 operations with its own verbs — this one among them, under a name only MCP declares. describe explains any of them:

curl -X POST https://api.hanzo.ai/v1/mcp \
  -H "Content-Type: application/json" \
  -d '{
       "jsonrpc": "2.0",
       "id": 1,
       "method": "tools/call",
       "params": {
         "name": "describe",
         "arguments": {
           "op": "get_collaborator"
         }
       }
     }'

Team API · All Hanzo APIs · Interactive reference

Request

Response

Examples

On this page