@sentry/junior-dashboard 0.60.1 → 0.62.0

package/dist/client/components/TranscriptText.d.ts

@@ -2,5 +2,6 @@
 export declare function TranscriptText(props: {
     firstChildIndex: number;
     lastChildIndex: number;
+    role?: string;
     text: string;
 }): import("react/jsx-runtime").JSX.Element;

package/dist/client/components/transcriptRenderModel.d.ts

@@ -26,5 +26,5 @@ export declare function groupTranscriptMessages(messages: TranscriptMessage[]):
 /** Build the plain-text clipboard/raw view for one transcript message. */
 export declare function messageRawText(message: TranscriptMessage): string;
 /** Count rendered rows so structured transcript expansion opens the newest node. */
-export declare function countRenderedTranscriptChildren(part: RenderedTranscriptPart): number;
+export declare function countRenderedTranscriptChildren(part: RenderedTranscriptPart, role?: string): number;
 export {};

package/dist/client/format.d.ts

@@ -18,6 +18,10 @@ export declare function formatMessageTimestamp(value: number | undefined): strin
 export declare function formatMessageOffset(turn: ConversationTurn, value: number | undefined): string | undefined;
 /** Format byte counts in lowercase compact units for transcript metadata. */
 export declare function formatBytes(value: number | undefined): string;
+/** Normalized role category for transcript messages. */
+export type TranscriptRoleKind = "assistant" | "other" | "system" | "tool" | "user";
+/** Normalize a raw transcript role string to a canonical kind. */
+export declare function transcriptRoleKind(role: string): TranscriptRoleKind;
 /** Count visible or redacted message records for a turn. */
 export declare function turnMessageCount(turn: ConversationTurn): number;
 /** Count tool calls from visible transcripts or safe redacted metadata. */
@@ -52,10 +56,31 @@ export declare function unavailableTranscriptLabel(turn: ConversationTurn): stri
 export declare function conversationPath(conversationId: string): string;
 /** Detect the syntax highlighter language for raw transcript blocks. */
 export declare function detectLanguage(text: string): BundledLanguage;
-/** Decide whether a fenced block can use the interactive markup renderer. */
-export declare function canRenderStructuredMarkup(language: BundledLanguage): boolean;
-/** Parse markdown into renderable code blocks while preserving plain text blocks. */
-export declare function parseMarkdownBlocks(text: string): CodeBlock[];
+/**
+ * Detect the language for LLM text output prose: json if the text is valid
+ * JSON or JSONL, markdown otherwise. Never auto-detects XML, HTML, TypeScript,
+ * or shell — those heuristics are unreliable for rendered assistant output.
+ */
+export declare function detectOutputLanguage(text: string): BundledLanguage;
+/**
+ * Decide whether a block can use the interactive markup renderer.
+ * Only xml/html language blocks qualify; fenced is tracked as metadata but
+ * does not gate eligibility — caller controls whether XML detection runs.
+ */
+export declare function canRenderStructuredMarkup(block: CodeBlock): boolean;
+/**
+ * Parse markdown into renderable code blocks while preserving plain text blocks.
+ *
+ * `outputOnly` (default `false`): when `true`, prose sections use
+ * `detectOutputLanguage` (json or markdown only — no xml/html heuristics).
+ * Use `outputOnly: true` for LLM-generated text (assistant messages) to
+ * prevent Slack autolinks and HTML snippets from triggering the XML tree
+ * renderer. Leave `false` (default) for user/system messages that may
+ * contain genuine XML runtime context.
+ */
+export declare function parseMarkdownBlocks(text: string, opts?: {
+    outputOnly?: boolean;
+}): CodeBlock[];
 /** Parse XML/HTML-ish fragments for the collapsible transcript renderer. */
 export declare function parseMarkupNodes(code: string, language: BundledLanguage): MarkupNode[];
 /** Group recent turn summaries into conversation rows. */

package/dist/client/types.d.ts

