@intangle/mcp-server 2.6.26 → 2.6.27

package/dist/tool-definitions.js

@@ -836,7 +836,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. 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`.",
+        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`.",
         inputSchema: {
             type: "object",
             properties: {
@@ -892,6 +892,54 @@ const BASE_TOOLS = [
                     type: "boolean",
                     description: "Optional. Set true to post into the chat like a message in a shared channel: it is saved, shown live with your sender labels and marked unread for the people in the chat, and Tan does not reply. Tan still answers when the content tags @Tan, or when Intangle judges that the post asks Tan directly to answer or act. A post that Tan did not answer returns status posted with its conversation_id and message_id. Use it for status reports, results and questions meant for people."
                 },
+                notify: {
+                    type: "object",
+                    description: "Optional, and only with post_only: true. Raises something for the person in Intangle with no Tan turn. A blocker is something they must do before you can continue (create a key, finish a sign-in): it leads their Activity until they resolve it and sends a push to their phone. A question needs their answer: it appears in Activity and, when you give 2 to 4 options, as a card above their composer in this chat. Their answer is posted into this chat as their own message and starts no Tan turn, so read it with fetch_conversation_messages on the conversation_id of the response. The response carries notify.status raised and the Activity entry id. A post with notify never starts a Tan turn, even if it tags @Tan. Use it only for what a person must act on.",
+                    properties: {
+                        kind: {
+                            type: "string",
+                            enum: [
+                                "blocker",
+                                "question"
+                            ],
+                            description: "blocker: you cannot continue until they act. question: you need their choice or answer."
+                        },
+                        title: {
+                            type: "string",
+                            description: "Required. One line saying what they must do or answer, up to 120 characters. For a question this is the question itself."
+                        },
+                        body: {
+                            type: "string",
+                            description: "Optional. Why it matters and what you need, up to 1000 characters."
+                        },
+                        options: {
+                            type: "array",
+                            minItems: 2,
+                            maxItems: 4,
+                            description: "Optional, for a question only. 2 to 4 different answers, your recommendation first, shown as buttons on the card. The person can always answer in their own words.",
+                            items: {
+                                type: "object",
+                                properties: {
+                                    label: {
+                                        type: "string",
+                                        description: "A short answer."
+                                    },
+                                    description: {
+                                        type: "string",
+                                        description: "What choosing it leads to, in one line."
+                                    }
+                                },
+                                required: [
+                                    "label"
+                                ]
+                            }
+                        }
+                    },
+                    required: [
+                        "kind",
+                        "title"
+                    ]
+                },
                 client_turn_id: {
                     type: "string",
                     description: "Optional caller correlation value. Phoenix derives the durable turn identity from idempotency_key and scopes it by the verified user, graph, Space, preferred Item room/channel, any legacy Project/Group compatibility coordinates, and the stable retry key."

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intangle/mcp-server",
-  "version": "2.6.26",
+  "version": "2.6.27",
   "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": "f97c002f142e2884a2dcdafeb760c8524603ff55081c6b2ccd54fc7d497e600b"
+  "intangleSourceHash": "aa932047ede13c15cbec0476f11759b0636e482dc4596f38517457b06d6f78d0"
 }