fix: support 'default' event type in get_issue_details tool (#571)

The 'default' event type represents error events without exception data.
Previously, these events were rejected with "Unknown event type:
default" error, causing the tool to fail.

Changes:
- Added DefaultEventSchema to handle events with type: "default"
- Updated EventSchema union to include DefaultEventSchema
- Updated API client validation to accept "default" events
- Updated isErrorEvent() type guard to include default events
- Updated formatting to show dateCreated for default events
- Added comprehensive test coverage to prevent regressions

Fixes #570

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-authored-by: Claude Code <noreply@anthropic.com>

Author: dcramer

packages/mcp-server/src/api-client/client.ts

@@ -1529,8 +1529,9 @@ export class SentryApiService {
     );
     const rawEvent = EventSchema.parse(body);
 
-    // Filter out unknown events - only return known error/transaction types
-    if (rawEvent.type === "error") {
+    // Filter out unknown events - only return known error/default/transaction types
+    // "default" type represents error events without exception data
+    if (rawEvent.type === "error" || rawEvent.type === "default") {
       return rawEvent as Event;
     }
     if (rawEvent.type === "transaction") {
@@ -1542,7 +1543,7 @@ export class SentryApiService {
     throw new ApiValidationError(
       `Unknown event type: ${eventType}`,
       400,
-      `Only error and transaction events are supported, got: ${eventType}`,
+      `Only error, default, and transaction events are supported, got: ${eventType}`,
       body,
     );
   }

packages/mcp-server/src/api-client/schema.ts

@@ -381,6 +381,14 @@ export const ErrorEventSchema = BaseEventSchema.omit({
   dateCreated: z.string().datetime(),
 });
 
+export const DefaultEventSchema = BaseEventSchema.omit({
+  type: true,
+}).extend({
+  type: z.literal("default"),
+  culprit: z.string().nullable().optional(),
+  dateCreated: z.string().datetime(),
+});
+
 export const TransactionEventSchema = BaseEventSchema.omit({
   type: true,
 }).extend({
@@ -425,6 +433,7 @@ export const UnknownEventSchema = BaseEventSchema.omit({
 // are completely different, for example.
 export const EventSchema = z.union([
   ErrorEventSchema,
+  DefaultEventSchema,
   TransactionEventSchema,
   UnknownEventSchema,
 ]);

packages/mcp-server/src/api-client/types.ts

@@ -46,6 +46,7 @@ import type {
   ClientKeyListSchema,
   ClientKeySchema,
   ErrorEventSchema,
+  DefaultEventSchema,
   TransactionEventSchema,
   UnknownEventSchema,
   EventSchema,
@@ -80,12 +81,13 @@ export type Issue = z.infer<typeof IssueSchema>;
 
 // Individual event types
 export type ErrorEvent = z.infer<typeof ErrorEventSchema>;
+export type DefaultEvent = z.infer<typeof DefaultEventSchema>;
 export type TransactionEvent = z.infer<typeof TransactionEventSchema>;
 export type UnknownEvent = z.infer<typeof UnknownEventSchema>;
 
 // Event union - use RawEvent for parsing, Event for known types only
 export type RawEvent = z.infer<typeof EventSchema>;
-export type Event = ErrorEvent | TransactionEvent;
+export type Event = ErrorEvent | DefaultEvent | TransactionEvent;
 
 export type EventAttachment = z.infer<typeof EventAttachmentSchema>;
 export type Tag = z.infer<typeof TagSchema>;

packages/mcp-server/src/internal/formatting.ts

@@ -1596,7 +1596,8 @@ export function formatIssueOutput({
   output += "\n";
   output += "## Event Details\n\n";
   output += `**Event ID**: ${event.id}\n`;
-  if (event.type === "error") {
+  // "default" type represents error events without exception data
+  if (event.type === "error" || event.type === "default") {
     output += `**Occurred At**: ${new Date((event as z.infer<typeof ErrorEventSchema>).dateCreated).toISOString()}\n`;
   }
   if (event.message) {

packages/mcp-server/src/tools/get-issue-details.test.ts

@@ -927,4 +927,89 @@ describe("get_issue_details", () => {
       "For detailed root cause analysis and solutions, call `analyze_issue_with_seer(organizationSlug='sentry-mcp-evals', issueId='CLOUDFLARE-MCP-41')`",
     );
   });
+
+  it("handles default event type (error without exception data)", async () => {
+    // Mock a "default" event type - represents errors without exception data
+    mswServer.use(
+      http.get(
+        "https://sentry.io/api/0/organizations/sentry-mcp-evals/issues/DEFAULT-001/events/latest/",
+        () => {
+          return HttpResponse.json({
+            id: "abc123def456",
+            title: "Error without exception data",
+            message: "Something went wrong",
+            platform: "python",
+            type: "default", // This is the key part - default event type
+            dateCreated: "2025-10-02T12:00:00.000Z",
+            culprit: "unknown",
+            entries: [
+              {
+                type: "message",
+                data: {
+                  formatted: "Something went wrong",
+                  message: "Something went wrong",
+                },
+              },
+            ],
+            tags: [
+              { key: "level", value: "error" },
+              { key: "environment", value: "production" },
+            ],
+            contexts: {},
+          });
+        },
+      ),
+      http.get(
+        "https://sentry.io/api/0/organizations/sentry-mcp-evals/issues/DEFAULT-001/",
+        () => {
+          return HttpResponse.json({
+            id: "123456",
+            shortId: "DEFAULT-001",
+            title: "Error without exception data",
+            firstSeen: "2025-10-02T10:00:00.000Z",
+            lastSeen: "2025-10-02T12:00:00.000Z",
+            count: "5",
+            userCount: 2,
+            permalink: "https://sentry-mcp-evals.sentry.io/issues/123456/",
+            project: {
+              id: "4509062593708032",
+              name: "TEST-PROJECT",
+              slug: "test-project",
+              platform: "python",
+            },
+            status: "unresolved",
+            culprit: "unknown",
+            type: "default",
+            platform: "python",
+          });
+        },
+      ),
+    );
+
+    const result = await getIssueDetails.handler(
+      {
+        organizationSlug: "sentry-mcp-evals",
+        issueId: "DEFAULT-001",
+        eventId: undefined,
+        issueUrl: undefined,
+        regionUrl: undefined,
+      },
+      {
+        constraints: {
+          organizationSlug: null,
+        },
+        accessToken: "access-token",
+        userId: "1",
+      },
+    );
+
+    // Verify the event was processed successfully
+    expect(result).toContain("# Issue DEFAULT-001 in **sentry-mcp-evals**");
+    expect(result).toContain("Error without exception data");
+    expect(result).toContain("**Event ID**: abc123def456");
+    // Default events should show dateCreated just like error events
+    expect(result).toContain("**Occurred At**: 2025-10-02T12:00:00.000Z");
+    expect(result).toContain("### Error");
+    expect(result).toContain("Something went wrong");
+  });
 });

packages/mcp-server/src/tools/get-issue-details.ts

@@ -12,6 +12,7 @@ import type { SentryApiService } from "../api-client";
 import type {
   Event,
   ErrorEvent,
+  DefaultEvent,
   TransactionEvent,
   Trace,
 } from "../api-client/types";
@@ -244,8 +245,9 @@ async function maybeFetchPerformanceTrace({
   }
 }
 
-function isErrorEvent(event: Event): event is ErrorEvent {
-  return event.type === "error";
+function isErrorEvent(event: Event): event is ErrorEvent | DefaultEvent {
+  // "default" type represents error events without exception data
+  return event.type === "error" || event.type === "default";
 }
 
 function isTransactionEvent(event: Event): event is TransactionEvent {