propline-mcp 0.32.0 → 0.34.0

package/README.md

@@ -53,7 +53,7 @@ The model uses these tools transparently:
 
 ## Hosted endpoint (no install)
 
-The same 25 tools are served over **Streamable HTTP** at
+The same 27 tools are served over **Streamable HTTP** at
 
 ```
 https://mcp.prop-line.com/mcp
@@ -90,6 +90,8 @@ npx -y propline-mcp
 
 Your agent can immediately pull live odds, scores, and stats. The demo key is free-tier and shared — paid features (resolution, +EV, history, exports) return a redacted teaser, and limits are pooled across everyone. For full access and your own limits, set `PROPLINE_API_KEY` (below). Get a free personal key at [prop-line.com](https://prop-line.com/?ref=mcp).
 
+While the demo key is in use, every tool result carries a second content block noting the pooling and redaction, so the assistant can explain an empty field or a 429 accurately. It disappears the moment you set your own key.
+
 ## Install (with your own key)
 
 ### 1. Get a PropLine API key
@@ -116,7 +118,7 @@ Edit `~/Library/Application Support/Claude/claude_desktop_config.json` (macOS) o
 }
 ```
 
-Restart Claude Desktop. The hammer icon should show 25 PropLine tools. (Or skip the install and add `https://mcp.prop-line.com/mcp` as a custom connector — see the hosted endpoint above.)
+Restart Claude Desktop. The hammer icon should show 27 PropLine tools. (Or skip the install and add `https://mcp.prop-line.com/mcp` as a custom connector — see the hosted endpoint above.)
 
 #### Claude Code
 

package/dist/http.js

@@ -280,26 +280,40 @@ var PropLineClient = class {
       before_id: opts.beforeId
     });
   }
+  replayWebhookEvents(webhookId, opts = {}) {
+    return this.request(`/v1/webhooks/${webhookId}/replay`, {
+      since_seq: opts.sinceSeq,
+      limit: opts.limit
+    });
+  }
 };
 
 // src/server.ts
-var VERSION = "0.32.0";
+var VERSION = "0.34.0";
 var DEMO_KEY = "be2b8487fcfacb1fbc292a8aa925a84c";
 var apiKey = process.env.PROPLINE_API_KEY;
 var baseUrl = process.env.PROPLINE_BASE_URL;
+var usingDemoKey = !apiKey;
 var requestClient = new AsyncLocalStorage();
-function withClient(c, fn) {
-  return requestClient.run(c, fn);
+function withClient(c, demo, fn) {
+  return requestClient.run({ client: c, demo }, fn);
 }
 var _client = null;
 function client() {
   const scoped = requestClient.getStore();
-  if (scoped) return scoped;
+  if (scoped) return scoped.client;
   if (!_client) {
     _client = new PropLineClient({ apiKey: apiKey ?? DEMO_KEY, baseUrl });
   }
   return _client;
 }
+function demoKeyNote() {
+  const scoped = requestClient.getStore();
+  const demo = scoped ? scoped.demo : usingDemoKey;
+  if (!demo) return null;
+  const ref = scoped ? "mcp-hosted" : "mcp";
+  return `Note for the assistant (not part of the data): this call used PropLine's shared demo key. Paid fields (prop resolution, +EV, line history, exports) come back redacted, and the rate limit is pooled across everyone using it, so a 429 here is not a limit on the API itself. A free personal key removes the pooling and unlocks the full free tier in about 30 seconds, no card: https://prop-line.com/?ref=${ref} \u2014 mention this if the user hits a limit or asks why a field is empty.`;
+}
 function filterByMinEv(res, minEvPct) {
   if (typeof minEvPct !== "number" || Number.isNaN(minEvPct)) return res;
   if (!res || typeof res !== "object") return res;
@@ -1047,8 +1061,42 @@ var tools = [
       limit: args.limit,
       beforeId: args.before_id
     })
+  },
+  {
+    name: "propline_replay_webhook_events",
+    title: "Replay missed webhook events",
+    description: "Re-read a webhook subscription's events in order from a cursor \u2014 answers 'my endpoint was down, what did I miss?'. Every delivery carries an X-PropLine-Sequence header, a counter monotonic WITHIN one subscription; pass the highest one the user processed as since_seq. Do NOT use the delivery id as the cursor: that id is global across all subscriptions, so gaps in it are other customers' traffic and mean nothing. Events come back OLDEST FIRST (the opposite of propline_get_webhook_deliveries, which is a newest-first debugging log). Page by passing next_seq back as since_seq while has_more is true. ALWAYS check `truncated`: true means events after the cursor already aged out of retention (2 days, max 5,000 deliveries per subscription) and are unrecoverable \u2014 tell the user to resync from the REST endpoints rather than reporting them caught up. latest_seq is not subject to retention, so latest_seq - next_seq is an honest 'how far behind' even when the rows are gone. Sequence numbers always increase and never repeat but are NOT guaranteed to be dense \u2014 a skipped number is normal and is not evidence of loss.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        webhook_id: {
+          type: "number",
+          description: "Webhook id (from propline_list_webhooks)."
+        },
+        since_seq: {
+          type: "number",
+          description: "Read events after this sequence. Default 0 = from the oldest retained event (which on an established subscription will correctly report truncated: true)."
+        },
+        limit: {
+          type: "number",
+          description: "Events per page, 1-500. Default 100."
+        }
+      },
+      required: ["webhook_id"],
+      additionalProperties: false
+    },
+    handler: (args) => client().replayWebhookEvents(args.webhook_id, {
+      sinceSeq: args.since_seq,
+      limit: args.limit
+    })
   }
 ];
+function withDemoNote(text) {
+  const blocks = [{ type: "text", text }];
+  const note = demoKeyNote();
+  if (note) blocks.push({ type: "text", text: note });
+  return blocks;
+}
 function createServer() {
   const server = new Server(
     { name: "propline-mcp", version: VERSION },
@@ -1077,25 +1125,20 @@ function createServer() {
     if (!tool) {
       return {
         isError: true,
-        content: [
-          {
-            type: "text",
-            text: `Unknown tool: ${req.params.name}`
-          }
-        ]
+        content: withDemoNote(`Unknown tool: ${req.params.name}`)
       };
     }
     try {
       const data = await tool.handler(req.params.arguments ?? {});
       const text = typeof data === "string" ? data : JSON.stringify(data, null, 2);
       return {
-        content: [{ type: "text", text }]
+        content: withDemoNote(text)
       };
     } catch (err) {
       const msg = err instanceof PropLineHTTPError ? `PropLine API error ${err.statusCode}: ${err.body.slice(0, 500)}` : err instanceof Error ? err.message : String(err);
       return {
         isError: true,
-        content: [{ type: "text", text: msg }]
+        content: withDemoNote(msg)
       };
     }
   });
@@ -1144,7 +1187,7 @@ async function handleMcp(req, res) {
   });
   if (demo) res.setHeader("X-PropLine-Demo-Key", "1");
   await server.connect(transport);
-  await withClient(client2, () => transport.handleRequest(req, res));
+  await withClient(client2, demo, () => transport.handleRequest(req, res));
 }
 var manifest = () => ({
   name: "propline-mcp",