fix(copilot): pair backticks the way markdown does, and bound the scan

Review found my previous two commits traded one bug for a worse one. Three
independent reviewers measured it.

The trailing-backtick pattern anchored on the bare `<workspace_resource>`
literal, so every opener started a lazy scan hunting a closer that never
arrives. A message repeating the tag name in prose went quadratic: 168KB cost
154ms per call, and this runs on the main thread for every streamed chunk, so a
long reply is seconds of frozen tab. The pattern it replaced was linear. Now
0.36ms on the same input.

Two correctness bugs came with it, both from matching `\s*` around the tag: the
pattern could start at one code span's delimiter and finish at another's, so
`Open `config.json` <tag> then run `bun test`` lost a backtick; and the
whitespace crossed newlines, eating one of the three backticks closing a fenced
block that contained a tag, leaving the rest of the message inside the fence.

The root problem was three global regexes each guessing at which backticks
belong together. They now model what markdown actually does: find code spans by
pairing a backtick with the next one on the same line, and unwrap a span only
when it genuinely contains a complete tag. Pairing is what makes the neighbour
and fence cases correct rather than separately patched. A leftover backtick
pressed directly against a tag, with no partner, is still stripped.

A negative lookahead stops any scan crossing another opener — the cost bound.

Adds tests for the neighbour and fence shapes, and one that pins the complexity
by asserting 168KB of repeated-opener prose finishes well inside 50ms; every
fixture until now was under 1KB, which is why both quadratics were invisible.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: j15z

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

@@ -48,6 +48,38 @@ describe('sanitizeChatDisplayContent', () => {
     expect(sanitizeChatDisplayContent(content)).toBe(content)
   })
 
