fix(copilot): keep prose a mispaired tag would swallow, and bail on dead JSON

Two more real cases from traces, both of which the earlier heuristics missed.

1. A MATCHED pair whose body fails to parse was silently dropped, cursor and
   all. When the model explains tag syntax and ends with a backticked example
   containing a real closing tag, that example closes an EARLIER opener and
   three paragraphs become the "body" — which is not valid JSON, so the whole
   span vanished and the render resumed mid-sentence (trace b095e080).

   Now emitted verbatim, but only when the body contains a tag-shaped marker,
   which is what shows the pairing was wrong. A marker-free body that merely
   fails validation is a genuinely malformed agent payload and keeps being
   dropped — an existing test asserts that deliberately, and showing the user
   raw JSON there would be a regression.

2. The JSON heuristic only checked the FIRST character, so
   `{"type":"file"}</workspac and then prose...` looked viable forever: it
   opens with `{`, and the truncated close is not a marker any rule can see
   (trace afbeefd0). Track depth instead — once the top-level value closes,
   any non-whitespace after it is fatal, so the stray character decides it
   immediately. String contents are blanked first so braces inside strings do
   not skew the count.

Author: j15z

apps/sim/app/workspace/[workspaceId]/home/components/message-content/components/special-tags/special-tags.test.ts

@@ -149,6 +149,53 @@ describe('parseSpecialTags with <question>', () => {
     expect(segments).toEqual([{ type: 'text', content: 'Thinking about it. ' }])
   })
 
