fix(chat): suppress broken payloads mid-stream; reserve marker rescan for mispaired quotes

Author: j15z

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

@@ -246,17 +246,20 @@ describe('parseSpecialTags with <question>', () => {
   })
 
   it('does not rescan the interior of a body that carried no markers', () => {
-    // Pins WHY the two literal reasons resume at different offsets. A
-    // not-viable-json body resumes past the CLOSE; resuming past the opener
-    // instead would rescan the interior, and since the marker scan runs on the
-    // blanked body, a tag quoted inside a JSON string is invisible to it and
-    // would be re-parsed as a real tag on the second pass — then dropped,
-    // deleting the very text this parser exists to preserve.
+    // Pins WHY a settled span resumes past the CLOSE, never past the opener.
+    // Resuming past the opener would rescan the interior, and since the marker
+    // scan runs on the blanked body, a tag quoted inside a JSON string is
+    // invisible to it and would be re-parsed as a REAL tag on the second pass —
+    // painting the quoted JSON verbatim as raw text (its escaped quotes cannot
+    // re-parse as a card), the exact failure `discard` exists to prevent. The
+    // span itself opens `{"` and will not parse (trailing junk), so it is an
+    // attempted payload and is discarded whole; what must never happen is a
+    // partial re-parse of its quoted interior.
     const raw =
       'A <question>{"a":"<options>{\\"k\\":{\\"title\\":\\"x\\",\\"description\\":\\"y\\"}}</options>"} junk</question> B'
     const { segments } = parseSpecialTags(raw, false)
     expect(segments.every((segment) => segment.type === 'text')).toBe(true)
-    expect(renderedText(segments)).toBe(raw)
+    expect(renderedText(segments)).toBe('A  B')
   })
 
   it('keeps prose a tag wrapped instead of a payload', () => {
@@ -374,6 +377,32 @@ describe('parseSpecialTags with <question>', () => {
     expect(renderedText(parseSpecialTags(raw, false).segments)).toBe(raw)
   })
 
+  it('treats brace-wrapped quoted prose as an attempted payload, by design', () => {
+    // The deliberate edge of the opener heuristic, pinned so it stays a
+    // decision: `{"..."}` reads as a payload the model started and botched (a
+    // key with no value), not prose — prose the reader was meant to see arrives
+    // unwrapped or in bare quotes, and both of those stay rendered (see the
+    // cases above). The array twin parses as JSON, so it was already dropped as
+    // `wrong-shape` before the opener heuristic existed.
+    const braceWrapped = 'see <options>{"the Q4 report"}</options> end'
+    expect(renderedText(parseSpecialTags(braceWrapped, false).segments)).toBe('see  end')
+    const arrayWrapped = 'see <options>["some list item"]</options> end'
+    expect(renderedText(parseSpecialTags(arrayWrapped, false).segments)).toBe('see  end')
+  })
+
+  it('discards a broken payload whose strings legitimately mention tag syntax', () => {
+    // The prompt quotes a tag name, so a raw scan sees a marker — but the
+    // body's quotes are balanced, so the blanked scan already proved the marker
+    // sits inside a string. Treating it as a nested tag would render the broken
+    // payload as raw JSON, the exact failure `discard` exists to prevent. The
+    // raw rescan is reserved for mispaired quotes, where blanked offsets lie.
+    const raw =
+      'Prose before. <question>{"type": "single_select", "prompt": "Use the <options> tag", "options": [{"id": "a", "label": "x"}}]}</question>'
+    const { segments } = parseSpecialTags(raw, false)
+    expect(renderedText(segments)).toBe('Prose before. ')
+    expect(segments.every((segment) => segment.type === 'text')).toBe(true)
+  })
+
   it('does not flash the payload while the closing tag is still arriving', () => {
     // Each frame below is a real mid-stream state: the JSON value has closed, so
     // without tolerating an arriving close the trailing `</opt` reads as stray
@@ -388,6 +417,23 @@ describe('parseSpecialTags with <question>', () => {
     }
   })
 
+  it('never flashes a broken payload at any streamed frame', () => {
+    // A body that goes non-viable mid-stream (the stray `]}` lands before the
+    // close does) used to release as literal text at that frame, then vanish
+    // when the close arrived and classified it not-parsable — raw JSON painted
+    // on screen only for the close to retract it. Suppression must hold at
+    // EVERY frame from the completed opener on, and the settled parse must
+    // agree with what the frames showed.
+    const raw =
+      'Prose before. <options>{"1": {"title": "Define the criteria", "description": "Populate"}}]}</options> after.'
+    const bodyStart = raw.indexOf('<options>') + '<options>'.length
+    for (let end = bodyStart; end <= raw.length; end++) {
+      const { segments } = parseSpecialTags(raw.slice(0, end), true)
+      expect(renderedText(segments), `frame ${end}`).not.toContain('{')
+    }
+    expect(renderedText(parseSpecialTags(raw, false).segments)).toBe('Prose before.  after.')
+  })
+
   it('still rejects a close whose name is wrong rather than merely unfinished', () => {
     // The counterpart to the case above: `</workflow_resource>` can never grow
     // into `</workspace_resource>`, so it settles immediately instead of hiding

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

@@ -639,6 +639,33 @@ function blankJsonStringLiterals(body: string): string {
   return out
 }
 
+/**
+ * Whether `body` ends inside a JSON string literal, under the same quote and
+ * escape rules as {@link blankJsonStringLiterals}.
+ *
+ * True means the body's quotes are mispaired, so blanking assigned at least one
+ * region to the wrong side of a string boundary — the one condition under which
+ * a marker missing from the blanked copy may still be real. With balanced
+ * quotes the blanked scan already saw every marker outside a string, so a
+ * marker visible only in the raw text really was quoted content (see
+ * {@link classifyBody}).
+ */
+function endsInsideJsonString(body: string): boolean {
+  let inString = false
+  let escaped = false
+  for (let i = 0; i < body.length; i++) {
+    const char = body[i]
+    if (escaped) {
+      escaped = false
+    } else if (char === '\\' && inString) {
+      escaped = true
+    } else if (char === '"') {
+      inString = !inString
+    }
+  }
+  return inString
+}
+
 /**
  * True while `scannable` could still grow into a single valid JSON value.
  *
@@ -675,6 +702,33 @@ function isViableJsonPrefixOf(scannable: string): boolean {
   return true
 }
 
+/**
+ * Index just past the close of `scannable`'s top-level JSON value, or -1 while
+ * the value is still open. Same depth rules as {@link isViableJsonPrefixOf},
+ * and takes the same blanked form, so braces inside JSON strings do not count.
+ */
+function jsonValueEndIn(scannable: string): number {
+  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 i + 1
+    }
+  }
+  return -1
+}
+
+/**
+ * Nothing but JSON punctuation and whitespace — what a fumbled payload's tail
+ * looks like on the BLANKED body, where string contents are already spaces. A
+ * letter or digit here means the model moved on to prose instead (see
+ * {@link resolveTagAt}).
+ */
+const JSON_DEBRIS_ONLY = /^[\s[\]{}",:]*$/
+
 /**
  * Whether `text` contains a marker for one of the tags this parser knows.
  *
@@ -989,17 +1043,24 @@ function classifyBody(tagName: (typeof SPECIAL_TAG_NAMES)[number], body: string)
 
   if (unparseable) {
     // literalTextReason blanked this body's quoted regions on the assumption it
-    // was valid JSON. It is not, so that assumption is void — and a body with
-    // an odd number of `"` blanks the WRONG regions, which can hide a real
-    // marker and misread a mispaired span as this tag's own body. The
-    // difference is not academic: both classes below resume past the close,
-    // flattening or discarding a genuine tag inside the span, so a card already
-    // on screen un-renders when the close finally arrives. With the JSON
-    // premise gone, the raw text is the honest evidence, and a marker in it
-    // means the close we matched belongs elsewhere. Only after both marker
-    // scans come up empty may the opener test decide the remaining two classes.
-    const rawMarker = TAG_SHAPED_MARKER.exec(inspected.text)
-    if (rawMarker) return { kind: 'nested-marker', offsetInBody: rawMarker.index }
+    // was valid JSON. It is not — but the blanked offsets only LIE when the
+    // body's quotes are mispaired: an odd `"` blanks the wrong regions, which
+    // can hide a real marker and misread a mispaired span as this tag's own
+    // body. The difference is not academic: both failure classes below resume
+    // past the close, flattening or discarding a genuine tag inside the span,
+    // so a card already on screen un-renders when the close finally arrives.
+    // With mispaired quotes the raw text is the honest evidence, and a marker
+    // in it means the close we matched belongs elsewhere. With BALANCED quotes
+    // the blanked scan above already saw every marker outside a string, so a
+    // marker visible only in the raw text is quoted content — rescanning would
+    // classify a broken payload whose strings legitimately mention tag syntax
+    // as nested markers and render it as raw JSON, the exact failure `discard`
+    // exists to prevent. Only after the marker question settles may the opener
+    // test decide the remaining two classes.
+    if (endsInsideJsonString(inspected.text)) {
+      const rawMarker = TAG_SHAPED_MARKER.exec(inspected.text)
+      if (rawMarker) return { kind: 'nested-marker', offsetInBody: rawMarker.index }
+    }
     return wasAttemptedPayload(body) ? { kind: 'not-parsable' } : { kind: 'not-a-payload' }
   }
 
@@ -1086,8 +1147,33 @@ function resolveTagAt(
 
   if (closeIdx === -1) {
     const inspected = inspectWithin(content, bodyStart)
-    if (isStreaming && !unclosedTagCannotResolve(tagName, inspected.text)) {
-      return { outcome: 'pending' }
+    if (isStreaming) {
+      if (!unclosedTagCannotResolve(tagName, inspected.text)) return { outcome: 'pending' }
+      // The body can no longer resolve, but it reads as a payload the model is
+      // still fumbling: it opens like an attempted payload and everything past
+      // its top-level value is JSON debris (a stray `}` or `]}`) — exactly the
+      // shapes the matched-pair path DISCARDS the moment a close arrives.
+      // Releasing such a body now paints raw JSON on screen only for the close
+      // to retract it, so keep suppressing while the stream runs; the settled
+      // parse still shows it if the close never comes. Two kinds of
+      // counter-evidence release immediately, because each means the model
+      // moved on and holding the remainder back would blank the rest of the
+      // message for the whole stream — the failure unclosedTagCannotResolve
+      // exists to prevent: a tag-shaped marker outside the payload's strings
+      // (a misspelled close, a new tag), or prose after the value closed (a
+      // mention flowing on, pinned by the trace 220cc02d and trace afbeefd0
+      // tests).
+      if (JSON_BODY_TAG_NAMES.has(tagName)) {
+        const pending = dropArrivingClose(inspected.text, closeTag)
+        const blanked = blankJsonStringLiterals(pending)
+        if (
+          wasAttemptedPayload(pending) &&
+          !TAG_SHAPED_MARKER.test(blanked) &&
+          JSON_DEBRIS_ONLY.test(blanked.slice(Math.max(0, jsonValueEndIn(blanked))))
+        ) {
+          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