@pipeworx/mcp-ecb 0.1.1 → 0.1.3

package/README.md

@@ -2,7 +2,7 @@
 
 European Central Bank Data Portal MCP — exchange rates, interest rates, monetary aggregates, HICP, bank lending. No auth.
 
-Part of [Pipeworx](https://pipeworx.io) — an MCP gateway connecting AI agents to 1679+ live data sources.
+Part of [Pipeworx](https://pipeworx.io) — an MCP gateway connecting AI agents to 1819+ live data sources. This is an independent, unofficial integration — not affiliated with, endorsed by, or published by the upstream provider.
 
 ## Tools
 
@@ -71,19 +71,19 @@ directly, instead of just this one's:
 }
 ```
 
-Both URLs reach the same gateway and the same 1679+ data sources. The
+Both URLs reach the same gateway and the same 1819+ data sources. The
 only difference is which pack's tools are listed **directly**; `ask_pipeworx`
 reaches all of them from either one.
 
 ## No MCP client? Call it over HTTP
 
 ```bash
-curl -X POST https://gateway.pipeworx.io/v1/tools/ecb_exchange_rate \
+curl -X POST https://gateway.pipeworx.io/v1/tools/ecb_policy_rate \
   -H 'Content-Type: application/json' \
-  -d '{"currency":"USD"}'
+  -d '{}'
 ```
 
-No account needed for the first calls. Inspect any tool: `GET https://gateway.pipeworx.io/v1/tools/ecb_exchange_rate`. Find one: `POST https://gateway.pipeworx.io/v1/tools/search_packs` with `{"query":"..."}`.
+No account needed for the first calls. Inspect any tool: `GET https://gateway.pipeworx.io/v1/tools/ecb_policy_rate`. Find one: `POST https://gateway.pipeworx.io/v1/tools/search_packs` with `{"query":"..."}`.
 
 ## Standalone (no gateway account)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pipeworx/mcp-ecb",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "ECB Data Portal MCP — European Central Bank statistical data",
   "type": "module",
   "main": "src/index.ts",
@@ -26,7 +26,7 @@
     "@cloudflare/workers-types": "^4.20260405.1"
   },
   "pipeworx": {
-    "sourceHash": "v1-291834a10f3874c627e789fe06b89ba136235d6cdc4364d5c0a2f4525dfe7910",
-    "sourceCommit": "76aa8f5d9b5dc2f665563030647c68e661478864"
+    "sourceHash": "v1-bfe61ace2c12fd6d1410588f76f6e3e05ed66708c4644931b3dc6a680afb929b",
+    "sourceCommit": "f5821587e59206a76fc200d1b9cbeaad15a549ab"
   }
 }

package/server.json

@@ -3,7 +3,7 @@
   "name": "io.github.pipeworx-io/ecb",
   "title": "Ecb",
   "description": "ECB Data Portal MCP — European Central Bank statistical data",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "websiteUrl": "https://pipeworx.io/packs/ecb",
   "repository": {
     "url": "https://github.com/pipeworx-io/mcp-ecb",

package/src/index.ts

@@ -452,7 +452,42 @@ async function fetchWithTimeout(
         ),
       );
     }
-    throw err;
+    // Fleet #2382. Everything that isn't a timeout/abort here is a genuine
+    // NETWORK-LEVEL failure — DNS resolution, connection refused, TLS handshake,
+    // Cloudflare's own "Network connection lost." — meaning `fetch()` itself
+    // threw and no HTTP response of any kind was ever received. Until this fix
+    // that raw exception was rethrown VERBATIM: a bare `TypeError: fetch failed`
+    // (or the Workers-runtime equivalent) names no upstream, carries no class
+    // token, and reads exactly like a defect in OUR code — because it says
+    // nothing about the call at all. It landed in `error`, the tier that means
+    // "Pipeworx has a defect", for every one of the (at the time of writing)
+    // ~470 packs that call this helper directly with no wrapper of their own.
+    //
+    // `dexscreener` hit this independently (fleet #1579) and fixed it with a
+    // bespoke per-pack try/catch around `fetchWithTimeout`. That fix is correct
+    // but only covers one pack; every other caller of this shared helper still
+    // leaked the raw exception. Moving the same fix HERE — the one place that
+    // already carries the timeout case — covers every pack that uses
+    // `fetchWithTimeout` without a wrapper, for free, and without widening
+    // `classifyToolError`'s regex list: the fix is giving the message a proper
+    // `upstream_down:` token at the point the two facts (no response was ever
+    // received, and which host we were trying to reach) are actually in hand,
+    // not teaching the classifier to guess from prose after the fact.
+    //
+    // Safe on the same grounds as the timeout branch above: no argument a
+    // caller passes can make `fetch()` itself throw a connection-level error,
+    // so this is always an availability failure, never a caller mistake. Same
+    // `markInternalOrigin` treatment — an origin we run that never answered is
+    // still ours, not a third party's outage.
+    const raw = err instanceof Error ? err.message : String(err);
+    throw new Error(
+      markInternalOrigin(
+        `upstream_down: could not reach ${name} at all (${raw.slice(0, 160)}). ` +
+          `No request reached ${name}, so this says NOTHING about whether the arguments you passed ` +
+          'are valid — do not re-check them on the strength of this error. Retry shortly.',
+        url,
+      ),
+    );
   }
 }
 
