@sentry/junior-dashboard 0.60.1 → 0.61.0

package/dist/client/format.d.ts

@@ -52,8 +52,18 @@ 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;
+/**
+ * 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 fenced block can use the interactive markup renderer.
+ * Structured XML/HTML rendering is only enabled for explicitly-fenced blocks;
+ * auto-detected prose is never eligible regardless of inferred language.
+ */
+export declare function canRenderStructuredMarkup(block: CodeBlock): boolean;
 /** Parse markdown into renderable code blocks while preserving plain text blocks. */
 export declare function parseMarkdownBlocks(text: string): CodeBlock[];
 /** Parse XML/HTML-ish fragments for the collapsible transcript renderer. */

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

@@ -31045,8 +31045,19 @@ 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.fenced === true && (block.language === "xml" || block.language === "html");
 }
 function parseMarkdownBlocks(text2) {
   const blocks = [];
@@ -31056,24 +31067,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 = detectOutputLanguage(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 = detectOutputLanguage(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 = detectOutputLanguage(text2);
+  return [{ code: formatCodeBlock(text2, language), fenced: false, language }];
 }
 function parseMarkupNodes(code, language) {
   const parser = new DOMParser();
@@ -54731,7 +54743,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;
 }
@@ -54888,7 +54900,7 @@ function TranscriptText(props) {
     const firstChildIndex = seenChildren;
     const childCount = countStructuredBlockChildren(block);
     seenChildren += childCount;
-    if (!canRenderStructuredMarkup(block.language)) {
+    if (!canRenderStructuredMarkup(block)) {
       return /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(
         HighlightedCode,
         {
@@ -55531,7 +55543,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.61.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.61.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

@@ -21,7 +21,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,7 @@ import { useState, type ClipboardEventHandler, type ReactNode } from "react";
 import { HighlightedCode } from "../code";
 import {
   detectLanguage,
+  detectOutputLanguage,
   formatBytes,
   formatMessageOffset,
   formatMessageTimestamp,
@@ -494,7 +495,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/format.ts

@@ -511,9 +511,34 @@ 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";
+}
+
+/**
+ * Decide whether a fenced block can use the interactive markup renderer.
+ * Structured XML/HTML rendering is only enabled for explicitly-fenced blocks;
+ * auto-detected prose is never eligible regardless of inferred language.
+ */
+export function canRenderStructuredMarkup(block: CodeBlock): boolean {
+  return (
+    block.fenced === true &&
+    (block.language === "xml" || block.language === "html")
+  );
 }
 
 /** Parse markdown into renderable code blocks while preserving plain text blocks. */
@@ -525,24 +550,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 = detectOutputLanguage(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 = detectOutputLanguage(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 = detectOutputLanguage(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 =
   | {