@riskmodels/mcp 1.0.1 → 1.0.4

package/data/schema-paths.json

@@ -10,7 +10,9 @@
   "/schemas/telemetry-v1.json",
   "/schemas/estimate-v1.json",
   "/schemas/decompose-v1.json",
+  "/schemas/hedge-levels-v1.json",
   "/schemas/risk-metadata-v1.json",
   "/schemas/portfolio-risk-snapshot-v1.json",
+  "/schemas/canonical-snapshot-v1.json",
   "/schemas/portfolio-risk-index-v1.json"
 ]

package/data/schemas/canonical-snapshot-v1.json

@@ -0,0 +1,46 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "CanonicalSnapshot",
+  "description": "POST /api/snapshot (type=portfolio) — request and top-level response shape (see OPENAPI_SPEC CanonicalSnapshotPortfolioRequest / CanonicalSnapshotResponse).",
+  "oneOf": [
+    {
+      "title": "CanonicalSnapshotPortfolioRequest",
+      "type": "object",
+      "required": ["type", "portfolio"],
+      "properties": {
+        "type": { "const": "portfolio" },
+        "portfolio": {
+          "type": "array",
+          "minItems": 1,
+          "maxItems": 100,
+          "items": {
+            "type": "object",
+            "required": ["ticker"],
+            "properties": {
+              "ticker": { "type": "string" },
+              "weight": { "type": "number", "exclusiveMinimum": 0 },
+              "shares": { "type": "number", "exclusiveMinimum": 0 }
+            }
+          }
+        },
+        "lookback_days": { "type": "integer", "minimum": 20, "maximum": 2000, "default": 252 },
+        "mode": { "type": "string", "enum": ["frozen"], "default": "frozen" },
+        "benchmark": { "type": "string" }
+      }
+    },
+    {
+      "title": "CanonicalSnapshotResponseCore",
+      "type": "object",
+      "required": ["snapshot", "time_behavior", "attribution", "risk_summary", "metadata"],
+      "properties": {
+        "snapshot": { "type": "object" },
+        "time_behavior": { "type": "object" },
+        "attribution": { "type": "object" },
+        "risk_summary": { "type": "object" },
+        "metadata": { "type": "object" },
+        "_metadata": { "type": "object" },
+        "_agent": { "type": "object" }
+      }
+    }
+  ]
+}

package/data/schemas/decompose-v1.json

