From 0fd92fe59e75d4b43416d58a39c72ea732a8a9d2 Mon Sep 17 00:00:00 2001
From: Patel230 <Lakshmanp230@gmail.com>
Date: Thu, 8 Jan 2026 16:07:54 +0530
Subject: [PATCH 1/7] fix: handle object rendering in chat UI (#2725)

---
 .../w/[workflowId]/components/chat/chat.tsx   |  17 +-
 .../components/chat-message/chat-message.tsx  |  11 +-
 apps/sim/lib/core/utils/format-output.test.ts | 277 +++++++++++++++++
 apps/sim/lib/core/utils/format-output.ts      | 278 ++++++++++++++++++
 4 files changed, 563 insertions(+), 20 deletions(-)
 create mode 100644 apps/sim/lib/core/utils/format-output.test.ts
 create mode 100644 apps/sim/lib/core/utils/format-output.ts

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..5fc1afd475 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
@@ -2,6 +2,7 @@
 
 import { type KeyboardEvent, useCallback, useEffect, useMemo, useRef, useState } from 'react'
 import { createLogger } from '@sim/logger'
+import { formatOutputForWorkflow } from '@/lib/core/utils/format-output'
 import {
   AlertCircle,
   ArrowDownToLine,
@@ -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..1769314adf 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,5 +1,6 @@
 import { useMemo } from 'react'
 import { StreamingIndicator } from '@/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/copilot/components/copilot-message/components/smooth-streaming'
+import { formatOutputForChat } from '@/lib/core/utils/format-output'
 
 interface ChatAttachment {
   id: string
@@ -93,12 +94,10 @@ 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..17c0925732
--- /dev/null
+++ b/apps/sim/lib/core/utils/format-output.test.ts
@@ -0,0 +1,277 @@
+import { describe, expect, it, vi } from 'vitest'
+import {
+  formatOutputForDisplay,
+  formatOutputForChat,
+  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(result).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 = { data: 'test' }
+
+      const chatFormat = formatOutputForDisplay(obj, { mode: 'chat' })
+      expect(chatFormat).toContain('test')
+
+      const workflowFormat = formatOutputForDisplay(obj, { mode: 'workflow' })
+      expect(workflowFormat).toMatch(/```json/)
+
+      const rawFormat = formatOutputForDisplay(obj, { mode: 'raw' })
+      expect(rawFormat).toBe('{"data":"test"}')
+    })
+
+    // 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')
+    })
+  })
+})
\ No newline at end of file
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..3b8634d92d
--- /dev/null
+++ b/apps/sim/lib/core/utils/format-output.ts
@@ -0,0 +1,278 @@
+import { createLogger } from '@sim/logger'
+
+const logger = createLogger('FormatOutput')
+
+// Cache for circular reference detection
+const seenObjects = new WeakSet()
+
+// Common text field names to search for
+const TEXT_FIELD_NAMES = [
+  'text', 'content', 'message', 'body', 'value', 'result',
+  'output', 'response', 'answer', 'reply', 'data'
+] as const
+
+// Maximum depth for recursive traversal
+const MAX_DEPTH = 10
+const MAX_STRING_LENGTH = 50000
+const MAX_ARRAY_ITEMS = 1000
+
+/**
+ * Deep traversal to find text content in nested structures
+ */
+function deepExtractText(
+  obj: any,
+  depth = 0,
+  visited = new Set<any>()
+): string | null {
+  // Prevent infinite recursion
+  if (depth > MAX_DEPTH) return null
+  if (!obj || typeof obj !== 'object') return null
+  if (visited.has(obj)) return null
+
+  visited.add(obj)
+
+  try {
+    // Check direct text fields first
+    for (const field of TEXT_FIELD_NAMES) {
+      if (field in obj) {
+        const value = obj[field]
+        if (typeof value === 'string' && value.trim()) {
+          return value
+        }
+        // Recursively check if the field itself contains text
+        const nestedText = deepExtractText(value, depth + 1, visited)
+        if (nestedText) return nestedText
+      }
+    }
+
+    // Check for toString method (custom objects)
+    if (typeof obj.toString === 'function' && obj.toString !== Object.prototype.toString) {
+      const str = obj.toString()
+      if (str && str !== '[object Object]') {
+        return str
+      }
+    }
+
+    // Traverse nested objects
+    for (const key in obj) {
+      if (obj.hasOwnProperty(key)) {
+        const nestedText = deepExtractText(obj[key], depth + 1, visited)
+        if (nestedText) return nestedText
+      }
+    }
+  } catch (error) {
+    logger.debug('Error during deep text extraction', { error })
+  }
+
+  return null
+}
+
+/**
+ * Safely stringify with circular reference handling
+ */
+function safeStringify(obj: any, indent = 2): string {
+  const seen = new Set()
+
+  try {
+    return JSON.stringify(obj, (key, value) => {
+      // Handle undefined, functions, symbols
+      if (value === undefined) return '[undefined]'
+      if (typeof value === 'function') return '[Function]'
+      if (typeof value === 'symbol') return '[Symbol]'
+
+      // Handle BigInt
+      if (typeof value === 'bigint') return value.toString()
+
+      // Handle circular references
+      if (typeof value === 'object' && value !== null) {
+        if (seen.has(value)) return '[Circular]'
+        seen.add(value)
+      }
+
+      return value
+    }, indent)
+  } catch (error) {
+    logger.warn('Failed to stringify object', { error })
+    return '[Serialization Error]'
+  }
+}
+
+/**
+ * Extract meaningful content from various output formats
+ */
+function extractContent(item: any): string | null {
+  // Primitives
+  if (item === null || item === undefined) return null
+  if (typeof item === 'string') return item.trim() || null
+  if (typeof item === 'number' || typeof item === 'boolean') return String(item)
+  if (typeof item === 'bigint') return item.toString()
+
+  // Special objects
+  if (item instanceof Date) return item.toISOString()
+  if (item instanceof Error) return item.message || item.toString()
+  if (item instanceof RegExp) return item.toString()
+
+  // Buffer or Uint8Array (might be binary data)
+  if (Buffer.isBuffer(item) || item instanceof Uint8Array) {
+    try {
+      // Try to decode as UTF-8
+      const text = Buffer.from(item).toString('utf-8')
+      // Check if it's actually readable text
+      if (/^[\x20-\x7E\s]+$/.test(text)) {
+        return text
+      }
+    } catch {}
+    return '[Binary Data]'
+  }
+
+  // Arrays - process recursively
+  if (Array.isArray(item)) {
+    if (item.length > MAX_ARRAY_ITEMS) {
+      return `[Large Array: ${item.length} items]`
+    }
+
+    const contents = item
+      .slice(0, MAX_ARRAY_ITEMS)
+      .map(extractContent)
+      .filter(Boolean)
+
+    return contents.length > 0 ? contents.join('\n') : null
+  }
+
+  // Objects - try deep extraction
+  if (typeof item === 'object') {
+    return deepExtractText(item)
+  }
+
+  return null
+}
+
+/**
+ * Main formatting function - BEAST MODE
+ */
+export function formatOutputForDisplay(
+  output: unknown,
+  options: {
+    mode?: 'chat' | 'workflow' | 'raw'
+    maxLength?: number
+    truncate?: boolean
+    preserveWhitespace?: boolean
+  } = {}
+): string {
+  const {
+    mode = 'chat',
+    maxLength = MAX_STRING_LENGTH,
+    truncate = true,
+    preserveWhitespace = false
+  } = options
+
+  try {
+    // Quick return for simple cases
+    if (!output && output !== 0 && output !== false) return ''
+
+    // Try to extract content
+    const extracted = extractContent(output)
+
+    if (extracted) {
+      let result = extracted
+
+      // Apply length limits
+      if (truncate && result.length > maxLength) {
+        result = result.substring(0, maxLength) + '... [truncated]'
+      }
+
+      // Clean whitespace unless preserved
+      if (!preserveWhitespace) {
+        result = result.replace(/\s+/g, ' ').trim()
+      }
+
+      return result
+    }
+
+    // Fallback to JSON representation
+    const json = safeStringify(output)
+
+    // Apply formatting based on mode
+    switch (mode) {
+      case 'workflow':
+        return `\`\`\`json\n${json}\n\`\`\``
+      case 'raw':
+        return json
+      case 'chat':
+      default:
+        // For chat, try to make it more readable
+        if (json.length > 500) {
+          return '[Complex Object - See logs for details]'
+        }
+        return json
+    }
+  } catch (error) {
+    logger.error('Critical error in formatOutputForDisplay', { error, output })
+    return '[Display Error]'
+  }
+}
+
+/**
+ * Specialized formatters with sensible defaults
+ */
+export const formatOutputForChat = (output: unknown) =>
+  formatOutputForDisplay(output, {
+    mode: 'chat',
+    maxLength: 5000,
+    truncate: true
+  })
+
+export const formatOutputForWorkflow = (output: unknown) =>
+  formatOutputForDisplay(output, {
+    mode: 'workflow',
+    maxLength: 10000,
+    truncate: true
+  })
+
+export const formatOutputRaw = (output: unknown) =>
+  formatOutputForDisplay(output, {
+    mode: 'raw',
+    truncate: false,
+    preserveWhitespace: true
+  })
+
+/**
+ * Validate and sanitize output before display
+ */
+export function isOutputSafe(output: unknown): boolean {
+  try {
+    // Check for potential XSS patterns
+    const str = String(output)
+    const dangerous = [
+      /<script/i,
+      /javascript:/i,
+      /on\w+\s*=/i, // onclick, onload, etc.
+      /<iframe/i,
+      /<embed/i,
+      /<object/i
+    ]
+
+    return !dangerous.some(pattern => pattern.test(str))
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Format with HTML escaping for safety
+ */
+export function formatOutputSafe(output: unknown): string {
+  const formatted = formatOutputForDisplay(output)
+
+  if (!isOutputSafe(formatted)) {
+    logger.warn('Potentially unsafe output detected, escaping HTML')
+    return formatted
+      .replace(/&/g, '&amp;')
+      .replace(/</g, '&lt;')
+      .replace(/>/g, '&gt;')
+      .replace(/"/g, '&quot;')
+      .replace(/'/g, '&#x27;')
+  }
+
+  return formatted
+}
\ No newline at end of file

From 24a523018b6b23672d0b3e0801fda7200086ac8f Mon Sep 17 00:00:00 2001
From: Patel230 <Lakshmanp230@gmail.com>
Date: Thu, 8 Jan 2026 16:20:39 +0530
Subject: [PATCH 2/7] fix: address code review feedback

- Remove unused seenObjects variable
- Use Object.entries instead of for...in for better performance
- Join arrays with spaces instead of newlines for better chat UI layout
- Improve whitespace normalization to preserve code formatting
---
 apps/sim/lib/core/utils/format-output.ts | 23 ++++++++++-------------
 1 file changed, 10 insertions(+), 13 deletions(-)

diff --git a/apps/sim/lib/core/utils/format-output.ts b/apps/sim/lib/core/utils/format-output.ts
index 3b8634d92d..f450932b5c 100644
--- a/apps/sim/lib/core/utils/format-output.ts
+++ b/apps/sim/lib/core/utils/format-output.ts
@@ -2,9 +2,6 @@ import { createLogger } from '@sim/logger'
 
 const logger = createLogger('FormatOutput')
 
-// Cache for circular reference detection
-const seenObjects = new WeakSet()
-
 // Common text field names to search for
 const TEXT_FIELD_NAMES = [
   'text', 'content', 'message', 'body', 'value', 'result',
@@ -53,12 +50,10 @@ function deepExtractText(
       }
     }
 
-    // Traverse nested objects
-    for (const key in obj) {
-      if (obj.hasOwnProperty(key)) {
-        const nestedText = deepExtractText(obj[key], depth + 1, visited)
-        if (nestedText) return nestedText
-      }
+    // Traverse nested objects using Object.entries for better performance
+    for (const [key, value] of Object.entries(obj)) {
+      const nestedText = deepExtractText(value, depth + 1, visited)
+      if (nestedText) return nestedText
     }
   } catch (error) {
     logger.debug('Error during deep text extraction', { error })
@@ -136,7 +131,8 @@ function extractContent(item: any): string | null {
       .map(extractContent)
       .filter(Boolean)
 
-    return contents.length > 0 ? contents.join('\n') : null
+    // Join with space for inline display in chat UI
+    return contents.length > 0 ? contents.join(' ') : null
   }
 
   // Objects - try deep extraction
@@ -181,9 +177,10 @@ export function formatOutputForDisplay(
         result = result.substring(0, maxLength) + '... [truncated]'
       }
 
-      // Clean whitespace unless preserved
-      if (!preserveWhitespace) {
-        result = result.replace(/\s+/g, ' ').trim()
+      // Clean whitespace unless preserved (but keep code formatting intact)
+      if (!preserveWhitespace && mode !== 'workflow') {
+        // Only normalize multiple spaces/tabs to single space, preserve newlines for readability
+        result = result.replace(/[ \t]+/g, ' ').trim()
       }
 
       return result

From c701c09a8a11a1d2248abd2ed70c21068651de25 Mon Sep 17 00:00:00 2001
From: Patel230 <Lakshmanp230@gmail.com>
Date: Thu, 8 Jan 2026 16:26:25 +0530
Subject: [PATCH 3/7] fix: resolve linting errors

---
 apps/sim/lib/core/utils/format-output.ts | 81 ++++++++++++++----------
 1 file changed, 46 insertions(+), 35 deletions(-)

diff --git a/apps/sim/lib/core/utils/format-output.ts b/apps/sim/lib/core/utils/format-output.ts
index f450932b5c..ef265d74ef 100644
--- a/apps/sim/lib/core/utils/format-output.ts
+++ b/apps/sim/lib/core/utils/format-output.ts
@@ -4,8 +4,17 @@ const logger = createLogger('FormatOutput')
 
 // Common text field names to search for
 const TEXT_FIELD_NAMES = [
-  'text', 'content', 'message', 'body', 'value', 'result',
-  'output', 'response', 'answer', 'reply', 'data'
+  'text',
+  'content',
+  'message',
+  'body',
+  'value',
+  'result',
+  'output',
+  'response',
+  'answer',
+  'reply',
+  'data',
 ] as const
 
 // Maximum depth for recursive traversal
@@ -16,11 +25,7 @@ const MAX_ARRAY_ITEMS = 1000
 /**
  * Deep traversal to find text content in nested structures
  */
-function deepExtractText(
-  obj: any,
-  depth = 0,
-  visited = new Set<any>()
-): string | null {
+function deepExtractText(obj: any, depth = 0, visited = new Set<any>()): string | null {
   // Prevent infinite recursion
   if (depth > MAX_DEPTH) return null
   if (!obj || typeof obj !== 'object') return null
@@ -69,23 +74,27 @@ function safeStringify(obj: any, indent = 2): string {
   const seen = new Set()
 
   try {
-    return JSON.stringify(obj, (key, value) => {
-      // Handle undefined, functions, symbols
-      if (value === undefined) return '[undefined]'
-      if (typeof value === 'function') return '[Function]'
-      if (typeof value === 'symbol') return '[Symbol]'
-
-      // Handle BigInt
-      if (typeof value === 'bigint') return value.toString()
-
-      // Handle circular references
-      if (typeof value === 'object' && value !== null) {
-        if (seen.has(value)) return '[Circular]'
-        seen.add(value)
-      }
+    return JSON.stringify(
+      obj,
+      (key, value) => {
+        // Handle undefined, functions, symbols
+        if (value === undefined) return '[undefined]'
+        if (typeof value === 'function') return '[Function]'
+        if (typeof value === 'symbol') return '[Symbol]'
+
+        // Handle BigInt
+        if (typeof value === 'bigint') return value.toString()
+
+        // Handle circular references
+        if (typeof value === 'object' && value !== null) {
+          if (seen.has(value)) return '[Circular]'
+          seen.add(value)
+        }
 
-      return value
-    }, indent)
+        return value
+      },
+      indent
+    )
   } catch (error) {
     logger.warn('Failed to stringify object', { error })
     return '[Serialization Error]'
@@ -126,10 +135,7 @@ function extractContent(item: any): string | null {
       return `[Large Array: ${item.length} items]`
     }
 
-    const contents = item
-      .slice(0, MAX_ARRAY_ITEMS)
-      .map(extractContent)
-      .filter(Boolean)
+    const contents = item.slice(0, MAX_ARRAY_ITEMS).map(extractContent).filter(Boolean)
 
     // Join with space for inline display in chat UI
     return contents.length > 0 ? contents.join(' ') : null
@@ -159,7 +165,7 @@ export function formatOutputForDisplay(
     mode = 'chat',
     maxLength = MAX_STRING_LENGTH,
     truncate = true,
-    preserveWhitespace = false
+    preserveWhitespace = false,
   } = options
 
   try {
@@ -174,7 +180,7 @@ export function formatOutputForDisplay(
 
       // Apply length limits
       if (truncate && result.length > maxLength) {
-        result = result.substring(0, maxLength) + '... [truncated]'
+        result = `${result.substring(0, maxLength)}... [truncated]`
       }
 
       // Clean whitespace unless preserved (but keep code formatting intact)
@@ -196,6 +202,11 @@ export function formatOutputForDisplay(
       case 'raw':
         return json
       case 'chat':
+        // For chat, try to make it more readable
+        if (json.length > 500) {
+          return '[Complex Object - See logs for details]'
+        }
+        return json
       default:
         // For chat, try to make it more readable
         if (json.length > 500) {
@@ -216,21 +227,21 @@ export const formatOutputForChat = (output: unknown) =>
   formatOutputForDisplay(output, {
     mode: 'chat',
     maxLength: 5000,
-    truncate: true
+    truncate: true,
   })
 
 export const formatOutputForWorkflow = (output: unknown) =>
   formatOutputForDisplay(output, {
     mode: 'workflow',
     maxLength: 10000,
-    truncate: true
+    truncate: true,
   })
 
 export const formatOutputRaw = (output: unknown) =>
   formatOutputForDisplay(output, {
     mode: 'raw',
     truncate: false,
-    preserveWhitespace: true
+    preserveWhitespace: true,
   })
 
 /**
@@ -246,10 +257,10 @@ export function isOutputSafe(output: unknown): boolean {
       /on\w+\s*=/i, // onclick, onload, etc.
       /<iframe/i,
       /<embed/i,
-      /<object/i
+      /<object/i,
     ]
 
-    return !dangerous.some(pattern => pattern.test(str))
+    return !dangerous.some((pattern) => pattern.test(str))
   } catch {
     return false
   }
@@ -272,4 +283,4 @@ export function formatOutputSafe(output: unknown): string {
   }
 
   return formatted
-}
\ No newline at end of file
+}

From 9c6657eee5f50eafac07059dc92fcbad0ed3a4e8 Mon Sep 17 00:00:00 2001
From: Patel230 <Lakshmanp230@gmail.com>
Date: Thu, 8 Jan 2026 16:34:59 +0530
Subject: [PATCH 4/7] refactor: optimize format-output utility

---
 apps/sim/lib/core/utils/format-output.test.ts |  17 +-
 apps/sim/lib/core/utils/format-output.ts      | 332 +++++++++---------
 2 files changed, 178 insertions(+), 171 deletions(-)

diff --git a/apps/sim/lib/core/utils/format-output.test.ts b/apps/sim/lib/core/utils/format-output.test.ts
index 17c0925732..32f9899d62 100644
--- a/apps/sim/lib/core/utils/format-output.test.ts
+++ b/apps/sim/lib/core/utils/format-output.test.ts
@@ -88,7 +88,7 @@ describe('format-output utilities', () => {
       obj.self = obj
       const result = formatOutputForDisplay(obj, { mode: 'raw' })
       expect(result).toContain('[Circular]')
-      expect(result).not.toThrow()
+      expect(() => formatOutputForDisplay(obj, { mode: 'raw' })).not.toThrow()
     })
 
     // Large arrays
@@ -126,16 +126,21 @@ describe('format-output utilities', () => {
 
     // Mode-specific formatting
     it('formats correctly for different modes', () => {
-      const obj = { data: 'test' }
+      const obj = { someField: 'value', type: 'test' }
 
       const chatFormat = formatOutputForDisplay(obj, { mode: 'chat' })
-      expect(chatFormat).toContain('test')
-
       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')
 
-      const rawFormat = formatOutputForDisplay(obj, { mode: 'raw' })
-      expect(rawFormat).toBe('{"data":"test"}')
+      // Raw mode should show plain JSON
+      expect(rawFormat).toMatch(/"someField":\s*"value"/)
     })
 
     // Edge cases
diff --git a/apps/sim/lib/core/utils/format-output.ts b/apps/sim/lib/core/utils/format-output.ts
index ef265d74ef..77a2e5e5a0 100644
--- a/apps/sim/lib/core/utils/format-output.ts
+++ b/apps/sim/lib/core/utils/format-output.ts
@@ -2,164 +2,170 @@ import { createLogger } from '@sim/logger'
 
 const logger = createLogger('FormatOutput')
 
-// Common text field names to search for
-const TEXT_FIELD_NAMES = [
-  'text',
-  'content',
-  'message',
-  'body',
-  'value',
-  'result',
-  'output',
-  'response',
-  'answer',
-  'reply',
-  'data',
+// 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
 
-// Maximum depth for recursive traversal
-const MAX_DEPTH = 10
 const MAX_STRING_LENGTH = 50000
-const MAX_ARRAY_ITEMS = 1000
+const MAX_ARRAY_ITEMS = 100
+const MAX_DEPTH = 5
 
 /**
- * Deep traversal to find text content in nested structures
+ * Extract text content from common LLM response formats
  */
-function deepExtractText(obj: any, depth = 0, visited = new Set<any>()): string | null {
-  // Prevent infinite recursion
+function extractText(value: unknown, depth = 0): string | null {
+  // Guard against deep recursion
   if (depth > MAX_DEPTH) return null
-  if (!obj || typeof obj !== 'object') return null
-  if (visited.has(obj)) return null
 
-  visited.add(obj)
+  // 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()
 
-  try {
-    // Check direct text fields first
-    for (const field of TEXT_FIELD_NAMES) {
+  // 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 value = obj[field]
-        if (typeof value === 'string' && value.trim()) {
-          return value
+        const fieldValue = obj[field]
+        if (typeof fieldValue === 'string' && fieldValue) {
+          return fieldValue
         }
-        // Recursively check if the field itself contains text
-        const nestedText = deepExtractText(value, depth + 1, visited)
-        if (nestedText) return nestedText
       }
     }
 
-    // Check for toString method (custom objects)
-    if (typeof obj.toString === 'function' && obj.toString !== Object.prototype.toString) {
-      const str = obj.toString()
-      if (str && str !== '[object Object]') {
-        return str
-      }
+    // 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
     }
 
-    // Traverse nested objects using Object.entries for better performance
+    // 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)) {
-      const nestedText = deepExtractText(value, depth + 1, visited)
-      if (nestedText) return nestedText
+      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
     }
-  } catch (error) {
-    logger.debug('Error during deep text extraction', { error })
   }
 
   return null
 }
 
 /**
- * Safely stringify with circular reference handling
+ * Safely stringify objects for fallback display
  */
-function safeStringify(obj: any, indent = 2): string {
-  const seen = new Set()
-
+function safeStringify(value: unknown): string {
   try {
-    return JSON.stringify(
-      obj,
-      (key, value) => {
-        // Handle undefined, functions, symbols
-        if (value === undefined) return '[undefined]'
-        if (typeof value === 'function') return '[Function]'
-        if (typeof value === 'symbol') return '[Symbol]'
-
-        // Handle BigInt
-        if (typeof value === 'bigint') return value.toString()
-
-        // Handle circular references
-        if (typeof value === 'object' && value !== null) {
-          if (seen.has(value)) return '[Circular]'
-          seen.add(value)
-        }
-
-        return value
-      },
-      indent
-    )
-  } catch (error) {
-    logger.warn('Failed to stringify object', { error })
-    return '[Serialization Error]'
-  }
-}
-
-/**
- * Extract meaningful content from various output formats
- */
-function extractContent(item: any): string | null {
-  // Primitives
-  if (item === null || item === undefined) return null
-  if (typeof item === 'string') return item.trim() || null
-  if (typeof item === 'number' || typeof item === 'boolean') return String(item)
-  if (typeof item === 'bigint') return item.toString()
-
-  // Special objects
-  if (item instanceof Date) return item.toISOString()
-  if (item instanceof Error) return item.message || item.toString()
-  if (item instanceof RegExp) return item.toString()
-
-  // Buffer or Uint8Array (might be binary data)
-  if (Buffer.isBuffer(item) || item instanceof Uint8Array) {
-    try {
-      // Try to decode as UTF-8
-      const text = Buffer.from(item).toString('utf-8')
-      // Check if it's actually readable text
-      if (/^[\x20-\x7E\s]+$/.test(text)) {
-        return text
+    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)
       }
-    } catch {}
-    return '[Binary Data]'
-  }
 
-  // Arrays - process recursively
-  if (Array.isArray(item)) {
-    if (item.length > MAX_ARRAY_ITEMS) {
-      return `[Large Array: ${item.length} items]`
-    }
-
-    const contents = item.slice(0, MAX_ARRAY_ITEMS).map(extractContent).filter(Boolean)
-
-    // Join with space for inline display in chat UI
-    return contents.length > 0 ? contents.join(' ') : null
-  }
-
-  // Objects - try deep extraction
-  if (typeof item === 'object') {
-    return deepExtractText(item)
+      return val
+    }, 2)
+  } catch (error) {
+    logger.debug('Stringify failed', { error })
+    return '[Unable to display]'
   }
-
-  return null
 }
 
 /**
- * Main formatting function - BEAST MODE
+ * Format output for display with smart text extraction
+ * Optimized for performance and common use cases
  */
 export function formatOutputForDisplay(
   output: unknown,
-  options: {
-    mode?: 'chat' | 'workflow' | 'raw'
-    maxLength?: number
-    truncate?: boolean
-    preserveWhitespace?: boolean
-  } = {}
+  options: FormatOptions = {}
 ): string {
   const {
     mode = 'chat',
@@ -169,75 +175,72 @@ export function formatOutputForDisplay(
   } = options
 
   try {
-    // Quick return for simple cases
+    // Early return for empty values
     if (!output && output !== 0 && output !== false) return ''
 
-    // Try to extract content
-    const extracted = extractContent(output)
+    // Try to extract text content
+    const text = extractText(output)
 
-    if (extracted) {
-      let result = extracted
+    if (text) {
+      let result = text
 
-      // Apply length limits
+      // Apply length limit
       if (truncate && result.length > maxLength) {
         result = `${result.substring(0, maxLength)}... [truncated]`
       }
 
-      // Clean whitespace unless preserved (but keep code formatting intact)
-      if (!preserveWhitespace && mode !== 'workflow') {
-        // Only normalize multiple spaces/tabs to single space, preserve newlines for readability
-        result = result.replace(/[ \t]+/g, ' ').trim()
+      // 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 representation
+    // Fallback to JSON for complex objects
     const json = safeStringify(output)
 
-    // Apply formatting based on mode
-    switch (mode) {
-      case 'workflow':
-        return `\`\`\`json\n${json}\n\`\`\``
-      case 'raw':
-        return json
-      case 'chat':
-        // For chat, try to make it more readable
-        if (json.length > 500) {
-          return '[Complex Object - See logs for details]'
-        }
-        return json
-      default:
-        // For chat, try to make it more readable
-        if (json.length > 500) {
-          return '[Complex Object - See logs for details]'
-        }
-        return json
+    // 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('Critical error in formatOutputForDisplay', { error, output })
+    logger.error('Format error', { error })
     return '[Display Error]'
   }
 }
 
 /**
- * Specialized formatters with sensible defaults
+ * Specialized formatters with optimized defaults
  */
-export const formatOutputForChat = (output: unknown) =>
+export const formatOutputForChat = (output: unknown): string =>
   formatOutputForDisplay(output, {
     mode: 'chat',
     maxLength: 5000,
     truncate: true,
   })
 
-export const formatOutputForWorkflow = (output: unknown) =>
+export const formatOutputForWorkflow = (output: unknown): string =>
   formatOutputForDisplay(output, {
     mode: 'workflow',
     maxLength: 10000,
     truncate: true,
   })
 
-export const formatOutputRaw = (output: unknown) =>
+export const formatOutputRaw = (output: unknown): string =>
   formatOutputForDisplay(output, {
     mode: 'raw',
     truncate: false,
@@ -245,35 +248,34 @@ export const formatOutputRaw = (output: unknown) =>
   })
 
 /**
- * Validate and sanitize output before display
+ * Check for potential XSS patterns in output
  */
 export function isOutputSafe(output: unknown): boolean {
   try {
-    // Check for potential XSS patterns
     const str = String(output)
-    const dangerous = [
+    const xssPatterns = [
       /<script/i,
       /javascript:/i,
-      /on\w+\s*=/i, // onclick, onload, etc.
+      /on\w+\s*=/i,
       /<iframe/i,
       /<embed/i,
       /<object/i,
     ]
 
-    return !dangerous.some((pattern) => pattern.test(str))
+    return !xssPatterns.some((pattern) => pattern.test(str))
   } catch {
     return false
   }
 }
 
 /**
- * Format with HTML escaping for safety
+ * Format output with HTML escaping for safety
  */
 export function formatOutputSafe(output: unknown): string {
   const formatted = formatOutputForDisplay(output)
 
   if (!isOutputSafe(formatted)) {
-    logger.warn('Potentially unsafe output detected, escaping HTML')
+    logger.warn('Unsafe content detected, escaping')
     return formatted
       .replace(/&/g, '&amp;')
       .replace(/</g, '&lt;')
@@ -283,4 +285,4 @@ export function formatOutputSafe(output: unknown): string {
   }
 
   return formatted
-}
+}
\ No newline at end of file

From 98d67c90dbf2a65387504aa7c0a3bddd97927ca6 Mon Sep 17 00:00:00 2001
From: Patel230 <Lakshmanp230@gmail.com>
Date: Thu, 8 Jan 2026 16:37:55 +0530
Subject: [PATCH 5/7] fix: linting issues

---
 .../components/chat/components/chat-message/chat-message.tsx   | 3 ++-
 apps/sim/lib/core/utils/format-output.test.ts                  | 2 +-
 2 files changed, 3 insertions(+), 2 deletions(-)

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 1769314adf..d7b719595c 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,6 +1,7 @@
 import { useMemo } from 'react'
-import { StreamingIndicator } from '@/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/copilot/components/copilot-message/components/smooth-streaming'
+
 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 {
   id: string
diff --git a/apps/sim/lib/core/utils/format-output.test.ts b/apps/sim/lib/core/utils/format-output.test.ts
index 32f9899d62..ac71897318 100644
--- a/apps/sim/lib/core/utils/format-output.test.ts
+++ b/apps/sim/lib/core/utils/format-output.test.ts
@@ -1,4 +1,4 @@
-import { describe, expect, it, vi } from 'vitest'
+import { describe, expect, it } from 'vitest'
 import {
   formatOutputForDisplay,
   formatOutputForChat,

From 6620206243baabe27a1c0c42a62e9b0b27119b2b Mon Sep 17 00:00:00 2001
From: Patel230 <Lakshmanp230@gmail.com>
Date: Thu, 8 Jan 2026 16:57:55 +0530
Subject: [PATCH 6/7] fix: formatting and imports

---
 .../w/[workflowId]/components/chat/chat.tsx   |  2 +-
 .../components/chat-message/chat-message.tsx  |  6 +-
 apps/sim/lib/core/utils/format-output.test.ts | 85 +++++++++----------
 apps/sim/lib/core/utils/format-output.ts      | 65 +++++++++-----
 4 files changed, 86 insertions(+), 72 deletions(-)

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 5fc1afd475..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
@@ -2,7 +2,6 @@
 
 import { type KeyboardEvent, useCallback, useEffect, useMemo, useRef, useState } from 'react'
 import { createLogger } from '@sim/logger'
-import { formatOutputForWorkflow } from '@/lib/core/utils/format-output'
 import {
   AlertCircle,
   ArrowDownToLine,
@@ -25,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,
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 d7b719595c..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,5 +1,4 @@
 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'
 
@@ -95,10 +94,7 @@ const WordWrap = ({ text }: { text: string }) => {
  * Renders a chat message with optional file attachments
  */
 export function ChatMessage({ message }: ChatMessageProps) {
-  const formattedContent = useMemo(
-    () => formatOutputForChat(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
index ac71897318..471ed02230 100644
--- a/apps/sim/lib/core/utils/format-output.test.ts
+++ b/apps/sim/lib/core/utils/format-output.test.ts
@@ -1,11 +1,11 @@
 import { describe, expect, it } from 'vitest'
 import {
-  formatOutputForDisplay,
   formatOutputForChat,
+  formatOutputForDisplay,
   formatOutputForWorkflow,
   formatOutputRaw,
   formatOutputSafe,
-  isOutputSafe
+  isOutputSafe,
 } from './format-output'
 
 describe('format-output utilities', () => {
@@ -37,32 +37,22 @@ describe('format-output utilities', () => {
         data: {
           response: {
             message: {
-              content: 'Deep text'
-            }
-          }
-        }
+              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' }
-      ]
+      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' }
-      ]
+      const mixed = ['String', { text: 'Object text' }, 123, null, { message: 'Message text' }]
       expect(formatOutputForDisplay(mixed)).toBe('String Object text 123 Message text')
     })
 
@@ -103,7 +93,7 @@ describe('format-output utilities', () => {
       const buffer = Buffer.from('Hello Buffer')
       expect(formatOutputForDisplay(buffer)).toBe('Hello Buffer')
 
-      const binaryBuffer = Buffer.from([0xFF, 0xFE, 0x00, 0x01])
+      const binaryBuffer = Buffer.from([0xff, 0xfe, 0x00, 0x01])
       expect(formatOutputForDisplay(binaryBuffer)).toBe('[Binary Data]')
     })
 
@@ -118,10 +108,12 @@ describe('format-output utilities', () => {
     // 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')
+      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
@@ -148,7 +140,7 @@ describe('format-output utilities', () => {
       const customObj = {
         toString() {
           return 'Custom String'
-        }
+        },
       }
       expect(formatOutputForDisplay(customObj)).toBe('Custom String')
     })
@@ -157,7 +149,7 @@ describe('format-output utilities', () => {
       const obj = {
         func: () => console.log('test'),
         undef: undefined,
-        sym: Symbol('test')
+        sym: Symbol('test'),
       }
       const result = formatOutputForDisplay(obj, { mode: 'raw' })
       expect(result).toContain('[Function]')
@@ -214,11 +206,14 @@ describe('format-output utilities', () => {
   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 evil = new Proxy(
+        {},
+        {
+          get() {
+            throw new Error('Evil object!')
+          },
         }
-      })
+      )
 
       const result = formatOutputForDisplay(evil)
       expect(result).toContain('[')
@@ -241,20 +236,24 @@ describe('format-output utilities', () => {
   describe('real-world LLM outputs', () => {
     it('handles OpenAI format', () => {
       const openAIResponse = {
-        choices: [{
-          message: {
-            content: 'AI response here'
-          }
-        }]
+        choices: [
+          {
+            message: {
+              content: 'AI response here',
+            },
+          },
+        ],
       }
       expect(formatOutputForDisplay(openAIResponse)).toBe('AI response here')
     })
 
     it('handles Anthropic format', () => {
       const anthropicResponse = {
-        content: [{
-          text: 'Claude response'
-        }]
+        content: [
+          {
+            text: 'Claude response',
+          },
+        ],
       }
       expect(formatOutputForDisplay(anthropicResponse)).toBe('Claude response')
     })
@@ -262,8 +261,8 @@ describe('format-output utilities', () => {
     it('handles streaming chunks', () => {
       const chunk = {
         delta: {
-          content: 'Streaming text'
-        }
+          content: 'Streaming text',
+        },
       }
       expect(formatOutputForDisplay(chunk)).toBe('Streaming text')
     })
@@ -272,11 +271,11 @@ describe('format-output utilities', () => {
       const toolOutput = {
         result: {
           data: {
-            output: 'Tool execution result'
-          }
-        }
+            output: 'Tool execution result',
+          },
+        },
       }
       expect(formatOutputForDisplay(toolOutput)).toBe('Tool execution result')
     })
   })
-})
\ No newline at end of file
+})
diff --git a/apps/sim/lib/core/utils/format-output.ts b/apps/sim/lib/core/utils/format-output.ts
index 77a2e5e5a0..11620d25d6 100644
--- a/apps/sim/lib/core/utils/format-output.ts
+++ b/apps/sim/lib/core/utils/format-output.ts
@@ -3,7 +3,18 @@ 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 TextFieldName =
+  | 'text'
+  | 'content'
+  | 'message'
+  | 'body'
+  | 'value'
+  | 'result'
+  | 'output'
+  | 'response'
+  | 'answer'
+  | 'reply'
+  | 'data'
 type FormatMode = 'chat' | 'workflow' | 'raw'
 
 interface FormatOptions {
@@ -30,8 +41,17 @@ interface TextExtractable {
 
 // Constants
 const TEXT_FIELDS: readonly TextFieldName[] = [
-  'text', 'content', 'message', 'body', 'value', 'result',
-  'output', 'response', 'answer', 'reply', 'data',
+  'text',
+  'content',
+  'message',
+  'body',
+  'value',
+  'result',
+  'output',
+  'response',
+  'answer',
+  'reply',
+  'data',
 ] as const
 
 const MAX_STRING_LENGTH = 50000
@@ -76,9 +96,7 @@ function extractText(value: unknown, depth = 0): string | null {
     }
 
     // For arrays, concatenate all text content
-    const texts = value
-      .map(item => extractText(item, depth + 1))
-      .filter(Boolean)
+    const texts = value.map((item) => extractText(item, depth + 1)).filter(Boolean)
 
     return texts.length > 0 ? texts.join(' ') : null
   }
@@ -140,19 +158,23 @@ function extractText(value: unknown, depth = 0): string | null {
 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 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)
+        return val
+      },
+      2
+    )
   } catch (error) {
     logger.debug('Stringify failed', { error })
     return '[Unable to display]'
@@ -163,10 +185,7 @@ function safeStringify(value: unknown): string {
  * Format output for display with smart text extraction
  * Optimized for performance and common use cases
  */
-export function formatOutputForDisplay(
-  output: unknown,
-  options: FormatOptions = {}
-): string {
+export function formatOutputForDisplay(output: unknown, options: FormatOptions = {}): string {
   const {
     mode = 'chat',
     maxLength = MAX_STRING_LENGTH,
@@ -285,4 +304,4 @@ export function formatOutputSafe(output: unknown): string {
   }
 
   return formatted
-}
\ No newline at end of file
+}

From 7211a0d346452f9dca3331c6b3f07bdf11fb5d71 Mon Sep 17 00:00:00 2001
From: Patel230 <Lakshmanp230@gmail.com>
Date: Thu, 8 Jan 2026 17:08:49 +0530
Subject: [PATCH 7/7] chore: trigger Vercel deployment