fix(wand): preserve nested fences and retire stale history on reset

Slice only the outermost fence delimiters so a fenced body containing
line-leading backticks keeps every interior line, and skip the history
append when a language reset retired the request mid-flight.

Author: waleedlatif1

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/hooks/use-wand.ts

@@ -1,4 +1,4 @@
-import { useCallback, useRef, useState } from 'react'
+import { useCallback, useEffect, useRef, useState } from 'react'
 import { toast } from '@sim/emcn'
 import { createLogger } from '@sim/logger'
 import { filterUndefined } from '@sim/utils/object'
@@ -143,11 +143,23 @@ export function useWand({
    * correctly makes the first render a no-op.
    */
   const [prevHistoryResetKey, setPrevHistoryResetKey] = useState(historyResetKey)
+  const [historyEpoch, setHistoryEpoch] = useState(0)
   if (prevHistoryResetKey !== historyResetKey) {
     setPrevHistoryResetKey(historyResetKey)
     setConversationHistory([])
+    setHistoryEpoch((epoch) => epoch + 1)
   }
 
+  /**
+   * Mirrors {@link historyEpoch} for the in-flight request to read on completion.
+   * A request that started before a reset must not append its turn to the fresh
+   * history — its prompt and reply belong to the superseded context.
+   */
+  const historyEpochRef = useRef(historyEpoch)
+  useEffect(() => {
+    historyEpochRef.current = historyEpoch
+  }, [historyEpoch])
+
   const abortControllerRef = useRef<AbortController | null>(null)
 
   const showPromptInline = useCallback(() => {
@@ -192,6 +204,9 @@ export function useWand({
       setError(null)
       setPromptInputValue('')
 
+      /** The context this request belongs to; a reset while it streams retires it. */
+      const startedHistoryEpoch = historyEpochRef.current
+
       abortControllerRef.current = new AbortController()
 
       if (onStreamStart) {
@@ -258,9 +273,12 @@ export function useWand({
         if (generatedContent) {
           onGeneratedContent(generatedContent)
 
-          if (wandConfig?.maintainHistory) {
-            // The sanitized form goes into history so a single fenced reply
-            // cannot become the in-context example for every later turn.
+          /**
+           * The sanitized form goes into history so a single fenced reply cannot
+           * become the in-context example for every later turn. Skipped entirely
+           * when a reset retired this request's context mid-flight.
+           */
+          if (wandConfig?.maintainHistory && historyEpochRef.current === startedHistoryEpoch) {
             setConversationHistory((prev) => [
               ...prev,
               { role: 'user', content: currentPrompt },

apps/sim/lib/wand/strip-code-fences.test.ts

@@ -35,9 +35,23 @@ describe('stripCodeFences', () => {
     expect(stripCodeFences(fenced)).toBe('if <flag>:\n    return "yes"\nreturn "no"')
   })
 
-  it('keeps every fenced region and drops prose between them', () => {
+  it('preserves fence lines embedded inside the fenced body', () => {
+    const fenced = '```javascript\nconst md = `\n```\nhello\n```\n`;\nreturn md;\n```'
+    expect(stripCodeFences(fenced)).toBe('const md = `\n```\nhello\n```\n`;\nreturn md;')
+  })
+
+  it('preserves a fenced docstring inside a Python body', () => {
+    const fenced = '```python\ntemplate = """\n```sql\nSELECT 1\n```\n"""\nreturn template\n```'
+    expect(stripCodeFences(fenced)).toBe(
+      'template = """\n```sql\nSELECT 1\n```\n"""\nreturn template'
+    )
+  })
+
+  it('keeps everything between the outer delimiters for a multi-block answer', () => {
+    // Prose survives rather than risk dropping code between two delimiters that
+    // may be a nested literal instead of a block boundary.
     const fenced = '```js\nconst a = 1;\n```\nThen send it:\n```js\nreturn a;\n```'
-    expect(stripCodeFences(fenced)).toBe('const a = 1;\nreturn a;')
+    expect(stripCodeFences(fenced)).toBe('const a = 1;\n```\nThen send it:\n```js\nreturn a;')
   })
 
   it('does not touch code that merely contains a fence later', () => {

apps/sim/lib/wand/strip-code-fences.ts

@@ -57,28 +57,41 @@ export function shouldStripCodeFences(generationType?: string): boolean {
  * a false positive here would corrupt working code, which is far worse than
  * leaving a rare unwrapped response for the user to fix.
  *
- * Within a fenced response every fenced region is kept and everything between
- * them is dropped: text outside a fence is prose, which is never valid code.
+ * Only the outermost delimiters are removed: everything between the first and
+ * last fence line is kept verbatim, including any fence lines inside it. A
+ * generated body may legitimately contain line-leading backticks (code that
+ * builds a markdown string), and pairing delimiters off would silently discard
+ * the lines between them. The cost is that a model which answers with several
+ * fenced blocks and prose between them keeps that prose — visibly wrong output
+ * the user can re-roll, rather than code quietly missing a chunk.
+ *
  * Falls back to the original text if stripping would leave nothing.
  */
 export function stripCodeFences(text: string): string {
   if (!text.trimStart().startsWith('```')) return text
 
-  const collected: string[] = []
-  let insideFence = false
+  const lines = text.split('\n')
+  const openingFence = lines.findIndex((line) => FENCE_LINE.test(line))
+  if (openingFence === -1) return text
 
-  for (const line of text.split('\n')) {
-    if (FENCE_LINE.test(line)) {
-      insideFence = !insideFence
-      continue
+  let closingFence = -1
+  for (let index = lines.length - 1; index > openingFence; index--) {
+    if (FENCE_LINE.test(lines[index])) {
+      closingFence = index
+      break
     }
-    if (insideFence) collected.push(line)
   }
 
+  // An unclosed fence (a truncated response) keeps everything after the opener.
+  const inner =
+    closingFence === -1
+      ? lines.slice(openingFence + 1)
+      : lines.slice(openingFence + 1, closingFence)
+
   // Trim blank lines only — leading whitespace on a kept line is indentation,
   // which is load-bearing in Python.
-  while (collected.length > 0 && collected[0].trim() === '') collected.shift()
-  while (collected.length > 0 && collected[collected.length - 1].trim() === '') collected.pop()
+  while (inner.length > 0 && inner[0].trim() === '') inner.shift()
+  while (inner.length > 0 && inner[inner.length - 1].trim() === '') inner.pop()
 
-  return collected.length > 0 ? collected.join('\n') : text
+  return inner.length > 0 ? inner.join('\n') : text
 }