@@ -328,6 +328,13 @@ export const POST = withRouteHandler(async (req: NextRequest) => {
         '\n\nIMPORTANT: Return ONLY the raw cron expression (e.g., "0 9 * * 1-5"). Do NOT wrap it in markdown code blocks, backticks, or quotes. Do NOT include any explanation or text before or after the expression.'
     }
 
+    // Both the JavaScript and Python function-body prompts share this type, so
+    // the reinforcement stays language-neutral.
+    if (generationType === 'javascript-function-body') {
+      finalSystemPrompt +=
+        '\n\nIMPORTANT: Return ONLY the raw function body. Do NOT wrap it in markdown code blocks (no ```javascript, no ```python, no ```). Do NOT include any explanation before or after the code.'
+    }
+
     if (generationType === 'json-object') {
       finalSystemPrompt +=
         '\n\nIMPORTANT: Return ONLY the raw JSON object. Do NOT wrap it in markdown code blocks (no ```json or ```). Do NOT include any explanation or text before or after the JSON. The response must start with { and end with }.'
 
@@ -67,9 +67,32 @@ IMPORTANT FORMATTING RULES:
 1. Reference Environment Variables: Use the exact syntax {{VARIABLE_NAME}}. Do NOT wrap it in quotes.
 2. Reference Input Parameters/Workflow Variables: Use the exact syntax <variable_name>. Do NOT wrap it in quotes.
 3. Function Body ONLY: Do NOT include the function signature (e.g., 'def my_func(...)') or surrounding braces. Return the final value with 'return'.
-4. Imports: You may add imports as needed (standard library or pip-installed packages) without comments.
+4. Imports: The Python standard library is always available. Third-party packages are available ONLY when the block has a sandbox selected — the sandbox's package list is appended below when one is. Never import a package that is not on that list.
 5. No Markdown: Do NOT include backticks, code fences, or any markdown.
-6. Clarity: Write clean, readable Python code.`
+6. Clarity: Write clean, readable Python code.
+7. No Explanations: Output the raw Python code only — no prose before or after it.
+
+Example Scenario:
+User Prompt: "Fetch user data from an API. Use the User ID passed in as 'userId' and an API Key stored as the 'SERVICE_API_KEY' environment variable."
+
+Generated Code:
+import json
+import urllib.error
+import urllib.request
+
+user_id = <userId>  # Correct: accessing an input parameter without quotes
+api_key = {{SERVICE_API_KEY}}  # Correct: accessing an environment variable without quotes
+url = f"https://api.example.com/users/{user_id}"
+
+request = urllib.request.Request(url, headers={"Authorization": f"Bearer {api_key}"})
+
+try:
+    with urllib.request.urlopen(request) as response:
+        # Return the fetched data, which becomes the block's output
+        return json.loads(response.read().decode())
+except urllib.error.HTTPError as error:
+    # Raising marks the block execution as failed
+    raise Exception(f"API request failed with status {error.code}: {error.read().decode()}")`
 
 /**
  * Line height constant for consistent rendering.
@@ -330,6 +353,9 @@ export const Code = memo(function Code({
       tableId: typeof tableIdValue === 'string' ? tableIdValue : null,
       sandboxId: typeof sandboxIdValue === 'string' ? sandboxIdValue : null,
     },
+    // Keyed off the same value that swaps the prompt below, so history from the
+    // previous language cannot steer the next generation back to it.
+    historyResetKey: typeof languageValue === 'string' ? languageValue : undefined,
     onStreamStart: () => handleStreamStartRef.current?.(),
     onStreamChunk: (chunk: string) => handleStreamChunkRef.current?.(chunk),
     onGeneratedContent: (content: string) => handleGeneratedContentRef.current?.(content),
 
@@ -8,6 +8,7 @@ import { requestRaw } from '@/lib/api/client'
 import { isApiClientError } from '@/lib/api/client/errors'
 import { wandGenerateStreamContract } from '@/lib/api/contracts'
 import { readSSEStream } from '@/lib/core/utils/sse'
+import { shouldStripCodeFences, stripCodeFences } from '@/lib/wand/strip-code-fences'
 import type { GenerationType } from '@/blocks/types'
 import { subscriptionKeys } from '@/hooks/queries/subscription'
 import { useSettingsNavigation } from '@/hooks/use-settings-navigation'
@@ -100,6 +101,13 @@ interface UseWandProps {
   wandConfig?: WandConfig
   currentValue?: string
   contextParams?: WandContextParams
+  /**
+   * Clears the conversation history whenever this value changes. Pass anything
+   * that invalidates prior turns — a Function block switching language rewrites
+   * `wandConfig.prompt`, but replayed history would keep steering the model back
+   * to the previous language.
+   */
+  historyResetKey?: string
   onGeneratedContent: (content: string) => void
   onStreamChunk?: (chunk: string) => void
   onStreamStart?: () => void
@@ -110,6 +118,7 @@ export function useWand({
   wandConfig,
   currentValue,
   contextParams,
+  historyResetKey,
   onGeneratedContent,
   onStreamChunk,
   onStreamStart,
@@ -127,6 +136,18 @@ export function useWand({
 
   const [conversationHistory, setConversationHistory] = useState<ChatMessage[]>([])
 
+  /**
+   * Adjusted during render rather than in an effect so a generation started in
+   * the same commit as the change can never send the stale history. History is
+   * already empty on mount, so seeding the tracker with the current key
+   * correctly makes the first render a no-op.
+   */
+  const [prevHistoryResetKey, setPrevHistoryResetKey] = useState(historyResetKey)
+  if (prevHistoryResetKey !== historyResetKey) {
+    setPrevHistoryResetKey(historyResetKey)
+    setConversationHistory([])
+  }
+
   const abortControllerRef = useRef<AbortController | null>(null)
 
   const showPromptInline = useCallback(() => {
@@ -224,25 +245,38 @@ export function useWand({
           signal: abortControllerRef.current?.signal,
         })
 
-        if (accumulatedContent) {
-          onGeneratedContent(accumulatedContent)
+        /**
+         * Sanitized once the full response is known, then written back over the
+         * streamed text. Doing it per-chunk would mean guessing whether a
+         * trailing backtick run opens a fence or is part of the code, so the
+         * editor may briefly show a fence that the final value does not.
+         */
+        const generatedContent = shouldStripCodeFences(wandConfig?.generationType)
+          ? stripCodeFences(accumulatedContent)
+          : accumulatedContent
+
+        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.
             setConversationHistory((prev) => [
               ...prev,
               { role: 'user', content: currentPrompt },
-              { role: 'assistant', content: accumulatedContent },
+              { role: 'assistant', content: generatedContent },
             ])
           }
 
           if (onGenerationComplete) {
-            onGenerationComplete(currentPrompt, accumulatedContent)
+            onGenerationComplete(currentPrompt, generatedContent)
           }
         }
 
         logger.debug('Wand generation completed', {
           prompt,
-          contentLength: accumulatedContent.length,
+          contentLength: generatedContent.length,
+          strippedFences: generatedContent !== accumulatedContent,
         })
 
         setTimeout(() => {
 
@@ -0,0 +1,83 @@
+/**
+ * @vitest-environment node
+ */
+import { describe, expect, it } from 'vitest'
+import { shouldStripCodeFences, stripCodeFences } from '@/lib/wand/strip-code-fences'
+
+describe('stripCodeFences', () => {
+  it('leaves unfenced code untouched', () => {
+    const code = 'const total = <a> + <b>;\nreturn total;'
+    expect(stripCodeFences(code)).toBe(code)
+  })
+
+  it('unwraps a fully wrapped response', () => {
+    expect(stripCodeFences('```python\nresult = <num1> + <num2>\nreturn result\n```')).toBe(
+      'result = <num1> + <num2>\nreturn result'
+    )
+  })
+
+  it('unwraps a response with no closing fence', () => {
+    expect(stripCodeFences('```javascript\nconst x = 1;\nreturn x;')).toBe(
+      'const x = 1;\nreturn x;'
+    )
+  })
+
+  it('unwraps an untagged fence', () => {
+    expect(stripCodeFences('```\nreturn 1;\n```')).toBe('return 1;')
+  })
+
+  it('tolerates leading whitespace before the opening fence', () => {
+    expect(stripCodeFences('\n  ```python\nreturn 1\n```')).toBe('return 1')
+  })
+
+  it('preserves indentation inside the fence', () => {
+    const fenced = '```python\nif <flag>:\n    return "yes"\nreturn "no"\n```'
+    expect(stripCodeFences(fenced)).toBe('if <flag>:\n    return "yes"\nreturn "no"')
+  })
+
+  it('keeps every fenced region and drops prose between them', () => {
+    const fenced = '```js\nconst a = 1;\n```\nThen send it:\n```js\nreturn a;\n```'
+    expect(stripCodeFences(fenced)).toBe('const a = 1;\nreturn a;')
+  })
+
+  it('does not touch code that merely contains a fence later', () => {
+    const code = 'const doc = `\n```json\n{"a":1}\n```\n`;\nreturn doc;'
+    expect(stripCodeFences(code)).toBe(code)
+  })
+
+  it('returns the original when stripping would leave nothing', () => {
+    const empty = '```python\n```'
+    expect(stripCodeFences(empty)).toBe(empty)
+  })
+
+  it('is idempotent', () => {
+    const once = stripCodeFences('```python\nreturn <x>\n```')
+    expect(stripCodeFences(once)).toBe(once)
+  })
+
+  it('handles an empty string', () => {
+    expect(stripCodeFences('')).toBe('')
+  })
+})
+
+describe('shouldStripCodeFences', () => {
+  it('strips for code and structured value types', () => {
+    expect(shouldStripCodeFences('javascript-function-body')).toBe(true)
+    expect(shouldStripCodeFences('custom-tool-schema')).toBe(true)
+    expect(shouldStripCodeFences('json-object')).toBe(true)
+    expect(shouldStripCodeFences('cron-expression')).toBe(true)
+  })
+
+  it('does not strip free-form prose', () => {
+    expect(shouldStripCodeFences('system-prompt')).toBe(false)
+  })
+
+  it('does not strip when no generation type is declared', () => {
+    expect(shouldStripCodeFences(undefined)).toBe(false)
+    expect(shouldStripCodeFences('')).toBe(false)
+  })
+
+  it('does not strip an unrecognized type', () => {
+    expect(shouldStripCodeFences('something-new')).toBe(false)
+  })
+})
@@ -0,0 +1,84 @@
+import type { GenerationType } from '@/blocks/types'
+
+/** A markdown fence delimiter at the start of a line, ignoring indentation. */
+const FENCE_LINE = /^\s*```/
+
+/**
+ * Whether a wand generation's output is a raw machine value, where a leading
+ * markdown fence is always wrong and must be removed.
+ *
+ * Declared as a total `Record` so adding a `GenerationType` fails the build
+ * until the new type opts in or out deliberately — a silent default would let a
+ * prose type start stripping fences (or a code type stop) without review.
+ *
+ * `system-prompt` is the sole exclusion: it is free-form prose for a model, so a
+ * fenced example inside it is legitimate authored content, not a formatting slip.
+ */
+const STRIPS_CODE_FENCES: Record<GenerationType, boolean> = {
+  'javascript-function-body': true,
+  'typescript-function-body': true,
+  'json-schema': true,
+  'json-object': true,
+  'table-schema': true,
+  'system-prompt': false,
+  'custom-tool-schema': true,
+  'sql-query': true,
+  postgrest: true,
+  'mongodb-filter': true,
+  'mongodb-pipeline': true,
+  'mongodb-sort': true,
+  'mongodb-documents': true,
+  'mongodb-update': true,
+  'neo4j-cypher': true,
+  'neo4j-parameters': true,
+  timestamp: true,
+  timezone: true,
+  'cron-expression': true,
+  'odata-expression': true,
+}
+
+/**
+ * Whether generated content for this type should have markdown fences stripped.
+ *
+ * An absent type means the field's `wandConfig` never declared one, which is the
+ * case for free-form prose fields — those are left untouched.
+ */
+export function shouldStripCodeFences(generationType?: string): boolean {
+  if (!generationType) return false
+  return STRIPS_CODE_FENCES[generationType as GenerationType] === true
+}
+
+/**
+ * Removes the markdown code fences a model wrapped around a raw value.
+ *
+ * Applies only when the response *opens* with a fence. Content that merely
+ * contains a fence later is left untouched, because a backtick run inside a
+ * template literal or a docstring is valid code that must survive verbatim —
+ * 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.
+ * 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
+
+  for (const line of text.split('\n')) {
+    if (FENCE_LINE.test(line)) {
+      insideFence = !insideFence
+      continue
+    }
+    if (insideFence) collected.push(line)
+  }
+
+  // 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()
+
+  return collected.length > 0 ? collected.join('\n') : text
+}