added ordering functionality back into index #970

Author: Adam Gough

apps/sim/app/api/chat/utils.ts

@@ -747,14 +747,13 @@ export async function executeWorkflowForChat(
               log.output.content = separator + formattedOutput
               processedOutputs.add(log.blockId)
 
-              // Stream non-streaming workflow block outputs as chunks so the client sees them
-              // as a separate section, matching multi-agent behavior. Function synthetic streaming is
-              // handled inside the executor; avoid duplicating here.
+              // Stream non-streaming selected block outputs as chunks so the client sees them
+              // as a separate section, matching multi-agent behavior.
               const isSelected = selectedOutputIds.some((id) => {
                 const idBlock = id.includes('_') ? id.split('_')[0] : id.split('.')[0]
                 return idBlock === blockIdForOutput
               })
-              if ((log as any).blockType === 'workflow' && isSelected) {
+              if (isSelected) {
                 try {
                   // Only emit separator into the stream if at least one block has already streamed
                   if (streamedBlocks.size > 0) {
@@ -788,7 +787,7 @@ export async function executeWorkflowForChat(
                   )
                 } catch (e) {
                   logger.warn(
-                    `[${requestId}] Failed to stream non-streaming output for function block ${blockIdForOutput}`,
+                    `[${requestId}] Failed to stream non-streaming output for selected block ${blockIdForOutput}`,
                     e
                   )
                 }

apps/sim/executor/index.ts

@@ -1649,6 +1649,78 @@ export class Executor {
 
       context.blockLogs.push(blockLog)
 
+      try {
+        const blockType = block.metadata?.id
+        const isStreamingEnabled = Boolean(context.stream)
+        const hasOnStream = typeof context.onStream === 'function'
+        const isSelected = (context.selectedOutputIds || []).some((outputId) => {
+          if (outputId === block.id) return true
+          const underscoreIdx = outputId.indexOf('_')
+          const dotIdx = outputId.indexOf('.')
+          if (underscoreIdx !== -1) return outputId.substring(0, underscoreIdx) === block.id
+          if (dotIdx !== -1) return outputId.substring(0, dotIdx) === block.id
+          return false
+        })
+
+        // Exclude infra/router/agent (agents already stream from handlers)
+        const excludedTypes = new Set([
+          BlockType.LOOP,
+          BlockType.PARALLEL,
+          BlockType.CONDITION,
+          BlockType.ROUTER,
+          BlockType.STARTER,
+          BlockType.WEBHOOK_TRIGGER,
+          BlockType.SCHEDULE,
+          BlockType.AGENT,
+        ])
+        const isEligible = !!blockType && !excludedTypes.has(blockType as any)
+
+        if (isEligible && isStreamingEnabled && hasOnStream && isSelected) {
+          const out = output as any
+          let formatted: string
+          if (typeof out?.result !== 'undefined') {
+            formatted =
+              typeof out.result === 'string' ? out.result : JSON.stringify(out.result, null, 2)
+          } else if (typeof out?.content === 'string') {
+            formatted = out.content
+          } else if (typeof out?.stdout === 'string' && out.stdout) {
+            formatted = out.stdout
+          } else if (typeof out?.data !== 'undefined') {
+            formatted = typeof out.data === 'string' ? out.data : JSON.stringify(out.data, null, 2)
+          } else if (typeof out?.response?.data !== 'undefined') {
+            const d = out.response.data
+            formatted = typeof d === 'string' ? d : JSON.stringify(d, null, 2)
+          } else {
+            formatted = typeof out === 'string' ? out : JSON.stringify(out ?? {}, null, 2)
+          }
+
+          const syntheticStream = new ReadableStream({
+            start(controller) {
+              const enc = new TextEncoder()
+              controller.enqueue(enc.encode(formatted))
+              controller.close()
+            },
+          })
+
+          const se: StreamingExecution = {
+            stream: syntheticStream,
+            execution: {
+              success: true,
+              output: { content: formatted },
+              logs: [],
+              metadata: { duration: 0, startTime: new Date().toISOString() },
+              blockId: block.id,
+              blockType: blockType,
+              isStreaming: true,
+            },
+          }
+
+          await context.onStream?.(se)
+        }
+      } catch (emitError) {
+        logger.warn('Failed to emit synthetic streaming for non-streaming block:', emitError)
+      }
+
       // Skip console logging for infrastructure blocks like loops and parallels
       if (block.metadata?.id !== BlockType.LOOP && block.metadata?.id !== BlockType.PARALLEL) {
         // Determine iteration context for this block