@@ -652,6 +687,10 @@ function collapse(s: string): string {
  * API docs: https://data.ecb.europa.eu/help/api/
  *
  * Tools:
+ * - ecb_policy_rate:   current deposit facility rate / main refinancing rate /
+ *                      marginal lending rate, each with effective_since,
+ *                      previous_rate and decision history (FM flow, the three
+ *                      official "key ECB interest rates" — fleet #3206)
  * - exchange_rate:     EUR → currency rate (convenience over EXR flow)
  * - hicp_inflation:    Harmonised CPI YoY change (convenience over ICP flow)
  * - get_data:          generic SDMX query against any flow
@@ -669,7 +708,27 @@ async function pwFetch(url: string | URL, init?: RequestInit): Promise<Response>
 
 const BASE = 'https://data-api.ecb.europa.eu/service';
 
+// The three official "key ECB interest rates", FM flow, confirmed against the
+// live series. DFR is the ECB's primary policy lever since the 2024 corridor
+// narrowing (deposits now drive short-term money-market rates); MRO and MLFR
+// are published alongside it and move on the same Governing Council dates.
+const POLICY_RATE_SERIES: { field: string; label: string; key: string }[] = [
+  { field: 'deposit_facility_rate', label: 'Deposit facility rate', key: 'D.U2.EUR.4F.KR.DFR.LEV' },
+  { field: 'main_refinancing_rate', label: 'Main refinancing operations rate (fixed-rate tenders)', key: 'D.U2.EUR.4F.KR.MRR_FR.LEV' },
+  { field: 'marginal_lending_facility_rate', label: 'Marginal lending facility rate', key: 'D.U2.EUR.4F.KR.MLFR.LEV' },
+];
+
 const tools: McpToolExport['tools'] = [
+  {
+    name: 'ecb_policy_rate',
+    description:
+      "The European Central Bank's three official key interest rates — the deposit facility rate (the ECB's " +
+      'primary policy rate since the 2024 operational-framework reform), the main refinancing operations rate, ' +
+      'and the marginal lending facility rate. For each: the current rate, the date it took effect, the previous ' +
+      'rate and when that one took effect, plus recent decision history (FM flow, series DFR/MRR_FR/MLFR). ' +
+      "Use this for \"ECB interest rate\" / \"ECB deposit rate\" / \"has the ECB cut rates\" instead of guessing an FM series key.",
+    inputSchema: { type: 'object', properties: {} },
+  },
   {
     name: 'ecb_exchange_rate',
     description:
@@ -742,6 +801,8 @@ const tools: McpToolExport['tools'] = [
 
 async function callTool(name: string, args: Record<string, unknown>): Promise<unknown> {
   switch (name) {
+    case 'ecb_policy_rate':
+      return policyRate();
     case 'ecb_exchange_rate':
       return exchangeRate(args);
     case 'ecb_hicp_inflation':
@@ -755,6 +816,76 @@ async function callTool(name: string, args: Record<string, unknown>): Promise<un
   }
 }
 
+/** {rate, effective_since, previous_rate, previous_rate_effective_since, decision_history, data_as_of} from an ascending {period,value} series. */
+function computeRateChanges(obs: { period: string; value: number | null }[]) {
+  const pts = obs.filter((o) => o.value !== null) as { period: string; value: number }[];
+  if (pts.length === 0) return null;
+  const changes: { rate: number; effective_since: string }[] = [{ rate: pts[0].value, effective_since: pts[0].period }];
+  for (let i = 1; i < pts.length; i++) {
+    if (pts[i].value !== changes[changes.length - 1].rate) {
+      changes.push({ rate: pts[i].value, effective_since: pts[i].period });
+    }
+  }
+  const current = changes[changes.length - 1];
+  const previous = changes.length > 1 ? changes[changes.length - 2] : null;
+  return {
+    rate: current.rate,
+    effective_since: current.effective_since,
+    previous_rate: previous?.rate ?? null,
+    previous_rate_effective_since: previous?.effective_since ?? null,
+    decision_history: changes.slice(-5).reverse(),
+    data_as_of: pts[pts.length - 1].period,
+  };
+}
+
+async function policyRate() {
+  // ~6 years of daily observations — comfortably more than enough to see the
+  // last several Governing Council rate decisions.
+  const results = await Promise.all(
+    POLICY_RATE_SERIES.map(async (s) => {
+      try {
+        const data = await fetchData('FM', s.key, { start_period: '2020-01-01' });
+        const series = data.series[0]?.observations ?? [];
+        return { field: s.field, label: s.label, computed: computeRateChanges(series), fetchError: null as string | null };
+      } catch (err) {
+        // A fixed, verified-live key failing is an upstream fault, not a bad
+        // query — surface it per-field rather than failing the whole call,
+        // since the other two rates may well still be answerable.
+        return { field: s.field, label: s.label, computed: null, fetchError: err instanceof Error ? err.message : String(err) };
+      }
+    }),
+  );
+  const missing = results.filter((r) => r.computed === null);
+  if (missing.length === results.length) {
+    return {
+      error: 'no_data',
+      message:
+        'The ECB returned no observations for any of the key interest rate series (FM flow, DFR/MRR_FR/MLFR). ' +
+        'The series shape may have changed upstream; try get_data with flow_ref "FM" directly.',
+    };
+  }
+  const primary = results.find((r) => r.field === 'deposit_facility_rate')!;
+  const out: Record<string, unknown> = {
+    unit: 'percent',
+    // Aggregate fields first: the deposit facility rate is the ECB's primary
+    // policy lever since the 2024 corridor reform, so it carries the
+    // top-level {rate, effective_since, previous_rate, ...} shape directly —
+    // a caller asking "the ECB rate" does not have to know there are three.
+    ...(primary.computed ?? {}),
+  };
+  for (const r of results) {
+    out[r.field] = r.computed
+      ? { label: r.label, ...r.computed }
+      : { label: r.label, error: 'no_data', message: r.fetchError ?? `The ECB returned no observations for ${r.label}.` };
+  }
+  out.note =
+    "The ECB's three official key interest rates (deposit facility, main refinancing, marginal lending). " +
+    'The deposit facility rate has been the primary signal of the ECB monetary-policy stance since the ' +
+    "2024 operational-framework reform narrowed the corridor; top-level fields describe it. All three " +
+    'normally change together, on the same Governing Council decision date.';
+  return out;
+}
+
 async function exchangeRate(args: Record<string, unknown>) {
   const currency = reqStr(args, 'currency', '"USD"').toUpperCase();
   const freq = ((args.frequency as string) ?? 'D').toUpperCase();
@@ -801,9 +932,23 @@ async function fetchData(
   if (opts.last_n) params.set('lastNObservations', String(opts.last_n));
   const url = `${BASE}/data/${encodeURIComponent(flow)}/${encodeURIComponent(key)}?${params}`;
   const res = await pwFetch(url, { headers: { Accept: 'application/json' } });
-  if (res.status === 404) throw new Error(`ECB: no data for flow=${flow} key=${key}`);
+  if (res.status === 404) {
+    throw new Error(
+      `not_found: the ECB has no series matching key "${key}" in flow "${flow}". The key does not exist at that ` +
+        'shape, not just empty for this period — check the dimension values, or call list_dataflows for valid flow_refs.',
+    );
+  }
   if (!res.ok) {
     const body = await res.text();
+    // A malformed key (wrong dimension count) gets ECB's generic error page —
+    // HTML, not SDMX JSON. Leaking it verbatim reads as a Pipeworx bug and
+    // buries the one useful fact (the request was malformed) under markup.
+    if (body.trimStart().startsWith('<')) {
+      throw new Error(
+        `user_error: the ECB rejected key "${key}" for flow "${flow}" as malformed (HTTP ${res.status}). ` +
+          'SDMX keys are dot-separated dimension values in a fixed order for that flow — check the dimension count.',
+      );
+    }
     throw new Error(`ECB error: ${res.status} ${body.slice(0, 200)}`);
   }
   // ECB answers a 200 with a ZERO-BYTE body during an outage, and res.json()

package/src/server.ts

@@ -8,8 +8,9 @@ import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 import pack from './index.js';
 
+
 const server = new Server(
-  { name: '@pipeworx/mcp-ecb', version: '0.1.1' },
+  { name: '@pipeworx/mcp-ecb', version: '0.1.3' },
   { capabilities: { tools: {} } },
 );
 
@@ -24,7 +25,9 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
   const { name, arguments: args } = request.params;
   try {
-    const result = await pack.callTool(name, (args ?? {}) as Record<string, unknown>);
+    const callArgs = { ...((args ?? {}) as Record<string, unknown>) };
+    
+    const result = await pack.callTool(name, callArgs);
     return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
   } catch (err) {
     return {