diff --git a/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/chat/chat.tsx b/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/chat/chat.tsx
index 0ad5e42f07..3b22271411 100644
--- a/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/chat/chat.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/chat/chat.tsx
@@ -24,6 +24,7 @@ import {
 } from '@/components/emcn'
 import { useSession } from '@/lib/auth/auth-client'
 import { cn } from '@/lib/core/utils/cn'
+import { formatOutputForWorkflow } from '@/lib/core/utils/format-output'
 import {
   extractBlockIdFromOutputId,
   extractPathFromOutputId,
@@ -156,20 +157,8 @@ const extractOutputFromLogs = (logs: BlockLog[] | undefined, outputId: string):
   return output
 }
 
-/**
- * Formats output content for display in chat
- * @param output - Output value to format (string, object, or other)
- * @returns Formatted string, markdown code block for objects, or empty string
- */
-const formatOutputContent = (output: unknown): string => {
-  if (typeof output === 'string') {
-    return output
-  }
-  if (output && typeof output === 'object') {
-    return `\`\`\`json\n${JSON.stringify(output, null, 2)}\n\`\`\``
-  }
-  return ''
-}
+// Use shared utility for formatting output - removed duplicate code
+const formatOutputContent = formatOutputForWorkflow
 
 /**
  * Represents a field in the start block's input format configuration
diff --git a/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/chat/components/chat-message/chat-message.tsx b/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/chat/components/chat-message/chat-message.tsx
index 2a01d630a4..723fe39cea 100644
--- a/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/chat/components/chat-message/chat-message.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/chat/components/chat-message/chat-message.tsx
@@ -1,4 +1,5 @@
 import { useMemo } from 'react'
+import { formatOutputForChat } from '@/lib/core/utils/format-output'
 import { StreamingIndicator } from '@/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/copilot/components/copilot-message/components/smooth-streaming'
 
 interface ChatAttachment {
@@ -93,12 +94,7 @@ const WordWrap = ({ text }: { text: string }) => {
  * Renders a chat message with optional file attachments
  */
 export function ChatMessage({ message }: ChatMessageProps) {
-  const formattedContent = useMemo(() => {
-    if (typeof message.content === 'object' && message.content !== null) {
-      return JSON.stringify(message.content, null, 2)
-    }
-    return String(message.content || '')
-  }, [message.content])
+  const formattedContent = useMemo(() => formatOutputForChat(message.content), [message.content])
 
   const handleAttachmentClick = (attachment: ChatAttachment) => {
     const validDataUrl = attachment.dataUrl?.trim()
diff --git a/apps/sim/lib/core/utils/format-output.test.ts b/apps/sim/lib/core/utils/format-output.test.ts
new file mode 100644
index 0000000000..471ed02230
--- /dev/null
+++ b/apps/sim/lib/core/utils/format-output.test.ts
@@ -0,0 +1,281 @@
+import { describe, expect, it } from 'vitest'
+import {
+  formatOutputForChat,
+  formatOutputForDisplay,
+  formatOutputForWorkflow,
+  formatOutputRaw,
+  formatOutputSafe,
+  isOutputSafe,
+} from './format-output'
+
+describe('format-output utilities', () => {
+  describe('formatOutputForDisplay', () => {
+    // Basic types
+    it('handles null and undefined', () => {
+      expect(formatOutputForDisplay(null)).toBe('')
+      expect(formatOutputForDisplay(undefined)).toBe('')
+    })
+
+    it('handles primitive types', () => {
+      expect(formatOutputForDisplay('hello')).toBe('hello')
+      expect(formatOutputForDisplay(123)).toBe('123')
+      expect(formatOutputForDisplay(true)).toBe('true')
+      expect(formatOutputForDisplay(false)).toBe('false')
+      expect(formatOutputForDisplay(0)).toBe('0')
+      expect(formatOutputForDisplay(BigInt(999))).toBe('999')
+    })
+
+    // Object with text property
+    it('extracts text from objects with text property', () => {
+      expect(formatOutputForDisplay({ text: 'Hello World', type: 'response' })).toBe('Hello World')
+      expect(formatOutputForDisplay({ text: '  spaced  ', other: 'data' })).toBe('spaced')
+    })
+
+    // Nested objects
+    it('handles deeply nested text properties', () => {
+      const nested = {
+        data: {
+          response: {
+            message: {
+              content: 'Deep text',
+            },
+          },
+        },
+      }
+      expect(formatOutputForDisplay(nested)).toBe('Deep text')
+    })
+
+    // Arrays
+    it('handles arrays of text objects', () => {
+      const arr = [{ text: 'Line 1' }, { text: 'Line 2' }, { content: 'Line 3' }]
+      expect(formatOutputForDisplay(arr)).toBe('Line 1 Line 2 Line 3')
+    })
+
+    it('handles mixed arrays', () => {
+      const mixed = ['String', { text: 'Object text' }, 123, null, { message: 'Message text' }]
+      expect(formatOutputForDisplay(mixed)).toBe('String Object text 123 Message text')
+    })
+
+    // Special objects
+    it('handles Date objects', () => {
+      const date = new Date('2024-01-01T00:00:00Z')
+      expect(formatOutputForDisplay(date)).toBe('2024-01-01T00:00:00.000Z')
+    })
+
+    it('handles Error objects', () => {
+      const error = new Error('Test error')
+      expect(formatOutputForDisplay(error)).toBe('Test error')
+    })
+
+    it('handles RegExp objects', () => {
+      const regex = /test.*pattern/gi
+      expect(formatOutputForDisplay(regex)).toBe('/test.*pattern/gi')
+    })
+
+    // Circular references
+    it('handles circular references', () => {
+      const obj: any = { a: 1 }
+      obj.self = obj
+      const result = formatOutputForDisplay(obj, { mode: 'raw' })
+      expect(result).toContain('[Circular]')
+      expect(() => formatOutputForDisplay(obj, { mode: 'raw' })).not.toThrow()
+    })
+
+    // Large arrays
+    it('handles large arrays gracefully', () => {
+      const bigArray = new Array(2000).fill('item')
+      const result = formatOutputForDisplay(bigArray)
+      expect(result).toContain('[Large Array: 2000 items]')
+    })
+
+    // Binary data
+    it('handles Buffer data', () => {
+      const buffer = Buffer.from('Hello Buffer')
+      expect(formatOutputForDisplay(buffer)).toBe('Hello Buffer')
+
+      const binaryBuffer = Buffer.from([0xff, 0xfe, 0x00, 0x01])
+      expect(formatOutputForDisplay(binaryBuffer)).toBe('[Binary Data]')
+    })
+
+    // Truncation
+    it('truncates long strings when specified', () => {
+      const longText = 'x'.repeat(10000)
+      const result = formatOutputForDisplay(longText, { maxLength: 100, truncate: true })
+      expect(result.length).toBeLessThan(150)
+      expect(result).toContain('... [truncated]')
+    })
+
+    // Whitespace handling
+    it('preserves whitespace when requested', () => {
+      const spaced = 'Line 1\n\nLine 2\t\tTabbed'
+      expect(formatOutputForDisplay(spaced, { preserveWhitespace: true })).toBe(
+        'Line 1\n\nLine 2\t\tTabbed'
+      )
+      expect(formatOutputForDisplay(spaced, { preserveWhitespace: false })).toBe(
+        'Line 1 Line 2 Tabbed'
+      )
+    })
+
+    // Mode-specific formatting
+    it('formats correctly for different modes', () => {
+      const obj = { someField: 'value', type: 'test' }
+
+      const chatFormat = formatOutputForDisplay(obj, { mode: 'chat' })
+      const workflowFormat = formatOutputForDisplay(obj, { mode: 'workflow' })
+      const rawFormat = formatOutputForDisplay(obj, { mode: 'raw' })
+
+      // Chat mode should show JSON for objects without text fields
+      expect(chatFormat).toContain('someField')
+
+      // Workflow mode should wrap in code blocks
+      expect(workflowFormat).toMatch(/```json/)
+      expect(workflowFormat).toContain('someField')
+
+      // Raw mode should show plain JSON
+      expect(rawFormat).toMatch(/"someField":\s*"value"/)
+    })
+
+    // Edge cases
+    it('handles objects with toString method', () => {
+      const customObj = {
+        toString() {
+          return 'Custom String'
+        },
+      }
+      expect(formatOutputForDisplay(customObj)).toBe('Custom String')
+    })
+
+    it('handles undefined and function properties', () => {
+      const obj = {
+        func: () => console.log('test'),
+        undef: undefined,
+        sym: Symbol('test'),
+      }
+      const result = formatOutputForDisplay(obj, { mode: 'raw' })
+      expect(result).toContain('[Function]')
+      expect(result).toContain('[undefined]')
+      expect(result).toContain('[Symbol]')
+    })
+  })
+
+  describe('specialized formatters', () => {
+    it('formatOutputForChat limits length', () => {
+      const longText = 'x'.repeat(10000)
+      const result = formatOutputForChat(longText)
+      expect(result.length).toBeLessThanOrEqual(5100) // 5000 + truncation message
+    })
+
+    it('formatOutputForWorkflow wraps in code block', () => {
+      const obj = { test: 'data' }
+      const result = formatOutputForWorkflow(obj)
+      expect(result).toMatch(/^```json/)
+      expect(result).toMatch(/```$/)
+    })
+
+    it('formatOutputRaw preserves everything', () => {
+      const text = '  \n\t  spaced  \n\t  '
+      const result = formatOutputRaw(text)
+      expect(result).toBe(text)
+    })
+  })
+
+  describe('security features', () => {
+    it('detects unsafe content', () => {
+      expect(isOutputSafe('<script>alert("xss")</script>')).toBe(false)
+      expect(isOutputSafe('javascript:void(0)')).toBe(false)
+      expect(isOutputSafe('<div onclick="alert(1)">')).toBe(false)
+      expect(isOutputSafe('<iframe src="evil">')).toBe(false)
+      expect(isOutputSafe('Normal text')).toBe(true)
+    })
+
+    it('escapes HTML in unsafe content', () => {
+      const unsafe = '<script>alert("xss")</script>'
+      const result = formatOutputSafe(unsafe)
+      expect(result).not.toContain('<script>')
+      expect(result).toContain('&lt;script')
+      expect(result).toContain('&gt;')
+    })
+
+    it('leaves safe content unescaped', () => {
+      const safe = 'Normal text with no HTML'
+      const result = formatOutputSafe(safe)
+      expect(result).toBe(safe)
+    })
+  })
+
+  describe('error handling', () => {
+    it('handles errors gracefully', () => {
+      // Create object that throws on property access
+      const evil = new Proxy(
+        {},
+        {
+          get() {
+            throw new Error('Evil object!')
+          },
+        }
+      )
+
+      const result = formatOutputForDisplay(evil)
+      expect(result).toContain('[')
+      expect(() => formatOutputForDisplay(evil)).not.toThrow()
+    })
+
+    it('handles very deep recursion', () => {
+      let deep: any = { text: 'Found it!' }
+      for (let i = 0; i < 20; i++) {
+        deep = { nested: deep }
+      }
+
+      const result = formatOutputForDisplay(deep)
+      // Should stop at MAX_DEPTH but not crash
+      expect(result).toBeTruthy()
+      expect(() => formatOutputForDisplay(deep)).not.toThrow()
+    })
+  })
+
+  describe('real-world LLM outputs', () => {
+    it('handles OpenAI format', () => {
+      const openAIResponse = {
+        choices: [
+          {
+            message: {
+              content: 'AI response here',
+            },
+          },
+        ],
+      }
+      expect(formatOutputForDisplay(openAIResponse)).toBe('AI response here')
+    })
+
+    it('handles Anthropic format', () => {
+      const anthropicResponse = {
+        content: [
+          {
+            text: 'Claude response',
+          },
+        ],
+      }
+      expect(formatOutputForDisplay(anthropicResponse)).toBe('Claude response')
+    })
+
+    it('handles streaming chunks', () => {
+      const chunk = {
+        delta: {
+          content: 'Streaming text',
+        },
+      }
+      expect(formatOutputForDisplay(chunk)).toBe('Streaming text')
+    })
+
+    it('handles tool outputs', () => {
+      const toolOutput = {
+        result: {
+          data: {
+            output: 'Tool execution result',
+          },
+        },
+      }
+      expect(formatOutputForDisplay(toolOutput)).toBe('Tool execution result')
+    })
+  })
+})
diff --git a/apps/sim/lib/core/utils/format-output.ts b/apps/sim/lib/core/utils/format-output.ts
new file mode 100644
index 0000000000..11620d25d6
--- /dev/null
+++ b/apps/sim/lib/core/utils/format-output.ts
@@ -0,0 +1,307 @@
+import { createLogger } from '@sim/logger'
+
+const logger = createLogger('FormatOutput')
+
+// Type definitions for better type safety
+type TextFieldName =
+  | 'text'
+  | 'content'
+  | 'message'
+  | 'body'
+  | 'value'
+  | 'result'
+  | 'output'
+  | 'response'
+  | 'answer'
+  | 'reply'
+  | 'data'
+type FormatMode = 'chat' | 'workflow' | 'raw'
+
+interface FormatOptions {
+  mode?: FormatMode
+  maxLength?: number
+  truncate?: boolean
+  preserveWhitespace?: boolean
+}
+
+interface TextExtractable {
+  [key: string]: unknown
+  text?: string
+  content?: string
+  message?: string
+  body?: string
+  value?: string
+  result?: string
+  output?: string
+  response?: string
+  answer?: string
+  reply?: string
+  data?: string
+}
+
+// Constants
+const TEXT_FIELDS: readonly TextFieldName[] = [
+  'text',
+  'content',
+  'message',
+  'body',
+  'value',
+  'result',
+  'output',
+  'response',
+  'answer',
+  'reply',
+  'data',
+] as const
+
+const MAX_STRING_LENGTH = 50000
+const MAX_ARRAY_ITEMS = 100
+const MAX_DEPTH = 5
+
+/**
+ * Extract text content from common LLM response formats
+ */
+function extractText(value: unknown, depth = 0): string | null {
+  // Guard against deep recursion
+  if (depth > MAX_DEPTH) return null
+
+  // Handle primitives
+  if (value === null || value === undefined) return null
+  if (typeof value === 'string') return value || null
+  if (typeof value === 'number' || typeof value === 'boolean') return String(value)
+  if (typeof value === 'bigint') return value.toString()
+
+  // Handle special objects
+  if (value instanceof Date) return value.toISOString()
+  if (value instanceof Error) return value.message
+  if (value instanceof RegExp) return value.toString()
+
+  // Handle Buffer/Uint8Array
+  if (Buffer.isBuffer(value) || value instanceof Uint8Array) {
+    try {
+      const text = Buffer.from(value).toString('utf-8')
+      // Check if it's readable text (printable ASCII + whitespace)
+      if (/^[\x20-\x7E\s]*$/.test(text) && text.trim()) {
+        return text
+      }
+    } catch {}
+    return '[Binary Data]'
+  }
+
+  // Handle arrays - extract first valid text
+  if (Array.isArray(value)) {
+    if (value.length === 0) return null
+    if (value.length > MAX_ARRAY_ITEMS) {
+      return `[Large Array: ${value.length} items]`
+    }
+
+    // For arrays, concatenate all text content
+    const texts = value.map((item) => extractText(item, depth + 1)).filter(Boolean)
+
+    return texts.length > 0 ? texts.join(' ') : null
+  }
+
+  // Handle objects with text fields
+  if (typeof value === 'object' && value !== null) {
+    const obj = value as TextExtractable
+
+    // Fast path: check common text fields first
+    for (const field of TEXT_FIELDS) {
+      if (field in obj) {
+        const fieldValue = obj[field]
+        if (typeof fieldValue === 'string' && fieldValue) {
+          return fieldValue
+        }
+      }
+    }
+
+    // Check nested structures (common in LLM responses)
+    // OpenAI format: choices[0].message.content
+    if ('choices' in obj && Array.isArray(obj.choices) && obj.choices[0]) {
+      const extracted = extractText(obj.choices[0], depth + 1)
+      if (extracted) return extracted
+    }
+
+    // Anthropic format: content[0].text
+    if ('content' in obj && Array.isArray(obj.content) && obj.content[0]) {
+      const extracted = extractText(obj.content[0], depth + 1)
+      if (extracted) return extracted
+    }
+
+    // Streaming format: delta.content
+    if ('delta' in obj && typeof obj.delta === 'object') {
+      const extracted = extractText(obj.delta, depth + 1)
+      if (extracted) return extracted
+    }
+
+    // Recursive search through all properties for text fields
+    for (const [key, value] of Object.entries(obj)) {
+      if (typeof value === 'object' && value !== null) {
+        const extracted = extractText(value, depth + 1)
+        if (extracted) return extracted
+      }
+    }
+
+    // Custom toString
+    if (typeof obj.toString === 'function' && obj.toString !== Object.prototype.toString) {
+      const str = obj.toString()
+      if (str && str !== '[object Object]') return str
+    }
+  }
+
+  return null
+}
+
+/**
+ * Safely stringify objects for fallback display
+ */
+function safeStringify(value: unknown): string {
+  try {
+    const seen = new WeakSet()
+    return JSON.stringify(
+      value,
+      (_, val) => {
+        if (val === undefined) return '[undefined]'
+        if (typeof val === 'function') return '[Function]'
+        if (typeof val === 'symbol') return '[Symbol]'
+        if (typeof val === 'bigint') return val.toString()
+
+        if (typeof val === 'object' && val !== null) {
+          if (seen.has(val)) return '[Circular]'
+          seen.add(val)
+        }
+
+        return val
+      },
+      2
+    )
+  } catch (error) {
+    logger.debug('Stringify failed', { error })
+    return '[Unable to display]'
+  }
+}
+
+/**
+ * Format output for display with smart text extraction
+ * Optimized for performance and common use cases
+ */
+export function formatOutputForDisplay(output: unknown, options: FormatOptions = {}): string {
+  const {
+    mode = 'chat',
+    maxLength = MAX_STRING_LENGTH,
+    truncate = true,
+    preserveWhitespace = false,
+  } = options
+
+  try {
+    // Early return for empty values
+    if (!output && output !== 0 && output !== false) return ''
+
+    // Try to extract text content
+    const text = extractText(output)
+
+    if (text) {
+      let result = text
+
+      // Apply length limit
+      if (truncate && result.length > maxLength) {
+        result = `${result.substring(0, maxLength)}... [truncated]`
+      }
+
+      // Normalize whitespace for chat display only
+      if (!preserveWhitespace && mode === 'chat') {
+        result = result.replace(/\s+/g, ' ').trim()
+      } else if (!preserveWhitespace && mode !== 'raw') {
+        result = result.trim()
+      }
+
+      return result
+    }
+
+    // Fallback to JSON for complex objects
+    const json = safeStringify(output)
+
+    // Format based on mode
+    if (mode === 'workflow') {
+      return `\`\`\`json\n${json}\n\`\`\``
+    }
+
+    if (mode === 'raw') {
+      return json
+    }
+
+    // Chat mode: keep it simple
+    if (json.length > 500) {
+      return '[Complex object]'
+    }
+
+    return json
+  } catch (error) {
+    logger.error('Format error', { error })
+    return '[Display Error]'
+  }
+}
+
+/**
+ * Specialized formatters with optimized defaults
+ */
+export const formatOutputForChat = (output: unknown): string =>
+  formatOutputForDisplay(output, {
+    mode: 'chat',
+    maxLength: 5000,
+    truncate: true,
+  })
+
+export const formatOutputForWorkflow = (output: unknown): string =>
+  formatOutputForDisplay(output, {
+    mode: 'workflow',
+    maxLength: 10000,
+    truncate: true,
+  })
+
+export const formatOutputRaw = (output: unknown): string =>
+  formatOutputForDisplay(output, {
+    mode: 'raw',
+    truncate: false,
+    preserveWhitespace: true,
+  })
+
+/**
+ * Check for potential XSS patterns in output
+ */
+export function isOutputSafe(output: unknown): boolean {
+  try {
+    const str = String(output)
+    const xssPatterns = [
+      /<script/i,
+      /javascript:/i,
+      /on\w+\s*=/i,
+      /<iframe/i,
+      /<embed/i,
+      /<object/i,
+    ]
+
+    return !xssPatterns.some((pattern) => pattern.test(str))
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Format output with HTML escaping for safety
+ */
+export function formatOutputSafe(output: unknown): string {
+  const formatted = formatOutputForDisplay(output)
+
+  if (!isOutputSafe(formatted)) {
+    logger.warn('Unsafe content detected, escaping')
+    return formatted
+      .replace(/&/g, '&amp;')
+      .replace(/</g, '&lt;')
+      .replace(/>/g, '&gt;')
+      .replace(/"/g, '&quot;')
+      .replace(/'/g, '&#x27;')
+  }
+
+  return formatted
+}