@@ -0,0 +1,132 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "Decompose Position",
+  "description": "Simplified four-layer ERM3 exposure + hedge map for a single ticker. Thin semantic wrapper over the metrics DAL; same billing profile as GET /metrics/{ticker}.",
+  "oneOf": [
+    { "$ref": "#/definitions/DecomposeRequest" },
+    { "$ref": "#/definitions/DecomposeResponse" }
+  ],
+  "definitions": {
+    "LevelHedgeSnapshot": {
+      "type": "object",
+      "required": [
+        "market_hr",
+        "sector_hr",
+        "subsector_hr",
+        "market_er",
+        "sector_er",
+        "subsector_er",
+        "residual_er",
+        "hedge_etfs"
+      ],
+      "properties": {
+        "market_hr": { "type": ["number", "null"] },
+        "sector_hr": { "type": ["number", "null"] },
+        "subsector_hr": { "type": ["number", "null"] },
+        "market_er": { "type": ["number", "null"] },
+        "sector_er": { "type": ["number", "null"] },
+        "subsector_er": { "type": ["number", "null"] },
+        "residual_er": { "type": ["number", "null"] },
+        "hedge_etfs": {
+          "type": "object",
+          "required": ["market", "sector", "subsector"],
+          "properties": {
+            "market": { "type": "string" },
+            "sector": { "type": ["string", "null"] },
+            "subsector": { "type": ["string", "null"] }
+          },
+          "additionalProperties": false
+        }
+      },
+      "additionalProperties": false
+    },
+    "HedgeLevelsBlock": {
+      "type": "object",
+      "required": ["L1", "L2", "L3"],
+      "properties": {
+        "L1": { "$ref": "#/definitions/LevelHedgeSnapshot" },
+        "L2": { "$ref": "#/definitions/LevelHedgeSnapshot" },
+        "L3": { "$ref": "#/definitions/LevelHedgeSnapshot" },
+        "recommended_level": { "type": ["string", "null"], "enum": ["L1", "L2", "L3", null] },
+        "statistical_lstar": { "type": ["string", "null"], "enum": ["L1", "L2", "L3", null] }
+      },
+      "additionalProperties": true
+    },
+    "DecomposeRequest": {
+      "type": "object",
+      "required": ["ticker"],
+      "properties": {
+        "ticker": {
+          "type": "string",
+          "description": "Stock ticker symbol (case-insensitive).",
+          "examples": ["NVDA", "AAPL"]
+        }
+      }
+    },
+    "DecomposeLayer": {
+      "type": "object",
+      "required": ["er", "hr", "hedge_etf"],
+      "properties": {
+        "er": {
+          "type": ["number", "null"],
+          "description": "Explained-risk variance fraction for this layer (0 to 1)."
+        },
+        "hr": {
+          "type": ["number", "null"],
+          "description": "Hedge ratio (dollar ratio). Null for residual."
+        },
+        "hedge_etf": {
+          "type": ["string", "null"],
+          "description": "Tradable ETF for this layer. Null for residual."
+        }
+      }
+    },
+    "DecomposeResponse": {
+      "type": "object",
+      "required": [
+        "ticker",
+        "symbol",
+        "data_as_of",
+        "teo",
+        "exposure",
+        "hedge"
+      ],
+      "properties": {
+        "ticker": { "type": "string" },
+        "symbol": { "type": "string" },
+        "data_as_of": {
+          "type": "string",
+          "format": "date"
+        },
+        "teo": {
+          "type": "string",
+          "format": "date"
+        },
+        "exposure": {
+          "type": "object",
+          "required": ["market", "sector", "subsector", "residual"],
+          "properties": {
+            "market": { "$ref": "#/definitions/DecomposeLayer" },
+            "sector": { "$ref": "#/definitions/DecomposeLayer" },
+            "subsector": { "$ref": "#/definitions/DecomposeLayer" },
+            "residual": { "$ref": "#/definitions/DecomposeLayer" }
+          }
+        },
+        "hedge": {
+          "type": "object",
+          "additionalProperties": { "type": "number" },
+          "description": "Map of hedge-ETF -> dollar ratio (= negative of layer hr). Duplicate ETFs across layers are summed."
+        },
+        "hedge_levels": { "$ref": "#/definitions/HedgeLevelsBlock" },
+        "_metadata": { "type": "object" },
+        "_data_health": {
+          "type": "object",
+          "properties": {
+            "er_populated": { "type": "boolean" },
+            "er_sum": { "type": ["number", "null"] }
+          }
+        }
+      }
+    }
+  }
+}

package/data/schemas/hedge-levels-v1.json

@@ -0,0 +1,68 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "riskmodels:///schemas/hedge-levels-v1.json",
+  "title": "Hedge levels (canonical L1/L2/L3)",
+  "description": "Canonical hedge_levels block emitted on GET /metrics/{ticker}, POST /decompose, POST /batch/analyze (success rows), hedge-basket, and related surfaces. Compare standalone L1/L2/L3 hedge solutions without parsing flat l*_mkt_hr wire keys.",
+  "oneOf": [{ "$ref": "#/definitions/HedgeLevelsBlock" }],
+  "definitions": {
+    "LevelHedgeSnapshot": {
+      "type": "object",
+      "required": [
+        "market_hr",
+        "sector_hr",
+        "subsector_hr",
+        "market_er",
+        "sector_er",
+        "subsector_er",
+        "residual_er",
+        "hedge_etfs"
+      ],
+      "properties": {
+        "market_hr": {
+          "type": ["number", "null"],
+          "description": "Dollar-ratio HR — ETF notional per $1 stock."
+        },
+        "sector_hr": { "type": ["number", "null"] },
+        "subsector_hr": { "type": ["number", "null"] },
+        "market_er": {
+          "type": ["number", "null"],
+          "description": "Explained-risk variance fraction for the populated leg(s) when defined."
+        },
+        "sector_er": { "type": ["number", "null"] },
+        "subsector_er": { "type": ["number", "null"] },
+        "residual_er": { "type": ["number", "null"] },
+        "hedge_etfs": {
+          "type": "object",
+          "required": ["market", "sector", "subsector"],
+          "properties": {
+            "market": { "type": "string", "examples": ["SPY"] },
+            "sector": { "type": ["string", "null"] },
+            "subsector": { "type": ["string", "null"] }
+          },
+          "additionalProperties": false
+        }
+      },
+      "additionalProperties": false
+    },
+    "HedgeLevelsBlock": {
+      "type": "object",
+      "required": ["L1", "L2", "L3"],
+      "properties": {
+        "L1": { "$ref": "#/definitions/LevelHedgeSnapshot" },
+        "L2": { "$ref": "#/definitions/LevelHedgeSnapshot" },
+        "L3": { "$ref": "#/definitions/LevelHedgeSnapshot" },
+        "recommended_level": {
+          "type": ["string", "null"],
+          "enum": ["L1", "L2", "L3", null],
+          "description": "Economically gated recommendation when emitted by the hedge stack."
+        },
+        "statistical_lstar": {
+          "type": ["string", "null"],
+          "enum": ["L1", "L2", "L3", null],
+          "description": "Cascade statistical layer pick (orthogonal Lstar)."
+        }
+      },
+      "additionalProperties": true
+    }
+  }
+}