@@ -140,6 +140,7 @@ export type SessionFilter = "active" | "recent" | "hung" | "failed" | "all";
 export type VisualStatus = "active" | "failed" | "hung" | "idle";
 export type CodeBlock = {
     code: string;
+    fenced?: boolean;
     language: BundledLanguage;
 };
 export type MarkupNode = {

package/dist/client.js

@@ -30836,9 +30836,13 @@ function formatBytes(value) {
 function transcriptSource(turn) {
   return turn.transcriptAvailable ? turn.transcript : turn.transcriptMetadata ?? [];
 }
-function isConversationMessageRole(role) {
+function transcriptRoleKind(role) {
   const normalized = role.toLowerCase();
-  return normalized === "user" || normalized === "assistant";
+  if (normalized === "assistant") return "assistant";
+  if (normalized === "user") return "user";
+  if (normalized === "system") return "system";
+  if (normalized.includes("tool")) return "tool";
+  return "other";
 }
 function hasTextPart(message) {
   return message.parts.some((part) => {
@@ -30848,8 +30852,9 @@ function hasTextPart(message) {
   });
 }
 function isConversationMessage(message) {
-  if (!isConversationMessageRole(message.role)) return false;
-  if (message.role.toLowerCase() === "assistant") return hasTextPart(message);
+  const kind = transcriptRoleKind(message.role);
+  if (kind !== "user" && kind !== "assistant") return false;
+  if (kind === "assistant") return hasTextPart(message);
   return message.parts.length > 0;
 }
 function turnMessageCount(turn) {
@@ -31045,10 +31050,22 @@ function prettyJsonData(text2) {
 function formatCodeBlock(code, language) {
   return language === "json" ? prettyJsonData(code) ?? code : code;
 }
-function canRenderStructuredMarkup(language) {
-  return language === "xml" || language === "html";
+function detectOutputLanguage(text2) {
+  const trimmed = text2.trim();
+  if (!trimmed) return "markdown";
+  try {
+    JSON.parse(trimmed);
+    return "json";
+  } catch {
+  }
+  if (prettyJsonl(trimmed)) return "json";
+  return "markdown";
+}
+function canRenderStructuredMarkup(block) {
+  return block.language === "xml" || block.language === "html";
 }
-function parseMarkdownBlocks(text2) {
+function parseMarkdownBlocks(text2, opts = {}) {
+  const detectProse = opts.outputOnly ? detectOutputLanguage : detectLanguage;
   const blocks = [];
   const fence = /```([A-Za-z0-9_-]+)?\n([\s\S]*?)```/g;
   let cursor = 0;
@@ -31056,24 +31073,25 @@ function parseMarkdownBlocks(text2) {
   while (match = fence.exec(text2)) {
     const prose = text2.slice(cursor, match.index).trim();
     if (prose) {
-      const language3 = detectLanguage(prose);
-      blocks.push({ code: formatCodeBlock(prose, language3), language: language3 });
+      const language3 = detectProse(prose);
+      blocks.push({ code: formatCodeBlock(prose, language3), fenced: false, language: language3 });
     }
     const language2 = normalizeLanguage(match[1]);
     blocks.push({
       code: formatCodeBlock(match[2] ?? "", language2),
+      fenced: true,
       language: language2
     });
     cursor = match.index + match[0].length;
   }
   const rest = text2.slice(cursor).trim();
   if (rest) {
-    const language2 = detectLanguage(rest);
-    blocks.push({ code: formatCodeBlock(rest, language2), language: language2 });
+    const language2 = detectProse(rest);
+    blocks.push({ code: formatCodeBlock(rest, language2), fenced: false, language: language2 });
   }
   if (blocks.length > 0) return blocks;
-  const language = detectLanguage(text2);
-  return [{ code: formatCodeBlock(text2, language), language }];
+  const language = detectProse(text2);
+  return [{ code: formatCodeBlock(text2, language), fenced: false, language }];
 }
 function parseMarkupNodes(code, language) {
   const parser = new DOMParser();
@@ -54731,7 +54749,7 @@ var import_react51 = __toESM(require_react(), 1);
 var import_react50 = __toESM(require_react(), 1);
 var import_jsx_runtime17 = __toESM(require_jsx_runtime(), 1);
 function countStructuredBlockChildren(block) {
-  if (!canRenderStructuredMarkup(block.language)) return 1;
+  if (!canRenderStructuredMarkup(block)) return 1;
   const rootCount = parseMarkupNodes(block.code, block.language).length;
   return rootCount > 0 ? rootCount : 1;
 }
@@ -54882,13 +54900,15 @@ function toolHeaderClass(interactive) {
 // src/client/components/TranscriptText.tsx
 var import_jsx_runtime19 = __toESM(require_jsx_runtime(), 1);
 function TranscriptText(props) {
-  const blocks = parseMarkdownBlocks(props.text);
+  const blocks = parseMarkdownBlocks(props.text, {
+    outputOnly: transcriptRoleKind(props.role ?? "") === "assistant"
+  });
   let seenChildren = props.firstChildIndex;
   return /* @__PURE__ */ (0, import_jsx_runtime19.jsx)("div", { className: "grid min-w-0 gap-2", children: blocks.map((block, index) => {
     const firstChildIndex = seenChildren;
     const childCount = countStructuredBlockChildren(block);
     seenChildren += childCount;
-    if (!canRenderStructuredMarkup(block.language)) {
+    if (!canRenderStructuredMarkup(block)) {
       return /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(
         HighlightedCode,
         {
@@ -55183,15 +55203,18 @@ function messageRawText(message) {
     return stringifyPartValue(part.output ?? part.input ?? part.text ?? part);
   }).filter((part) => part.trim().length > 0).join("\n\n");
 }
-function countTextRenderedChildren(text2) {
-  return parseMarkdownBlocks(text2).reduce((count, block) => {
+function countTextRenderedChildren(text2, outputOnly) {
+  return parseMarkdownBlocks(text2, { outputOnly }).reduce((count, block) => {
     return count + countStructuredBlockChildren(block);
   }, 0);
 }
-function countRenderedTranscriptChildren(part) {
+function countRenderedTranscriptChildren(part, role) {
   if (part.kind === "tool") return 1;
   if (part.part.type === "text") {
-    return countTextRenderedChildren(part.part.text ?? "");
+    return countTextRenderedChildren(
+      part.part.text ?? "",
+      transcriptRoleKind(role ?? "") === "assistant"
+    );
   }
   return 1;
 }
@@ -55228,14 +55251,6 @@ function turnMarkerClass(status) {
     status === "idle" && "border-[#beaaff]/70 bg-[#beaaff]/50"
   );
 }
-function transcriptRoleKind(role) {
-  const normalized = role.toLowerCase();
-  if (normalized === "assistant") return "assistant";
-  if (normalized === "user") return "user";
-  if (normalized === "system") return "system";
-  if (normalized.includes("tool")) return "tool";
-  return "other";
-}
 function transcriptRoleLabel(role, turn) {
   const kind = transcriptRoleKind(role);
   if (kind === "assistant") return "Junior";
@@ -55438,8 +55453,9 @@ function TranscriptMessageView(props) {
   const offset = formatMessageOffset(props.turn, props.message.timestamp);
   const renderedParts = groupTranscriptParts(props.message.parts);
   const rawText = messageRawText(props.message);
+  const role = props.message.role;
   const totalRenderedChildren = renderedParts.reduce(
-    (count, part) => count + countRenderedTranscriptChildren(part),
+    (count, part) => count + countRenderedTranscriptChildren(part, role),
     0
   );
   let seenRenderedChildren = 0;
@@ -55466,13 +55482,14 @@ function TranscriptMessageView(props) {
           }
         ) : /* @__PURE__ */ (0, import_jsx_runtime21.jsx)("div", { className: "grid min-w-0 gap-2", children: renderedParts.map((part, index) => {
           const firstChildIndex = seenRenderedChildren;
-          seenRenderedChildren += countRenderedTranscriptChildren(part);
+          seenRenderedChildren += countRenderedTranscriptChildren(part, role);
           return /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(
             TranscriptPartView,
             {
               firstChildIndex,
               lastChildIndex: totalRenderedChildren - 1,
-              part
+              part,
+              role
             },
             index
           );
@@ -55492,6 +55509,7 @@ function TranscriptPartView(props) {
       {
         firstChildIndex: props.firstChildIndex,
         lastChildIndex: props.lastChildIndex,
+        role: props.role,
         text: part.text ?? ""
       }
     );
@@ -55531,7 +55549,7 @@ function ThinkingPartView(props) {
           HighlightedCode,
           {
             code: rendered || "{}",
-            language: detectLanguage(rendered)
+            language: detectOutputLanguage(rendered)
           }
         ) })
       ]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/junior-dashboard",
-  "version": "0.60.1",
+  "version": "0.62.0",
   "private": false,
   "publishConfig": {
     "access": "public"
@@ -39,7 +39,7 @@
     "react-router": "^7.16.0",
     "recharts": "^3.8.1",
     "shiki": "4.1.0",
-    "@sentry/junior": "0.60.1"
+    "@sentry/junior": "0.62.0"
   },
   "devDependencies": {
     "@tailwindcss/cli": "^4.3.0",

package/src/client/code.tsx

@@ -7,7 +7,7 @@ import type { CodeBlock, MarkupNode } from "./types";
 
 /** Count rendered children so transcripts can decide which markup node expands. */
 export function countStructuredBlockChildren(block: CodeBlock): number {
-  if (!canRenderStructuredMarkup(block.language)) return 1;
+  if (!canRenderStructuredMarkup(block)) return 1;
   const rootCount = parseMarkupNodes(block.code, block.language).length;
   return rootCount > 0 ? rootCount : 1;
 }

package/src/client/components/TranscriptText.tsx

@@ -3,15 +3,18 @@ import {
   HighlightedCode,
   StructuredMarkup,
 } from "../code";
-import { canRenderStructuredMarkup, parseMarkdownBlocks } from "../format";
+import { canRenderStructuredMarkup, parseMarkdownBlocks, transcriptRoleKind } from "../format";
 
 /** Render transcript markdown/code blocks with structured markup expansion. */
 export function TranscriptText(props: {
   firstChildIndex: number;
   lastChildIndex: number;
+  role?: string;
   text: string;
 }) {
-  const blocks = parseMarkdownBlocks(props.text);
+  const blocks = parseMarkdownBlocks(props.text, {
+    outputOnly: transcriptRoleKind(props.role ?? "") === "assistant",
+  });
   let seenChildren = props.firstChildIndex;
 
   return (
@@ -21,7 +24,7 @@ export function TranscriptText(props: {
         const childCount = countStructuredBlockChildren(block);
         seenChildren += childCount;
 
-        if (!canRenderStructuredMarkup(block.language)) {
+        if (!canRenderStructuredMarkup(block)) {
           return (
             <HighlightedCode
               code={block.code}

package/src/client/components/TranscriptTurn.tsx

@@ -3,6 +3,9 @@ import { useState, type ClipboardEventHandler, type ReactNode } from "react";
 import { HighlightedCode } from "../code";
 import {
   detectLanguage,
+  detectOutputLanguage,
+  transcriptRoleKind,
+  type TranscriptRoleKind,
   formatBytes,
   formatMessageOffset,
   formatMessageTimestamp,
@@ -71,17 +74,6 @@ function turnMarkerClass(
   );
 }
 
-type TranscriptRoleKind = "assistant" | "other" | "system" | "tool" | "user";
-
-function transcriptRoleKind(role: string): TranscriptRoleKind {
-  const normalized = role.toLowerCase();
-  if (normalized === "assistant") return "assistant";
-  if (normalized === "user") return "user";
-  if (normalized === "system") return "system";
-  if (normalized.includes("tool")) return "tool";
-  return "other";
-}
-
 function transcriptRoleLabel(role: string, turn: ConversationTurn): string {
   const kind = transcriptRoleKind(role);
   if (kind === "assistant") return "Junior";
@@ -375,8 +367,9 @@ function TranscriptMessageView(props: {
   const offset = formatMessageOffset(props.turn, props.message.timestamp);
   const renderedParts = groupTranscriptParts(props.message.parts);
   const rawText = messageRawText(props.message);
+  const role = props.message.role;
   const totalRenderedChildren = renderedParts.reduce(
-    (count, part) => count + countRenderedTranscriptChildren(part),
+    (count, part) => count + countRenderedTranscriptChildren(part, role),
     0,
   );
   let seenRenderedChildren = 0;
@@ -410,13 +403,14 @@ function TranscriptMessageView(props: {
         <div className="grid min-w-0 gap-2">
           {renderedParts.map((part, index) => {
             const firstChildIndex = seenRenderedChildren;
-            seenRenderedChildren += countRenderedTranscriptChildren(part);
+            seenRenderedChildren += countRenderedTranscriptChildren(part, role);
             return (
               <TranscriptPartView
                 firstChildIndex={firstChildIndex}
                 key={index}
                 lastChildIndex={totalRenderedChildren - 1}
                 part={part}
+                role={role}
               />
             );
           })}
@@ -430,6 +424,7 @@ function TranscriptPartView(props: {
   firstChildIndex: number;
   lastChildIndex: number;
   part: RenderedTranscriptPart;
+  role?: string;
 }) {
   if (props.part.kind === "tool") {
     return (
@@ -443,6 +438,7 @@ function TranscriptPartView(props: {
       <TranscriptText
         firstChildIndex={props.firstChildIndex}
         lastChildIndex={props.lastChildIndex}
+        role={props.role}
         text={part.text ?? ""}
       />
     );
@@ -494,7 +490,7 @@ function ThinkingPartView(props: { value: unknown }) {
       <div className="border-t border-[#beaaff]/15 px-3 py-3">
         <HighlightedCode
           code={rendered || "{}"}
-          language={detectLanguage(rendered)}
+          language={detectOutputLanguage(rendered)}
         />
       </div>
     </details>

package/src/client/components/transcriptRenderModel.ts

@@ -1,5 +1,5 @@
 import { countStructuredBlockChildren } from "../code";
-import { parseMarkdownBlocks, stringifyPartValue } from "../format";
+import { parseMarkdownBlocks, stringifyPartValue, transcriptRoleKind } from "../format";
 import type { TranscriptMessage, TranscriptPart } from "../types";
 
 export type RenderedTranscriptPart =
@@ -175,8 +175,8 @@ export function messageRawText(message: TranscriptMessage): string {
     .join("\n\n");
 }
 
-function countTextRenderedChildren(text: string): number {
-  return parseMarkdownBlocks(text).reduce((count, block) => {
+function countTextRenderedChildren(text: string, outputOnly: boolean): number {
+  return parseMarkdownBlocks(text, { outputOnly }).reduce((count, block) => {
     return count + countStructuredBlockChildren(block);
   }, 0);
 }
@@ -184,10 +184,14 @@ function countTextRenderedChildren(text: string): number {
 /** Count rendered rows so structured transcript expansion opens the newest node. */
 export function countRenderedTranscriptChildren(
   part: RenderedTranscriptPart,
+  role?: string,
 ): number {
   if (part.kind === "tool") return 1;
   if (part.part.type === "text") {
-    return countTextRenderedChildren(part.part.text ?? "");
+    return countTextRenderedChildren(
+      part.part.text ?? "",
+      transcriptRoleKind(role ?? "") === "assistant",
+    );
   }
   return 1;
 }

package/src/client/format.ts

@@ -204,9 +204,22 @@ function transcriptSource(turn: ConversationTurn) {
     : (turn.transcriptMetadata ?? []);
 }
 
-function isConversationMessageRole(role: string): boolean {
+/** Normalized role category for transcript messages. */
+export type TranscriptRoleKind =
+  | "assistant"
+  | "other"
+  | "system"
+  | "tool"
+  | "user";
+
+/** Normalize a raw transcript role string to a canonical kind. */
+export function transcriptRoleKind(role: string): TranscriptRoleKind {
   const normalized = role.toLowerCase();
-  return normalized === "user" || normalized === "assistant";
+  if (normalized === "assistant") return "assistant";
+  if (normalized === "user") return "user";
+  if (normalized === "system") return "system";
+  if (normalized.includes("tool")) return "tool";
+  return "other";
 }
 
 function hasTextPart(
@@ -222,8 +235,9 @@ function hasTextPart(
 function isConversationMessage(
   message: Pick<ConversationTurn["transcript"][number], "parts" | "role">,
 ): boolean {
-  if (!isConversationMessageRole(message.role)) return false;
-  if (message.role.toLowerCase() === "assistant") return hasTextPart(message);
+  const kind = transcriptRoleKind(message.role);
+  if (kind !== "user" && kind !== "assistant") return false;
+  if (kind === "assistant") return hasTextPart(message);
   return message.parts.length > 0;
 }
 
@@ -511,13 +525,48 @@ function formatCodeBlock(code: string, language: BundledLanguage): string {
   return language === "json" ? (prettyJsonData(code) ?? code) : code;
 }
 
-/** Decide whether a fenced block can use the interactive markup renderer. */
-export function canRenderStructuredMarkup(language: BundledLanguage): boolean {
-  return language === "xml" || language === "html";
+/**
+ * Detect the language for LLM text output prose: json if the text is valid
+ * JSON or JSONL, markdown otherwise. Never auto-detects XML, HTML, TypeScript,
+ * or shell — those heuristics are unreliable for rendered assistant output.
+ */
+export function detectOutputLanguage(text: string): BundledLanguage {
+  const trimmed = text.trim();
+  if (!trimmed) return "markdown";
+  try {
+    JSON.parse(trimmed);
+    return "json";
+  } catch {
+    // continue
+  }
+  if (prettyJsonl(trimmed)) return "json";
+  return "markdown";
 }
 
-/** Parse markdown into renderable code blocks while preserving plain text blocks. */
-export function parseMarkdownBlocks(text: string): CodeBlock[] {
+/**
+ * Decide whether a block can use the interactive markup renderer.
+ * Only xml/html language blocks qualify; fenced is tracked as metadata but
+ * does not gate eligibility — caller controls whether XML detection runs.
+ */
+export function canRenderStructuredMarkup(block: CodeBlock): boolean {
+  return block.language === "xml" || block.language === "html";
+}
+
+/**
+ * Parse markdown into renderable code blocks while preserving plain text blocks.
+ *
+ * `outputOnly` (default `false`): when `true`, prose sections use
+ * `detectOutputLanguage` (json or markdown only — no xml/html heuristics).
+ * Use `outputOnly: true` for LLM-generated text (assistant messages) to
+ * prevent Slack autolinks and HTML snippets from triggering the XML tree
+ * renderer. Leave `false` (default) for user/system messages that may
+ * contain genuine XML runtime context.
+ */
+export function parseMarkdownBlocks(
+  text: string,
+  opts: { outputOnly?: boolean } = {},
+): CodeBlock[] {
+  const detectProse = opts.outputOnly ? detectOutputLanguage : detectLanguage;
   const blocks: CodeBlock[] = [];
   const fence = /```([A-Za-z0-9_-]+)?\n([\s\S]*?)```/g;
   let cursor = 0;
@@ -525,24 +574,25 @@ export function parseMarkdownBlocks(text: string): CodeBlock[] {
   while ((match = fence.exec(text))) {
     const prose = text.slice(cursor, match.index).trim();
     if (prose) {
-      const language = detectLanguage(prose);
-      blocks.push({ code: formatCodeBlock(prose, language), language });
+      const language = detectProse(prose);
+      blocks.push({ code: formatCodeBlock(prose, language), fenced: false, language });
     }
     const language = normalizeLanguage(match[1]);
     blocks.push({
       code: formatCodeBlock(match[2] ?? "", language),
+      fenced: true,
       language,
     });
     cursor = match.index + match[0].length;
   }
   const rest = text.slice(cursor).trim();
   if (rest) {
-    const language = detectLanguage(rest);
-    blocks.push({ code: formatCodeBlock(rest, language), language });
+    const language = detectProse(rest);
+    blocks.push({ code: formatCodeBlock(rest, language), fenced: false, language });
   }
   if (blocks.length > 0) return blocks;
-  const language = detectLanguage(text);
-  return [{ code: formatCodeBlock(text, language), language }];
+  const language = detectProse(text);
+  return [{ code: formatCodeBlock(text, language), fenced: false, language }];
 }
 
 /** Parse XML/HTML-ish fragments for the collapsible transcript renderer. */

package/src/client/types.ts

@@ -141,7 +141,7 @@ export type SessionFilter = "active" | "recent" | "hung" | "failed" | "all";
 
 export type VisualStatus = "active" | "failed" | "hung" | "idle";
 
-export type CodeBlock = { code: string; language: BundledLanguage };
+export type CodeBlock = { code: string; fenced?: boolean; language: BundledLanguage };
 
 export type MarkupNode =
   | {