improvement(copilot): show text as soon as an unclosed tag cannot resolve

Restoring the text only at end of stream left a real gap: once the model
mentions a tag in prose, everything after it stays invisible for the rest of
the stream and reappears in one jump when streaming stops. On a long reply
that is most of the message.

Two properties let us decide much earlier, both conservative — they only fire
on content that could not have parsed:

- Tags never nest, so any special-tag marker inside the body (opening OR
  closing, not just a mismatched close) proves the opener was literal text.
- JSON-bodied tags must start with `{` or `[`, so the first non-space
  character settles it — prose after the marker is caught on the very next
  chunk rather than at the end.

The second is per-tag, not global: `thinking` bodies are prose by design
(parseTextTagBody), so the JSON rule cannot apply there and only the nesting
rule can rescue it. A test documents that remaining gap rather than leaving
it implicit.

A false positive is cheap by construction: text shows early and the
end-of-stream parse still produces the correct final render.

Author: j15z

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

@@ -149,6 +149,47 @@ describe('parseSpecialTags with <question>', () => {
     expect(segments).toEqual([{ type: 'text', content: 'Thinking about it. ' }])
   })
 
+  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.
+    const content = 'The `<workspace_resource>` chip only renders for a real file.'
+    const { segments, hasPendingTag } = parseSpecialTags(content, true)
+    expect(hasPendingTag).toBe(false)
+    expect(segments.map((s) => ('content' in s ? s.content : s.type)).join('')).toContain(
+      'chip only renders for a real file.'
+    )
+  })
+
+  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"',
+      true
+    )
+    expect(hasPendingTag).toBe(true)
+    expect(segments).toEqual([{ type: 'text', content: 'Here you go ' }])
+  })
+
+  it('bails when a foreign closing tag appears inside the body', () => {
+    // Tags never nest, so a close for a different tag proves the opener was text.
+    const { hasPendingTag } = parseSpecialTags(
+      'see <options>[{"title":"a","description":"b"}] </question> more',
+      true
+    )
+    expect(hasPendingTag).toBe(false)
+  })
+
+  it('bails on a nested opening tag', () => {
+    const { hasPendingTag } = parseSpecialTags('a <thinking>b <thinking> c', true)
+    expect(hasPendingTag).toBe(false)
+  })
+
+  it('keeps suppressing an unclosed thinking tag with prose — its body is not JSON', () => {
+    // Documents the deliberate gap: `thinking` bodies are prose, so the JSON
+    // heuristic cannot apply and only the nesting rule can rescue it.
+    const { hasPendingTag } = parseSpecialTags('a <thinking>still reasoning about', true)
+    expect(hasPendingTag).toBe(true)
+  })
+
   it('renders an unclosed tag as text once the message is complete', () => {
     const content =
       'The `<workspace_resource>` file chip only renders when its path points to a real file.'

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

@@ -473,6 +473,56 @@ function parseSpecialTagData(
  * Trailing partial opening tags (e.g. `<opt`, `<usage_`) are also stripped
  * during streaming to prevent flashing raw markup.
  */
+/**
+ * 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
+ * whether a close is still coming.
+ */
+const JSON_BODY_TAG_NAMES = new Set<(typeof SPECIAL_TAG_NAMES)[number]>([
+  'options',
+  'usage_upgrade',
+  'credential',
+  'mothership-error',
+  'workspace_resource',
+  'question',
+])
+
+/**
+ * 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
+ * ends.
+ *
+ * Without this, a message that merely mentions a tag in prose goes blank from
+ * that point on for the rest of the stream — the text is only restored once
+ * streaming stops. Two facts let us decide early:
+ *
+ * 1. Tags never nest. Any other special-tag marker inside the body — opening or
+ *    closing — means this opener was literal text, not a real tag.
+ * 2. JSON-bodied tags must start with `{` or `[`. The first non-space character
+ *    settles it, so prose after the marker is caught on the very next chunk.
+ *
+ * Both are conservative: they only fire on content that could not have parsed.
+ * A false positive would merely show text early that a later chunk resolves
+ * into a tag — the end-of-stream parse still produces the correct final render.
+ */
+function unclosedTagCannotResolve(
+  tagName: (typeof SPECIAL_TAG_NAMES)[number],
+  body: string
+): boolean {
+  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 (JSON_BODY_TAG_NAMES.has(tagName)) {
+    const firstChar = body.trimStart().charAt(0)
+    if (firstChar !== '' && firstChar !== '{' && firstChar !== '[') return true
+  }
+
+  return false
+}
+
 export function parseSpecialTags(content: string, isStreaming: boolean): ParsedSpecialContent {
   const segments: ContentSegment[] = []
   let hasPendingTag = false
@@ -526,14 +576,19 @@ export function parseSpecialTags(content: string, isStreaming: boolean): ParsedS
     const closeIdx = content.indexOf(closeTag, bodyStart)
 
     if (closeIdx === -1) {
-      if (isStreaming) {
+      // 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
       }
-      // A completed message can never finish an unclosed tag — the marker was
-      // literal text mentioning the tag (e.g. "the `<workspace_resource>`
-      // chip"), not a real tag. Render the remainder instead of swallowing it.
       const remaining = content.slice(nearestStart)
       if (remaining.trim()) {
         segments.push({ type: 'text', content: remaining })