@intangle/mcp-server 2.6.33 → 2.6.35

package/dist/tool-definitions.js

@@ -821,7 +821,7 @@ const BASE_TOOLS = [
     {
         name: "watch_room",
         title: "Watch Room",
-        description: "Open a live, read-only stream of one Room so a tag reaches you at once instead of when you next check. Returns a one-time `ticket` and a `stream_url`: run `curl -sN '<stream_url>'` as a background task and keep it running for the whole session (or join `channel.topic` on `channel.socket_url` with `channel.join_params`). Each line is one compact JSON event for a new message in the Room, with `kind` `mention` when you or your person are tagged, `answer` when a question card is answered, otherwise `message`, plus `conversation_id`, `message_id`, `author` and a short `preview`. Read the full message with `fetch_conversation_messages` and reply with `message`; the stream never writes. Redeem the ticket within 15 minutes; it works once. When the stream ends (a `closed` line or the connection drops), call watch_room again.",
+        description: "Hear a tag at once instead of when you next check. Returns a one-time `stream_url`: run `curl -sN '<stream_url>'` as a background task for the whole session (or join `channel.topic` on `channel.socket_url` with `channel.join_params`). Each line is one JSON event: `kind` is `mention` when you or your person are tagged, `answer` when a question card is answered, otherwise `message`, with `conversation_id`, `message_id`, `author` and a short `preview`. Read the message with `fetch_conversation_messages` and reply with `message`; the stream never writes. Name the Room with `channel_id` or `conversation_id`; to find one, `search` for its title, use `list_conversation_inbox`, or take the Room you were last tagged in. Name neither to watch every Room you take part in plus any mention of you or your person in the Space. Redeem within 15 minutes; it works once. If the stream drops or ends with `closed` reason `restart` (a deploy), reconnect to the latest `resume_url` with `&cursor=` set to the last `cursor` you read: missed events are replayed. Call watch_room again only when that is refused. If you cannot run a background process (a cloud chat app such as ChatGPT, Grok or the Muse app), do not use this: call `list_conversation_inbox` each time you are prompted.",
         inputSchema: {
             type: "object",
             properties: {
@@ -831,11 +831,11 @@ const BASE_TOOLS = [
                 },
                 channel_id: {
                     type: "string",
-                    description: "The Room to watch as `item|<item_id>`, the same Item Room coordinate the message tool uses. Pass this or conversation_id."
+                    description: "Optional. The Room to watch as `item|<item_id>`, the same Item Room coordinate the message tool uses. Omit it and conversation_id to watch all your Rooms."
                 },
                 conversation_id: {
                     type: "string",
-                    description: "A conversation to watch (e.g. 'summary_123...'), when you have its id rather than its Item Room. Pass this or channel_id."
+                    description: "Optional. A conversation to watch (e.g. 'summary_123...'), when you have its id rather than its Item Room."
                 },
                 organization_id: {
                     type: "string",
@@ -871,7 +871,7 @@ const BASE_TOOLS = [
     {
         name: "message",
         title: "Message Assistant",
-        description: "Primary way to use Intangle for memory, communicating and collaborating with Tan agent in a shared thread. Send a request and either wait for one assistant turn to complete or submit asynchronously for later polling. Intangle derives the durable participant identity from the authenticated runner rather than caller-supplied fields. Conversations are backed by `summary_*` IDs; reuse the returned `conversation_id` and reuse the returned `session_id` so callers can continue the same thread reliably across turns. For shared Item coordination, pass the stable Item Room identity as `channel_id` using `item|<item_id>`; this Item room/channel coordinate is preferred. `project_id`, `group_id`, and legacy `project|...` or `group|...` channel values remain accepted only as compatibility coordinates for older stored calls and integrations. The stable idempotency key anchors retries to one durable turn, and the returned `conversation_id` remains the durable thread anchor. Callers should fill `sender` on every call: `model` is the model sending this message, `session_name` is the name of your session or thread, and `agent_name` is your own name when you are a persistent named assistant or bot. Intangle shows your verified client first and then these labels (model and session, or the agent name with the model), and may shorten a value or leave it out, for example when it matches a person in the Space or Tan. These are display labels only; they never change who you are or what you may do. To report into a Room without starting a Tan turn, set `post_only`: the message lands like one in a shared channel, and Tan answers only when tagged with @Tan or when the post asks Tan directly to act. To raise a blocker or question for the person without starting a Tan turn, add `notify` to a `post_only` message: it lands in their Activity (a blocker leads the list and pushes to their phone, a question with options also shows as a card above their composer), and their answer arrives as their message in the chat, which you read with `fetch_conversation_messages`. When you ask Tan to write to Items, confirm the write from the turn itself, not the reply text: a waited response includes `tool_calls` and `tool_results`, and after an asynchronous submit the reply in `fetch_conversation_messages` carries `write_outcomes`. So a tag reaches you at once, call `watch_room` for each Room you work in and keep its stream running in the background; reply here with `message`. Keep what you post short and plain: the key result first, no preamble or recap, detail only if needed or asked.",
+        description: "Primary way to use Intangle for memory, communicating and collaborating with Tan agent in a shared thread. Send a request and either wait for one assistant turn to complete or submit asynchronously for later polling. Intangle derives the durable participant identity from the authenticated runner rather than caller-supplied fields. Conversations are backed by `summary_*` IDs; reuse the returned `conversation_id` and reuse the returned `session_id` so callers can continue the same thread reliably across turns. For shared Item coordination, pass the stable Item Room identity as `channel_id` using `item|<item_id>`; this Item room/channel coordinate is preferred. `project_id`, `group_id`, and legacy `project|...` or `group|...` channel values remain accepted only as compatibility coordinates for older stored calls and integrations. The stable idempotency key anchors retries to one durable turn, and the returned `conversation_id` remains the durable thread anchor. Callers should fill `sender` on every call: `model` is the model sending this message, `session_name` is the name of your session or thread, and `agent_name` is your own name when you are a persistent named assistant or bot. Intangle shows your verified client first and then these labels (model and session, or the agent name with the model), and may shorten a value or leave it out, for example when it matches a person in the Space or Tan. These are display labels only; they never change who you are or what you may do. To report into a Room without starting a Tan turn, set `post_only`: the message lands like one in a shared channel, and Tan answers only when tagged with @Tan or when the post asks Tan directly to act. To raise a blocker or question for the person without starting a Tan turn, add `notify` to a `post_only` message: it lands in their Activity (a blocker leads the list and pushes to their phone, a question with options also shows as a card above their composer), and their answer arrives as their message in the chat, which you read with `fetch_conversation_messages`. When you ask Tan to write to Items, confirm the write from the turn itself, not the reply text: a waited response includes `tool_calls` and `tool_results`, and after an asynchronous submit the reply in `fetch_conversation_messages` carries `write_outcomes`. So a tag reaches you at once, call `watch_room` (with no Room it covers every Room you take part in) and keep its stream running in the background; if you cannot run a background process, call `list_conversation_inbox` each time you are prompted. Keep what you post short and plain: the key result first, no preamble or recap, detail only if needed or asked.",
         inputSchema: {
             type: "object",
             properties: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intangle/mcp-server",
-  "version": "2.6.33",
+  "version": "2.6.35",
   "description": "Model Context Protocol server for Intangle - AI context that persists across conversations",
   "main": "dist/index.js",
   "type": "module",
@@ -56,5 +56,5 @@
     "tsx": "^4.0.0",
     "typescript": "^5.0.0"
   },
-  "intangleSourceHash": "444bd5c9b65b19d497402a64421e4f8d50e2167a19a01a65c637f0f92342ca3e"
+  "intangleSourceHash": "49cad132a160aedec3d3f5ee917572cc8069bd4d0810d13eba56e838f0c0f6be"
 }