fix(copilot): ignore tag syntax quoted inside a JSON tag body

The nesting rule treated any tag marker in the body as proof the opener was
literal text. But a JSON body can legitimately quote tag syntax — a
`<question>` asking which tag to use, a `<workspace_resource>` whose title
mentions one — and that is exactly the "model explains its own tags"
situation this whole fix exists for.

Bailing there is the one expensive false positive in the design: the raw JSON
renders and STAYS for the rest of the stream, then snaps into a card when the
real close arrives. More jarring than the bug being fixed.

For JSON-bodied tags the nesting scan now runs over a copy with string
literals blanked (escape-aware, and tolerant of the unterminated trailing
string that is normal mid-stream). Markers in real body position still count.
`thinking` is unaffected — its body is prose, so there are no strings to
confuse it.

Tests cover both halves: the streaming case does not bail, and the same body
resolves to a question card once it closes.

Author: j15z

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

@@ -178,6 +178,29 @@ describe('parseSpecialTags with <question>', () => {
     expect(hasPendingTag).toBe(false)
   })
 
+  it('does not bail on tag syntax quoted inside a JSON string', () => {
+    // The false positive this guards: a question whose text legitimately quotes
+    // another tag. Bailing would show raw JSON that later snaps into a card.
+    const streaming = 'ok <question>[{"type":"single_select","prompt":"Use the </options> tag?"'
+    expect(parseSpecialTags(streaming, true).hasPendingTag).toBe(true)
+  })
+
+  it('resolves that same question correctly once it closes', () => {
+    // The other half of the guarantee: the body the streaming case refused to
+    // bail on does render as a question card, so nothing flickered for nothing.
+    const complete =
+      'ok <question>[{"type":"single_select","prompt":"Use the </options> tag?","options":[{"id":"y","label":"Yes"},{"id":"n","label":"No"}]}]</question>'
+    const { segments } = parseSpecialTags(complete, false)
+    expect(segments.some((s) => s.type === 'question')).toBe(true)
+  })
+
+  it('still bails on a marker outside the JSON strings', () => {
+    // Escapes must not end the string early, and a marker in real body position
+    // is still evidence.
+    const streaming = 'ok <question>[{"prompt":"a \\" quote"} </options>'
+    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)

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

@@ -487,6 +487,44 @@ const JSON_BODY_TAG_NAMES = new Set<(typeof SPECIAL_TAG_NAMES)[number]>([
   'question',
 ])
 
+/**
+ * Strip the contents of JSON string literals from `body`, replacing them with
+ * spaces so every other index is preserved.
+ *
+ * A JSON tag body can legitimately quote tag syntax — a `<question>` asking
+ * which tag to use, or a `<workspace_resource>` whose title mentions one. Those
+ * markers live inside a string and say nothing about whether the tag will
+ * close, so the nesting rule must not see them. Tracks escapes so a `\"` inside
+ * a string does not end it early. Handles an unterminated trailing string, which
+ * is the normal state mid-stream.
+ */
+function blankJsonStringLiterals(body: string): string {
+  let out = ''
+  let inString = false
+  let escaped = false
+
+  for (const char of body) {
+    if (escaped) {
+      escaped = false
+      out += ' '
+      continue
+    }
+    if (char === '\\' && inString) {
+      escaped = true
+      out += ' '
+      continue
+    }
+    if (char === '"') {
+      inString = !inString
+      out += '"'
+      continue
+    }
+    out += inString ? ' ' : char
+  }
+
+  return out
+}
+
 /**
  * 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
@@ -509,10 +547,15 @@ function unclosedTagCannotResolve(
   tagName: (typeof SPECIAL_TAG_NAMES)[number],
   body: string
 ): boolean {
+  // For a JSON-bodied tag, ignore markers inside string literals: quoting tag
+  // syntax is legitimate content, and treating it as evidence would bail on a
+  // tag that goes on to close correctly — showing raw JSON that then snaps into
+  // a rendered card.
+  const scannable = JSON_BODY_TAG_NAMES.has(tagName) ? blankJsonStringLiterals(body) : body
   for (const name of SPECIAL_TAG_NAMES) {
     // A close for this tag is absent by definition here, so this catches a
     // FOREIGN close; the open check catches nesting, including self-nesting.
-    if (body.includes(`</${name}>`) || body.includes(`<${name}>`)) return true
+    if (scannable.includes(`</${name}>`) || scannable.includes(`<${name}>`)) return true
   }
 
   if (JSON_BODY_TAG_NAMES.has(tagName)) {