refactor(copilot): resolve each special tag through four named outcomes

parseSpecialTags had grown five inline branches, each added for a specific
malformation found in a trace. The shape made "drop it" the implicit
fallback, which is how spans that were never malformed payloads ended up
silently swallowed.

Extracts resolveTagAt, returning one of four named outcomes — segment,
literal, discard, pending — so each decision is explicit and the main loop
just dispatches on it.

Fixes a latent bug the old shape hid: rejecting an unclosed tag ran `break`,
abandoning the rest of the message, so a genuinely valid tag after a literal
mention was never parsed. Resolution now resumes just past the rejected
opener and scanning continues. Test added.

Two behavior notes:
- Rejected spans are emitted in smaller pieces. The renderer concatenates
  adjacent text segments into one markdown string, so this is display-neutral;
  the two tests that asserted exact segment arrays now assert joined text.
- Each opener is judged on its own evidence. Previously one verdict ended the
  whole parse, so a nested opener released everything; now the outer is
  released immediately and the inner is a fresh candidate that can still hold
  mid-stream. It resolves at end of stream either way.

Author: j15z

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

@@ -176,6 +176,16 @@ describe('parseSpecialTags with <question>', () => {
     )
   })
 
+  it('still parses a valid tag that follows a rejected one', () => {
+    // Before the rewrite, rejecting an unclosed tag abandoned the rest of the
+    // message, so this <options> tag was never parsed at all.
+    const { segments } = parseSpecialTags(
+      'I use <thinking> loosely here. Anyway: <options>[{"title":"A","description":"d"}]</options> done.',
+      false
+    )
+    expect(segments.map((segment) => segment.type)).toContain('options')
+  })
+
   it('keeps prose a tag wrapped instead of a payload', () => {
     // Verbatim from a real message (trace 1206fd8a): a matched pair whose body
     // is plain prose, never an attempted JSON payload. The sentence read
@@ -279,9 +289,22 @@ describe('parseSpecialTags with <question>', () => {
     expect(parseSpecialTags(streaming, true).hasPendingTag).toBe(false)
   })
 
-  it('bails on a nested opening tag', () => {
-    const { hasPendingTag } = parseSpecialTags('a <thinking>b <thinking> c', true)
-    expect(hasPendingTag).toBe(false)
+  it('rejects an opener a nested one disproves, then judges the inner on its own', () => {
+    // Each opener is evaluated independently. The first is disproved by the
+    // nested opener and its text is released immediately; the second is a fresh
+    // candidate that nothing has ruled out yet, so it holds mid-stream.
+    const streaming = parseSpecialTags('a <thinking>b <thinking> c', true)
+    expect(streaming.hasPendingTag).toBe(true)
+    expect(
+      streaming.segments.map((segment) => ('content' in segment ? segment.content : '')).join('')
+    ).toBe('a <thinking>b ')
+
+    // Once the stream ends nothing can close it, so the whole line is shown.
+    const done = parseSpecialTags('a <thinking>b <thinking> c', false)
+    expect(done.hasPendingTag).toBe(false)
+    expect(
+      done.segments.map((segment) => ('content' in segment ? segment.content : '')).join('')
+    ).toBe('a <thinking>b <thinking> c')
   })
 
   it('keeps suppressing an unclosed thinking tag with prose — its body is not JSON', () => {
@@ -296,14 +319,13 @@ describe('parseSpecialTags with <question>', () => {
       'The `<workspace_resource>` file chip only renders when its path points to a real file.'
     const { segments, hasPendingTag } = parseSpecialTags(content, false)
     expect(hasPendingTag).toBe(false)
-    expect(segments).toEqual([
-      { type: 'text', content: 'The `' },
-      {
-        type: 'text',
-        content:
-          '<workspace_resource>` file chip only renders when its path points to a real file.',
-      },
-    ])
+    // Asserted on the joined text, not segment boundaries: the renderer
+    // concatenates adjacent text segments, so how the span is split is not
+    // observable to a reader.
+    expect(segments.every((segment) => segment.type === 'text')).toBe(true)
+    expect(segments.map((segment) => ('content' in segment ? segment.content : '')).join('')).toBe(
+      content
+    )
   })
 
   it('strips a trailing partial opening tag while streaming', () => {

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

@@ -604,11 +604,83 @@ function unclosedTagCannotResolve(
   return false
 }
 
+/**
+ * How one opening tag resolved. Naming the four outcomes is the point: the
+ * parser previously decided each case inline, which is how "drop it" quietly
+ * became the fallback for situations that were never malformed payloads.
+ */
+type TagResolution =
+  /** Body parsed; emit the typed segment and resume after the closing tag. */
+  | { outcome: 'segment'; segment: ContentSegment; resumeAt: number }
+  /** Provably not a tag; render the span verbatim and resume after it. */
+  | { outcome: 'literal'; resumeAt: number }
+  /** A well-formed payload that failed its shape guard — dropped deliberately. */
+  | { outcome: 'discard'; resumeAt: number }
+  /** Still streaming and a close remains plausible; suppress the remainder. */
+  | { outcome: 'pending' }
+
+/**
+ * True when a failed body was never an attempted payload — so the markers were
+ * literal text and the span must be shown rather than swallowed.
+ *
+ * Either the close we matched belongs to a different opener (the body carries
+ * tag markers), or the tag wrapped prose that was never JSON to begin with.
+ */
+function bodyIsLiteralText(tagName: (typeof SPECIAL_TAG_NAMES)[number], body: string): boolean {
+  if (TAG_SHAPED_MARKER.test(body)) return true
+  return JSON_BODY_TAG_NAMES.has(tagName) && !isViableJsonPrefix(body)
+}
+
+function resolveTagAt(
+  content: string,
+  openIndex: number,
+  tagName: (typeof SPECIAL_TAG_NAMES)[number],
+  isStreaming: boolean
+): TagResolution {
+  const openTag = `<${tagName}>`
+  const closeTag = `</${tagName}>`
+  const bodyStart = openIndex + openTag.length
+  const closeIdx = content.indexOf(closeTag, bodyStart)
+
+  if (closeIdx === -1) {
+    if (isStreaming && !unclosedTagCannotResolve(tagName, content.slice(bodyStart))) {
+      return { outcome: 'pending' }
+    }
+    // Nothing can close it, so only the opener itself is literal. Resuming just
+    // past it (rather than abandoning the message) keeps a genuinely valid tag
+    // later in the same reply parseable.
+    return { outcome: 'literal', resumeAt: bodyStart }
+  }
+
+  const resumeAt = closeIdx + closeTag.length
+  const body = content.slice(bodyStart, closeIdx)
+
+  const parsed = parseSpecialTagData(tagName, body)
+  if (parsed) return { outcome: 'segment', segment: parsed, resumeAt }
+
+  if (bodyIsLiteralText(tagName, body)) return { outcome: 'literal', resumeAt }
+
+  // A well-formed value that failed its shape guard is a broken emission from
+  // the agent; showing the user raw JSON there would be worse than nothing.
+  return { outcome: 'discard', resumeAt }
+}
+
+/**
+ * Splits streamed text into renderable segments, extracting complete special
+ * tags and deciding what to do with the ones that never resolve.
+ *
+ * Adjacent text segments are concatenated by the renderer, so emitting a span
+ * as several pieces is display-neutral.
+ */
 export function parseSpecialTags(content: string, isStreaming: boolean): ParsedSpecialContent {
   const segments: ContentSegment[] = []
   let hasPendingTag = false
   let cursor = 0
 
+  const pushText = (text: string) => {
+    if (text.trim()) segments.push({ type: 'text', content: text })
+  }
+
   while (cursor < content.length) {
     let nearestStart = -1
     let nearestTagName: (typeof SPECIAL_TAG_NAMES)[number] | '' = ''
@@ -621,10 +693,11 @@ export function parseSpecialTags(content: string, isStreaming: boolean): ParsedS
       }
     }
 
-    if (nearestStart === -1) {
+    if (nearestStart === -1 || nearestTagName === '') {
       let remaining = content.slice(cursor)
 
       if (isStreaming) {
+        // Hide a half-arrived opening marker so it does not flash as text.
         const partial = remaining.match(/<[a-z_-]*$/i)
         if (partial) {
           const fragment = partial[0].slice(1)
@@ -638,75 +711,26 @@ export function parseSpecialTags(content: string, isStreaming: boolean): ParsedS
         }
       }
 
-      if (remaining.trim()) {
-        segments.push({ type: 'text', content: remaining })
-      }
+      pushText(remaining)
       break
     }
 
-    if (nearestStart > cursor) {
-      const text = content.slice(cursor, nearestStart)
-      if (text.trim()) {
-        segments.push({ type: 'text', content: text })
-      }
-    }
+    pushText(content.slice(cursor, nearestStart))
 
-    const openTag = `<${nearestTagName}>`
-    const closeTag = `</${nearestTagName}>`
-    const bodyStart = nearestStart + openTag.length
-    const closeIdx = content.indexOf(closeTag, bodyStart)
-
-    if (closeIdx === -1) {
-      // Hold the text back only while a close is still plausible. A completed
-      // message can never finish an unclosed tag, and mid-stream the heuristics
-      // in unclosedTagCannotResolve rule it out early — otherwise a tag merely
-      // mentioned in prose blanks the rest of the message until the stream ends.
-      const stillResolvable =
-        isStreaming &&
-        nearestTagName !== '' &&
-        !unclosedTagCannotResolve(nearestTagName, content.slice(bodyStart))
-      if (stillResolvable) {
-        hasPendingTag = true
-        cursor = content.length
-        break
-      }
-      const remaining = content.slice(nearestStart)
-      if (remaining.trim()) {
-        segments.push({ type: 'text', content: remaining })
-      }
+    const resolution = resolveTagAt(content, nearestStart, nearestTagName, isStreaming)
+
+    if (resolution.outcome === 'pending') {
+      hasPendingTag = true
       break
     }
 
-    const body = content.slice(bodyStart, closeIdx)
-    if (!nearestTagName) {
-      cursor = closeIdx + closeTag.length
-      continue
-    }
-    const parsedTag = parseSpecialTagData(nearestTagName, body)
-    if (parsedTag) {
-      segments.push(parsedTag)
-    } else if (
-      // The close we matched was not this opener's: the model was explaining tag
-      // syntax and a later example closed an earlier opener, making paragraphs
-      // of prose the "body".
-      TAG_SHAPED_MARKER.test(body) ||
-      // Or the tag wrapped prose that was never an attempted payload at all.
-      (JSON_BODY_TAG_NAMES.has(nearestTagName) && !isViableJsonPrefix(body))
-    ) {
-      // Either way the markers were literal text, so dropping the span loses
-      // real content and resumes mid-sentence. Emit it verbatim — Streamdown
-      // escapes the markers, so it reads as literal text.
-      //
-      // A body that IS a well-formed JSON value and merely fails its shape
-      // guard keeps being dropped: that is a genuinely malformed payload from
-      // the agent, and showing the user raw JSON there would be a regression.
-      const literal = content.slice(nearestStart, closeIdx + closeTag.length)
-      if (literal.trim()) {
-        segments.push({ type: 'text', content: literal })
-      }
+    if (resolution.outcome === 'segment') {
+      segments.push(resolution.segment)
+    } else if (resolution.outcome === 'literal') {
+      pushText(content.slice(nearestStart, resolution.resumeAt))
     }
 
-    cursor = closeIdx + closeTag.length
+    cursor = resolution.resumeAt
   }
 
   if (segments.length === 0 && !hasPendingTag) {