+  it('keeps the text when a matched pair fails to parse', () => {
+    // Verbatim from a real message (trace b095e080). The model explained the
+    // tag and ended with a backticked example containing a REAL closing tag,
+    // which closed the earlier opener and made everything between it the body.
+    // That body is not valid JSON, so the segment was dropped and the render
+    // resumed mid-sentence at ") is what actually produces the interactive
+    // chip." — three paragraphs silently gone.
+    const raw =
+      'Here you go — with the ending tag intentionally malformed as `</workflow_resource>`:\n\n' +
+      '<workspace_resource>{"type": "file", "path": "files/notes.md", "title": "notes.md"}</workflow_resource>\n\n' +
+      "Since the closing tag doesn't match the opening `<workspace_resource>`, the chat won't " +
+      'recognize it as a valid resource chip. A properly matched pair ' +
+      '(`<workspace_resource>...</workspace_resource>`) is what actually produces the interactive chip.'
+
+    const rendered = parseSpecialTags(raw, false)
+      .segments.map((segment) => ('content' in segment ? segment.content : ''))
+      .join('')
+
+    expect(rendered).toContain("Since the closing tag doesn't match")
+    expect(rendered).toContain('A properly matched pair')
+    expect(rendered).toContain('"path": "files/notes.md"')
+    // No segment renders as a resource chip — the body was never valid.
+    expect(parseSpecialTags(raw, false).segments.some((s) => s.type === 'workspace_resource')).toBe(
+      false
+    )
+  })
+
+  it('still drops a marker-free malformed payload rather than showing raw JSON', () => {
+    // The complement of the case above: no tag markers in the body, so this is
+    // a genuinely broken emission from the agent, not swallowed prose.
+    const { segments } = parseSpecialTags(
+      'Before. <question>{"type":"single_select"}</question> After.',
+      false
+    )
+    expect(segments).toEqual([
+      { type: 'text', content: 'Before. ' },
+      { type: 'text', content: ' After.' },
+    ])
+  })
+
+  it('still renders a matched pair whose body IS valid', () => {
+    const raw =
+      'see <workspace_resource>{"type":"file","path":"files/a.md","title":"a.md"}</workspace_resource> ok'
+    const { segments } = parseSpecialTags(raw, false)
+    expect(segments.some((s) => s.type === 'workspace_resource')).toBe(true)
+  })
+
   it('shows prose immediately mid-stream instead of blanking the rest', () => {
     // The failure this replaces: everything after the marker stayed invisible
     // for the remainder of the stream, then reappeared when it ended.
@@ -160,6 +207,24 @@ describe('parseSpecialTags with <question>', () => {
     )
   })
 
+  it('shows text once the JSON value has closed and stray content follows', () => {
+    // Verbatim shape from a real message (trace afbeefd0): the close tag was
+    // TRUNCATED to `</workspac`, so no marker rule can see it — but the JSON
+    // value completes at the `}`, which makes everything after it fatal.
+    const raw =
+      'kicks off in <workspace_resource>{"type":"file","path":"files/notes.md"}</workspac and after that I brew a cup of coffee.'
+    const { segments, hasPendingTag } = parseSpecialTags(raw, true)
+    expect(hasPendingTag).toBe(false)
+    expect(segments.map((s) => ('content' in s ? s.content : '')).join('')).toContain(
+      'I brew a cup of coffee'
+    )
+  })
+
+  it('tolerates braces inside JSON strings when tracking depth', () => {
+    const raw = 'x <workspace_resource>{"title":"a } b","path":"files/a.md"'
+    expect(parseSpecialTags(raw, true).hasPendingTag).toBe(true)
+  })
+
   it('still suppresses a JSON-bodied tag that is genuinely mid-stream', () => {
     const { segments, hasPendingTag } = parseSpecialTags(
       'Here you go <workspace_resource>{"type":"file","id":"abc"',

apps/sim/app/workspace/[workspaceId]/home/components/message-content/components/special-tags/special-tags.tsx

@@ -473,6 +473,12 @@ function parseSpecialTagData(
  * Trailing partial opening tags (e.g. `<opt`, `<usage_`) are also stripped
  * during streaming to prevent flashing raw markup.
  */
+/**
+ * Any tag-shaped marker, including names that are not special tags at all — the
+ * model inventing `</workflow_resource>` is exactly the case that matters.
+ */
+const TAG_SHAPED_MARKER = /<\/?[a-zA-Z][\w-]*>/
+
 /**
  * Tags whose body must be JSON. `thinking` is the exception — its body is prose
  * (see {@link parseTextTagBody}), so a non-JSON body there says nothing about
@@ -525,6 +531,41 @@ function blankJsonStringLiterals(body: string): string {
   return out
 }
 
+/**
+ * True while `body` could still grow into a single valid JSON value.
+ *
+ * Checking only the first character is not enough: a body like
+ * `{"type":"file"}</workspac and then prose...` opens with `{` and looks fine,
+ * but the value CLOSES at the `}` and everything after it is fatal. Tracking
+ * depth catches that the moment the stray character arrives, instead of waiting
+ * for a close tag that is never coming.
+ *
+ * String contents are blanked first, so braces and brackets inside JSON strings
+ * do not affect the depth count.
+ */
+function isViableJsonPrefix(body: string): boolean {
+  const scannable = blankJsonStringLiterals(body)
+  if (scannable.trim() === '') return true
+
+  const firstChar = scannable.trimStart().charAt(0)
+  if (firstChar !== '{' && firstChar !== '[') return false
+
+  let depth = 0
+  for (let i = 0; i < scannable.length; i++) {
+    const char = scannable[i]
+    if (char === '{' || char === '[') {
+      depth++
+    } else if (char === '}' || char === ']') {
+      depth--
+      if (depth < 0) return false
+      // The top-level value just closed: only trailing whitespace may follow.
+      if (depth === 0) return scannable.slice(i + 1).trim() === ''
+    }
+  }
+
+  return true
+}
+
 /**
  * True when an opening tag with no close yet can NEVER resolve, so the text
  * after it should be shown immediately instead of held back until the stream
@@ -558,10 +599,7 @@ function unclosedTagCannotResolve(
     if (scannable.includes(`</${name}>`) || scannable.includes(`<${name}>`)) return true
   }
 
-  if (JSON_BODY_TAG_NAMES.has(tagName)) {
-    const firstChar = body.trimStart().charAt(0)
-    if (firstChar !== '' && firstChar !== '{' && firstChar !== '[') return true
-  }
+  if (JSON_BODY_TAG_NAMES.has(tagName) && !isViableJsonPrefix(body)) return true
 
   return false
 }
@@ -647,6 +685,21 @@ export function parseSpecialTags(content: string, isStreaming: boolean): ParsedS
     const parsedTag = parseSpecialTagData(nearestTagName, body)
     if (parsedTag) {
       segments.push(parsedTag)
+    } else if (TAG_SHAPED_MARKER.test(body)) {
+      // The body failed to parse AND contains tag markers, which means the
+      // close we matched was not this opener's — the model was explaining tag
+      // syntax and a later example like `<workspace_resource>...</workspace_resource>`
+      // closed an earlier opener, making paragraphs of prose the "body".
+      // Dropping that silently loses the text and resumes mid-sentence, so emit
+      // it verbatim. Streamdown escapes the markers, so it reads as literal text.
+      //
+      // A marker-free body that merely fails validation is a genuinely
+      // malformed payload from the agent; that keeps being dropped rather than
+      // showing the user raw JSON.
+      const literal = content.slice(nearestStart, closeIdx + closeTag.length)
+      if (literal.trim()) {
+        segments.push({ type: 'text', content: literal })
+      }
     }
 
     cursor = closeIdx + closeTag.length