propline-mcp 0.25.3 → 0.27.0

package/README.md

@@ -30,6 +30,7 @@ The model uses these tools transparently:
 | `propline_get_odds` | Live odds — bulk by sport or full props per event. Accepts `period` (q1/h1/p1/f5/…) to scope to game-period markets. |
 | `propline_get_odds_history` | Hobby+: snapshot history per outcome; supports `period` (q1/h1/…) plus time-window filters (from/to, relative_from/relative_to, interval, changes_only) |
 | `propline_get_odds_closing` | Hobby+: opening **and** closing line per (book, market, outcome) — CLV helper. Accepts `period` to scope to a specific game period. |
+| `propline_grade_clv` | Hobby+: grade **placed** bets against their closing lines. Returns closing price, de-vigged closing fair (`fair_source` = sharpest book at close, not yours), `clv_pct` (price-vs-price, vig-blind) **and** `ev_vs_close_pct` (the honest number), plus the graded result once the game settles. Fail-closed matching; unstarted events come back `closing_is_final: false` and are excluded from the averages. |
 | `propline_export_odds_history` | Backfill-pass / Enterprise: bulk line-movement tick history (every snapshot, per book) for a sport. Requires a `since`/`until` window; result capped to 200 rows (use the REST endpoint directly for the full file). |
 | `propline_get_futures` | Season-long futures — championship/division/conference winners, MVP + awards, season win totals — across Bovada/FanDuel/DraftKings/Pinnacle (free) |
 | `propline_get_scores` | Game scores + status (free) |
@@ -42,6 +43,7 @@ The model uses these tools transparently:
 | `propline_get_event_movement` | Line movement + steam detection (sharp-money signal across all books) from the tick history (Hobby+) |
 | `propline_get_event_results` | Pro: graded won/lost/push per prop |
 | `propline_get_player_history` | Player prop history with resolution |
+| `propline_get_player_games` | Player game log — recent games with every raw box-score stat per game, one call instead of one per event; `opponent` gives head-to-head (last N *meetings*). Raw-stat archive, so it includes games no book priced |
 | `propline_get_player_trends` | Hit-rate trends — over/under/push splits over last 5/10/20/50 graded games, streak, avg actual (optional `dfs_odds_type` to scope to a PrizePicks flavor) |
 | `propline_get_event_ev` | Pro: cross-book +EV with no-vig fair lines |
 | `propline_get_best_line` | Hobby+: cross-book line shopping — best price per (market, player, line) across all comparable books, `all_prices` sorted best-first; optional `bookmakers` filter |
@@ -50,7 +52,7 @@ The model uses these tools transparently:
 
 ## Hosted endpoint (no install)
 
-The same 23 tools are served over **Streamable HTTP** at
+The same 25 tools are served over **Streamable HTTP** at
 
 ```
 https://mcp.prop-line.com/mcp
@@ -113,7 +115,7 @@ Edit `~/Library/Application Support/Claude/claude_desktop_config.json` (macOS) o
 }
 ```
 
-Restart Claude Desktop. The hammer icon should show 21 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 25 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

@@ -69,6 +69,40 @@ var PropLineClient = class {
       clearTimeout(timer);
     }
   }
+  /**
+   * POST with a JSON body. Kept separate from `request` because every other
+   * endpoint on this server is a GET with query params; folding a body into
+   * that signature would make the common case harder to read.
+   */
+  async postRequest(path, body) {
+    const url = new URL(this.baseUrl + path);
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+    try {
+      const r = await fetch(url, {
+        method: "POST",
+        headers: {
+          "X-API-Key": this.apiKey,
+          Accept: "application/json",
+          "Content-Type": "application/json",
+          "User-Agent": "propline-mcp/0.1.0"
+        },
+        body: JSON.stringify(body),
+        signal: controller.signal
+      });
+      const text = await r.text();
+      if (!r.ok) {
+        throw new PropLineHTTPError(r.status, text);
+      }
+      try {
+        return JSON.parse(text);
+      } catch {
+        return text;
+      }
+    } finally {
+      clearTimeout(timer);
+    }
+  }
   // ----- Discovery -----
   listSports() {
     return this.request("/v1/sports");
@@ -120,6 +154,14 @@ var PropLineClient = class {
       { markets: opts.markets, bookmakers: opts.bookmakers, period: opts.period }
     );
   }