package/dist/lib/mcp/tools/riskmodels-tools.d.ts

@@ -3,7 +3,7 @@ type McpContent = {
     type: "text";
     text: string;
 };
-type McpToolResult = {
+export type McpToolResult = {
     content: McpContent[];
 };
 type McpPromptResult = {
@@ -13,7 +13,7 @@ type McpPromptResult = {
         content: McpContent;
     }>;
 };
-type McpLikeServer = {
+export type McpLikeServer = {
     registerTool: (name: string, config: Record<string, unknown>, handler: (args: any) => Promise<McpToolResult>) => void;
     registerResource: (name: string, uri: string, config: Record<string, unknown>, handler: (uri: URL) => Promise<{
         contents: Array<{
@@ -24,11 +24,13 @@ type McpLikeServer = {
     }>) => void;
     registerPrompt?: (name: string, config: Record<string, unknown>, handler: (args: any) => McpPromptResult | Promise<McpPromptResult>) => void;
 };
+export declare function textResult(payload: unknown): McpToolResult;
+export declare function errorResult(error: unknown): McpToolResult;
 export declare function createRiskModelsSdk(opts: {
     apiKey?: string | null;
     apiBase?: string;
 }): RiskModelsClient;
-export declare function registerRiskModelsTools(sdk: Pick<RiskModelsClient, "decompose" | "compare" | "hedgePosition" | "portfolioDecompose" | "whitepaperExample">, server: McpLikeServer): void;
+export declare function registerRiskModelsTools(sdk: Pick<RiskModelsClient, "decompose" | "getHedgeLevels" | "compare" | "hedgePosition" | "analyzePortfolio" | "hedgePortfolio" | "portfolioDecompose" | "whitepaperExample">, server: McpLikeServer): void;
 export declare function registerRiskModelsWhitepaperResources(server: McpLikeServer, dataDir: string): void;
 export declare function registerRiskModelsPrompts(server: McpLikeServer): void;
 export {};

package/dist/lib/mcp/tools/riskmodels-tools.js

@@ -35,7 +35,7 @@ const WHITEPAPER_RESOURCES = [
     },
 ];
 const CHART_INSTRUCTION = "If chart_data is present, render the suggested_chart. Use grouped bars for comparisons and bars for single-stock decomposition. Always explain the result in plain English.";
-function textResult(payload) {
+export function textResult(payload) {
     return {
         content: [
             {
@@ -50,7 +50,7 @@ function textResult(payload) {
         ],
     };
 }
-function errorResult(error) {
+export function errorResult(error) {
     return textResult({
         error: error instanceof Error ? error.message : String(error),
     });
@@ -73,7 +73,8 @@ export function createRiskModelsSdk(opts) {
 export function registerRiskModelsTools(sdk, server) {
     server.registerTool("riskmodels_decompose", {
         title: "RiskModels Single-Stock Decomposition",
-        description: "Decompose one stock into market, sector, subsector, and residual risk. Returns chart_data, suggested_chart, plain_english, and reproducible api_call metadata.",
+        annotations: { readOnlyHint: true },
+        description: "L3 four-bet view: decompose one stock into additive market, sector, subsector, and residual layers (same semantics as POST /decompose exposure/hedge). Returns chart_data and plain_english. To compare standalone L1 vs L2 vs L3 hedge solutions (HR/ER + ETF legs), call riskmodels_get_hedge_levels or read hedge_levels on the API response.",
         inputSchema: {
             ticker: z.string().min(1).describe("Ticker symbol, e.g. NVDA or AAPL"),
         },
@@ -85,8 +86,24 @@ export function registerRiskModelsTools(sdk, server) {
             return errorResult(error);
         }
     });
+    server.registerTool("riskmodels_get_hedge_levels", {
+        title: "RiskModels L1/L2/L3 hedge_levels",
+        annotations: { readOnlyHint: true },
+        description: "Canonical L1, L2, and L3 hedge snapshots (semantic HR/ER + hedge_etfs) from GET /metrics/{ticker}. Use this when you need to compare which cascade depth to trade, distinct from decompose four-bet exposure.",
+        inputSchema: {
+            ticker: z.string().min(1).describe("Ticker symbol, e.g. NVDA or AAPL"),
+        },
+    }, async ({ ticker }) => {
+        try {
+            return textResult(await sdk.getHedgeLevels(ticker));
+        }
+        catch (error) {
+            return errorResult(error);
+        }
+    });
     server.registerTool("riskmodels_compare", {
         title: "RiskModels Multi-Ticker Comparison",
+        annotations: { readOnlyHint: true },
         description: "Compare tickers across market, sector, subsector, and residual risk layers. Prefer grouped bar charts when chart_data is present.",
         inputSchema: {
             tickers: z.array(z.string().min(1)).min(2).max(100).describe("Ticker symbols to compare"),
@@ -101,6 +118,7 @@ export function registerRiskModelsTools(sdk, server) {
     });
     server.registerTool("riskmodels_hedge_position", {
         title: "RiskModels Position Hedge",
+        annotations: { readOnlyHint: true },
         description: "Scale ETF hedge ratios for a ticker to a dollar position. Returns chart-ready hedge notionals.",
         inputSchema: {
             ticker: z.string().min(1).describe("Ticker symbol, e.g. NVDA"),
@@ -114,8 +132,62 @@ export function registerRiskModelsTools(sdk, server) {
             return errorResult(error);
         }
     });
+    server.registerTool("riskmodels_analyze_portfolio", {
+        title: "RiskModels Portfolio hedge_levels aggregate",
+        annotations: { readOnlyHint: true },
+        description: "Holdings-weighted L1/L2/L3 hedge_levels across names via POST /batch/analyze (hedge_ratios). Returns normalized portfolio.portfolio_hedge_levels and per-ticker blocks when present.",
+        inputSchema: {
+            positions: z
+                .array(z.object({
+                ticker: z.string().min(1),
+                weight: z.number().positive().optional(),
+                dollars: z.number().positive().optional(),
+            }))
+                .min(1)
+                .max(100)
+                .describe("Positions with weight or dollars (combined per ticker)"),
+            years: z.number().int().min(1).max(30).optional().describe("Batch lookback window, default 1"),
+        },
+    }, async ({ positions, years }) => {
+        try {
+            return textResult(await sdk.analyzePortfolio(positions, { years }));
+        }
+        catch (error) {
+            return errorResult(error);
+        }
+    });
+    server.registerTool("riskmodels_hedge_portfolio", {
+        title: "RiskModels Portfolio ETF hedge notionals",
+        annotations: { readOnlyHint: true },
+        description: "Batch hedge_ratios at a chosen cascade level (L1/L2/L3), scale HRs by dollar notionals per ticker, and aggregate ETF USD hedge legs.",
+        inputSchema: {
+            positions: z
+                .array(z.object({
+                ticker: z.string().min(1),
+                dollars: z.number().positive(),
+            }))
+                .min(1)
+                .max(100),
+            level: z.enum(["L1", "L2", "L3"]).optional().describe("Cascade depth; default L3"),
+            years: z.number().int().min(1).max(30).optional(),
+        },
+    }, async ({ positions, level, years }) => {
+        try {
+            return textResult(await sdk.hedgePortfolio(positions.map((row) => ({
+                ticker: row.ticker,
+                dollars: row.dollars,
+            })), {
+                level,
+                years,
+            }));
+        }
+        catch (error) {
+            return errorResult(error);
+        }
+    });
     server.registerTool("riskmodels_portfolio_decompose", {
         title: "RiskModels Portfolio Decomposition",
+        annotations: { readOnlyHint: true },
         description: "Decompose a weighted portfolio into market, sector, subsector, and residual risk layers.",
         inputSchema: {
             positions: z
@@ -138,6 +210,7 @@ export function registerRiskModelsTools(sdk, server) {
     });
     server.registerTool("riskmodels_whitepaper_example", {
         title: "RiskModels Live White-Paper Example",
+        annotations: { readOnlyHint: true },
         description: "Run a live example from the RiskModels white paper. Returns chapter text plus SDK/API output with chart_data.",
         inputSchema: {
             exampleId: z
@@ -207,5 +280,5 @@ ${CHART_INSTRUCTION}`));
     server.registerPrompt("explain_my_portfolio", {
         title: "Explain My Portfolio",
         description: "Decompose a portfolio into RiskModels layers.",
-    }, () => promptText(`Ask me for tickers and weights or dollar notionals, then call riskmodels_portfolio_decompose. Render chart_data using suggested_chart and explain the market, sector, subsector, and residual risk layers.`));
+    }, () => promptText(`Ask me for tickers and weights or dollar notionals, then call riskmodels_portfolio_decompose (L3 four-bet aggregation) or riskmodels_analyze_portfolio for holdings-weighted hedge_levels across L1/L2/L3. Render chart_data using suggested_chart and explain the layers.`));
 }

package/dist/mcp/src/server.js

@@ -430,5 +430,60 @@ export function createMcpServer(opts = {}) {
         }
         return { content: [{ type: "text", text: wrapWithMeter(data, meter) }] };
     });
+    server.registerTool("post_snapshot", {
+        title: "Canonical Portfolio Snapshot",
+        description: "Run a canonical risk snapshot on a portfolio (1–100 positions): L3 variance decomposition (market / sector / subsector / residual / systematic), L3 hedge ratios per position, frozen-weight daily return attribution (gross + market / sector / subsector strips + residual), cumulative return and drawdown over the lookback window, and a risk_summary with dominant drivers, concentration flags, and top exposures. This is the canonical RiskModels public surface — same response shape across UI, CLI, SDK, and agents. Provide either weight or shares for every position (do not mix). Bills as portfolio-risk-snapshot ($0.25 per request).",
+        inputSchema: z.object({
+            portfolio: z
+                .array(z
+                .object({
+                ticker: z.string().describe("US equity ticker, e.g. NVDA, AAPL, SPY"),
+                weight: z
+                    .number()
+                    .positive()
+                    .optional()
+                    .describe("Positive weight or dollar amount; server normalizes to sum to 1"),
+                shares: z
+                    .number()
+                    .positive()
+                    .optional()
+                    .describe("Share count; converted to weights via latest price_close"),
+            })
+                .refine((p) => (p.weight != null) !== (p.shares != null), {
+                message: "Each position must have exactly one of weight or shares",
+            }))
+                .min(1)
+                .max(100)
+                .describe("Portfolio positions. Use weights for every position OR shares for every position — do not mix."),
+            lookback_days: z
+                .number()
+                .int()
+                .min(20)
+                .max(2000)
+                .optional()
+                .default(252)
+                .describe("Trading days of history for return curves and attribution series (default 252)"),
+            benchmark: z
+                .string()
+                .optional()
+                .describe("Optional benchmark ticker (reserved for comparison views)"),
+        }),
+    }, async ({ portfolio, lookback_days, benchmark }) => {
+        const body = {
+            type: "portfolio",
+            portfolio,
+            lookback_days,
+        };
+        if (benchmark)
+            body.benchmark = benchmark;
+        const { status, data, meter, error } = await apiCall(opts, "POST", "/snapshot", { body });
+        if (error) {
+            return { content: [{ type: "text", text: JSON.stringify({ error }) }] };
+        }
+        if (status >= 400) {
+            return { content: [{ type: "text", text: JSON.stringify({ error: `API ${status}`, detail: data }) }] };
+        }
+        return { content: [{ type: "text", text: wrapWithMeter(data, meter) }] };
+    });
     return server;
 }

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@riskmodels/mcp",
-  "version": "1.0.1",
+  "version": "1.0.4",
+  "mcpName": "io.github.BlueWaterCorp/riskmodels",
   "description": "MCP server for RiskModels: decompose US equities into four-bet variance shares with ETF hedge ratios",
   "type": "module",
   "main": "dist/index.js",
   "bin": {
-    "riskmodels-mcp": "./dist/index.js"
+    "riskmodels-mcp": "dist/index.js"
   },
   "exports": {
     ".": {
@@ -29,7 +30,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.0.0",
-    "@riskmodels/sdk": "^0.1.0",
+    "@riskmodels/sdk": "^0.1.2",
     "zod": "^3.23.8"
   },
   "devDependencies": {

package/server.json

@@ -0,0 +1,18 @@
+{
+  "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
+  "name": "io.github.BlueWaterCorp/riskmodels",
+  "title": "RiskModels",
+  "description": "US equity risk: decompose any stock into market/sector/subsector/residual bets + ETF hedge ratios.",
+  "websiteUrl": "https://riskmodels.app",
+  "repository": {
+    "url": "https://github.com/BlueWaterCorp/RiskModels_API",
+    "source": "github"
+  },
+  "version": "1.0.4",
+  "remotes": [
+    {
+      "type": "streamable-http",
+      "url": "https://riskmodels.app/api/mcp/sse"
+    }
+  ]
+}

package/src/server.ts

@@ -551,5 +551,69 @@ export function createMcpServer(opts: McpServerOptions = {}): McpServer {
     },
   );
 
+  server.registerTool(
+    "post_snapshot",
+    {
+      title: "Canonical Portfolio Snapshot",
+      description:
+        "Run a canonical risk snapshot on a portfolio (1–100 positions): L3 variance decomposition (market / sector / subsector / residual / systematic), L3 hedge ratios per position, frozen-weight daily return attribution (gross + market / sector / subsector strips + residual), cumulative return and drawdown over the lookback window, and a risk_summary with dominant drivers, concentration flags, and top exposures. This is the canonical RiskModels public surface — same response shape across UI, CLI, SDK, and agents. Provide either weight or shares for every position (do not mix). Bills as portfolio-risk-snapshot ($0.25 per request).",
+      inputSchema: z.object({
+        portfolio: z
+          .array(
+            z
+              .object({
+                ticker: z.string().describe("US equity ticker, e.g. NVDA, AAPL, SPY"),
+                weight: z
+                  .number()
+                  .positive()
+                  .optional()
+                  .describe("Positive weight or dollar amount; server normalizes to sum to 1"),
+                shares: z
+                  .number()
+                  .positive()
+                  .optional()
+                  .describe("Share count; converted to weights via latest price_close"),
+              })
+              .refine((p) => (p.weight != null) !== (p.shares != null), {
+                message: "Each position must have exactly one of weight or shares",
+              }),
+          )
+          .min(1)
+          .max(100)
+          .describe(
+            "Portfolio positions. Use weights for every position OR shares for every position — do not mix.",
+          ),
+        lookback_days: z
+          .number()
+          .int()
+          .min(20)
+          .max(2000)
+          .optional()
+          .default(252)
+          .describe("Trading days of history for return curves and attribution series (default 252)"),
+        benchmark: z
+          .string()
+          .optional()
+          .describe("Optional benchmark ticker (reserved for comparison views)"),
+      }),
+    },
+    async ({ portfolio, lookback_days, benchmark }) => {
+      const body: Record<string, unknown> = {
+        type: "portfolio",
+        portfolio,
+        lookback_days,
+      };
+      if (benchmark) body.benchmark = benchmark;
+      const { status, data, meter, error } = await apiCall(opts, "POST", "/snapshot", { body });
+      if (error) {
+        return { content: [{ type: "text", text: JSON.stringify({ error }) }] };
+      }
+      if (status >= 400) {
+        return { content: [{ type: "text", text: JSON.stringify({ error: `API ${status}`, detail: data }) }] };
+      }
+      return { content: [{ type: "text", text: wrapWithMeter(data, meter) }] };
+    },
+  );
+
   return server;
 }