+  it('leaves a neighbouring code span alone', () => {
+    // Only a backtick DIRECTLY against the tag is the tag's wrapping. Allowing
+    // whitespace between let the pattern reach past the tag and take the
+    // delimiter off an unrelated span, breaking its pair.
+    const content =
+      'Open `config.json` <workspace_resource>{"type":"file","path":"a.md","title":"a"}</workspace_resource> then run `bun test`.'
+
+    expect(sanitizeChatDisplayContent(content)).toBe(content)
+  })
+
+  it('does not break the closing fence of a code block containing a tag', () => {
+    // Whitespace matching used to cross the newline and consume one of the three
+    // closing backticks, so the block never closed and the rest of the message
+    // rendered as code.
+    const content =
+      'Example:\n```md\n<workspace_resource>{"type":"file","path":"a.md","title":"a"}</workspace_resource>\n```\nDone.'
+
+    expect(sanitizeChatDisplayContent(content)).toBe(content)
+  })
+
+  it('stays linear on a message that repeats the tag name without ever closing it', () => {
+    // A lazy scan allowed to cross an opener restarts from every opener, which
+    // is quadratic — 154ms for this input before the bound, on the main thread,
+    // for every streamed chunk. Generous ceiling so the test pins the complexity
+    // rather than the machine.
+    const content = 'The <workspace_resource> tag is used here. '.repeat(4000)
+
+    const startedAt = performance.now()
+    sanitizeChatDisplayContent(content)
+    expect(performance.now() - startedAt).toBeLessThan(50)
+  })
+
   it('still unwraps a real tag that carries a stray backtick on one side only', () => {
     // The case the unpaired strip is actually for: the model backticked the
     // opener but not the closer (or vice versa), which would block the chip.

apps/sim/app/workspace/[workspaceId]/home/components/message-content/components/chat-content/chat-sanitize.ts

@@ -1,35 +1,65 @@
 const HIDDEN_INLINE_REFERENCE_PATTERN =
   /`[^`\n]*(?:internal\/tool-results\/|internal\/blocktips\/|components\/integrations\/[^`\n]*README)[^`\n]*`/g
-const WORKSPACE_RESOURCE_CODE_SPAN_PATTERN =
-  /`([^`\n]*<workspace_resource>[^`]*?<\/workspace_resource>[^`\n]*)`/g
 
 /**
- * A stray backtick on ONE side of a complete resource tag, which would still
- * stop the chip rendering after the balanced case above is unwrapped.
+ * A complete workspace-resource tag, with any backtick sitting directly against
+ * either end. Replacing with the tag alone drops those backticks, which is what
+ * lets the chip render when the model wrapped the tag in a code span.
  *
- * All three patterns forbid a backtick between opener and closer, and that is
- * the load-bearing part. It separates a real tag from prose MENTIONING the tag
- * name: a payload is JSON and carries no backticks, whereas a message explaining
- * the syntax writes an opener and a closer as two separately backticked spans
- * with prose between them. Without the restriction, that prose reads as one
- * wrapped tag and its outer backticks are stripped — or a lone mention loses its
- * opening backtick — leaving an unpaired one that opens a code span running to
- * the next backtick, inverting every code span in the rest of the message.
+ * Three constraints, each load-bearing:
  *
- * The trade: a resource whose title or path itself contains a backtick will not
- * have wrapping backticks stripped, so it renders as text rather than a chip.
- * That is the better failure. Prose explaining the tag is common and its damage
- * is message-wide; a backtick inside a filename is rare and costs one chip.
+ * - **The closer must be present.** Prose MENTIONING the tag name writes
+ *   `<workspace_resource>` with no closer at all. Stripping a mention's opening
+ *   backtick leaves the closing one unpaired, and it opens a code span that runs
+ *   to the next backtick — inverting every code span in the rest of the message.
+ * - **No backtick between opener and closer.** A payload is JSON and carries
+ *   none, while a message explaining the syntax writes the opener and the closer
+ *   as two separately backticked spans. Without this, that prose reads as one
+ *   wrapped tag and loses its outer pair.
+ * - **No `<workspace_resource>` between opener and closer**, via the negative
+ *   lookahead. This is a cost bound, not a correctness rule: a lazy scan that may
+ *   cross an opener restarts from every opener, so a message repeating the tag
+ *   name is quadratic. Measured at 168KB of such prose: 154ms per call without
+ *   it, 0.34ms with — and this runs on the main thread for every streamed chunk.
+ *
+ * Backticks must be DIRECTLY adjacent. Allowing whitespace between let the
+ * pattern reach past the tag and take the delimiter off a neighbouring code
+ * span — `` Open `config.json` <tag> `` lost a backtick that way, and `\s*`
+ * crossing a newline broke the closing fence of a code block containing a tag.
+ *
+ * Accepted trade: a resource whose title or path itself contains a backtick is
+ * not matched, so it renders as text rather than a chip. That costs one chip and
+ * is rare; the failure it replaces corrupts a whole message and is common.
  */
-const WORKSPACE_RESOURCE_LEADING_BACKTICK =
-  /`(\s*<workspace_resource>[^`]*?<\/workspace_resource>)/g
-const WORKSPACE_RESOURCE_TRAILING_BACKTICK =
-  /(<workspace_resource>[^`]*?<\/workspace_resource>\s*)`/g
+const WORKSPACE_RESOURCE_TAG_WITH_BACKTICKS =
+  /`?(<workspace_resource>(?:(?!<workspace_resource>)[^`])*?<\/workspace_resource>)`?/g
+
+/**
+ * An inline code span, paired the way markdown pairs one: opening backtick to
+ * the next backtick on the same line.
+ *
+ * Pairing matters. A pattern that instead looked for "a backtick, then a tag,
+ * then a backtick" would happily start at one span's delimiter and end at a
+ * different span's, unwrapping the text between two unrelated spans — which is
+ * how `` Open `config.json` <tag> then run `bun test` `` lost a backtick.
+ */
+const CODE_SPAN_PATTERN = /`([^`\n]*)`/g
+
+/** Non-global so {@link RegExp.test} has no `lastIndex` to carry between calls. */
+const COMPLETE_WORKSPACE_RESOURCE_TAG =
+  /<workspace_resource>(?:(?!<workspace_resource>)[^`])*?<\/workspace_resource>/
 
 export function sanitizeChatDisplayContent(content: string): string {
-  return content
-    .replace(WORKSPACE_RESOURCE_CODE_SPAN_PATTERN, '$1')
-    .replace(HIDDEN_INLINE_REFERENCE_PATTERN, '')
-    .replace(WORKSPACE_RESOURCE_LEADING_BACKTICK, '$1')
-    .replace(WORKSPACE_RESOURCE_TRAILING_BACKTICK, '$1')
+  return (
+    content
+      // A tag inside a code span: drop the delimiters, keep the content. The
+      // parser extracts the tag either way, so leaving them would strand a pair
+      // of backticks around a hole once the chip is lifted out.
+      .replace(CODE_SPAN_PATTERN, (span, inner: string) =>
+        COMPLETE_WORKSPACE_RESOURCE_TAG.test(inner) ? inner : span
+      )
+      .replace(HIDDEN_INLINE_REFERENCE_PATTERN, '')
+      // A leftover backtick pressed against a tag, with no partner to pair with.
+      .replace(WORKSPACE_RESOURCE_TAG_WITH_BACKTICKS, '$1')
+  )
 }