From 45c7b97c48094caa446de6a984567c5dce83183f Mon Sep 17 00:00:00 2001 From: "sentry-junior[bot]" <264270552+sentry-junior[bot]@users.noreply.github.com> Date: Thu, 19 Nov 2026 04:39:49 +0000 Subject: [PATCH 01/23] feat(mcp): Pass tool _meta through and list MCP Apps UI resources Tools can now declare MCP `_meta`, which the server sends in tools/list. A tool that points `_meta.ui.resourceUri` at a view in the new UI resource registry gets that `ui://` resource listed and readable, with the MCP Apps mime type. The registry is empty until the chart view lands. Refs getsentry/toolkit#741 Co-Authored-By: David Cramer <23610+dcramer@users.noreply.github.com> --- packages/mcp-core/package.json | 5 ++ packages/mcp-core/src/server.ts | 6 ++ packages/mcp-core/src/tools/types.ts | 6 ++ packages/mcp-core/src/ui-resources.ts | 86 +++++++++++++++++++++++++++ pnpm-lock.yaml | 63 ++++++++++++++++++++ pnpm-workspace.yaml | 4 ++ 6 files changed, 170 insertions(+) create mode 100644 packages/mcp-core/src/ui-resources.ts diff --git a/packages/mcp-core/package.json b/packages/mcp-core/package.json index ea61352bd..5d4eaaea0 100644 --- a/packages/mcp-core/package.json +++ b/packages/mcp-core/package.json @@ -164,9 +164,13 @@ "devDependencies": { "@ai-sdk/provider": "^3.0.6", "@ai-sdk/provider-utils": "^4.0.11", + "@modelcontextprotocol/client": "catalog:", + "@modelcontextprotocol/core": "catalog:", "@modelcontextprotocol/sdk": "catalog:", "@sentry/mcp-server-mocks": "workspace:*", + "esbuild": "^0.28.1", "msw": "catalog:", + "playwright-core": "catalog:", "tiktoken": "^1.0.18", "yaml": "^2.8.3" }, @@ -176,6 +180,7 @@ "@ai-sdk/openai": "catalog:", "@logtape/logtape": "^1.1.1", "@logtape/sentry": "^1.1.1", + "@modelcontextprotocol/ext-apps": "catalog:", "@modelcontextprotocol/server": "catalog:", "@sentry/api": "catalog:", "@sentry/core": "catalog:", diff --git a/packages/mcp-core/src/server.ts b/packages/mcp-core/src/server.ts index 4d5616148..49702c0b8 100644 --- a/packages/mcp-core/src/server.ts +++ b/packages/mcp-core/src/server.ts @@ -59,6 +59,7 @@ import tools from "./tools/index"; import { isCatalogInfrastructureToolName } from "./tools/surfaces"; import type { StructuredToolOutput } from "./tools/types"; import type { ServerContext } from "./types"; +import { registerUiResources } from "./ui-resources"; import { getServerVersion } from "./version"; function getSkillGrantedAttributeName(skill: Skill): string { @@ -340,6 +341,10 @@ export function buildServer({ for (const { name, config, handler } of registrations) { server.registerTool(name, config, handler); } + registerUiResources( + server, + registrations.map(({ config }) => config), + ); // Registration enables this by default, but each server's tool catalog is fixed. if (registrations.length > 0) { server.server.registerCapabilities({ tools: { listChanged: false } }); @@ -409,6 +414,7 @@ function configureServer({ tool.outputSchema ?? (experimentalMode ? tool.experimentalOutputSchema : undefined), annotations: tool.annotations, + ...(tool._meta && { _meta: tool._meta }), }; const handleToolCall = async ( params: unknown, diff --git a/packages/mcp-core/src/tools/types.ts b/packages/mcp-core/src/tools/types.ts index e453e9332..083c45726 100644 --- a/packages/mcp-core/src/tools/types.ts +++ b/packages/mcp-core/src/tools/types.ts @@ -170,6 +170,12 @@ export interface ToolConfig< idempotentHint?: boolean; openWorldHint: boolean; }; + /** + * MCP `_meta` sent with the tool in tools/list, for keys that hosts read, + * such as `ui.resourceUri` (MCP Apps). Every key must be listed in + * `ALLOWED_TOOL_META` in server.metadata.test.ts. + */ + _meta?: Record; handler: ToolHandler>; /** * Optional hook invoked when the handler throws, for tool-specific failure diff --git a/packages/mcp-core/src/ui-resources.ts b/packages/mcp-core/src/ui-resources.ts new file mode 100644 index 000000000..f666aa2b8 --- /dev/null +++ b/packages/mcp-core/src/ui-resources.ts @@ -0,0 +1,86 @@ +/** + * MCP Apps views: `ui://` HTML resources that a host renders inline for a + * tool result. A tool opts in with `_meta: uiToolMeta(resource)`, and the + * server lists each resource that a registered tool references. + * + * Spec: https://github.com/modelcontextprotocol/ext-apps/blob/main/specification/2026-01-26/apps.mdx + */ +import type { + McpUiResourceMeta, + McpUiToolMeta, +} from "@modelcontextprotocol/ext-apps"; +import { RESOURCE_MIME_TYPE } from "@modelcontextprotocol/ext-apps/server"; +import type { McpServer } from "@modelcontextprotocol/server"; + +export interface UiResource { + /** Hosts cache a view by its URI, so bump the version when the HTML changes. */ + uri: `ui://${string}`; + name: string; + title: string; + description: string; + /** A self-contained HTML5 document: inline scripts and styles only. */ + html: string; + meta: McpUiResourceMeta; +} + +export const UI_RESOURCES: readonly UiResource[] = []; + +/** + * `_meta` for a tool whose result renders in `resource`. ChatGPT reads + * `openai/outputTemplate`; MCP Apps hosts read `ui.resourceUri`. + */ +export function uiToolMeta(resource: UiResource): { + ui: McpUiToolMeta; + "openai/outputTemplate": string; +} { + return { + ui: { resourceUri: resource.uri }, + "openai/outputTemplate": resource.uri, + }; +} + +function referencedResourceUri( + meta: Record | undefined, +): string | undefined { + const ui = meta?.["ui"]; + if (typeof ui !== "object" || ui === null || !("resourceUri" in ui)) { + return undefined; + } + return typeof ui.resourceUri === "string" ? ui.resourceUri : undefined; +} + +/** Lists the views that the registered tools reference. */ +export function registerUiResources( + server: McpServer, + tools: readonly { _meta?: Record | undefined }[], +): void { + const referenced = new Set( + tools.map((tool) => referencedResourceUri(tool._meta)), + ); + const resources = UI_RESOURCES.filter((resource) => + referenced.has(resource.uri), + ); + for (const resource of resources) { + const content = { + uri: resource.uri, + mimeType: RESOURCE_MIME_TYPE, + text: resource.html, + _meta: { ui: resource.meta }, + }; + server.registerResource( + resource.name, + resource.uri, + { + title: resource.title, + description: resource.description, + mimeType: RESOURCE_MIME_TYPE, + _meta: { ui: resource.meta }, + }, + () => ({ contents: [content] }), + ); + } + // Registration enables this by default, but the set of views is fixed. + if (resources.length > 0) { + server.server.registerCapabilities({ resources: { listChanged: false } }); + } +} diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index a3ee071ae..59d94b3a9 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -195,6 +195,15 @@ catalogs: '@cloudflare/workers-types': specifier: ^4.20260405.1 version: 4.20260405.1 + '@modelcontextprotocol/client': + specifier: 2.4.0 + version: 2.4.0 + '@modelcontextprotocol/core': + specifier: 2.4.0 + version: 2.4.0 + '@modelcontextprotocol/ext-apps': + specifier: 2.0.4 + version: 2.0.4 '@modelcontextprotocol/server': specifier: 2.4.0 version: 2.4.0 @@ -312,6 +321,9 @@ catalogs: oxlint: specifier: 1.93.0 version: 1.93.0 + playwright-core: + specifier: 1.65.1 + version: 1.65.1 react: specifier: ^19.2.8 version: 19.2.8 @@ -1021,6 +1033,9 @@ importers: '@logtape/sentry': specifier: ^1.1.1 version: 1.1.1(@logtape/logtape@1.1.1) + '@modelcontextprotocol/ext-apps': + specifier: 'catalog:' + version: 2.0.4(@modelcontextprotocol/client@2.4.0)(@modelcontextprotocol/core@2.4.0)(@modelcontextprotocol/server@2.4.0)(react-dom@19.2.8(react@19.2.8))(react@19.2.8)(zod@4.6.7) '@modelcontextprotocol/server': specifier: 'catalog:' version: 2.4.0 @@ -1058,15 +1073,27 @@ importers: '@ai-sdk/provider-utils': specifier: ^4.0.33 version: 4.0.40(zod@4.6.7) + '@modelcontextprotocol/client': + specifier: 'catalog:' + version: 2.4.0 + '@modelcontextprotocol/core': + specifier: 'catalog:' + version: 2.4.0 '@modelcontextprotocol/sdk': specifier: 1.32.2 version: 1.32.2(@cfworker/json-schema@4.1.1)(supports-color@10.1.0)(zod@4.6.7) '@sentry/mcp-server-mocks': specifier: workspace:* version: link:../mcp-server-mocks + esbuild: + specifier: ^0.28.1 + version: 0.28.2 msw: specifier: 'catalog:' version: 2.15.0(@types/node@22.20.3)(typescript@7.0.2) + playwright-core: + specifier: 'catalog:' + version: 1.65.1 tiktoken: specifier: ^1.0.18 version: 1.0.22 @@ -2991,6 +3018,24 @@ packages: resolution: {integrity: sha512-z8QBKqdfXLPzkLQuG4xp8hrVEMm1PZ1IgxMN2sMbJiFiAKOWXnAzogXn2W4aqIBlP1ea6U5yiqVquvUNM1Cj6Q==} engines: {node: '>=20'} + '@modelcontextprotocol/ext-apps@2.0.4': + resolution: {integrity: sha512-B+PcbuGiaf0e5I3uy4iO5tS3Abo+5w8JvZFzHMzQdq9yVwP836zJkw2+KCGOQ0r4TM1fuQi4JdnbuWjkS4aBvg==} + engines: {node: '>=20'} + peerDependencies: + '@modelcontextprotocol/client': ^2.0.0 + '@modelcontextprotocol/core': ^2.0.0 + '@modelcontextprotocol/server': ^2.0.0 + react: ^17.0.0 || ^18.0.0 || ^19.0.0 + react-dom: ^17.0.0 || ^18.0.0 || ^19.0.0 + zod: ^4.6.6 + peerDependenciesMeta: + '@modelcontextprotocol/server': + optional: true + react: + optional: true + react-dom: + optional: true + '@modelcontextprotocol/sdk@1.32.2': resolution: {integrity: sha512-SWsVtH/0vULSQStoZ6xxH2K09Li8fXYTMC64ZeogCdpZ3XSi1eCPOByV1OpuJxuI3OcmHhosDWYyii07tpPsLw==} engines: {node: '>=18'} @@ -7354,6 +7399,11 @@ packages: resolution: {integrity: sha512-wQ0b/W4Fr01qtpHlqSqspcj3EhBvimsdh0KlHhH8HRZnMsEa0ea2fTULOXOS9ccQr3om+GcGRk4e+isrZWV8qQ==} engines: {node: '>=16.20.0'} + playwright-core@1.65.1: + resolution: {integrity: sha512-hqPpz7blSMPxWVdoeE1yiBSzXsKiVOd2k+kjCvmUywD2GPO2Dd9HfcWnq9NN0GHbNZDFgZ9JfBFr+X5/BLo0qw==} + engines: {node: '>=20'} + hasBin: true + pngjs@7.0.0: resolution: {integrity: sha512-LKWqWJRhstyYo9pGvgor/ivk2w94eSjE3RGVuzLGlr3NmD8bf7RcYGze1mNdEHRP6TRP6rMuDHk5t44hnTRyow==} engines: {node: '>=14.19.0'} @@ -10422,6 +10472,17 @@ snapshots: dependencies: zod: 4.6.7 + '@modelcontextprotocol/ext-apps@2.0.4(@modelcontextprotocol/client@2.4.0)(@modelcontextprotocol/core@2.4.0)(@modelcontextprotocol/server@2.4.0)(react-dom@19.2.8(react@19.2.8))(react@19.2.8)(zod@4.6.7)': + dependencies: + '@modelcontextprotocol/client': 2.4.0 + '@modelcontextprotocol/core': 2.4.0 + '@standard-schema/spec': 1.1.0 + zod: 4.6.7 + optionalDependencies: + '@modelcontextprotocol/server': 2.4.0 + react: 19.2.8 + react-dom: 19.2.8(react@19.2.8) + '@modelcontextprotocol/sdk@1.32.2(@cfworker/json-schema@4.1.1)(supports-color@10.1.0)(zod@4.6.7)': dependencies: '@hono/node-server': 2.1.7(hono@4.13.18) @@ -14764,6 +14825,8 @@ snapshots: pkce-challenge@5.0.1: {} + playwright-core@1.65.1: {} + pngjs@7.0.0: {} portable-executable-signature@2.0.6: {} diff --git a/pnpm-workspace.yaml b/pnpm-workspace.yaml index 186ff9edb..51d7f42ef 100644 --- a/pnpm-workspace.yaml +++ b/pnpm-workspace.yaml @@ -56,6 +56,9 @@ catalog: "@cloudflare/vitest-plugin": 1.4.12 "@cloudflare/workers-oauth-provider": ^0.10.3 "@cloudflare/workers-types": ^4.20260405.1 + "@modelcontextprotocol/client": 2.4.0 + "@modelcontextprotocol/core": 2.4.0 + "@modelcontextprotocol/ext-apps": 2.0.4 "@modelcontextprotocol/sdk": 1.32.2 "@modelcontextprotocol/server": 2.4.0 "@radix-ui/react-accordion": ^1.2.20 @@ -94,6 +97,7 @@ catalog: miniflare: 5.20261101.0-beta msw: ^2.15.0 open: ^10.1.2 + playwright-core: 1.65.1 oxfmt: 0.78.0 oxlint: 1.93.0 react: ^19.2.8 From 8c20c22cd88094c87d0f1a060a218ba254d72f71 Mon Sep 17 00:00:00 2001 From: "sentry-junior[bot]" <264270552+sentry-junior[bot]@users.noreply.github.com> Date: Thu, 19 Nov 2026 04:49:24 +0000 Subject: [PATCH 02/23] feat(mcp): Add render_sentry_chart for full time series charts render_sentry_chart fetches an events time series for a query and returns every bucket of each series, so values never round-trip through the model and the chart is not capped at 48 buckets like search results are. With groupBy it asks events-timeseries for the top 5 values of one attribute (topEvents, without the Other series) and returns one series per value. Time series results from the dataset search tools now suggest the same chart as a callable render_sentry_chart action. Refs getsentry/toolkit#741 Co-Authored-By: David Cramer <23610+dcramer@users.noreply.github.com> --- packages/mcp-core/src/api-client/client.ts | 12 + packages/mcp-core/src/api-client/schema.ts | 11 +- packages/mcp-core/src/skillDefinitions.json | 21 +- packages/mcp-core/src/toolDefinitions.json | 287 ++++++++++++++++++ packages/mcp-core/src/tools/catalog/index.ts | 2 + .../tools/catalog/render-sentry-chart.test.ts | 215 +++++++++++++ .../src/tools/catalog/render-sentry-chart.ts | 247 +++++++++++++++ .../catalog/search-errors.structured.test.ts | 15 +- .../src/tools/support/chart/schema.ts | 62 ++++ .../mcp-core/src/tools/support/ingestion.ts | 29 ++ .../tools/support/search-events/formatters.ts | 93 +++--- .../src/tools/support/search-events/search.ts | 9 + .../tools/support/search-events/structured.ts | 46 +-- .../mcp-server-mocks/src/events-timeseries.ts | 102 +++++++ packages/mcp-server-mocks/src/index.ts | 6 + .../agents/sentry-mcp.md | 1 + plugins/sentry-mcp/agents/sentry-mcp.md | 1 + 17 files changed, 1097 insertions(+), 62 deletions(-) create mode 100644 packages/mcp-core/src/tools/catalog/render-sentry-chart.test.ts create mode 100644 packages/mcp-core/src/tools/catalog/render-sentry-chart.ts create mode 100644 packages/mcp-core/src/tools/support/chart/schema.ts create mode 100644 packages/mcp-core/src/tools/support/ingestion.ts create mode 100644 packages/mcp-server-mocks/src/events-timeseries.ts diff --git a/packages/mcp-core/src/api-client/client.ts b/packages/mcp-core/src/api-client/client.ts index 1b2d5f3dc..7f848ce72 100644 --- a/packages/mcp-core/src/api-client/client.ts +++ b/packages/mcp-core/src/api-client/client.ts @@ -4747,6 +4747,7 @@ export class SentryApiService { statsPeriod, start, end, + topEvents, }: { organizationSlug: string; query: string; @@ -4757,6 +4758,11 @@ export class SentryApiService { statsPeriod?: string; start?: string; end?: string; + /** + * One series per value of `groupBy`, for the `limit` values with the + * highest `yAxis`, without an "Other" series. + */ + topEvents?: { groupBy: string; limit: number } | undefined; }, opts?: RequestOptions, ) { @@ -4764,6 +4770,12 @@ export class SentryApiService { queryParams.set("dataset", normalizeEventsDataset(dataset)); queryParams.set("query", query); queryParams.set("yAxis", yAxis); + if (topEvents) { + queryParams.set("topEvents", String(topEvents.limit)); + queryParams.set("groupBy", topEvents.groupBy); + queryParams.set("sort", `-${yAxis}`); + queryParams.set("excludeOther", "1"); + } // Omit interval to let Sentry pick a sensible bucket size for the range. if (interval) { queryParams.set("interval", interval); diff --git a/packages/mcp-core/src/api-client/schema.ts b/packages/mcp-core/src/api-client/schema.ts index 79b4a826f..00321a075 100644 --- a/packages/mcp-core/src/api-client/schema.ts +++ b/packages/mcp-core/src/api-client/schema.ts @@ -2668,7 +2668,8 @@ export const EventsTimeSeriesValueSchema = z /** * Response from the events-timeseries endpoint. The MCP always requests a - * single yAxis without topEvents, so `timeSeries` holds exactly one series. + * single yAxis, so `timeSeries` holds one series, or one per group with + * `topEvents`, each naming its group in `groupBy`. */ export const EventsTimeSeriesResponseSchema = z .object({ @@ -2677,6 +2678,14 @@ export const EventsTimeSeriesResponseSchema = z .object({ yAxis: z.string(), values: z.array(EventsTimeSeriesValueSchema), + groupBy: z + .array( + z.object({ + key: z.string(), + value: z.union([z.string(), z.number()]).nullable(), + }), + ) + .optional(), meta: z .object({ // Bucket width in milliseconds diff --git a/packages/mcp-core/src/skillDefinitions.json b/packages/mcp-core/src/skillDefinitions.json index cd770a91c..d72806401 100644 --- a/packages/mcp-core/src/skillDefinitions.json +++ b/packages/mcp-core/src/skillDefinitions.json @@ -5,7 +5,7 @@ "description": "Read-only access to core Sentry data: issues, events, traces, replays, releases, cron monitors, uptime monitors, metric monitors, profiles, documentation, and project metadata", "defaultEnabled": true, "order": 1, - "toolCount": 49, + "toolCount": 50, "tools": [ { "name": "find_alert_rules", @@ -192,6 +192,11 @@ "description": "Get a Sentry uptime monitor: its URL, interval, thresholds, status, and recent HTTP check results (status code, duration, failures). Request bodies are never returned; sensitive headers are redacted.\nScheduled jobs (cron): find_monitors. Metric thresholds: find_metric_monitors.\nRelated issues: search_issues with uptime_rule:.", "requiredScopes": ["project:read"] }, + { + "name": "render_sentry_chart", + "description": "Chart a count, rate, duration, or other aggregate of Sentry errors, logs, spans, metrics, or profiles over time, optionally split into the top 5 values of one attribute. Returns every bucket of each series, and MCP Apps hosts show it as an interactive chart. To find individual events, use the dataset search tools.", + "requiredScopes": ["event:read"] + }, { "name": "search_agent_conversations", "description": "Search Sentry agent conversations (formerly AI conversations): one summary row per LLM agent conversation with title, cost, tokens, call counts, and previews. For one conversation's transcript, use get_agent_conversation_details.", @@ -260,7 +265,7 @@ "description": "Sentry's AI debugger that helps you analyze, root cause, and fix issues", "defaultEnabled": true, "order": 2, - "toolCount": 19, + "toolCount": 20, "tools": [ { "name": "analyze_issue_with_seer", @@ -307,6 +312,11 @@ "description": "Fetch a Sentry resource by URL or ID: issues, events, traces, spans, agent conversations, replays, preprod snapshots, and snapshot images. Start here for any Sentry URL or issue, event, trace, or replay ID; the type is detected from the URL. To list agent conversations, use search_agent_conversations.", "requiredScopes": ["event:read", "project:read"] }, + { + "name": "render_sentry_chart", + "description": "Chart a count, rate, duration, or other aggregate of Sentry errors, logs, spans, metrics, or profiles over time, optionally split into the top 5 values of one attribute. Returns every bucket of each series, and MCP Apps hosts show it as an interactive chart. To find individual events, use the dataset search tools.", + "requiredScopes": ["event:read"] + }, { "name": "search_agent_conversations", "description": "Search Sentry agent conversations (formerly AI conversations): one summary row per LLM agent conversation with title, cost, tokens, call counts, and previews. For one conversation's transcript, use get_agent_conversation_details.", @@ -411,7 +421,7 @@ "description": "Resolve, assign, and update issues", "defaultEnabled": false, "order": 4, - "toolCount": 27, + "toolCount": 28, "tools": [ { "name": "add_issue_note", @@ -483,6 +493,11 @@ "description": "Link an existing external ticket or GitHub pull request to a Sentry issue by URL: Jira, GitHub, GitLab, Bitbucket, Azure DevOps, or an installed Sentry App such as Linear. Adds a reference only; it does not create the ticket or change the issue status (use update_issue).", "requiredScopes": ["event:write", "org:read"] }, + { + "name": "render_sentry_chart", + "description": "Chart a count, rate, duration, or other aggregate of Sentry errors, logs, spans, metrics, or profiles over time, optionally split into the top 5 values of one attribute. Returns every bucket of each series, and MCP Apps hosts show it as an interactive chart. To find individual events, use the dataset search tools.", + "requiredScopes": ["event:read"] + }, { "name": "search_agent_conversations", "description": "Search Sentry agent conversations (formerly AI conversations): one summary row per LLM agent conversation with title, cost, tokens, call counts, and previews. For one conversation's transcript, use get_agent_conversation_details.", diff --git a/packages/mcp-core/src/toolDefinitions.json b/packages/mcp-core/src/toolDefinitions.json index 79b26b062..4590455f2 100644 --- a/packages/mcp-core/src/toolDefinitions.json +++ b/packages/mcp-core/src/toolDefinitions.json @@ -12150,6 +12150,293 @@ "skills": ["project-management"], "surface": "direct" }, + { + "name": "render_sentry_chart", + "title": "Render Sentry Chart", + "description": "Chart a count, rate, duration, or other aggregate of Sentry errors, logs, spans, metrics, or profiles over time, optionally split into the top 5 values of one attribute. Returns every bucket of each series, and MCP Apps hosts show it as an interactive chart. To find individual events, use the dataset search tools.", + "inputSchema": { + "type": "object", + "properties": { + "organizationSlug": { + "type": "string", + "description": "The organization slug, from `find_organizations`. In `org/project` notation, the part before the slash." + }, + "regionUrl": { + "default": null, + "anyOf": [ + { + "type": "string", + "description": "The organization's region URL from `find_organizations`, e.g. `https://us.sentry.io`. Omit for self-hosted Sentry." + }, + { + "type": "null" + } + ] + }, + "dataset": { + "type": "string", + "enum": ["spans", "errors", "logs", "metrics", "profiles"], + "description": "Data to chart." + }, + "query": { + "default": "", + "description": "Sentry search syntax filter, such as `level:error environment:production`. Empty matches everything.", + "type": "string" + }, + "yAxis": { + "type": "string", + "minLength": 1, + "description": "Aggregate to plot, such as `count()`, `p95(span.duration)`, or `count_unique(user)`." + }, + "groupBy": { + "default": null, + "description": "Attribute to split by, such as `release` or `transaction`; plots its top 5 values. Not supported for profiles.", + "anyOf": [ + { + "type": "string", + "minLength": 1 + }, + { + "type": "null" + } + ] + }, + "projectSlug": { + "default": null, + "anyOf": [ + { + "type": "string", + "description": "The project slug. In `org/project` notation, the part after the slash." + }, + { + "type": "null" + } + ] + }, + "period": { + "default": null, + "description": "Relative time window, e.g. `1h`, `24h`, `7d`; defaults to 24h. Do not combine with start and end.", + "anyOf": [ + { + "type": "string", + "pattern": "^\\d+[mhdw]$", + "description": "Relative time window, e.g. `30m`, `24h`, `7d`, `90d`." + }, + { + "type": "null" + } + ] + }, + "start": { + "default": null, + "description": "Absolute start, ISO 8601; requires end.", + "type": ["string", "null"] + }, + "end": { + "default": null, + "description": "Absolute end, ISO 8601; requires start.", + "type": ["string", "null"] + }, + "interval": { + "default": null, + "description": "Bucket size such as 5m or 1h. Omit to let Sentry pick.", + "anyOf": [ + { + "type": "string", + "pattern": "^\\d+[mhd]$" + }, + { + "type": "null" + } + ] + }, + "title": { + "default": null, + "description": "Chart heading; defaults to the aggregate.", + "anyOf": [ + { + "type": "string", + "minLength": 1 + }, + { + "type": "null" + } + ] + }, + "fresh": { + "description": "Bypass cached reads.", + "type": "boolean" + } + }, + "required": ["organizationSlug", "dataset", "yAxis"] + }, + "outputSchema": { + "type": "object", + "properties": { + "title": { + "type": "string" + }, + "dataset": { + "type": "string" + }, + "query": { + "type": "string" + }, + "yAxis": { + "type": "string" + }, + "groupBy": { + "type": ["string", "null"] + }, + "valueType": { + "description": "Such as integer, number, duration, percentage, or size.", + "type": ["string", "null"] + }, + "valueUnit": { + "description": "Such as millisecond or byte.", + "type": ["string", "null"] + }, + "interval": { + "type": "string", + "description": "Bucket size, such as 5m or 1h." + }, + "timeRange": { + "type": "object", + "properties": { + "statsPeriod": { + "type": ["string", "null"] + }, + "start": { + "type": ["string", "null"] + }, + "end": { + "type": ["string", "null"] + } + }, + "required": ["statsPeriod", "start", "end"], + "additionalProperties": false + }, + "url": { + "type": "string" + }, + "series": { + "type": "array", + "items": { + "type": "object", + "properties": { + "label": { + "type": "string", + "description": "The group's value, or the aggregate when ungrouped." + }, + "total": { + "description": "Sum of all buckets; null for non-additive aggregates.", + "type": ["number", "null"] + }, + "buckets": { + "type": "array", + "items": { + "type": "object", + "properties": { + "time": { + "type": "string" + }, + "value": { + "type": "number" + }, + "incomplete": { + "type": "boolean", + "description": "Data is still arriving, so the value may rise." + }, + "outsideRetention": { + "type": "boolean", + "description": "Starts before the retention window, so older data is missing and the value will not change." + } + }, + "required": [ + "time", + "value", + "incomplete", + "outsideRetention" + ], + "additionalProperties": false + }, + "description": "Every bucket, oldest first." + } + }, + "required": ["label", "total", "buckets"], + "additionalProperties": false + }, + "description": "One series, or one per top group, largest first." + }, + "peak": { + "anyOf": [ + { + "type": "object", + "properties": { + "series": { + "type": "string" + }, + "time": { + "type": "string" + }, + "value": { + "type": "number" + } + }, + "required": ["series", "time", "value"], + "additionalProperties": false + }, + { + "type": "null" + } + ], + "description": "Highest bucket across series that is no longer receiving data." + }, + "ingestion": { + "anyOf": [ + { + "type": "object", + "properties": { + "status": { + "type": "string" + }, + "delaySeconds": { + "type": ["number", "null"] + }, + "completeThrough": { + "type": ["string", "null"] + } + }, + "required": ["status", "delaySeconds", "completeThrough"], + "additionalProperties": false + }, + { + "type": "null" + } + ] + } + }, + "required": [ + "title", + "dataset", + "query", + "yAxis", + "groupBy", + "valueType", + "valueUnit", + "interval", + "timeRange", + "url", + "series", + "peak", + "ingestion" + ], + "additionalProperties": false + }, + "requiredScopes": ["event:read"], + "skills": ["inspect", "triage", "seer"], + "surface": "direct" + }, { "name": "search_agent_conversations", "title": "Search Agent Conversations", diff --git a/packages/mcp-core/src/tools/catalog/index.ts b/packages/mcp-core/src/tools/catalog/index.ts index d2a897479..155fab4b4 100644 --- a/packages/mcp-core/src/tools/catalog/index.ts +++ b/packages/mcp-core/src/tools/catalog/index.ts @@ -42,6 +42,7 @@ import linkIssue from "./link-issue"; import unlinkIssue from "./unlink-issue"; import searchEvents from "./search-events"; import searchErrors from "./search-errors"; +import renderSentryChart from "./render-sentry-chart"; import searchLogs from "./search-logs"; import searchTraces from "./search-traces"; import searchMetrics from "./search-metrics"; @@ -176,6 +177,7 @@ const catalogTools = withFreshReadInputs({ search_profiles: searchProfiles, search_replays: searchReplays, search_events: searchEvents, + render_sentry_chart: renderSentryChart, create_team: createTeam, create_project: createProject, update_project: updateProject, diff --git a/packages/mcp-core/src/tools/catalog/render-sentry-chart.test.ts b/packages/mcp-core/src/tools/catalog/render-sentry-chart.test.ts new file mode 100644 index 000000000..32d537081 --- /dev/null +++ b/packages/mcp-core/src/tools/catalog/render-sentry-chart.test.ts @@ -0,0 +1,215 @@ +import { mswServer } from "@sentry/mcp-server-mocks"; +import { HttpResponse, http } from "msw"; +import { describe, expect, it } from "vitest"; +import { UserInputError } from "../../errors"; +import { + assertStructuredOnlyResult, + getStructuredContent, +} from "../../test-utils/structured-content.js"; +import type { ChartResult } from "../support/chart/schema"; +import renderSentryChart from "./render-sentry-chart.js"; + +const context = { + constraints: { organizationSlug: null }, + accessToken: "access-token", + userId: "1", +}; + +const TIMESERIES_URL = + "https://sentry.io/api/0/organizations/sentry-mcp-evals/events-timeseries/"; + +const baseParams = { + organizationSlug: "sentry-mcp-evals", + regionUrl: null, + dataset: "errors" as const, + query: "level:error", + yAxis: "count()", + groupBy: null, + projectSlug: null, + period: "1h", + start: null, + end: null, + interval: "15m", + title: null, +}; + +describe("render_sentry_chart", () => { + it("returns every bucket of the series", async () => { + const result = await renderSentryChart.handler(baseParams, context); + + assertStructuredOnlyResult(result); + expect(getStructuredContent(result)).toMatchInlineSnapshot(` + { + "dataset": "errors", + "groupBy": null, + "ingestion": null, + "interval": "15m", + "peak": { + "series": "count()", + "time": "2025-09-10T23:30:00.000Z", + "value": 140, + }, + "query": "level:error", + "series": [ + { + "buckets": [ + { + "incomplete": false, + "outsideRetention": false, + "time": "2025-09-10T23:00:00.000Z", + "value": 56, + }, + { + "incomplete": false, + "outsideRetention": false, + "time": "2025-09-10T23:15:00.000Z", + "value": 56, + }, + { + "incomplete": false, + "outsideRetention": false, + "time": "2025-09-10T23:30:00.000Z", + "value": 140, + }, + { + "incomplete": true, + "outsideRetention": false, + "time": "2025-09-10T23:45:00.000Z", + "value": 56, + }, + ], + "label": "count()", + "total": 308, + }, + ], + "timeRange": { + "end": null, + "start": null, + "statsPeriod": "1h", + }, + "title": "count()", + "url": "https://sentry-mcp-evals.sentry.io/explore/discover/homepage/?dataset=errors&queryDataset=error-events&query=level%3Aerror&field=count%28%29&sort=-count%28%29&statsPeriod=1h&mode=aggregate&yAxis=count%28%29", + "valueType": "integer", + "valueUnit": null, + "yAxis": "count()", + } + `); + }); + + it("asks Sentry for the top 5 groups and labels each series by its value", async () => { + let captured: URLSearchParams | undefined; + mswServer.use( + http.get(TIMESERIES_URL, ({ request }) => { + captured = new URL(request.url).searchParams; + return HttpResponse.json({ + timeSeries: ["2.4.1", null].map((release, index) => ({ + yAxis: "p95(span.duration)", + groupBy: [{ key: "release", value: release }], + values: [ + { + timestamp: 1757545200000, + value: 120 - index, + incomplete: false, + }, + ], + meta: { + interval: 3600000, + valueType: "duration", + valueUnit: "millisecond", + order: index, + isOther: false, + }, + })), + }); + }), + ); + + const result = await renderSentryChart.handler( + { + ...baseParams, + dataset: "spans", + yAxis: "p95(span.duration)", + groupBy: "release", + period: null, + interval: null, + }, + context, + ); + + expect(Object.fromEntries(captured ?? [])).toMatchObject({ + dataset: "spans", + yAxis: "p95(span.duration)", + topEvents: "5", + groupBy: "release", + sort: "-p95(span.duration)", + excludeOther: "1", + statsPeriod: "24h", + }); + const chart = getStructuredContent(result); + expect(chart.title).toBe("p95(span.duration) by release"); + expect(chart.valueUnit).toBe("millisecond"); + expect(chart.series.map(({ label, total }) => ({ label, total }))).toEqual([ + { label: "2.4.1", total: null }, + { label: "(none)", total: null }, + ]); + expect(chart.peak).toEqual({ + series: "2.4.1", + time: "2025-09-10T23:00:00.000Z", + value: 120, + }); + }); + + it("returns an empty chart when a grouped query matches nothing", async () => { + mswServer.use( + http.get(TIMESERIES_URL, () => HttpResponse.json({ timeSeries: [] })), + ); + + const chart = getStructuredContent( + await renderSentryChart.handler( + { ...baseParams, groupBy: "release" }, + context, + ), + ); + + expect(chart.series).toEqual([]); + expect(chart.peak).toBeNull(); + }); + + it.each([ + ["start without end", { start: "2025-09-10T00:00:00Z", period: null }], + [ + "period with start and end", + { start: "2025-09-10T00:00:00Z", end: "2025-09-11T00:00:00Z" }, + ], + ["grouped profiles", { dataset: "profiles" as const, groupBy: "release" }], + ])("rejects %s", async (_, overrides) => { + await expect( + renderSentryChart.handler({ ...baseParams, ...overrides }, context), + ).rejects.toBeInstanceOf(UserInputError); + }); + + it("rejects an aggregate that returns text", async () => { + mswServer.use( + http.get(TIMESERIES_URL, () => + HttpResponse.json({ + timeSeries: [ + { + yAxis: "latest_event()", + values: [ + { timestamp: 1757545200000, value: "abc", incomplete: false }, + ], + meta: { interval: 3600000, valueType: "string" }, + }, + ], + }), + ), + ); + + await expect( + renderSentryChart.handler( + { ...baseParams, yAxis: "latest_event()" }, + context, + ), + ).rejects.toBeInstanceOf(UserInputError); + }); +}); diff --git a/packages/mcp-core/src/tools/catalog/render-sentry-chart.ts b/packages/mcp-core/src/tools/catalog/render-sentry-chart.ts new file mode 100644 index 000000000..be15b4983 --- /dev/null +++ b/packages/mcp-core/src/tools/catalog/render-sentry-chart.ts @@ -0,0 +1,247 @@ +import { z } from "zod"; +import type { EventsTimeSeriesResponse } from "../../api-client/schema"; +import { UserInputError } from "../../errors"; +import { apiServiceFromContext } from "../../internal/tool-helpers/api"; +import { defineTool } from "../../internal/tool-helpers/define"; +import { structuredResult } from "../../internal/tool-helpers/results"; +import { + ParamOrganizationSlug, + ParamPeriod, + ParamProjectSlug, + ParamRegionUrl, +} from "../../schema"; +import { setTargetTagsAndAttributes } from "../../telem/scope"; +import type { ServerContext } from "../../types"; +import { PUBLIC_EVENTS_DATASETS } from "../../utils/events-datasets"; +import { + type ChartResult, + renderSentryChartOutputSchema, +} from "../support/chart/schema"; +import { toStructuredIngestion } from "../support/ingestion"; +import { summarizeSeries } from "../support/search-events/formatters"; + +/** Top groups plotted when the chart is split by an attribute. */ +const MAX_CHART_SERIES = 5; +const DEFAULT_PERIOD = "24h"; + +const INTERVAL_UNITS: [unit: string, ms: number][] = [ + ["d", 86_400_000], + ["h", 3_600_000], + ["m", 60_000], +]; + +function formatInterval(ms: number): string { + for (const [unit, unitMs] of INTERVAL_UNITS) { + if (ms % unitMs === 0) return `${ms / unitMs}${unit}`; + } + return `${ms / 1000}s`; +} + +function seriesLabel( + series: EventsTimeSeriesResponse["timeSeries"][number], +): string { + if (!series.groupBy?.length) return series.yAxis; + return series.groupBy + .map(({ value }) => (value === null || value === "" ? "(none)" : value)) + .join(", "); +} + +function toChartSeries( + response: EventsTimeSeriesResponse, + yAxis: string, +): { series: ChartResult["series"]; peak: ChartResult["peak"] } { + let peak: ChartResult["peak"] = null; + const series = response.timeSeries.map((entry) => { + const label = seriesLabel(entry); + const summary = summarizeSeries(entry, yAxis); + if (summary.peak && (!peak || summary.peak.value > peak.value)) { + peak = { + series: label, + time: new Date(summary.peak.timestamp).toISOString(), + value: summary.peak.value, + }; + } + return { + label, + total: summary.total, + buckets: summary.points.map((point) => ({ + time: new Date(point.timestamp).toISOString(), + value: point.value, + incomplete: point.filling, + outsideRetention: point.outsideRetention, + })), + }; + }); + return { series, peak }; +} + +export default defineTool({ + name: "render_sentry_chart", + title: "Render Sentry Chart", + skills: ["inspect", "triage", "seer"], + requiredScopes: ["event:read"], + description: + "Chart a count, rate, duration, or other aggregate of Sentry errors, logs, spans, metrics, or profiles over time, optionally split into the top 5 values of one attribute. Returns every bucket of each series, and MCP Apps hosts show it as an interactive chart. To find individual events, use the dataset search tools.", + inputSchema: { + organizationSlug: ParamOrganizationSlug, + regionUrl: ParamRegionUrl.nullable().default(null), + dataset: z.enum(PUBLIC_EVENTS_DATASETS).describe("Data to chart."), + query: z + .string() + .trim() + .default("") + .describe( + "Sentry search syntax filter, such as `level:error environment:production`. Empty matches everything.", + ), + yAxis: z + .string() + .trim() + .min(1) + .describe( + "Aggregate to plot, such as `count()`, `p95(span.duration)`, or `count_unique(user)`.", + ), + groupBy: z + .string() + .trim() + .min(1) + .nullable() + .default(null) + .describe( + "Attribute to split by, such as `release` or `transaction`; plots its top 5 values. Not supported for profiles.", + ), + projectSlug: ParamProjectSlug.nullable().default(null), + period: ParamPeriod.nullable() + .default(null) + .describe( + "Relative time window, e.g. `1h`, `24h`, `7d`; defaults to 24h. Do not combine with start and end.", + ), + start: z + .string() + .trim() + .nullable() + .default(null) + .describe("Absolute start, ISO 8601; requires end."), + end: z + .string() + .trim() + .nullable() + .default(null) + .describe("Absolute end, ISO 8601; requires start."), + interval: z + .string() + .trim() + .regex(/^\d+[mhd]$/, "Use a bucket size like `5m`, `1h`, or `1d`.") + .nullable() + .default(null) + .describe("Bucket size such as 5m or 1h. Omit to let Sentry pick."), + title: z + .string() + .trim() + .min(1) + .nullable() + .default(null) + .describe("Chart heading; defaults to the aggregate."), + }, + annotations: { + readOnlyHint: true, + destructiveHint: false, + openWorldHint: true, + }, + outputSchema: renderSentryChartOutputSchema, + async handler(params, context: ServerContext) { + if ((params.start === null) !== (params.end === null)) { + throw new UserInputError("Pass both `start` and `end`, or neither."); + } + if (params.start !== null && params.period !== null) { + throw new UserInputError( + "Pass either `period` or `start` and `end`, not both.", + ); + } + if (params.groupBy !== null && params.dataset === "profiles") { + throw new UserInputError( + "Sentry cannot split profile charts by an attribute. Remove `groupBy`.", + ); + } + + const apiService = apiServiceFromContext(context, { + regionUrl: params.regionUrl ?? undefined, + }); + const organizationSlug = params.organizationSlug; + setTargetTagsAndAttributes({ + organizationSlug, + projectSlug: params.projectSlug ?? undefined, + }); + + let projectId: string | undefined; + if (params.projectSlug) { + const project = await apiService.getProject({ + organizationSlug, + projectSlugOrId: params.projectSlug, + }); + projectId = String(project.id); + } + + const timeParams: { statsPeriod?: string; start?: string; end?: string } = + params.start !== null && params.end !== null + ? { start: params.start, end: params.end } + : { statsPeriod: params.period ?? DEFAULT_PERIOD }; + const response = await apiService.getEventsTimeSeries({ + organizationSlug, + query: params.query, + yAxis: params.yAxis, + interval: params.interval ?? undefined, + projectId, + dataset: params.dataset, + ...timeParams, + topEvents: params.groupBy + ? { groupBy: params.groupBy, limit: MAX_CHART_SERIES } + : undefined, + }); + + const meta = response.timeSeries[0]?.meta; + if (meta?.valueType === "string") { + throw new UserInputError( + `\`${params.yAxis}\` returns text, which cannot be charted. Use a numeric aggregate such as \`count()\`.`, + ); + } + const { series, peak } = toChartSeries(response, params.yAxis); + + return structuredResult({ + title: + params.title ?? + (params.groupBy + ? `${params.yAxis} by ${params.groupBy}` + : params.yAxis), + dataset: params.dataset, + query: params.query, + yAxis: params.yAxis, + groupBy: params.groupBy, + valueType: meta?.valueType ?? null, + valueUnit: meta?.valueUnit ?? null, + interval: meta + ? formatInterval(meta.interval) + : (params.interval ?? "auto"), + timeRange: { + statsPeriod: timeParams.statsPeriod ?? null, + start: timeParams.start ?? null, + end: timeParams.end ?? null, + }, + url: apiService.getEventsExplorerUrl( + organizationSlug, + params.query, + projectId, + params.dataset, + [params.yAxis], + `-${params.yAxis}`, + [params.yAxis], + params.groupBy ? [params.groupBy] : [], + timeParams.statsPeriod, + timeParams.start, + timeParams.end, + ), + series, + peak, + ingestion: toStructuredIngestion(response.meta?.ingestion), + }); + }, +}); diff --git a/packages/mcp-core/src/tools/catalog/search-errors.structured.test.ts b/packages/mcp-core/src/tools/catalog/search-errors.structured.test.ts index 266b25a1f..39e26250f 100644 --- a/packages/mcp-core/src/tools/catalog/search-errors.structured.test.ts +++ b/packages/mcp-core/src/tools/catalog/search-errors.structured.test.ts @@ -346,7 +346,20 @@ describe("search_errors structured output", () => { "query": "errors per hour", "resultType": "timeSeries", "results": [], - "suggestedActions": [], + "suggestedActions": [ + { + "arguments": { + "dataset": "errors", + "organizationSlug": "test-org", + "period": "24h", + "query": "level:error", + "yAxis": "count()", + }, + "reason": "Chart every bucket of this series.", + "toolName": "render_sentry_chart", + "type": "tool_call", + }, + ], "timeSeries": { "bucketCount": 4, "buckets": [ diff --git a/packages/mcp-core/src/tools/support/chart/schema.ts b/packages/mcp-core/src/tools/support/chart/schema.ts new file mode 100644 index 000000000..00034948e --- /dev/null +++ b/packages/mcp-core/src/tools/support/chart/schema.ts @@ -0,0 +1,62 @@ +/** + * The render_sentry_chart result. Imports only zod, so the chart view parses + * the same contract the tool declares. + */ +import { z } from "zod"; +import { ingestionSchema } from "../ingestion"; + +const chartBucketSchema = z.object({ + time: z.string(), + value: z.number(), + incomplete: z + .boolean() + .describe("Data is still arriving, so the value may rise."), + outsideRetention: z + .boolean() + .describe( + "Starts before the retention window, so older data is missing and the value will not change.", + ), +}); + +export const renderSentryChartOutputSchema = z.object({ + title: z.string(), + dataset: z.string(), + query: z.string(), + yAxis: z.string(), + groupBy: z.string().nullable(), + valueType: z + .string() + .nullable() + .describe("Such as integer, number, duration, percentage, or size."), + valueUnit: z.string().nullable().describe("Such as millisecond or byte."), + interval: z.string().describe("Bucket size, such as 5m or 1h."), + timeRange: z.object({ + statsPeriod: z.string().nullable(), + start: z.string().nullable(), + end: z.string().nullable(), + }), + url: z.string(), + series: z + .array( + z.object({ + label: z + .string() + .describe("The group's value, or the aggregate when ungrouped."), + total: z + .number() + .nullable() + .describe("Sum of all buckets; null for non-additive aggregates."), + buckets: z + .array(chartBucketSchema) + .describe("Every bucket, oldest first."), + }), + ) + .describe("One series, or one per top group, largest first."), + peak: z + .object({ series: z.string(), time: z.string(), value: z.number() }) + .nullable() + .describe("Highest bucket across series that is no longer receiving data."), + ingestion: ingestionSchema, +}); + +export type ChartResult = z.output; diff --git a/packages/mcp-core/src/tools/support/ingestion.ts b/packages/mcp-core/src/tools/support/ingestion.ts new file mode 100644 index 000000000..a388a4644 --- /dev/null +++ b/packages/mcp-core/src/tools/support/ingestion.ts @@ -0,0 +1,29 @@ +/** + * Ingestion delay in structured time series results. Imports only zod, so the + * chart view can share it. + */ +import { z } from "zod"; +import type { IngestionMeta } from "../../api-client/schema"; + +export const ingestionSchema = z + .object({ + status: z.string(), + delaySeconds: z.number().nullable(), + completeThrough: z.string().nullable(), + }) + .nullable(); + +export function toStructuredIngestion( + ingestion: IngestionMeta | undefined, +): z.output { + return ingestion + ? { + status: ingestion.status, + delaySeconds: ingestion.delaySeconds ?? null, + completeThrough: + ingestion.completeThrough === undefined + ? null + : new Date(ingestion.completeThrough).toISOString(), + } + : null; +} diff --git a/packages/mcp-core/src/tools/support/search-events/formatters.ts b/packages/mcp-core/src/tools/support/search-events/formatters.ts index a36d05fe2..e380db313 100644 --- a/packages/mcp-core/src/tools/support/search-events/formatters.ts +++ b/packages/mcp-core/src/tools/support/search-events/formatters.ts @@ -989,7 +989,7 @@ function formatIngestionStatus(ingestion: IngestionMeta): string { return `- **Ingestion**: ${ingestion.status}${detail}`; } -interface TimeSeriesPoint { +export interface TimeSeriesPoint { timestamp: number; time: string; /** Sort key: the number, or parsed time for date-typed strings. */ @@ -1001,62 +1001,61 @@ interface TimeSeriesPoint { outsideRetention: boolean; } -interface TimeSeriesSummary { +/** One series of an events-timeseries result, with every bucket. */ +export interface SeriesSummary { /** Every bucket, oldest first. */ - bucketCount: number; - /** The most recent `MAX_TIME_SERIES_ROWS` buckets. */ - shown: TimeSeriesPoint[]; + points: TimeSeriesPoint[]; total: number | null; hasFilling: boolean; peak: TimeSeriesPoint | undefined; +} + +interface TimeSeriesSummary extends Omit { + bucketCount: number; + /** The most recent `MAX_TIME_SERIES_ROWS` buckets. */ + shown: TimeSeriesPoint[]; ingestion: IngestionMeta | undefined; } const MAX_TIME_SERIES_ROWS = 48; /** - * Summarize an events-timeseries result: a metric bucketed over time. + * Summarize one series: a metric bucketed over time. * Buckets flagged `incomplete` by Sentry are still receiving data and are * excluded from the peak; those that start before the retention window are * permanently partial and will not change. */ -export function summarizeTimeSeries( - series: EventsTimeSeriesResponse, +export function summarizeSeries( + series: EventsTimeSeriesResponse["timeSeries"][number] | undefined, yAxis: string, -): TimeSeriesSummary { +): SeriesSummary { // String aggregates can return identifiers, even when their values look numeric. - const isStringSeries = series.timeSeries[0]?.meta.valueType === "string"; - const points = (series.timeSeries[0]?.values ?? []).map( - (bucket): TimeSeriesPoint => { - // OUTSIDE_RETENTION buckets start before the retention window: their data - // is permanently partial. Every other reason means data is still arriving. - const outsideRetention = - bucket.incomplete && bucket.incompleteReason === "OUTSIDE_RETENTION"; - const raw = bucket.value ?? 0; - // Date-typed aggregates such as max(timestamp) return ISO datetime - // strings. Number() rejects those whole (parseFloat would keep the year), - // so order them by parsed time and display the raw string. - const numeric = typeof raw === "number" ? raw : Number(raw); - const isNumeric = !Number.isNaN(numeric); - const keepsNumber = !isStringSeries && isNumeric; - return { - timestamp: bucket.timestamp, - time: formatBucketTime(bucket.timestamp), - value: isNumeric ? numeric : Date.parse(String(raw)) || 0, - rawValue: keepsNumber ? numeric : String(raw), - display: keepsNumber ? numeric.toLocaleString() : String(raw), - filling: bucket.incomplete && !outsideRetention, - outsideRetention, - }; - }, - ); + const isStringSeries = series?.meta.valueType === "string"; + const points = (series?.values ?? []).map((bucket): TimeSeriesPoint => { + // OUTSIDE_RETENTION buckets start before the retention window: their data + // is permanently partial. Every other reason means data is still arriving. + const outsideRetention = + bucket.incomplete && bucket.incompleteReason === "OUTSIDE_RETENTION"; + const raw = bucket.value ?? 0; + // Date-typed aggregates such as max(timestamp) return ISO datetime + // strings. Number() rejects those whole (parseFloat would keep the year), + // so order them by parsed time and display the raw string. + const numeric = typeof raw === "number" ? raw : Number(raw); + const isNumeric = !Number.isNaN(numeric); + const keepsNumber = !isStringSeries && isNumeric; + return { + timestamp: bucket.timestamp, + time: formatBucketTime(bucket.timestamp), + value: isNumeric ? numeric : Date.parse(String(raw)) || 0, + rawValue: keepsNumber ? numeric : String(raw), + display: keepsNumber ? numeric.toLocaleString() : String(raw), + filling: bucket.incomplete && !outsideRetention, + outsideRetention, + }; + }); return { - bucketCount: points.length, - shown: - points.length > MAX_TIME_SERIES_ROWS - ? points.slice(-MAX_TIME_SERIES_ROWS) - : points, + points, // Total is only meaningful for additive aggregates; summing count_unique / // avg / percentile buckets would be wrong, so omit it for those. total: @@ -1072,6 +1071,22 @@ export function summarizeTimeSeries( (max, p) => (max === undefined || p.value > max.value ? p : max), undefined, ), + }; +} + +/** Summarize an ungrouped events-timeseries result, keeping recent buckets. */ +export function summarizeTimeSeries( + series: EventsTimeSeriesResponse, + yAxis: string, +): TimeSeriesSummary { + const { points, ...summary } = summarizeSeries(series.timeSeries[0], yAxis); + return { + ...summary, + bucketCount: points.length, + shown: + points.length > MAX_TIME_SERIES_ROWS + ? points.slice(-MAX_TIME_SERIES_ROWS) + : points, ingestion: series.meta?.ingestion, }; } diff --git a/packages/mcp-core/src/tools/support/search-events/search.ts b/packages/mcp-core/src/tools/support/search-events/search.ts index 2d6a07663..6eeda9581 100644 --- a/packages/mcp-core/src/tools/support/search-events/search.ts +++ b/packages/mcp-core/src/tools/support/search-events/search.ts @@ -1224,6 +1224,15 @@ async function executeSearchEvents( notes: droppedEventsNote ? [...notesFor(pointsWithData), droppedEventsNote] : notesFor(pointsWithData), + session: { + apiService, + organizationSlug, + experimentalMode: context.experimentalMode ?? false, + availableToolNames: context.availableToolNames, + directToolNames: context.directToolNames, + }, + projectSlug: params.projectSlug, + regionUrl: params.regionUrl, }); } const timeSeriesOutput = formatTimeSeriesResults({ diff --git a/packages/mcp-core/src/tools/support/search-events/structured.ts b/packages/mcp-core/src/tools/support/search-events/structured.ts index f9d62dddc..1d2f0a56d 100644 --- a/packages/mcp-core/src/tools/support/search-events/structured.ts +++ b/packages/mcp-core/src/tools/support/search-events/structured.ts @@ -30,6 +30,7 @@ import { type SearchResultHints, summarizeTimeSeries, } from "./formatters"; +import { ingestionSchema, toStructuredIngestion } from "../ingestion"; import { type FlexibleEventData, isAggregateQuery } from "./utils"; export const timeRangeSchema = z.object({ @@ -64,13 +65,7 @@ const timeSeriesSchema = z.object({ }) .nullable() .describe("Highest bucket that is no longer receiving data."), - ingestion: z - .object({ - status: z.string(), - delaySeconds: z.number().nullable(), - completeThrough: z.string().nullable(), - }) - .nullable(), + ingestion: ingestionSchema, bucketCount: z.number(), buckets: z .array( @@ -455,9 +450,33 @@ export function buildStructuredTimeSeriesResult(params: { timeRange: { statsPeriod?: string; start?: string; end?: string }; url: string; notes: string[]; + session: StructuredSearchSession; + projectSlug: string | null; + regionUrl: string | null; }): StructuredToolOutput { const { bucketCount, shown, total, hasFilling, peak, ingestion } = summarizeTimeSeries(params.series, params.yAxis); + const { session, timeRange } = params; + const chartAction = buildSuggestedToolAction({ + toolName: "render_sentry_chart", + arguments: { + organizationSlug: session.organizationSlug, + dataset: params.dataset, + query: params.query, + yAxis: params.yAxis, + ...(timeRange.start && timeRange.end + ? { start: timeRange.start, end: timeRange.end } + : timeRange.statsPeriod + ? { period: timeRange.statsPeriod } + : {}), + ...(params.projectSlug && { projectSlug: params.projectSlug }), + ...(params.regionUrl && { regionUrl: params.regionUrl }), + }, + reason: "Chart every bucket of this series.", + experimentalMode: session.experimentalMode, + availableToolNames: session.availableToolNames, + directToolNames: session.directToolNames, + }); return structuredResult({ query: params.inputQuery, @@ -484,16 +503,7 @@ export function buildStructuredTimeSeriesResult(params: { peak: peak ? { time: new Date(peak.timestamp).toISOString(), value: peak.rawValue } : null, - ingestion: ingestion - ? { - status: ingestion.status, - delaySeconds: ingestion.delaySeconds ?? null, - completeThrough: - ingestion.completeThrough === undefined - ? null - : new Date(ingestion.completeThrough).toISOString(), - } - : null, + ingestion: toStructuredIngestion(ingestion), bucketCount, buckets: shown.map((point) => ({ time: new Date(point.timestamp).toISOString(), @@ -502,6 +512,6 @@ export function buildStructuredTimeSeriesResult(params: { outsideRetention: point.outsideRetention, })), }, - suggestedActions: [], + suggestedActions: chartAction ? [chartAction] : [], }); } diff --git a/packages/mcp-server-mocks/src/events-timeseries.ts b/packages/mcp-server-mocks/src/events-timeseries.ts new file mode 100644 index 000000000..608d748c4 --- /dev/null +++ b/packages/mcp-server-mocks/src/events-timeseries.ts @@ -0,0 +1,102 @@ +/** + * Deterministic `events-timeseries` responses. The series ends at a fixed + * time and its bucket size follows the requested range, so a chart drawn + * from it looks the same on every run and changes shape when the range does. + */ +import { HttpResponse } from "msw"; + +const SERIES_END = Date.UTC(2025, 8, 11, 0, 0, 0); +const MINUTE = 60_000; +const HOUR = 60 * MINUTE; +const DAY = 24 * HOUR; + +/** Bucket size per range when the request names no interval. */ +const DEFAULT_INTERVALS: [rangeMs: number, intervalMs: number][] = [ + [HOUR, MINUTE], + [DAY, 30 * MINUTE], + [7 * DAY, 3 * HOUR], + [Number.POSITIVE_INFINITY, 6 * HOUR], +]; + +const UNIT_MS: Record = { + s: 1000, + m: MINUTE, + h: HOUR, + d: DAY, + w: 7 * DAY, +}; + +function parseDuration(value: string | null): number | undefined { + const match = value ? /^(\d+)([smhdw])$/.exec(value) : null; + const unit = match?.[2]; + return match && unit ? Number(match[1]) * (UNIT_MS[unit] ?? 0) : undefined; +} + +const GROUP_VALUES = ["frontend@2.4.1", "frontend@2.4.0", "frontend@2.3.9"]; + +export function eventsTimeSeriesResponse(request: Request): Response { + const params = new URL(request.url).searchParams; + const yAxis = params.get("yAxis"); + if (!params.get("dataset") || !yAxis) { + return HttpResponse.json( + { detail: "dataset and yAxis are required" }, + { status: 400 }, + ); + } + const topEvents = params.get("topEvents"); + const groupBy = params.get("groupBy"); + if (topEvents && (!groupBy || !params.get("sort"))) { + return HttpResponse.json( + { detail: "groupBy is a required parameter when doing topEvents" }, + { status: 400 }, + ); + } + + const start = params.get("start"); + const end = params.get("end"); + const [rangeStart, rangeEnd] = + start && end + ? [Date.parse(start), Date.parse(end)] + : [ + SERIES_END - (parseDuration(params.get("statsPeriod")) ?? 14 * DAY), + SERIES_END, + ]; + const range = rangeEnd - rangeStart; + const interval = + parseDuration(params.get("interval")) ?? + DEFAULT_INTERVALS.find(([limit]) => range <= limit)?.[1] ?? + 6 * HOUR; + const bucketCount = Math.max(1, Math.round(range / interval)); + + const groups = groupBy + ? GROUP_VALUES.slice(0, Number(topEvents) || GROUP_VALUES.length) + : [null]; + const isDuration = /duration/.test(yAxis); + const timeSeries = groups.map((group, groupIndex) => ({ + yAxis, + ...(group !== null && { groupBy: [{ key: groupBy, value: group }] }), + values: Array.from({ length: bucketCount }, (_, index) => { + const wave = Math.sin((index / bucketCount) * Math.PI * 4 + groupIndex); + const spike = index === Math.floor(bucketCount * 0.7) ? 2.5 : 1; + const base = (isDuration ? 180 : 40) / (groupIndex + 1); + const isLast = index === bucketCount - 1; + return { + timestamp: rangeEnd - (bucketCount - index) * interval, + value: Math.round(base * (1.4 + wave) * spike), + incomplete: isLast, + ...(isLast && { incompleteReason: "INGESTION_PENDING" }), + }; + }), + meta: { + interval, + valueType: isDuration ? "duration" : "integer", + valueUnit: isDuration ? "millisecond" : null, + ...(group !== null && { order: groupIndex, isOther: false }), + }, + })); + + return HttpResponse.json({ + timeSeries, + meta: { start: rangeStart, end: rangeEnd }, + }); +} diff --git a/packages/mcp-server-mocks/src/index.ts b/packages/mcp-server-mocks/src/index.ts index 268be4de1..b08563193 100644 --- a/packages/mcp-server-mocks/src/index.ts +++ b/packages/mcp-server-mocks/src/index.ts @@ -85,6 +85,7 @@ import uptimeChecksFixture from "./fixtures/uptime-checks.json" with { type: "js import uptimeMonitorFixture from "./fixtures/uptime-monitor.json" with { type: "json" }; import userFixture from "./fixtures/user.json" with { type: "json" }; import { issueFixture2 } from "./payloads"; +import { eventsTimeSeriesResponse } from "./events-timeseries"; /** * Builds MSW handlers for both SaaS and self-hosted Sentry instances. @@ -563,6 +564,11 @@ export const restHandlers: HttpHandler[] = buildHandlers([ }); }, }, + { + method: "get", + path: "/api/0/organizations/sentry-mcp-evals/events-timeseries/", + fetch: ({ request }) => eventsTimeSeriesResponse(request), + }, { method: "get", path: "/api/0/organizations/sentry-mcp-evals/events/", diff --git a/plugins/sentry-mcp-experimental/agents/sentry-mcp.md b/plugins/sentry-mcp-experimental/agents/sentry-mcp.md index 17eb42990..65124e583 100644 --- a/plugins/sentry-mcp-experimental/agents/sentry-mcp.md +++ b/plugins/sentry-mcp-experimental/agents/sentry-mcp.md @@ -63,6 +63,7 @@ allowedTools: - link_issue - onboarding_status_update - remove_team_from_project + - render_sentry_chart - search_agent_conversations - search_attributes - search_docs diff --git a/plugins/sentry-mcp/agents/sentry-mcp.md b/plugins/sentry-mcp/agents/sentry-mcp.md index 9f4f516e3..058d66be0 100644 --- a/plugins/sentry-mcp/agents/sentry-mcp.md +++ b/plugins/sentry-mcp/agents/sentry-mcp.md @@ -65,6 +65,7 @@ allowedTools: - link_issue - onboarding_status_update - remove_team_from_project + - render_sentry_chart - search_agent_conversations - search_docs - search_errors From 027ac6e8a746c7bdfcc8c9b8dfae69643953809a Mon Sep 17 00:00:00 2001 From: "sentry-junior[bot]" <264270552+sentry-junior[bot]@users.noreply.github.com> Date: Thu, 19 Nov 2026 05:01:40 +0000 Subject: [PATCH 03/23] feat(mcp): Render render_sentry_chart inline in MCP Apps hosts Add the chart view as the ui://sentry/chart/v1.html resource and link the tool to it with _meta.ui.resourceUri (plus openai/outputTemplate for ChatGPT). The view is vanilla TypeScript with hand-drawn SVG, uses the ext-apps App class, follows the host theme, and calls the tool again through the host for its 1h/24h/7d/14d range picker. esbuild bundles chart-app/ into src/ui/chart-app.generated.ts so stdio and the Worker serve it with no file system. ci:policy fails when the generated file is stale. Co-Authored-By: David Cramer <23610+dcramer@users.noreply.github.com> --- .oxfmtrc.json | 1 + .oxlintrc.json | 1 + packages/cli/script/lib/zod-locales-plugin.ts | 3 +- packages/mcp-core/chart-app/chart.ts | 337 ++++++++++++++++++ packages/mcp-core/chart-app/main.ts | 298 ++++++++++++++++ packages/mcp-core/chart-app/styles.css | 241 +++++++++++++ packages/mcp-core/chart-app/tsconfig.json | 12 + packages/mcp-core/package.json | 4 +- .../mcp-core/scripts/generate-chart-app.ts | 67 ++++ packages/mcp-core/src/server.metadata.test.ts | 3 + .../mcp-core/src/server.ui-resources.test.ts | 87 +++++ .../src/tools/catalog/render-sentry-chart.ts | 2 + packages/mcp-core/src/ui-resources.ts | 16 +- .../mcp-core/src/ui/chart-app.generated.ts | 2 + 14 files changed, 1071 insertions(+), 3 deletions(-) create mode 100644 packages/mcp-core/chart-app/chart.ts create mode 100644 packages/mcp-core/chart-app/main.ts create mode 100644 packages/mcp-core/chart-app/styles.css create mode 100644 packages/mcp-core/chart-app/tsconfig.json create mode 100644 packages/mcp-core/scripts/generate-chart-app.ts create mode 100644 packages/mcp-core/src/server.ui-resources.test.ts create mode 100644 packages/mcp-core/src/ui/chart-app.generated.ts diff --git a/.oxfmtrc.json b/.oxfmtrc.json index 39e40ef1b..b27ad9c22 100644 --- a/.oxfmtrc.json +++ b/.oxfmtrc.json @@ -12,6 +12,7 @@ "packages/cli/CHANGELOG.md", "packages/cli/AGENTS.md", "packages/mcp-server-mocks/src/fixtures/**", + "packages/mcp-core/src/ui/chart-app.generated.ts", "packages/codemod-cli3to4/tests/**", "**/worker-configuration.d.ts", "**/tsconfig*.json" diff --git a/.oxlintrc.json b/.oxlintrc.json index d39013cae..9a657d123 100644 --- a/.oxlintrc.json +++ b/.oxlintrc.json @@ -13,6 +13,7 @@ "**/worker-configuration.d.ts", "**/tsconfig*.json", "packages/mcp-server-mocks/src/fixtures/**", + "packages/mcp-core/src/ui/chart-app.generated.ts", "packages/codemod-cli3to4/tests/**" ], "rules": { diff --git a/packages/cli/script/lib/zod-locales-plugin.ts b/packages/cli/script/lib/zod-locales-plugin.ts index 21ee6ba15..6159a95b3 100644 --- a/packages/cli/script/lib/zod-locales-plugin.ts +++ b/packages/cli/script/lib/zod-locales-plugin.ts @@ -10,7 +10,8 @@ * directly to set the default locale, so that path is not touched. * * Shared by the CLI bundles (`script/bundle.ts`, `script/build.ts`), which - * inline `@sentry/mcp-core` for `sentry mcp`. + * inline `@sentry/mcp-core` for `sentry mcp`, the `@sentry/mcp-server` + * bundle, and the MCP Apps chart view (`mcp-core/scripts/generate-chart-app.ts`). */ import { existsSync } from "node:fs"; diff --git a/packages/mcp-core/chart-app/chart.ts b/packages/mcp-core/chart-app/chart.ts new file mode 100644 index 000000000..a70338568 --- /dev/null +++ b/packages/mcp-core/chart-app/chart.ts @@ -0,0 +1,337 @@ +/** + * Draws a render_sentry_chart result as SVG: one area (or line, when there + * are several series) per series, a y grid, time labels, a hatched band over + * buckets that are still filling, and a hover tooltip. Values come from an + * untrusted tool result, so text only ever goes in through textContent. + */ +import type { ChartResult } from "../src/tools/support/chart/schema"; + +const SVG_NS = "http://www.w3.org/2000/svg"; +const HEIGHT = 220; +const MARGIN = { top: 8, right: 8, bottom: 22, left: 48 }; +export const SERIES_COLORS = [ + "#7553ff", + "#f2b712", + "#ff45a8", + "#3fb68b", + "#2ba1db", +]; + +const DURATION_MS: Record = { + nanosecond: 1e-6, + microsecond: 1e-3, + millisecond: 1, + second: 1000, + minute: 60_000, + hour: 3_600_000, +}; +const SIZE_UNITS = ["B", "KB", "MB", "GB", "TB"]; + +const compact = new Intl.NumberFormat(undefined, { + notation: "compact", + maximumFractionDigits: 1, +}); + +export function formatValue(value: number, chart: ChartResult): string { + if (chart.valueType === "duration") { + const ms = value * (DURATION_MS[chart.valueUnit ?? "millisecond"] ?? 1); + if (Math.abs(ms) < 1000) return `${Number(ms.toFixed(1))}ms`; + if (Math.abs(ms) < 60_000) return `${Number((ms / 1000).toFixed(2))}s`; + return `${Number((ms / 60_000).toFixed(1))}min`; + } + if (chart.valueType === "percentage") { + return `${Number((value * 100).toFixed(2))}%`; + } + if (chart.valueType === "size") { + let size = value; + let unit = 0; + while (Math.abs(size) >= 1024 && unit < SIZE_UNITS.length - 1) { + size /= 1024; + unit++; + } + return `${Number(size.toFixed(1))} ${SIZE_UNITS[unit]}`; + } + return compact.format(value); +} + +function svg( + tag: K, + attrs: Record, + parent?: Element, +): SVGElementTagNameMap[K] { + const el = document.createElementNS(SVG_NS, tag); + for (const [key, value] of Object.entries(attrs)) { + el.setAttribute(key, String(value)); + } + parent?.appendChild(el); + return el; +} + +/** Round step for about `count` gridlines between 0 and `max`. */ +function niceStep(max: number, count: number): number { + const raw = max / count; + const magnitude = 10 ** Math.floor(Math.log10(raw)); + const factor = [1, 2, 2.5, 5, 10].find((f) => f * magnitude >= raw) ?? 10; + return factor * magnitude; +} + +export interface TimeFormat { + locale: string | undefined; + timeZone: string | undefined; +} + +function timeFormatter(spanMs: number, format: TimeFormat) { + return new Intl.DateTimeFormat(format.locale, { + timeZone: format.timeZone, + ...(spanMs <= 2 * 86_400_000 + ? { hour: "2-digit", minute: "2-digit", hourCycle: "h23" } + : { month: "short", day: "numeric" }), + }); +} + +export function formatTooltipTime(time: number, format: TimeFormat): string { + return new Intl.DateTimeFormat(format.locale, { + timeZone: format.timeZone, + month: "short", + day: "numeric", + hour: "2-digit", + minute: "2-digit", + hourCycle: "h23", + timeZoneName: "short", + }).format(time); +} + +/** Renders the chart into `container`, replacing what was there. */ +export function drawChart( + container: HTMLElement, + chart: ChartResult, + format: TimeFormat, +): void { + container.replaceChildren(); + const width = Math.max(container.clientWidth, 280); + const plotWidth = width - MARGIN.left - MARGIN.right; + const plotHeight = HEIGHT - MARGIN.top - MARGIN.bottom; + const times = chart.series[0]?.buckets.map((b) => Date.parse(b.time)) ?? []; + const first = times[0] ?? 0; + const last = times.at(-1) ?? first; + const span = Math.max(last - first, 1); + const max = Math.max( + 0, + ...chart.series.flatMap((s) => s.buckets.map((b) => b.value)), + ); + const step = max > 0 ? niceStep(max, 4) : 1; + const top = Math.max(step, Math.ceil(max / step) * step); + const x = (time: number) => + MARGIN.left + (times.length > 1 ? ((time - first) / span) * plotWidth : 0); + const y = (value: number) => + MARGIN.top + plotHeight - (value / top) * plotHeight; + + const root = svg("svg", { + viewBox: `0 0 ${width} ${HEIGHT}`, + height: HEIGHT, + role: "img", + "aria-label": chart.title, + }); + const defs = svg("defs", {}, root); + const hatch = svg( + "pattern", + { + id: "incomplete-hatch", + width: 6, + height: 6, + patternUnits: "userSpaceOnUse", + patternTransform: "rotate(45)", + }, + defs, + ); + svg("line", { x1: 0, y1: 0, x2: 0, y2: 6, "stroke-width": 2 }, hatch); + + const grid = svg("g", { class: "grid axis" }, root); + for (let value = 0; value <= top + step / 2; value += step) { + svg( + "line", + { x1: MARGIN.left, x2: width - MARGIN.right, y1: y(value), y2: y(value) }, + grid, + ); + const label = svg( + "text", + { x: MARGIN.left - 6, y: y(value) + 4, "text-anchor": "end" }, + grid, + ); + label.textContent = formatValue(value, chart); + } + + const ticks = svg("g", { class: "axis" }, root); + const tickFormat = timeFormatter(span, format); + const tickCount = Math.min( + times.length, + Math.max(2, Math.floor(plotWidth / 90)), + ); + for (let i = 0; i < tickCount; i++) { + const time = first + (span * i) / Math.max(tickCount - 1, 1); + const label = svg( + "text", + { + x: x(time), + y: HEIGHT - 6, + "text-anchor": + i === 0 ? "start" : i === tickCount - 1 ? "end" : "middle", + }, + ticks, + ); + label.textContent = tickFormat.format(time); + } + + // Buckets still filling: a hatched band from the first one to the end. + const firstFilling = chart.series[0]?.buckets.findIndex((b) => b.incomplete); + if (firstFilling !== undefined && firstFilling >= 0) { + const fillingStart = x(times[Math.max(firstFilling - 1, 0)] ?? last); + svg( + "rect", + { + class: "incomplete-band", + x: fillingStart, + y: MARGIN.top, + width: Math.max(x(last) - fillingStart, 2), + height: plotHeight, + }, + root, + ); + } + svg( + "line", + { + class: "baseline", + x1: MARGIN.left, + x2: width - MARGIN.right, + y1: y(0), + y2: y(0), + }, + root, + ); + + const single = chart.series.length === 1; + chart.series.forEach((series, index) => { + const color = SERIES_COLORS[index % SERIES_COLORS.length] ?? "#7553ff"; + const points = series.buckets.map( + (b) => [x(Date.parse(b.time)), y(b.value)] as const, + ); + const split = series.buckets.findIndex((b) => b.incomplete); + const settled = split < 0 ? points : points.slice(0, Math.max(split, 1)); + const filling = split < 0 ? [] : points.slice(Math.max(split - 1, 0)); + const path = (pts: readonly (readonly [number, number])[]) => + pts.map(([px, py], i) => `${i ? "L" : "M"}${px},${py}`).join(""); + if (single && points.length > 1) { + svg( + "path", + { + d: `${path(points)}L${points.at(-1)?.[0]},${y(0)}L${points[0]?.[0]},${y(0)}Z`, + fill: color, + "fill-opacity": 0.16, + }, + root, + ); + } + svg( + "path", + { d: path(settled), fill: "none", stroke: color, "stroke-width": 2 }, + root, + ); + if (filling.length > 1) { + svg( + "path", + { + d: path(filling), + fill: "none", + stroke: color, + "stroke-width": 2, + "stroke-dasharray": "4 3", + }, + root, + ); + } + }); + + const crosshair = svg( + "line", + { class: "crosshair", y1: MARGIN.top, y2: y(0), visibility: "hidden" }, + root, + ); + const markers = chart.series.map((_, index) => + svg( + "circle", + { + r: 3.5, + fill: SERIES_COLORS[index % SERIES_COLORS.length] ?? "#7553ff", + visibility: "hidden", + }, + root, + ), + ); + container.appendChild(root); + + const tooltip = document.createElement("div"); + tooltip.className = "tooltip"; + tooltip.hidden = true; + container.appendChild(tooltip); + + const hide = () => { + tooltip.hidden = true; + crosshair.setAttribute("visibility", "hidden"); + for (const marker of markers) marker.setAttribute("visibility", "hidden"); + }; + const showAt = (index: number) => { + const time = times[index]; + if (time === undefined) return hide(); + const px = x(time); + crosshair.setAttribute("x1", String(px)); + crosshair.setAttribute("x2", String(px)); + crosshair.setAttribute("visibility", "visible"); + const timeRow = document.createElement("div"); + timeRow.className = "time"; + const incomplete = chart.series[0]?.buckets[index]?.incomplete; + timeRow.textContent = `${formatTooltipTime(time, format)}${incomplete ? " (still filling)" : ""}`; + const rows = chart.series.map((series, s) => { + const bucket = series.buckets[index]; + const marker = markers[s]; + if (bucket && marker) { + marker.setAttribute("cx", String(px)); + marker.setAttribute("cy", String(y(bucket.value))); + marker.setAttribute("visibility", "visible"); + } + const row = document.createElement("div"); + row.className = "row"; + const swatch = document.createElement("span"); + swatch.className = "swatch"; + swatch.style.background = SERIES_COLORS[s % SERIES_COLORS.length] ?? ""; + const label = document.createElement("span"); + label.textContent = series.label; + const value = document.createElement("span"); + value.textContent = bucket ? formatValue(bucket.value, chart) : "–"; + row.append(swatch, label, value); + return row; + }); + tooltip.replaceChildren(timeRow, ...rows); + tooltip.hidden = false; + const left = Math.min(px + 12, width - tooltip.offsetWidth - 4); + tooltip.style.left = `${left < px && px - tooltip.offsetWidth - 12 > 0 ? px - tooltip.offsetWidth - 12 : left}px`; + tooltip.style.top = `${MARGIN.top}px`; + }; + + root.addEventListener("pointermove", (event) => { + const box = root.getBoundingClientRect(); + const px = ((event.clientX - box.left) / box.width) * width; + if (px < MARGIN.left || px > width - MARGIN.right || times.length === 0) { + return hide(); + } + const time = first + ((px - MARGIN.left) / plotWidth) * span; + let nearest = 0; + times.forEach((t, i) => { + if (Math.abs(t - time) < Math.abs((times[nearest] ?? 0) - time)) { + nearest = i; + } + }); + showAt(nearest); + }); + root.addEventListener("pointerleave", hide); +} diff --git a/packages/mcp-core/chart-app/main.ts b/packages/mcp-core/chart-app/main.ts new file mode 100644 index 000000000..d94ea22d0 --- /dev/null +++ b/packages/mcp-core/chart-app/main.ts @@ -0,0 +1,298 @@ +/** + * The render_sentry_chart view. The host sends the tool's arguments and + * result; the range picker calls the tool again through the host and redraws + * in place. + */ +import { + App, + applyDocumentTheme, + applyHostStyleVariables, + type McpUiHostContext, +} from "@modelcontextprotocol/ext-apps"; +import { + type ChartResult, + renderSentryChartOutputSchema, +} from "../src/tools/support/chart/schema"; +import { + drawChart, + formatTooltipTime, + formatValue, + SERIES_COLORS, + type TimeFormat, +} from "./chart"; + +type CallToolResult = Awaited>; + +const TOOL_NAME = "render_sentry_chart"; +const RANGES = ["1h", "24h", "7d", "14d"] as const; +const UNIT_NAMES: Record = { + m: "minute", + h: "hour", + d: "day", + w: "week", +}; + +type View = + | { kind: "waiting" } + | { kind: "ready"; chart: ChartResult } + | { kind: "error"; message: string; chart: ChartResult | null }; + +let view: View = { kind: "waiting" }; +let toolArgs: Record = {}; +let pendingRange: string | null = null; +let format: TimeFormat = { locale: undefined, timeZone: undefined }; + +function el( + tag: K, + className?: string, + text?: string, +): HTMLElementTagNameMap[K] { + const node = document.createElement(tag); + if (className) node.className = className; + if (text !== undefined) node.textContent = text; + return node; +} + +const title = el("h1", undefined, "Sentry chart"); +const subtitle = el("div", "subtitle"); +const ranges = el("div", "ranges"); +const openButton = el("button", "open", "Open in Sentry"); +const stats = el("div", "stats"); +const chartBox = el("div", "chart"); +const legend = el("div", "legend"); +const note = el("div", "note"); +const state = el("div", "state", "Loading chart…"); +const rangeButtons = RANGES.map((range) => { + const button = el("button", undefined, range); + button.type = "button"; + button.addEventListener("click", () => void changeRange(range)); + ranges.appendChild(button); + return button; +}); + +const header = el("header"); +const heading = el("div"); +heading.append(title, subtitle); +const controls = el("div", "controls"); +controls.append(ranges, openButton); +header.append(heading, controls); +const main = el("main"); +main.append(header, stats, chartBox, legend, note, state); +document.body.appendChild(main); + +function rangeLabel(chart: ChartResult): string { + const { statsPeriod, start, end } = chart.timeRange; + const match = statsPeriod ? /^(\d+)([mhdw])$/.exec(statsPeriod) : null; + if (match?.[1] && match[2]) { + const count = Number(match[1]); + const unit = UNIT_NAMES[match[2]] ?? match[2]; + return `Last ${count === 1 ? unit : `${count} ${unit}s`}`; + } + if (start && end) { + return `${formatTooltipTime(Date.parse(start), format)} – ${formatTooltipTime(Date.parse(end), format)}`; + } + return statsPeriod ?? ""; +} + +function stat(label: string, value: string): HTMLElement { + const item = el("span", undefined, `${label} `); + item.appendChild(el("strong", undefined, value)); + return item; +} + +function render(): void { + const chart = view.kind === "waiting" ? null : view.chart; + const busy = pendingRange !== null; + chartBox.dataset["loading"] = String(busy); + for (const [index, button] of rangeButtons.entries()) { + const range = RANGES[index]; + button.disabled = busy || chart === null; + button.setAttribute( + "aria-pressed", + String((pendingRange ?? chart?.timeRange.statsPeriod) === range), + ); + } + openButton.disabled = !chart?.url.startsWith("https://"); + + if (view.kind === "error") { + state.hidden = false; + state.className = "state error"; + state.textContent = view.message; + } + if (!chart) { + if (view.kind === "waiting") state.hidden = false; + stats.replaceChildren(); + legend.replaceChildren(); + chartBox.replaceChildren(); + note.textContent = ""; + return; + } + + title.textContent = chart.title; + subtitle.replaceChildren( + `${chart.dataset} · `, + el("code", undefined, chart.query || "all events"), + ` · ${rangeLabel(chart)}`, + ); + + const hasData = chart.series.some((series) => series.buckets.length > 0); + if (view.kind === "ready") { + state.className = "state"; + state.hidden = hasData; + state.textContent = "No data for this query in this range."; + } + + const single = chart.series.length === 1 ? chart.series[0] : undefined; + const items: HTMLElement[] = []; + if (single?.total != null) { + items.push(stat("Total", formatValue(single.total, chart))); + } + if (chart.peak) { + items.push( + stat( + "Peak", + `${formatValue(chart.peak.value, chart)}${single ? "" : ` (${chart.peak.series})`} at ${formatTooltipTime(Date.parse(chart.peak.time), format)}`, + ), + ); + } + if (hasData) items.push(stat("Interval", chart.interval)); + stats.replaceChildren(...items); + + legend.replaceChildren( + ...(single + ? [] + : chart.series.map((series, index) => { + const item = el("span", "item"); + const swatch = el("span", "swatch"); + swatch.style.background = + SERIES_COLORS[index % SERIES_COLORS.length] ?? ""; + const total = + series.total === null + ? "" + : ` · ${formatValue(series.total, chart)}`; + item.append(swatch, `${series.label}${total}`); + return item; + })), + ); + + const filling = chart.series.some((series) => + series.buckets.some((bucket) => bucket.incomplete), + ); + const ingestion = + chart.ingestion && chart.ingestion.status !== "healthy" + ? ` Ingestion is ${chart.ingestion.status}.` + : ""; + note.textContent = hasData + ? `${filling ? "Hatched area: buckets still receiving data." : ""}${ingestion}`.trim() + : ""; + + if (hasData) { + drawChart(chartBox, chart, format); + } else { + chartBox.replaceChildren(); + } +} + +function errorText(result: CallToolResult): string { + const text = result.content.find((block) => block.type === "text"); + return text && "text" in text ? text.text : "The chart could not load."; +} + +function showResult(result: CallToolResult): void { + const previous = view.kind === "waiting" ? null : view.chart; + if (result.isError) { + view = { kind: "error", message: errorText(result), chart: previous }; + return; + } + const parsed = renderSentryChartOutputSchema.safeParse( + result.structuredContent, + ); + view = parsed.success + ? { kind: "ready", chart: parsed.data } + : { + kind: "error", + message: "The chart data was not in the expected shape.", + chart: previous, + }; +} + +const app = new App({ name: "Sentry chart", version: "1.0.0" }); + +async function changeRange(range: string): Promise { + const args: Record = { + ...toolArgs, + period: range, + start: null, + end: null, + }; + // A fixed bucket size may not fit the new range, so let Sentry pick. + delete args["interval"]; + pendingRange = range; + render(); + try { + const result = await app.callServerTool({ + name: TOOL_NAME, + arguments: args, + }); + if (!result.isError) toolArgs = args; + showResult(result); + } catch (error) { + view = { + kind: "error", + message: error instanceof Error ? error.message : String(error), + chart: view.kind === "waiting" ? null : view.chart, + }; + } finally { + pendingRange = null; + render(); + } +} + +function applyHostContext(context: McpUiHostContext | undefined): void { + if (!context) return; + if (context.theme) applyDocumentTheme(context.theme); + if (context.styles?.variables) { + applyHostStyleVariables(context.styles.variables); + } + if (context.locale || context.timeZone) { + format = { + locale: context.locale ?? format.locale, + timeZone: context.timeZone ?? format.timeZone, + }; + } + render(); +} + +openButton.addEventListener("click", () => { + const chart = view.kind === "waiting" ? null : view.chart; + if (chart?.url.startsWith("https://")) void app.openLink({ url: chart.url }); +}); + +app.ontoolinput = (params) => { + toolArgs = { ...params.arguments }; +}; +app.ontoolresult = (result) => { + showResult(result); + render(); +}; +app.ontoolcancelled = () => { + view = { + kind: "error", + message: "The chart request was cancelled.", + chart: null, + }; + render(); +}; +app.onhostcontextchanged = applyHostContext; + +let lastWidth = 0; +new ResizeObserver(([entry]) => { + const width = Math.round(entry?.contentRect.width ?? 0); + if (width !== lastWidth && view.kind !== "waiting") { + lastWidth = width; + render(); + } +}).observe(main); + +render(); +void app.connect().then(() => applyHostContext(app.getHostContext())); diff --git a/packages/mcp-core/chart-app/styles.css b/packages/mcp-core/chart-app/styles.css new file mode 100644 index 000000000..be9ca23e3 --- /dev/null +++ b/packages/mcp-core/chart-app/styles.css @@ -0,0 +1,241 @@ +:root { + color-scheme: light; + --bg: var(--color-background-primary, #ffffff); + --panel: var(--color-background-secondary, #faf9fb); + --fg: var(--color-text-primary, #2b2233); + --muted: var(--color-text-secondary, #71637e); + --border: var(--color-border-primary, #e0dce5); + --grid: var(--color-border-tertiary, #f0ecf3); + --danger: var(--color-text-danger, #cf2126); + --accent: #6c5fc7; + --radius: var(--border-radius-md, 6px); + font-family: var( + --font-sans, + -apple-system, + BlinkMacSystemFont, + "Segoe UI", + Roboto, + sans-serif + ); + font-size: var(--font-text-sm-size, 13px); +} + +[data-theme="dark"] { + color-scheme: dark; + --bg: var(--color-background-primary, #1e1a25); + --panel: var(--color-background-secondary, #262130); + --fg: var(--color-text-primary, #ebe6ef); + --muted: var(--color-text-secondary, #a397b0); + --border: var(--color-border-primary, #3e3446); + --grid: var(--color-border-tertiary, #2f2838); + --danger: var(--color-text-danger, #ff7f7f); + --accent: #a796f0; +} + +* { + box-sizing: border-box; +} + +html, +body { + margin: 0; + background: var(--bg); + color: var(--fg); +} + +main { + padding: 14px 16px 12px; +} + +header { + display: flex; + flex-wrap: wrap; + align-items: flex-start; + justify-content: space-between; + gap: 8px 16px; +} + +h1 { + margin: 0; + font-size: var(--font-heading-sm-size, 15px); + font-weight: var(--font-weight-semibold, 600); + overflow-wrap: anywhere; +} + +.subtitle { + margin-top: 2px; + color: var(--muted); + overflow-wrap: anywhere; +} + +.subtitle code { + font-family: var(--font-mono, ui-monospace, SFMono-Regular, Menlo, monospace); + font-size: 0.95em; +} + +.controls { + display: flex; + gap: 8px; + align-items: center; +} + +.ranges { + display: inline-flex; + border: 1px solid var(--border); + border-radius: var(--radius); + overflow: hidden; +} + +button { + font: inherit; + color: var(--fg); + background: var(--bg); + border: 0; + padding: 4px 10px; + cursor: pointer; +} + +.ranges button + button { + border-left: 1px solid var(--border); +} + +.ranges button[aria-pressed="true"] { + background: var(--accent); + color: #ffffff; +} + +button:disabled { + cursor: default; + opacity: 0.6; +} + +.open { + border: 1px solid var(--border); + border-radius: var(--radius); +} + +.stats { + display: flex; + flex-wrap: wrap; + gap: 4px 16px; + margin: 10px 0 4px; + color: var(--muted); +} + +.stats strong { + color: var(--fg); + font-weight: var(--font-weight-semibold, 600); +} + +.chart { + position: relative; + transition: opacity 120ms; +} + +.chart[data-loading="true"] { + opacity: 0.45; +} + +svg { + display: block; + width: 100%; + overflow: visible; +} + +.axis text { + fill: var(--muted); + font-size: 11px; +} + +.grid line { + stroke: var(--grid); +} + +.baseline { + stroke: var(--border); +} + +.incomplete-band { + fill: url(#incomplete-hatch); +} + +#incomplete-hatch line { + stroke: var(--border); +} + +.crosshair { + stroke: var(--muted); + stroke-dasharray: 2 3; +} + +.tooltip { + position: absolute; + pointer-events: none; + min-width: 140px; + padding: 6px 8px; + background: var(--panel); + border: 1px solid var(--border); + border-radius: var(--radius); + box-shadow: var(--shadow-md, 0 2px 8px rgba(0, 0, 0, 0.15)); + font-size: 12px; +} + +.tooltip .time { + color: var(--muted); + margin-bottom: 4px; +} + +.tooltip .row, +.legend .item { + display: flex; + gap: 6px; + align-items: center; +} + +.tooltip .row span:last-child { + margin-left: auto; + padding-left: 12px; + font-variant-numeric: tabular-nums; +} + +.swatch { + width: 8px; + height: 8px; + border-radius: 2px; + flex: none; +} + +.legend { + display: flex; + flex-wrap: wrap; + gap: 4px 14px; + margin-top: 6px; + color: var(--muted); +} + +.note { + margin-top: 6px; + color: var(--muted); + font-size: 12px; +} + +.state { + display: grid; + place-items: center; + min-height: 160px; + color: var(--muted); + text-align: center; + border: 1px dashed var(--border); + border-radius: var(--radius); + margin-top: 10px; + padding: 16px; +} + +.state.error { + color: var(--danger); +} + +/* Author display rules otherwise beat the hidden attribute. */ +[hidden] { + display: none !important; +} diff --git a/packages/mcp-core/chart-app/tsconfig.json b/packages/mcp-core/chart-app/tsconfig.json new file mode 100644 index 000000000..0f98db4f5 --- /dev/null +++ b/packages/mcp-core/chart-app/tsconfig.json @@ -0,0 +1,12 @@ +{ + "extends": "../../../tsconfig.base.json", + "compilerOptions": { + // Runs in an MCP Apps host's sandboxed iframe, not in Node. + "lib": ["ES2023", "DOM", "DOM.Iterable"], + "types": [], + "noEmit": true, + // skipLibCheck exception: @modelcontextprotocol/client declarations, which @modelcontextprotocol/ext-apps imports, use Node's Buffer (TS2591) and this browser view has no Node types. Remove when they check cleanly without @types/node. + "skipLibCheck": true + }, + "include": ["*.ts"] +} diff --git a/packages/mcp-core/package.json b/packages/mcp-core/package.json index 5d4eaaea0..278892d79 100644 --- a/packages/mcp-core/package.json +++ b/packages/mcp-core/package.json @@ -154,8 +154,10 @@ "test": "pnpm run validate-skills && vitest run", "test:ci": "pnpm run generate-definitions && pnpm run validate-skills && vitest run --reporter=default --reporter=junit --outputFile=tests.junit.xml", "test:watch": "pnpm run generate-definitions && vitest", - "typecheck": "tsc --noEmit && tsc --noEmit -p scripts/tsconfig.json", + "typecheck": "tsc --noEmit && tsc --noEmit -p scripts/tsconfig.json && tsc --noEmit -p chart-app", "generate-definitions": "node --experimental-strip-types --import ../../scripts/strip-types-resolve.mjs scripts/generate-definitions.ts && oxfmt --write src/toolDefinitions.json src/skillDefinitions.json", + "generate-chart-app": "node --experimental-strip-types --import ../../scripts/strip-types-resolve.mjs scripts/generate-chart-app.ts", + "ci:policy": "pnpm run generate-chart-app --check", "generate-platform-setup": "node --experimental-strip-types --import ../../scripts/strip-types-resolve.mjs scripts/generate-platform-setup.ts && oxfmt --write src/tools/support/project-setup/platforms.json", "generate-otel-namespaces": "node --experimental-strip-types --import ../../scripts/strip-types-resolve.mjs scripts/generate-otel-namespaces.ts", "measure-tokens": "node --experimental-strip-types --import ../../scripts/strip-types-resolve.mjs scripts/measure-token-cost.ts", diff --git a/packages/mcp-core/scripts/generate-chart-app.ts b/packages/mcp-core/scripts/generate-chart-app.ts new file mode 100644 index 000000000..e1b44f04f --- /dev/null +++ b/packages/mcp-core/scripts/generate-chart-app.ts @@ -0,0 +1,67 @@ +/** + * Bundles the render_sentry_chart view (chart-app/) into one self-contained + * HTML document and writes it to src/ui/chart-app.generated.ts, so the stdio + * server and the Cloudflare Worker serve it without reading files. + * + * `--check` fails instead of writing when the committed file is stale. + */ +import { readFileSync, writeFileSync } from "node:fs"; +import { fileURLToPath } from "node:url"; +import { build, transform } from "esbuild"; +// Shared with the CLI and @sentry/mcp-server bundles. +import { zodEnglishLocalesPlugin } from "../../cli/script/lib/zod-locales-plugin.ts"; + +const appDir = fileURLToPath(new URL("../chart-app/", import.meta.url)); +const outFile = fileURLToPath( + new URL("../src/ui/chart-app.generated.ts", import.meta.url), +); + +const bundle = await build({ + entryPoints: [`${appDir}main.ts`], + bundle: true, + minify: true, + format: "iife", + platform: "browser", + target: "es2022", + legalComments: "none", + charset: "utf8", + plugins: [zodEnglishLocalesPlugin], + write: false, +}); +const script = bundle.outputFiles[0]?.text; +if (!script) { + throw new Error("esbuild produced no output for chart-app/main.ts"); +} +const style = await transform(readFileSync(`${appDir}styles.css`, "utf8"), { + loader: "css", + minify: true, +}); + +const html = [ + "", + '', + '', + "Sentry chart", + ``, + // An inline script ends at the first ``, +].join(""); + +const source = `// Generated by scripts/generate-chart-app.ts from chart-app/. Do not edit. +export const CHART_APP_HTML = ${JSON.stringify(html)}; +`; + +if (process.argv.includes("--check")) { + if (readFileSync(outFile, "utf8") !== source) { + console.error( + "src/ui/chart-app.generated.ts is stale. Run: pnpm --filter @sentry/mcp-core generate-chart-app", + ); + process.exit(1); + } + console.log("src/ui/chart-app.generated.ts is up to date."); +} else { + writeFileSync(outFile, source); + console.log( + `Wrote src/ui/chart-app.generated.ts (${Math.round(html.length / 1024)} KiB of HTML).`, + ); +} diff --git a/packages/mcp-core/src/server.metadata.test.ts b/packages/mcp-core/src/server.metadata.test.ts index b6ad31bb0..04fe4b834 100644 --- a/packages/mcp-core/src/server.metadata.test.ts +++ b/packages/mcp-core/src/server.metadata.test.ts @@ -34,6 +34,9 @@ const ALLOWED_TOOL_META: Record = { // Claude Code keeps it loaded so a pasted Sentry URL works without a tool // search. See docs/mcp/harnesses.md. get_sentry_resource: ["anthropic/alwaysLoad"], + // MCP Apps hosts (Claude, VS Code) read `ui`; ChatGPT reads + // `openai/outputTemplate`. See src/ui-resources.ts. + render_sentry_chart: ["ui", "openai/outputTemplate"], }; /** Tools that return no `structuredContent` by design. */ diff --git a/packages/mcp-core/src/server.ui-resources.test.ts b/packages/mcp-core/src/server.ui-resources.test.ts new file mode 100644 index 000000000..9e438c84f --- /dev/null +++ b/packages/mcp-core/src/server.ui-resources.test.ts @@ -0,0 +1,87 @@ +/** + * MCP Apps: what a host reads to render render_sentry_chart inline. The tool + * names its view in `_meta.ui.resourceUri`, and that `ui://` resource reads + * back as a self-contained HTML document with the MCP Apps mime type. + */ +import { Client } from "@modelcontextprotocol/sdk/client/index.js"; +import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js"; +import { describe, expect, it, vi } from "vitest"; +import { buildServer } from "./server"; +import type { Skill } from "./skills"; +import type { ServerContext } from "./types"; + +vi.mock("@sentry/core/server", () => ({ + wrapMcpServerWithSentry: vi.fn((server) => server), +})); + +const CHART_URI = "ui://sentry/chart/v1.html"; +const MCP_APP_MIME_TYPE = "text/html;profile=mcp-app"; + +async function connect(skills: Skill[]) { + const context: ServerContext = { + accessToken: "test-token", + grantedSkills: new Set(skills), + constraints: { organizationSlug: null, projectSlug: null }, + sentryHost: "sentry.io", + }; + const server = buildServer({ context }); + const [clientTransport, serverTransport] = + InMemoryTransport.createLinkedPair(); + const client = new Client({ name: "mcp-apps-host", version: "1.0.0" }); + await server.connect(serverTransport); + await client.connect(clientTransport); + return { + client, + async [Symbol.asyncDispose]() { + await client.close(); + await server.close(); + }, + }; +} + +describe("MCP Apps chart view", () => { + it("links render_sentry_chart to its view in tools/list", async () => { + await using session = await connect(["inspect"]); + const { tools } = await session.client.listTools(); + const chartTool = tools.find((tool) => tool.name === "render_sentry_chart"); + + expect(chartTool?._meta).toEqual({ + ui: { resourceUri: CHART_URI }, + "openai/outputTemplate": CHART_URI, + }); + }); + + it("lists and reads the view as a self-contained HTML document", async () => { + await using session = await connect(["inspect"]); + + expect(session.client.getServerCapabilities()?.resources).toEqual({ + listChanged: false, + }); + const { resources } = await session.client.listResources(); + expect(resources).toEqual([ + expect.objectContaining({ uri: CHART_URI, mimeType: MCP_APP_MIME_TYPE }), + ]); + + const { contents } = await session.client.readResource({ uri: CHART_URI }); + expect(contents).toHaveLength(1); + const [view] = contents; + expect(view).toMatchObject({ + uri: CHART_URI, + mimeType: MCP_APP_MIME_TYPE, + _meta: { ui: { csp: {}, prefersBorder: true } }, + }); + const html = view && "text" in view ? view.text : ""; + expect(html.startsWith("")).toBe(true); + expect(html.endsWith("")).toBe(true); + // Hosts block network loads unless `csp` declares the domain. + expect(html).not.toMatch(/<(script|link|img)[^>]+(src|href)=/i); + }); + + it("lists no view when the session cannot call the chart tool", async () => { + await using session = await connect(["project-management"]); + const { tools } = await session.client.listTools(); + + expect(tools.map((tool) => tool.name)).not.toContain("render_sentry_chart"); + expect(session.client.getServerCapabilities()?.resources).toBeUndefined(); + }); +}); diff --git a/packages/mcp-core/src/tools/catalog/render-sentry-chart.ts b/packages/mcp-core/src/tools/catalog/render-sentry-chart.ts index be15b4983..2e468caa9 100644 --- a/packages/mcp-core/src/tools/catalog/render-sentry-chart.ts +++ b/packages/mcp-core/src/tools/catalog/render-sentry-chart.ts @@ -12,6 +12,7 @@ import { } from "../../schema"; import { setTargetTagsAndAttributes } from "../../telem/scope"; import type { ServerContext } from "../../types"; +import { CHART_UI_RESOURCE, uiToolMeta } from "../../ui-resources"; import { PUBLIC_EVENTS_DATASETS } from "../../utils/events-datasets"; import { type ChartResult, @@ -148,6 +149,7 @@ export default defineTool({ openWorldHint: true, }, outputSchema: renderSentryChartOutputSchema, + _meta: uiToolMeta(CHART_UI_RESOURCE), async handler(params, context: ServerContext) { if ((params.start === null) !== (params.end === null)) { throw new UserInputError("Pass both `start` and `end`, or neither."); diff --git a/packages/mcp-core/src/ui-resources.ts b/packages/mcp-core/src/ui-resources.ts index f666aa2b8..5e567af96 100644 --- a/packages/mcp-core/src/ui-resources.ts +++ b/packages/mcp-core/src/ui-resources.ts @@ -2,6 +2,7 @@ * MCP Apps views: `ui://` HTML resources that a host renders inline for a * tool result. A tool opts in with `_meta: uiToolMeta(resource)`, and the * server lists each resource that a registered tool references. + * Views are generated HTML strings, so they need no file system at runtime. * * Spec: https://github.com/modelcontextprotocol/ext-apps/blob/main/specification/2026-01-26/apps.mdx */ @@ -11,6 +12,7 @@ import type { } from "@modelcontextprotocol/ext-apps"; import { RESOURCE_MIME_TYPE } from "@modelcontextprotocol/ext-apps/server"; import type { McpServer } from "@modelcontextprotocol/server"; +import { CHART_APP_HTML } from "./ui/chart-app.generated"; export interface UiResource { /** Hosts cache a view by its URI, so bump the version when the HTML changes. */ @@ -23,7 +25,19 @@ export interface UiResource { meta: McpUiResourceMeta; } -export const UI_RESOURCES: readonly UiResource[] = []; +/** The render_sentry_chart view. Built from chart-app/ by generate-chart-app. */ +export const CHART_UI_RESOURCE: UiResource = { + uri: "ui://sentry/chart/v1.html", + name: "sentry_chart", + title: "Sentry Chart", + description: + "Interactive time series chart for render_sentry_chart results, with a range picker and a link to Sentry.", + html: CHART_APP_HTML, + // Self-contained, so it loads nothing from the network. + meta: { csp: {}, prefersBorder: true }, +}; + +export const UI_RESOURCES: readonly UiResource[] = [CHART_UI_RESOURCE]; /** * `_meta` for a tool whose result renders in `resource`. ChatGPT reads diff --git a/packages/mcp-core/src/ui/chart-app.generated.ts b/packages/mcp-core/src/ui/chart-app.generated.ts new file mode 100644 index 000000000..baa57f883 --- /dev/null +++ b/packages/mcp-core/src/ui/chart-app.generated.ts @@ -0,0 +1,2 @@ +// Generated by scripts/generate-chart-app.ts from chart-app/. Do not edit. +export const CHART_APP_HTML = "Sentry chart"; From a83a6fe6d5f5ec07c5d4ce868258699fb8ee9214 Mon Sep 17 00:00:00 2001 From: "sentry-junior[bot]" <264270552+sentry-junior[bot]@users.noreply.github.com> Date: Thu, 19 Nov 2026 05:15:58 +0000 Subject: [PATCH 04/23] docs(mcp): Verify the chart view as an MCP Apps host Add scripts/mcp-apps-host.mjs and the mcp-apps verify-toolkit map. The script starts the mock stdio server, reads render_sentry_chart's ui:// view, mounts it through the ext-apps AppBridge in headless Chromium under the spec's default CSP, and screenshots light, dark, the range picker round trip, and a grouped chart. Document MCP Apps views in the tool and response design docs and contributor guides. Co-Authored-By: David Cramer <23610+dcramer@users.noreply.github.com> --- .agents/skills/verify-toolkit/SKILL.md | 9 + .agents/skills/verify-toolkit/map/README.md | 2 + .agents/skills/verify-toolkit/map/mcp-apps.md | 43 +++ .../verify-toolkit/scripts/mcp-apps-host.mjs | 310 ++++++++++++++++++ design/mcp-tool-responses.md | 6 + design/mcp-tools.md | 8 + docs/contributing/adding-tools.md | 4 + docs/contributing/tool-responses.md | 24 ++ docs/evidence/mcp-apps-chart/chart-dark.png | Bin 0 -> 69337 bytes .../mcp-apps-chart/chart-grouped-dark.png | Bin 0 -> 106386 bytes docs/evidence/mcp-apps-chart/chart-light.png | Bin 0 -> 75477 bytes .../mcp-apps-chart/chart-range-7d.png | Bin 0 -> 64720 bytes docs/evidence/mcp-apps-chart/checks.txt | 8 + 13 files changed, 414 insertions(+) create mode 100644 .agents/skills/verify-toolkit/map/mcp-apps.md create mode 100644 .agents/skills/verify-toolkit/scripts/mcp-apps-host.mjs create mode 100644 docs/evidence/mcp-apps-chart/chart-dark.png create mode 100644 docs/evidence/mcp-apps-chart/chart-grouped-dark.png create mode 100644 docs/evidence/mcp-apps-chart/chart-light.png create mode 100644 docs/evidence/mcp-apps-chart/chart-range-7d.png create mode 100644 docs/evidence/mcp-apps-chart/checks.txt diff --git a/.agents/skills/verify-toolkit/SKILL.md b/.agents/skills/verify-toolkit/SKILL.md index 799b77a47..ada5bcf55 100644 --- a/.agents/skills/verify-toolkit/SKILL.md +++ b/.agents/skills/verify-toolkit/SKILL.md @@ -89,6 +89,15 @@ node .agents/skills/verify-toolkit/scripts/check-results.mjs subset WIDE_DIR DIR node .agents/skills/verify-toolkit/scripts/check-results.mjs local DIR ``` +`scripts/mcp-apps-host.mjs` acts as an MCP Apps host for +`render_sentry_chart` on the mock server: it reads the tool's `ui://` view, +mounts it in headless Chromium through the ext-apps `AppBridge`, and writes +screenshots, `host-log.json`, and `checks.txt` to `--out`: + +```bash +node .agents/skills/verify-toolkit/scripts/mcp-apps-host.mjs --out DIR +``` + `scripts/sentry-offline.mjs` runs one CLI command with the same offline env, and writes `command.txt`, `stdout.txt`, `stderr.txt`, and `exit-code.txt`: diff --git a/.agents/skills/verify-toolkit/map/README.md b/.agents/skills/verify-toolkit/map/README.md index 8ab5a451d..54a2ad8a0 100644 --- a/.agents/skills/verify-toolkit/map/README.md +++ b/.agents/skills/verify-toolkit/map/README.md @@ -57,5 +57,7 @@ out of the map. - `mcp-access.md` covers who can start `sentry mcp` and what a session reaches: login, skills, and org scope. - `cli.md` covers CLI behavior with no login and with a token. +- `mcp-apps.md` covers what an MCP Apps host gets for `render_sentry_chart`: + the `ui://` view, rendering, theme, and calls back through the host. - `sentry-local.md` covers `sentry local`: verifying an app's SDK, querying a retained session, hiding session credentials, and stopping the daemon. diff --git a/.agents/skills/verify-toolkit/map/mcp-apps.md b/.agents/skills/verify-toolkit/map/mcp-apps.md new file mode 100644 index 000000000..4a61371c2 --- /dev/null +++ b/.agents/skills/verify-toolkit/map/mcp-apps.md @@ -0,0 +1,43 @@ +# MCP Apps chart view + +What an MCP Apps host (Claude, VS Code, ChatGPT) gets for `render_sentry_chart`: +the tool names a `ui://` view in `tools/list`, the view reads back as one +self-contained HTML document, and the view renders the tool result, follows +the host theme, and calls the tool again through the host. The goals are in +`design/mcp-tools.md` and `design/mcp-tool-responses.md`. + +## Claims + +- `tool-meta` `render_sentry_chart` sets `_meta.ui.resourceUri` to a `ui://` URI and `_meta["openai/outputTemplate"]` to the same URI, with no deprecated flat `ui/resourceUri` key. Proof: `drive`. +- `view-resource` `resources/list` lists that URI, and `resources/read` returns it with mime type `text/html;profile=mcp-app` and an HTML document. Proof: `drive`. +- `view-listing` A session that cannot call `render_sentry_chart` lists no resources and no resources capability. Proof: `test` with `pnpm --filter @sentry/mcp-core exec vitest run src/server.ui-resources.test.ts`. +- `view-renders` Mounted through the ext-apps AppBridge, the view draws the series, shows a tooltip on hover, and hides its empty state. Proof: `drive`. +- `view-theme` The view follows the host's light or dark theme. Proof: `drive`. +- `range-roundtrip` The range picker calls `render_sentry_chart` through the host with the new period and redraws without remounting. Proof: `drive`. +- `open-link` "Open in Sentry" asks the host to open the result's Sentry URL with `ui/open-link`. Proof: `drive`. +- `grouped` A `groupBy` result draws one series per top group, with a legend. Proof: `drive`. +- `default-csp` The view loads and runs under the spec's default CSP with no console errors, so it needs no `csp` domains. Proof: `drive`. + +## How to get to it + +- An MCP Apps host that lists `render_sentry_chart` and reads its `ui://` resource, over stdio (`sentry mcp`, `npx @sentry/mcp-server`) or remote HTTP. +- A host with no MCP Apps support gets the same tool with a text and structured result only. + +## Driving it with mcp-apps-host.mjs + +Preconditions: + +- Launch from `../SKILL.md` has run on this checkout, and `$VERIFY_RUN` is set. +- A Chromium build for playwright-core is installed. If the script cannot launch it, run `pnpm --filter @sentry/mcp-core exec playwright-core install chromium-headless-shell`. + +- **Every `drive` claim: act as the host.** Run `node .agents/skills/verify-toolkit/scripts/mcp-apps-host.mjs --out "$VERIFY_RUN/mcp-apps"`. It starts the mock server, calls the tool, reads the view, and mounts it in headless Chromium inside a host page that uses `AppBridge`. Every line it prints, also in `checks.txt`, is `PASS`. The screenshots `chart-light.png`, `chart-dark.png`, `chart-range-7d.png`, and `chart-grouped-dark.png` show each state. `host-log.json` holds the view's `tools/call` and `ui/open-link` requests to the host. + +## Gotchas + +- The mock server answers from built packages. Rerun `pnpm run build` after changing mcp-core or the mocks, or the script drives stale code. +- The view is generated. After changing `packages/mcp-core/chart-app/`, run `pnpm --filter @sentry/mcp-core generate-chart-app`, then build. +- The host page sets the default CSP with a meta tag in `srcdoc`. Real hosts serve the view from a sandbox origin with CSP headers. + +## Gaps + +- `real-hosts` Rendering in Claude, VS Code, ChatGPT, and Codex desktop needs those apps with a live server; this map drives only the reference AppBridge. Use `mcp-qa` for real hosts. diff --git a/.agents/skills/verify-toolkit/scripts/mcp-apps-host.mjs b/.agents/skills/verify-toolkit/scripts/mcp-apps-host.mjs new file mode 100644 index 000000000..1f96cbf7a --- /dev/null +++ b/.agents/skills/verify-toolkit/scripts/mcp-apps-host.mjs @@ -0,0 +1,310 @@ +#!/usr/bin/env node +// Act as an MCP Apps host for render_sentry_chart, with no LLM: start the mock +// stdio server, call the tool, read its `ui://` view, and mount the view in a +// headless browser through the ext-apps AppBridge, the way Claude or VS Code +// does. Screenshots the chart in light and dark, after the range picker calls +// the tool again through the host, and split by an attribute. Writes evidence +// and one PASS or FAIL line per check to checks.txt in --out. See ../SKILL.md. +import { appendFileSync, mkdirSync, writeFileSync } from "node:fs"; +import { createRequire } from "node:module"; +import { dirname, join, resolve } from "node:path"; +import { fileURLToPath, pathToFileURL } from "node:url"; +import { offlineEnv } from "./offline-env.mjs"; + +const repo = resolve(dirname(fileURLToPath(import.meta.url)), "../../../.."); +const argv = process.argv.slice(2); +const out = argv[argv.indexOf("--out") + 1]; +if (!argv.includes("--out") || !out) { + console.error("usage: mcp-apps-host.mjs --out DIR"); + process.exit(2); +} +mkdirSync(out, { recursive: true }); + +// The MCP client SDK is a dependency of the test client; esbuild, the +// AppBridge, and playwright-core are dev dependencies of mcp-core. +const fromClient = createRequire( + join(repo, "packages/mcp-test-client/package.json"), +); +const fromCore = createRequire(join(repo, "packages/mcp-core/package.json")); +const load = (require, id) => import(pathToFileURL(require.resolve(id)).href); +const { Client } = await load( + fromClient, + "@modelcontextprotocol/sdk/client/index.js", +); +const { StdioClientTransport } = await load( + fromClient, + "@modelcontextprotocol/sdk/client/stdio.js", +); +const { build } = await load(fromCore, "esbuild"); +const { chromium } = fromCore("playwright-core"); + +const TOOL = "render_sentry_chart"; +const ORG = "sentry-mcp-evals"; +const ERRORS_CHART = { + organizationSlug: ORG, + dataset: "errors", + query: "level:error", + yAxis: "count()", + period: "24h", +}; +const GROUPED_CHART = { + organizationSlug: ORG, + dataset: "spans", + query: "is_transaction:true", + yAxis: "p95(span.duration)", + groupBy: "release", + period: "7d", +}; +// The spec's default view CSP: no network, no eval. +const DEFAULT_CSP = + "default-src 'none'; script-src 'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline'; img-src 'self' data:; media-src 'self' data:; connect-src 'none'"; + +const write = (name, value) => + writeFileSync( + join(out, name), + typeof value === "string" ? value : `${JSON.stringify(value, null, 2)}\n`, + ); +let failures = 0; +function check(id, ok, detail) { + const line = `${ok ? "PASS" : "FAIL"} mcp-apps#${id}: ${detail}`; + if (!ok) failures++; + console.log(line); + appendFileSync(join(out, "checks.txt"), `${line}\n`); +} + +// A minimal host page: mounts the view in a sandboxed iframe under the +// default CSP and bridges it with AppBridge. Tool calls from the view go to +// Node (window.mcpCallTool), which forwards them to the real server. +const hostScript = ( + await build({ + stdin: { + resolveDir: join(repo, "packages/mcp-core"), + contents: ` + import { AppBridge, PostMessageTransport } from "@modelcontextprotocol/ext-apps/app-bridge"; + window.hostLog = []; + window.mountView = async ({ html, theme, toolArgs, toolResult }) => { + document.body.dataset.theme = theme; + const iframe = document.createElement("iframe"); + iframe.setAttribute("sandbox", "allow-scripts"); + document.getElementById("host").replaceChildren(iframe); + const bridge = new AppBridge( + null, + { name: "verify-toolkit host", version: "0.0.0" }, + { openLinks: {}, serverTools: {} }, + { hostContext: { theme, locale: "en-US", timeZone: "UTC", platform: "web", displayMode: "inline", containerDimensions: { width: 720, maxHeight: 900 } } }, + ); + bridge.oncalltool = async (params) => { + window.hostLog.push({ method: "tools/call", params }); + return await window.mcpCallTool(params); + }; + bridge.onopenlink = async (params) => { + window.hostLog.push({ method: "ui/open-link", params }); + return {}; + }; + bridge.onsizechange = ({ height }) => { + if (height) iframe.style.height = height + "px"; + }; + const initialized = new Promise((done) => { bridge.oninitialized = done; }); + await bridge.connect(new PostMessageTransport(iframe.contentWindow, iframe.contentWindow)); + iframe.srcdoc = html.replace("", ${JSON.stringify(``)}); + await initialized; + await bridge.sendToolInput({ arguments: toolArgs }); + await bridge.sendToolResult(toolResult); + }; + `, + }, + bundle: true, + format: "iife", + write: false, + }) +).outputFiles[0].text; +const hostPage = `
`; + +const { env, cleanup } = offlineEnv({ token: true }); +delete env.SENTRY_HOST; +const transport = new StdioClientTransport({ + command: process.execPath, + args: [ + "--experimental-strip-types", + "--import", + join(repo, "scripts/strip-types-resolve.mjs"), + join(repo, "packages/mcp-server-evals/src/bin/start-mock-stdio.ts"), + ], + env, + cwd: repo, + stderr: "pipe", +}); +let stderr = ""; +transport.stderr?.on("data", (chunk) => { + stderr += chunk; +}); +const client = new Client({ + name: "verify-toolkit-apps-host", + version: "0.0.0", +}); +let browser; +try { + await client.connect(transport); + const { tools } = await client.listTools(); + const tool = tools.find((t) => t.name === TOOL); + write("tool.json", tool ?? null); + const uri = tool?._meta?.ui?.resourceUri; + check( + "tool-meta", + typeof uri === "string" && + uri.startsWith("ui://") && + tool._meta["openai/outputTemplate"] === uri && + !("ui/resourceUri" in tool._meta), + `${TOOL} _meta.ui.resourceUri=${uri}, openai/outputTemplate=${tool?._meta?.["openai/outputTemplate"]}`, + ); + + const { resources } = await client.listResources(); + const { contents } = await client.readResource({ uri }); + const view = contents[0]; + write("resources-list.json", resources); + write("resource-read.json", { + ...view, + text: `<${view?.text?.length ?? 0} chars, see view.html>`, + }); + write("view.html", view?.text ?? ""); + check( + "view-resource", + resources.some((r) => r.uri === uri) && + view?.mimeType === "text/html;profile=mcp-app" && + view.text.startsWith(""), + `resources/read ${uri}: ${view?.mimeType}, ${Math.round((view?.text?.length ?? 0) / 1024)} KiB HTML`, + ); + + const calls = []; + const callTool = async (params) => { + const result = await client.callTool(params); + calls.push({ request: params, result }); + return result; + }; + const errorsResult = await callTool({ name: TOOL, arguments: ERRORS_CHART }); + const groupedResult = await callTool({ + name: TOOL, + arguments: GROUPED_CHART, + }); + + browser = await chromium.launch(); + const page = await browser.newPage({ + viewport: { width: 768, height: 520 }, + deviceScaleFactor: 2, + }); + const consoleErrors = []; + page.on("console", (msg) => { + if (msg.type() === "error") consoleErrors.push(msg.text()); + }); + await page.exposeFunction("mcpCallTool", callTool); + await page.setContent(hostPage); + const frame = page.frameLocator("iframe"); + const mount = async (theme, toolArgs, toolResult) => { + await page.evaluate((input) => window.mountView(input), { + html: view.text, + theme, + toolArgs, + toolResult, + }); + await frame.locator("svg path").first().waitFor(); + // Let the view report its size and the host resize the iframe. + await page.waitForTimeout(300); + }; + const shot = async (name) => { + await page.locator("#host").screenshot({ path: join(out, name) }); + return join(out, name); + }; + + await mount("light", ERRORS_CHART, errorsResult); + const svgBox = await frame.locator("svg").boundingBox(); + await page.mouse.move( + svgBox.x + svgBox.width * 0.7, + svgBox.y + svgBox.height / 2, + ); + const tooltip = await frame.locator(".tooltip").innerText(); + const light = await shot("chart-light.png"); + const lightBg = await frame + .locator("body") + .evaluate((el) => getComputedStyle(el).backgroundColor); + const emptyHidden = await frame.locator(".state").isHidden(); + check( + "view-renders", + tooltip.includes("count()") && emptyHidden, + `light chart with hover tooltip "${tooltip.replace(/\s+/g, " ")}" -> ${light}`, + ); + + await mount("dark", ERRORS_CHART, errorsResult); + const darkBg = await frame + .locator("body") + .evaluate((el) => getComputedStyle(el).backgroundColor); + const dark = await shot("chart-dark.png"); + check( + "view-theme", + lightBg !== darkBg, + `host theme light=${lightBg} dark=${darkBg} -> ${dark}`, + ); + + await mount("light", ERRORS_CHART, errorsResult); + const before = await frame.locator(".subtitle").innerText(); + await frame.getByRole("button", { name: "7d", exact: true }).click(); + await frame.locator(".subtitle", { hasText: "Last 7 days" }).waitFor(); + await frame.locator('.chart[data-loading="false"]').waitFor(); + const range = await shot("chart-range-7d.png"); + const hostLog = await page.evaluate(() => window.hostLog); + const rangeCall = hostLog.find((entry) => entry.method === "tools/call"); + const rangeResult = calls.at(-1); + check( + "range-roundtrip", + rangeCall?.params?.name === TOOL && + rangeCall.params.arguments.period === "7d" && + rangeResult?.result?.structuredContent?.timeRange?.statsPeriod === "7d", + `"${before}" -> view called ${TOOL} period=7d through the host, got ${rangeResult?.result?.structuredContent?.series?.[0]?.buckets?.length} buckets -> ${range}`, + ); + + await frame.getByRole("button", { name: "Open in Sentry" }).click(); + await page.waitForFunction(() => + window.hostLog.some((e) => e.method === "ui/open-link"), + ); + const openLink = (await page.evaluate(() => window.hostLog)).find( + (e) => e.method === "ui/open-link", + ); + check( + "open-link", + openLink?.params?.url?.startsWith(`https://${ORG}.sentry.io/`), + `ui/open-link ${openLink?.params?.url}`, + ); + + await mount("dark", GROUPED_CHART, groupedResult); + const legend = await frame.locator(".legend").innerText(); + const grouped = await shot("chart-grouped-dark.png"); + check( + "grouped", + legend.split("\n").filter(Boolean).length === 3, + `top groups "${legend.replace(/\n/g, " | ")}" -> ${grouped}`, + ); + + write("host-log.json", await page.evaluate(() => window.hostLog)); + write("calls.json", calls); + write("console-errors.json", consoleErrors); + check( + "default-csp", + consoleErrors.length === 0, + `${consoleErrors.length} console errors under the default CSP`, + ); +} catch (error) { + check( + "host-run", + false, + error instanceof Error ? (error.stack ?? error.message) : String(error), + ); +} finally { + await browser?.close(); + await client.close().catch(() => {}); + cleanup(); + writeFileSync(join(out, "server-stderr.txt"), stderr); +} +process.exit(failures > 0 ? 1 : 0); diff --git a/design/mcp-tool-responses.md b/design/mcp-tool-responses.md index cd5a0e5da..1a5d17377 100644 --- a/design/mcp-tool-responses.md +++ b/design/mcp-tool-responses.md @@ -26,6 +26,8 @@ question, in Sentry's own terms, without reading upstream API payloads. - Response notes and side quests: short tips at the end of a result, such as a pagination cursor or source maps that failed to apply. - Feedback suggestions that point at `submit_feedback_to_sentry_team`. +- MCP Apps views, which render a tool's structured content inline in hosts + that support them. ## Rules @@ -42,6 +44,10 @@ question, in Sentry's own terms, without reading upstream API payloads. - A failed call is a tool error (`isError`), not a success-shaped result. An empty result is a success. A missing resource is an input error that points at the tool that can find it. +- A view renders the structured content of the call and treats it as + untrusted. The result is never shaped for the view alone, and a tool with a + view fetches its own data from its input, so values do not pass through the + model. - Optional details, such as a suspect commit, never stop the main result from loading when they fail. - Long lists and long text are capped, and the result says how much it left diff --git a/design/mcp-tools.md b/design/mcp-tools.md index 79cf5834d..e35721d34 100644 --- a/design/mcp-tools.md +++ b/design/mcp-tools.md @@ -32,6 +32,9 @@ harness the user already works in, such as Claude Code, Codex, or Cursor. that are not stable yet. - `search_sentry_tools` and `execute_sentry_tool`, only on the fallback gateway surface. +- MCP Apps views: a host that supports MCP Apps reads a tool's + `_meta.ui.resourceUri` and renders that `ui://` resource inline. + `render_sentry_chart` is the one tool with a view. ## Rules @@ -44,6 +47,11 @@ harness the user already works in, such as Claude Code, Codex, or Cursor. - Server instructions stay under 1,500 characters, and name a tool only when the session has it. - The fallback gateway surface lists about 20 tools, and never more than 25. +- A tool with a view is listed for every client and stays complete without + it: a host with no MCP Apps support gets the same result. A session lists a + view only when it lists a tool that names it. +- A view is one self-contained HTML document that loads nothing from the + network, and its `ui://` URI carries a version, because hosts cache by URI. - Tools are not a raw proxy for the Sentry API. A tool exists for a question or task a user brings, and its result follows [MCP tool responses](./mcp-tool-responses.md). diff --git a/docs/contributing/adding-tools.md b/docs/contributing/adding-tools.md index 618cf14a8..d51bc578e 100644 --- a/docs/contributing/adding-tools.md +++ b/docs/contributing/adding-tools.md @@ -264,6 +264,10 @@ particular: See [common-patterns.md](common-patterns.md#response-formatting) for shared formatting patterns and examples. +To render a result inline in MCP Apps hosts, see +[tool-responses.md](tool-responses.md#mcp-apps-views). A view is optional: +the tool still answers in full for every other client. + ## Step 3: Add Tests Follow comprehensive testing patterns from [../testing/overview.md](../testing/overview.md) for unit, integration, and evaluation tests. diff --git a/docs/contributing/tool-responses.md b/docs/contributing/tool-responses.md index 6c47e210e..21af2f7f1 100644 --- a/docs/contributing/tool-responses.md +++ b/docs/contributing/tool-responses.md @@ -232,6 +232,30 @@ experimental sessions first stays pending until it graduates. The PR that makes an entry stale also deletes it. To add a `_meta` key, add it to `ALLOWED_TOOL_META` with a comment that says which client reads it. +## MCP Apps Views + +A tool can name an inline view for hosts that support +[MCP Apps](https://github.com/modelcontextprotocol/ext-apps/blob/main/specification/2026-01-26/apps.mdx), +such as Claude and VS Code. `render_sentry_chart` is the example: + +- The view is a `UiResource` in `packages/mcp-core/src/ui-resources.ts` with a + versioned `ui://` URI. The server lists it, with mime type + `text/html;profile=mcp-app`, only when the session lists a tool that names + it. +- The tool sets `_meta: uiToolMeta(resource)`, which writes + `_meta.ui.resourceUri` for MCP Apps hosts and `openai/outputTemplate` for + ChatGPT. Add both keys to `ALLOWED_TOOL_META`. +- The view source lives outside `src/` (the chart is in + `packages/mcp-core/chart-app/`) and is bundled into a generated string + module, so stdio and the Worker serve it without a file system. Run + `pnpm --filter @sentry/mcp-core generate-chart-app` after changing it; + `ci:policy` fails when the generated file is stale. +- The view renders `structuredContent` and validates it with the tool's own + output schema. The text content stays the compact JSON payload, so hosts + without MCP Apps get the full answer. +- Prove a view with `.agents/skills/verify-toolkit/map/mcp-apps.md`, which + mounts it through the ext-apps `AppBridge` in headless Chromium. + ## Suggested Actions Use `suggestedActions` when a tool result reveals a concrete follow-up tool call diff --git a/docs/evidence/mcp-apps-chart/chart-dark.png b/docs/evidence/mcp-apps-chart/chart-dark.png new file mode 100644 index 0000000000000000000000000000000000000000..746cd8d2e694c3403bb20a37875247b9024cd739 GIT binary patch literal 69337 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