+  /**
+   * Grade placed bets against their closing lines (CLV). Hobby+.
+   * See the propline_grade_clv tool description for the semantics that
+   * matter when presenting the result.
+   */
+  gradeClv(bets) {
+    return this.postRequest("/v1/clv/grade", bets);
+  }
   // ----- Bulk exports -----
   /**
    * Full line-movement tick history as CSV text (Backfill pass / Enterprise
@@ -189,6 +231,13 @@ var PropLineClient = class {
       { limit: opts.limit, markets: opts.markets }
     );
   }
+  // ----- Player game log / H2H -----
+  getPlayerGames(sportKey, playerName, opts = {}) {
+    return this.request(
+      `/v1/sports/${sportKey}/players/${encodeURIComponent(playerName)}/games`,
+      { limit: opts.limit, opponent: opts.opponent, stat_type: opts.statType }
+    );
+  }
   // ----- Player trends -----
   getPlayerTrends(sportKey, playerName, opts = {}) {
     return this.request(
@@ -228,7 +277,7 @@ var PropLineClient = class {
 };
 
 // src/server.ts
-var VERSION = "0.25.3";
+var VERSION = "0.27.0";
 var DEMO_KEY = "be2b8487fcfacb1fbc292a8aa925a84c";
 var apiKey = process.env.PROPLINE_API_KEY;
 var baseUrl = process.env.PROPLINE_BASE_URL;
@@ -457,6 +506,64 @@ var tools = [
       }
     )
   },
+  {
+    name: "propline_grade_clv",
+    title: "Grade bets against the close (CLV)",
+    description: "Hobby+ endpoint. Grades PLACED bets against their closing lines. Closing line value is the only durable proxy for whether a bettor has edge: did the price they took beat the number the market settled on? Send the bets and each comes back with its closing price, the de-vigged closing fair probability, CLV, and \u2014 once the game settles \u2014 the graded resolution and actual stat value, plus a portfolio summary. Stateless: nothing is stored. TWO CLV numbers are returned deliberately. clv_pct is price-vs-price: familiar and quotable, but VIG-BLIND, so it flatters a bet taken on the juicy side of a wide market. ev_vs_close_pct scores the price against the DE-VIGGED close and is the honest one \u2014 report that one when the user asks whether they got value. The de-vig anchors to the SHARPEST book quoting that line at close (fair_source), not the book they bet at, because de-vigging their own book always returns a negative number (they paid its hold). Bets whose event has not started carry closing_is_final=false, are counted in summary.pending, and are EXCLUDED from the summary averages: before kickoff the 'closing' price is just the latest price, so CLV is ~0 by construction \u2014 do not present those as results. Matching is fail-closed: a bet that cannot be pinned to exactly one stored outcome returns matched=false with an unmatched_reason instead of a wrong match, so surface those rows rather than silently dropping them. Max 500 bets per request. Free tier returns structure with every number nulled.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        bets: {
+          type: "array",
+          maxItems: 500,
+          description: "Placed bets to grade. selection is the subject: player name for a prop, team name for a game line.",
+          items: {
+            type: "object",
+            properties: {
+              ref: {
+                type: "string",
+                description: "Echoed back untouched, so rows can be aligned without relying on order."
+              },
+              sport_key: { type: "string" },
+              event_id: { type: ["string", "number"] },
+              market: { type: "string" },
+              bookmaker: { type: "string" },
+              selection: { type: "string" },
+              side: {
+                type: "string",
+                description: "'Over' or 'Under' for two-way markets. Omit for YES-only props where the player IS the outcome."
+              },
+              point: { type: "number" },
+              period: {
+                type: "string",
+                description: "Canonical period code (q1, h1, p1, f5). Omit for full-game markets."
+              },
+              price: {
+                type: "number",
+                description: "American odds actually taken, e.g. -110 or 145."
+              },
+              stake: {
+                type: "number",
+                description: "Defaults to 1 unit when computing profit_units."
+              }
+            },
+            required: [
+              "sport_key",
+              "event_id",
+              "market",
+              "bookmaker",
+              "selection",
+              "price"
+            ],
+            additionalProperties: false
+          }
+        }
+      },
+      required: ["bets"],
+      additionalProperties: false
+    },
+    handler: (args) => client().gradeClv(args.bets)
+  },
   {
     name: "propline_export_odds_history",
     title: "Export odds history",
@@ -729,6 +836,44 @@ var tools = [
       }
     )
   },
+  {
+    name: "propline_get_player_games",
+    title: "Get player game log / H2H",
+    description: "A player's recent games with every raw box-score stat per game \u2014 one call instead of one request per event. Use this to answer 'how has X actually performed lately?' and to build L5/L10/L20, season splits and head-to-head yourself. Pass `opponent` for H2H (accepts a full name, nickname or abbreviation \u2014 'Boston Red Sox', 'Red Sox', 'BOS'); the limit applies AFTER that filter, so opponent + limit=10 means the last 10 MEETINGS, not the Boston games among the last 10 games. H2H is not capped to the current season. IMPORTANT: this is the raw box-score archive, NOT graded-prop history \u2014 it covers every game with a box score on file, including games no sportsbook priced, so a 'last 10 games' window here really is the last 10 games (one built from propline_get_player_trends silently skips unpriced games). It carries no line, price or grade; use propline_get_player_trends for hit rates against a posted line. `player_team`/`opponent`/`is_home` are null when the player's side can't be identified, and always for individual sports (tennis, golf, UFC) \u2014 report them as unknown rather than guessing.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        sport_key: { type: "string" },
+        player_name: {
+          type: "string",
+          description: "Player name as it appears in box scores \u2014 e.g. 'Aaron Judge', 'Nikola Jokic'"
+        },
+        limit: {
+          type: "number",
+          description: "Games to return, 1-100. Default 20."
+        },
+        opponent: {
+          type: "string",
+          description: "Optional head-to-head filter \u2014 team name, nickname or abbreviation."
+        },
+        stat_type: {
+          type: "string",
+          description: "Optional comma-separated stat names to return; omit for all. Vocabulary is per-sport."
+        }
+      },
+      required: ["sport_key", "player_name"],
+      additionalProperties: false
+    },
+    handler: (args) => client().getPlayerGames(
+      args.sport_key,
+      args.player_name,
+      {
+        limit: args.limit,
+        opponent: args.opponent,
+        statType: args.stat_type
+      }
+    )
+  },
   {
     name: "propline_get_player_trends",
     title: "Get player trends",