@paigy/mcp 0.10.4 → 0.11.0

package/dist/{chunk-UWM2Q4DJ.js → chunk-CGEKDPQW.js}

@@ -103,22 +103,14 @@ var ScheduleCallbackSchema = z.object({
 });
 var PendingRepliesSchema = z.object({
   replies: z.array(
-    z.object({
-      threadId: z.string(),
-      notificationId: z.string(),
-      answer: UserAnswerSchema,
-      /** True if this reply was already claimed on a prior check_replies/await_reply —
-       *  re-surfaced because includeRecent recovered it (e.g. after an unexpected
-       *  restart). You may have already acted on it; check before repeating a
-       *  side-effecting response. */
-      redelivered: z.boolean().optional()
-    })
+    z.object({ threadId: z.string(), notificationId: z.string(), answer: UserAnswerSchema })
   ),
   pending: z.array(
     z.object({ threadId: z.string(), notificationId: z.string(), createdAt: z.string() })
   ),
   /** User-initiated requests addressed to this agent; act on them and reply via
-   *  notify_user on the same threadId. Each is returned once (claimed on read). */
+   *  notify_user on the same threadId. Keeps reappearing until you call
+   *  set_task_state on its notificationId. */
   requests: z.array(
     z.object({ threadId: z.string(), notificationId: z.string(), text: z.string(), createdAt: z.string() })
   ),
@@ -400,10 +392,9 @@ async function awaitReply(notificationId, opts = {}) {
     await doSleep(intervalMs);
   }
 }
-async function checkReplies(includeRecent = false) {
+async function checkReplies() {
   const token = loadToken();
-  const qs = includeRecent ? "?includeRecent=true" : "";
-  const res = ensureAuthed(await reach(`${BACKEND_URL}/api/pending${qs}`, {
+  const res = ensureAuthed(await reach(`${BACKEND_URL}/api/pending`, {
     headers: { authorization: `Bearer ${token}` }
   }));
   if (!res.ok) throw new Error(`check_replies failed: ${res.status} ${await res.text()}`);

package/dist/index.js

@@ -8,7 +8,7 @@ import {
   scheduleCallback,
   setTaskState,
   submitNotification
-} from "./chunk-UWM2Q4DJ.js";
+} from "./chunk-CGEKDPQW.js";
 import {
   deleteToken,
   openBrowser,
@@ -61,11 +61,6 @@ function json(s) {
 var AwaitReplySchema = z.object({
   notificationId: z.string().describe("The notificationId returned by notify_user \u2014 waits for the user's reply to THIS notification only.")
 });
-var CheckRepliesSchema = z.object({
-  includeRecent: z.boolean().optional().describe(
-    "Set true only if you just unexpectedly restarted/reconnected and might have already claimed a reply without acting on it (that reply won't show up again otherwise \u2014 claims are one-time). Re-includes replies from the last ~10 min, marked redelivered:true so you can tell they may be duplicates. Leave false/omitted for normal use."
-  )
-});
 var PairSchema = z.object({
   device_code: z.string().optional().describe("Omit to start pairing (returns an approval link to show the user). Pass the device_code from that first call to finish, once the user has approved.")
 });
@@ -120,12 +115,12 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
     },
     {
       name: "check_replies",
-      description: "The catch-up sweep for everything you haven't consumed yet: returns answers to notifications you sent that you haven't seen (now marked seen), your still-pending notifications, and `requests` \u2014 new requests the user started toward you (each { notificationId, threadId, text }, returned once). Act on each request and reply with notify_user on the SAME threadId. Use it when booting up / starting a session, or when you've been waiting a long time on something else, to discover acks or work you're unaware of. To wait on an answer to a notify_user call you just made, use await_reply instead. Also returns owedCallbacks: callbacks now due that you promised \u2014 fulfill each with notify_user on its threadId. Also returns `stalled`: work (either direction) that got reported in_progress via set_task_state a while ago and never reported completed \u2014 likely left half-done by this session or a prior one that crashed or went idle. For each, either continue the work and report a real state, or investigate why it stalled. Pass includeRecent:true only right after an unexpected restart, to recover a reply you may have claimed but not acted on.",
-      inputSchema: json(CheckRepliesSchema)
+      description: "The catch-up sweep for everything outstanding \u2014 a PURE read, takes no arguments, safe to call as often as you like: nothing here is consumed by reading it. Returns `replies` (answers to notifications you sent), your still-pending notifications, and `requests` \u2014 requests the user started toward you (each { notificationId, threadId, text }). Each keeps reappearing on every call until you actually engage with it: call set_task_state on its notificationId, which is what claims/acknowledges it \u2014 a human-initiated reply or request must never be silently dropped just because you read the list without acting. Use check_replies when booting up / starting a session, or when you've been waiting a long time on something else. To wait on an answer to a notify_user call you just made, use await_reply instead. Also returns owedCallbacks: callbacks now due that you promised \u2014 fulfill each with notify_user on its threadId. Also returns `stalled`: work (either direction) you reported in_progress via set_task_state a while ago and never reported completed \u2014 likely left half-done by this session or a prior one that crashed or went idle. For each, either continue the work and report a real state, or investigate why it stalled.",
+      inputSchema: json(z.object({}))
     },
     {
       name: "set_task_state",
-      description: "Report progress on the follow-up work behind ANY notification you own \u2014 a user-initiated request (from check_replies), or your OWN notify_user question once await_reply/check_replies returns its answer and you start acting on it. Pass that notificationId. States: in_progress (you started working), completed (done), or needs_input (you need more from the user \u2014 usually paired with a notify_user carrying parentId = the same notificationId you're reporting on). Calling this reliably is what lets a future session's check_replies surface `stalled` work you (or a crashed/idle prior session) left at in_progress without ever reporting completed.",
+      description: "Report progress on the follow-up work behind ANY notification you own \u2014 a user-initiated request (from check_replies), or your OWN notify_user question once await_reply/check_replies returns its answer and you start acting on it. Pass that notificationId. THIS is what actually claims/acknowledges a reply or request \u2014 check_replies is a pure read that never consumes anything on its own, so call this as soon as you start engaging with something it returned; otherwise that same item just keeps reappearing forever. States: in_progress (you started working), completed (done), or needs_input (you need more from the user \u2014 usually paired with a notify_user carrying parentId = the same notificationId you're reporting on). Calling this reliably is also what lets a future session's check_replies surface `stalled` work you (or a crashed/idle prior session) left at in_progress without ever reporting completed.",
       inputSchema: json(SetTaskStateToolSchema)
     },
     {
@@ -226,8 +221,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       return { content: [{ type: "text", text: JSON.stringify(item) }] };
     }
     case "check_replies": {
-      const { includeRecent } = CheckRepliesSchema.parse(request.params.arguments ?? {});
-      const result = await checkReplies(includeRecent);
+      const result = await checkReplies();
       return { content: [{ type: "text", text: JSON.stringify(result) }] };
     }
     case "set_task_state": {

package/dist/listen.js

@@ -4,7 +4,7 @@ import {
   checkReplies,
   registerDelivery,
   wakeChannel
-} from "./chunk-UWM2Q4DJ.js";
+} from "./chunk-CGEKDPQW.js";
 import "./chunk-GU7C5H6L.js";
 
 // src/listen.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@paigy/mcp",
-  "version": "0.10.4",
+  "version": "0.11.0",
   "description": "Paigy MCP server — a voice inbox for your AI agents. Lets an agent notify a user and await their reply.",
   "license": "MIT",
   "type": "module",