setlist-mcp 0.5.0 → 0.5.1

package/.claude-plugin/marketplace.json

@@ -7,7 +7,7 @@
   },
   "metadata": {
     "description": "MCP server for setlist.fm — concert setlists, artists, venues, and tours via the setlist.fm API",
-    "version": "0.5.0"
+    "version": "0.5.1"
   },
   "plugins": [
     {
@@ -15,7 +15,7 @@
       "displayName": "setlist.fm",
       "source": "./",
       "description": "MCP server for setlist.fm — search concert setlists, artists, venues, and tours via natural language",
-      "version": "0.5.0",
+      "version": "0.5.1",
       "author": {
         "name": "Chris Hall"
       },

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "setlist-mcp",
   "displayName": "setlist.fm",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "description": "MCP server for setlist.fm — search concert setlists, artists, venues, and tours via the setlist.fm API",
   "author": {
     "name": "Chris Hall",

package/SKILL.md

@@ -76,6 +76,9 @@ All tools are read-only and prefixed `setlist_`.
 - **`setlist_get_setlist`** — a setlist (with full song list) by `setlistId`.
 - **`setlist_get_setlist_version`** — a specific historical version by `versionId`.
 
+### Batch
+- **`setlist_resolve_concerts`** — resolve up to **24** `{artist, date, city?, venue?}` to their best-match setlists in one call (with `songCount`/`hasSongs` + a `{matched, stubs, unmatched, pending}` summary). Calls are paced to setlist.fm's rate limit; if a batch can't finish in time the rest come back `pending: true` — re-call with just those. For more than 24 shows, chunk into batches of ≤24.
+
 ### Venues
 - **`setlist_search_venues`** — find venues by `name` and/or location.
 - **`setlist_get_venue`** — get a venue by `venueId`.

package/dist/bundle.js

@@ -31258,7 +31258,7 @@ function toolAnnotations(opts = {}) {
 }
 
 // src/version.ts
-var VERSION = "0.5.0";
+var VERSION = "0.5.1";
 
 // src/client.ts
 import { dirname, join } from "path";
@@ -31630,6 +31630,8 @@ function registerUserTools(server) {
 
 // src/tools/resolve.ts
 var MAX_BATCH = 24;
+var PACE_MS = 500;
+var BUDGET_MS = 45e3;
 function songCountOf(s) {
   const sets = Array.isArray(s.sets?.set) ? s.sets.set : [];
   return sets.reduce((n, set2) => n + (Array.isArray(set2?.song) ? set2.song.length : 0), 0);
@@ -31645,17 +31647,15 @@ async function emptyOn404(run, fallback) {
     throw err;
   }
 }
-async function searchSetlists(query) {
+async function searchSetlists(req, query) {
   return emptyOn404(async () => {
-    const data = await client.request("GET", "/1.0/search/setlists", {
-      query
-    });
+    const data = await req("GET", "/1.0/search/setlists", { query });
     return data?.setlist ?? [];
   }, []);
 }
-async function topArtistMbid(artistName) {
+async function topArtistMbid(req, artistName) {
   return emptyOn404(async () => {
-    const data = await client.request("GET", "/1.0/search/artists", {
+    const data = await req("GET", "/1.0/search/artists", {
       query: { artistName, sort: "relevance" }
     });
     return data?.artist?.[0]?.mbid;
@@ -31674,21 +31674,21 @@ function pickBest(list, city, venue) {
   if (list.length === 0) return void 0;
   return [...list].sort((a, b) => score(b, city, venue) - score(a, city, venue) || songCountOf(b) - songCountOf(a))[0];
 }
-async function resolveOne(c) {
+async function resolveOne(req, c) {
   const filters = {
     date: isoToDmy(c.date),
     ...c.city ? { cityName: c.city } : {},
     ...c.venue ? { venueName: c.venue } : {}
   };
-  let list = await searchSetlists({ artistName: c.artist, ...filters });
+  let list = await searchSetlists(req, { artistName: c.artist, ...filters });
   if (list.length === 0) {
-    const mbid = await topArtistMbid(c.artist);
-    if (mbid) list = await searchSetlists({ artistMbid: mbid, ...filters });
+    const mbid = await topArtistMbid(req, c.artist);
+    if (mbid) list = await searchSetlists(req, { artistMbid: mbid, ...filters });
   }
   if (list.length === 0) {
     const norm = normalizeArtist(c.artist);
     if (norm && norm.toLowerCase() !== c.artist.toLowerCase()) {
-      list = await searchSetlists({ artistName: norm, ...filters });
+      list = await searchSetlists(req, { artistName: norm, ...filters });
     }
   }
   const best = pickBest(list, c.city, c.venue);
@@ -31711,11 +31711,49 @@ async function resolveOne(c) {
     alternatives: list.length - 1
   };
 }
+var defaultSleep2 = (ms) => new Promise((r) => setTimeout(r, ms));
+async function resolveConcerts(concerts, deps = {}) {
+  const baseRequest = deps.request ?? ((m, p, o) => client.request(m, p, o));
+  const sleep = deps.sleep ?? defaultSleep2;
+  const now = deps.now ?? Date.now;
+  const paceMs = deps.paceMs ?? PACE_MS;
+  const budgetMs = deps.budgetMs ?? BUDGET_MS;
+  let lastCallAt = 0;
+  const req = async (method, path, opts) => {
+    const wait = paceMs - (now() - lastCallAt);
+    if (wait > 0) await sleep(wait);
+    lastCallAt = now();
+    return baseRequest(method, path, opts);
+  };
+  const start = now();
+  const results = [];
+  let budgetSpent = false;
+  for (const c of concerts) {
+    if (budgetSpent || now() - start >= budgetMs) {
+      budgetSpent = true;
+      results.push({ input: c, match: null, alternatives: 0, pending: true });
+      continue;
+    }
+    results.push(await resolveOne(req, c));
+  }
+  return results;
+}
+function summarizeResults(results) {
+  const pending = results.filter((r) => r.pending).length;
+  const matched = results.filter((r) => r.match).length;
+  const stubs = results.filter((r) => r.match && !r.match.hasSongs).length;
+  const summary = { total: results.length, matched, stubs, unmatched: results.length - matched - pending, pending };
+  const payload = { results, summary };
+  if (pending > 0) {
+    payload.note = `Reached the time budget after ${results.length - pending} of ${results.length} concerts. Re-call setlist_resolve_concerts with just the ${pending} pending concert(s).`;
+  }
+  return payload;
+}
 function registerResolveTools(server) {
   server.registerTool(
     "setlist_resolve_concerts",
     {
-      description: "Resolve many concerts to their setlists in ONE call (instead of 2+ per show). Given up to 24 `{artist, date, city?, venue?}`, returns the best-match setlist for each \u2014 `{setlistId, url, eventDate, artist, venue, city, tour, songCount, hasSongs}` \u2014 plus a `{matched, stubs, unmatched}` summary. For each: searches artist + date (narrowed by your city/venue), and on a miss falls back to a relevance artist lookup (by mbid) and a punctuation-normalized name so format variants still resolve. `hasSongs: false` flags an empty stub page. Processed sequentially to respect setlist.fm's rate limit; chunk lists longer than 24 across calls." + ATTRIBUTION_NOTE,
+      description: "Resolve many concerts to their setlists in ONE call (instead of 2+ per show). Given up to 24 `{artist, date, city?, venue?}`, returns the best-match setlist for each \u2014 `{setlistId, url, eventDate, artist, venue, city, tour, songCount, hasSongs}` \u2014 plus a `{matched, stubs, unmatched, pending}` summary. For each: searches artist + date (narrowed by your city/venue), and on a miss falls back to a relevance artist lookup (by mbid) and a punctuation-normalized name so format variants still resolve. `hasSongs: false` flags an empty stub page. Calls are paced to setlist.fm's ~2 req/sec limit; if a big batch can't finish within the time budget the rest come back `pending: true` (re-call with just those) rather than timing out. Keep batches \u226424." + ATTRIBUTION_NOTE,
       annotations: { readOnlyHint: true },
       inputSchema: {
         concerts: external_exports.array(
@@ -31729,16 +31767,8 @@ function registerResolveTools(server) {
       }
     },
     async ({ concerts }) => {
-      const results = [];
-      for (const c of concerts) {
-        results.push(await resolveOne(c));
-      }
-      const matched = results.filter((r) => r.match).length;
-      const stubs = results.filter((r) => r.match && !r.match.hasSongs).length;
-      return textResult({
-        results,
-        summary: { total: results.length, matched, stubs, unmatched: results.length - matched }
-      });
+      const results = await resolveConcerts(concerts);
+      return textResult(summarizeResults(results));
     }
   );
 }

package/dist/tools/resolve.js

@@ -3,6 +3,13 @@ import { textResult, isoToDmy, messageOf } from '@chrischall/mcp-utils';
 import { client } from '../client.js';
 import { ATTRIBUTION_NOTE } from '../attribution.js';
 const MAX_BATCH = 24;
+// Pace upstream calls to ~2 req/sec (setlist.fm's standard-tier limit). Bursting
+// a whole batch trips the limit → 429s → retries stack up → the tool call times
+// out; spacing the requests keeps the batch steady and predictable.
+const PACE_MS = 500;
+// Overall wall-clock budget for one tool call. When it's exhausted, the
+// remaining concerts come back `pending` instead of timing the whole call out.
+const BUDGET_MS = 45_000;
 function songCountOf(s) {
     const sets = Array.isArray(s.sets?.set) ? s.sets.set : [];
     return sets.reduce((n, set) => n + (Array.isArray(set?.song) ? set.song.length : 0), 0);
@@ -30,17 +37,15 @@ async function emptyOn404(run, fallback) {
         throw err;
     }
 }
-async function searchSetlists(query) {
+async function searchSetlists(req, query) {
     return emptyOn404(async () => {
-        const data = await client.request('GET', '/1.0/search/setlists', {
-            query,
-        });
+        const data = await req('GET', '/1.0/search/setlists', { query });
         return data?.setlist ?? [];
     }, []);
 }
-async function topArtistMbid(artistName) {
+async function topArtistMbid(req, artistName) {
     return emptyOn404(async () => {
-        const data = await client.request('GET', '/1.0/search/artists', {
+        const data = await req('GET', '/1.0/search/artists', {
             query: { artistName, sort: 'relevance' },
         });
         return data?.artist?.[0]?.mbid;
@@ -64,25 +69,25 @@ function pickBest(list, city, venue) {
     // Best location/song score wins; prefer a populated setlist on ties via songCount.
     return [...list].sort((a, b) => score(b, city, venue) - score(a, city, venue) || songCountOf(b) - songCountOf(a))[0];
 }
-async function resolveOne(c) {
+async function resolveOne(req, c) {
     const filters = {
         date: isoToDmy(c.date),
         ...(c.city ? { cityName: c.city } : {}),
         ...(c.venue ? { venueName: c.venue } : {}),
     };
-    let list = await searchSetlists({ artistName: c.artist, ...filters });
+    let list = await searchSetlists(req, { artistName: c.artist, ...filters });
     // Fuzzy fallback 1: resolve the artist via the (more forgiving) relevance
     // search, then query by its mbid.
     if (list.length === 0) {
-        const mbid = await topArtistMbid(c.artist);
+        const mbid = await topArtistMbid(req, c.artist);
         if (mbid)
-            list = await searchSetlists({ artistMbid: mbid, ...filters });
+            list = await searchSetlists(req, { artistMbid: mbid, ...filters });
     }
     // Fuzzy fallback 2: a punctuation-normalized name.
     if (list.length === 0) {
         const norm = normalizeArtist(c.artist);
         if (norm && norm.toLowerCase() !== c.artist.toLowerCase()) {
-            list = await searchSetlists({ artistName: norm, ...filters });
+            list = await searchSetlists(req, { artistName: norm, ...filters });
         }
     }
     const best = pickBest(list, c.city, c.venue);
@@ -105,9 +110,56 @@ async function resolveOne(c) {
         alternatives: list.length - 1,
     };
 }
+const defaultSleep = (ms) => new Promise((r) => setTimeout(r, ms));
+/**
+ * Resolve each concert sequentially, pacing upstream calls to stay under
+ * setlist.fm's rate limit and stopping (remaining → `pending`) once the
+ * wall-clock budget is spent, so a large batch returns partial results instead
+ * of timing the whole call out. Exported for testing.
+ */
+export async function resolveConcerts(concerts, deps = {}) {
+    const baseRequest = deps.request ?? ((m, p, o) => client.request(m, p, o));
+    const sleep = deps.sleep ?? defaultSleep;
+    const now = deps.now ?? Date.now;
+    const paceMs = deps.paceMs ?? PACE_MS;
+    const budgetMs = deps.budgetMs ?? BUDGET_MS;
+    // Gate every upstream call to at least `paceMs` apart (the first runs immediately).
+    let lastCallAt = 0;
+    const req = async (method, path, opts) => {
+        const wait = paceMs - (now() - lastCallAt);
+        if (wait > 0)
+            await sleep(wait);
+        lastCallAt = now();
+        return baseRequest(method, path, opts);
+    };
+    const start = now();
+    const results = [];
+    let budgetSpent = false;
+    for (const c of concerts) {
+        if (budgetSpent || now() - start >= budgetMs) {
+            budgetSpent = true;
+            results.push({ input: c, match: null, alternatives: 0, pending: true });
+            continue;
+        }
+        results.push(await resolveOne(req, c));
+    }
+    return results;
+}
+/** Build the tool payload (results + summary, plus a note when work was deferred). */
+export function summarizeResults(results) {
+    const pending = results.filter((r) => r.pending).length;
+    const matched = results.filter((r) => r.match).length;
+    const stubs = results.filter((r) => r.match && !r.match.hasSongs).length;
+    const summary = { total: results.length, matched, stubs, unmatched: results.length - matched - pending, pending };
+    const payload = { results, summary };
+    if (pending > 0) {
+        payload.note = `Reached the time budget after ${results.length - pending} of ${results.length} concerts. Re-call setlist_resolve_concerts with just the ${pending} pending concert(s).`;
+    }
+    return payload;
+}
 export function registerResolveTools(server) {
     server.registerTool('setlist_resolve_concerts', {
-        description: "Resolve many concerts to their setlists in ONE call (instead of 2+ per show). Given up to 24 `{artist, date, city?, venue?}`, returns the best-match setlist for each — `{setlistId, url, eventDate, artist, venue, city, tour, songCount, hasSongs}` — plus a `{matched, stubs, unmatched}` summary. For each: searches artist + date (narrowed by your city/venue), and on a miss falls back to a relevance artist lookup (by mbid) and a punctuation-normalized name so format variants still resolve. `hasSongs: false` flags an empty stub page. Processed sequentially to respect setlist.fm's rate limit; chunk lists longer than 24 across calls." +
+        description: "Resolve many concerts to their setlists in ONE call (instead of 2+ per show). Given up to 24 `{artist, date, city?, venue?}`, returns the best-match setlist for each — `{setlistId, url, eventDate, artist, venue, city, tour, songCount, hasSongs}` — plus a `{matched, stubs, unmatched, pending}` summary. For each: searches artist + date (narrowed by your city/venue), and on a miss falls back to a relevance artist lookup (by mbid) and a punctuation-normalized name so format variants still resolve. `hasSongs: false` flags an empty stub page. Calls are paced to setlist.fm's ~2 req/sec limit; if a big batch can't finish within the time budget the rest come back `pending: true` (re-call with just those) rather than timing out. Keep batches ≤24." +
             ATTRIBUTION_NOTE,
         annotations: { readOnlyHint: true },
         inputSchema: {
@@ -123,17 +175,7 @@ export function registerResolveTools(server) {
                 .describe(`Concerts to resolve (1–${MAX_BATCH} per call)`),
         },
     }, async ({ concerts }) => {
-        const results = [];
-        // Sequential on purpose: one request at a time keeps us within setlist.fm's
-        // ~2 req/sec limit (the client also retries once on a 429).
-        for (const c of concerts) {
-            results.push((await resolveOne(c)));
-        }
-        const matched = results.filter((r) => r.match).length;
-        const stubs = results.filter((r) => r.match && !r.match.hasSongs).length;
-        return textResult({
-            results,
-            summary: { total: results.length, matched, stubs, unmatched: results.length - matched },
-        });
+        const results = await resolveConcerts(concerts);
+        return textResult(summarizeResults(results));
     });
 }

package/dist/version.js

@@ -3,4 +3,4 @@
 // release-please-config.json's `extra-files`), and `versionSyncTest` guards
 // that it stays equal to package.json. Import VERSION wherever the version is
 // needed rather than re-declaring it.
-export const VERSION = '0.5.0'; // x-release-please-version
+export const VERSION = '0.5.1'; // x-release-please-version

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "setlist-mcp",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "mcpName": "io.github.chrischall/setlist-mcp",
   "description": "setlist.fm MCP server for Claude — developed and maintained by AI (Claude Code)",
   "author": "Claude Code (AI) <https://www.anthropic.com/claude>",

package/server.json

@@ -6,12 +6,12 @@
     "url": "https://github.com/chrischall/setlist-mcp",
     "source": "github"
   },
-  "version": "0.5.0",
+  "version": "0.5.1",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "setlist-mcp",
-      "version": "0.5.0",
+      "version": "0.5.1",
       "transport": {
         "type": "stdio"
       },