use unused var

apps/sim/app/api/workflows/[id]/deployments/[version]/route.ts

@@ -29,7 +29,7 @@ const patchBodySchema = z
     description: z
       .string()
       .trim()
-      .max(2000, 'Description must be 2000 characters or less')
+      .max(500, 'Description must be 500 characters or less')
       .nullable()
       .optional(),
     isActive: z.literal(true).optional(), // Set to true to activate this version

apps/sim/app/api/workflows/[id]/execute/route.ts

@@ -12,7 +12,7 @@ import {
 import { generateRequestId } from '@/lib/core/utils/request'
 import { SSE_HEADERS } from '@/lib/core/utils/sse'
 import { getBaseUrl } from '@/lib/core/utils/urls'
-import { createExecutionEventWriter, setExecutionMeta } from '@/lib/execution/event-buffer'
+import { markExecutionCancelled } from '@/lib/execution/cancellation'
 import { processInputFileFields } from '@/lib/execution/files'
 import { preprocessExecution } from '@/lib/execution/preprocessing'
 import { LoggingSession } from '@/lib/logs/execution/logging-session'
@@ -700,27 +700,15 @@ export async function POST(req: NextRequest, { params }: { params: Promise<{ id:
     const timeoutController = createTimeoutAbortController(preprocessResult.executionTimeout?.sync)
     let isStreamClosed = false
 
-    const eventWriter = createExecutionEventWriter(executionId)
-    setExecutionMeta(executionId, {
-      status: 'active',
-      userId: actorUserId,
-      workflowId,
-    }).catch(() => {})
-
     const stream = new ReadableStream<Uint8Array>({
       async start(controller) {
-        let finalMetaStatus: 'complete' | 'error' | 'cancelled' | null = null
-
         const sendEvent = (event: ExecutionEvent) => {
-          if (!isStreamClosed) {
-            try {
-              controller.enqueue(encodeSSEEvent(event))
-            } catch {
-              isStreamClosed = true
-            }
-          }
-          if (event.type !== 'stream:chunk' && event.type !== 'stream:done') {
-            eventWriter.write(event).catch(() => {})
+          if (isStreamClosed) return
+
+          try {
+            controller.enqueue(encodeSSEEvent(event))
+          } catch {
+            isStreamClosed = true
           }
         }
 
@@ -841,12 +829,14 @@ export async function POST(req: NextRequest, { params }: { params: Promise<{ id:
 
             const reader = streamingExec.stream.getReader()
             const decoder = new TextDecoder()
+            let chunkCount = 0
 
             try {
               while (true) {
                 const { done, value } = await reader.read()
                 if (done) break
 
+                chunkCount++
                 const chunk = decoder.decode(value, { stream: true })
                 sendEvent({
                   type: 'stream:chunk',
@@ -961,7 +951,6 @@ export async function POST(req: NextRequest, { params }: { params: Promise<{ id:
                   duration: result.metadata?.duration || 0,
                 },
               })
-              finalMetaStatus = 'error'
             } else {
               logger.info(`[${requestId}] Workflow execution was cancelled`)
 
@@ -974,7 +963,6 @@ export async function POST(req: NextRequest, { params }: { params: Promise<{ id:
                   duration: result.metadata?.duration || 0,
                 },
               })
-              finalMetaStatus = 'cancelled'
             }
             return
           }
@@ -998,7 +986,6 @@ export async function POST(req: NextRequest, { params }: { params: Promise<{ id:
               endTime: result.metadata?.endTime || new Date().toISOString(),
             },
           })
-          finalMetaStatus = 'complete'
         } catch (error: unknown) {
           const isTimeout = isTimeoutError(error) || timeoutController.isTimedOut()
           const errorMessage = isTimeout
@@ -1030,18 +1017,7 @@ export async function POST(req: NextRequest, { params }: { params: Promise<{ id:
               duration: executionResult?.metadata?.duration || 0,
             },
           })
-          finalMetaStatus = 'error'
         } finally {
-          try {
-            await eventWriter.close()
-          } catch (closeError) {
-            logger.warn(`[${requestId}] Failed to close event writer`, {
-              error: closeError instanceof Error ? closeError.message : String(closeError),
-            })
-          }
-          if (finalMetaStatus) {
-            setExecutionMeta(executionId, { status: finalMetaStatus }).catch(() => {})
-          }
           timeoutController.cleanup()
           if (executionId) {
             await cleanupExecutionBase64Cache(executionId)
@@ -1056,7 +1032,10 @@ export async function POST(req: NextRequest, { params }: { params: Promise<{ id:
       },
       cancel() {
         isStreamClosed = true
-        logger.info(`[${requestId}] Client disconnected from SSE stream`)
+        timeoutController.cleanup()
+        logger.info(`[${requestId}] Client aborted SSE stream, signalling cancellation`)
+        timeoutController.abort()
+        markExecutionCancelled(executionId).catch(() => {})
       },
     })
 

apps/sim/app/api/workflows/[id]/executions/[executionId]/stream/route.ts

@@ -1,170 +0,0 @@
-import { createLogger } from '@sim/logger'
-import { type NextRequest, NextResponse } from 'next/server'
-import { checkHybridAuth } from '@/lib/auth/hybrid'
-import { SSE_HEADERS } from '@/lib/core/utils/sse'
-import {
-  type ExecutionStreamStatus,
-  getExecutionMeta,
-  readExecutionEvents,
-} from '@/lib/execution/event-buffer'
-import { formatSSEEvent } from '@/lib/workflows/executor/execution-events'
-import { authorizeWorkflowByWorkspacePermission } from '@/lib/workflows/utils'
-
-const logger = createLogger('ExecutionStreamReconnectAPI')
-
-const POLL_INTERVAL_MS = 500
-const MAX_POLL_DURATION_MS = 10 * 60 * 1000 // 10 minutes
-
-function isTerminalStatus(status: ExecutionStreamStatus): boolean {
-  return status === 'complete' || status === 'error' || status === 'cancelled'
-}
-
-export const runtime = 'nodejs'
-export const dynamic = 'force-dynamic'
-
-export async function GET(
-  req: NextRequest,
-  { params }: { params: Promise<{ id: string; executionId: string }> }
-) {
-  const { id: workflowId, executionId } = await params
-
-  try {
-    const auth = await checkHybridAuth(req, { requireWorkflowId: false })
-    if (!auth.success || !auth.userId) {
-      return NextResponse.json({ error: auth.error || 'Unauthorized' }, { status: 401 })
-    }
-
-    const workflowAuthorization = await authorizeWorkflowByWorkspacePermission({
-      workflowId,
-      userId: auth.userId,
-      action: 'read',
-    })
-    if (!workflowAuthorization.allowed) {
-      return NextResponse.json(
-        { error: workflowAuthorization.message || 'Access denied' },
-        { status: workflowAuthorization.status }
-      )
-    }
-
-    const meta = await getExecutionMeta(executionId)
-    if (!meta) {
-      return NextResponse.json({ error: 'Execution buffer not found or expired' }, { status: 404 })
-    }
-
-    if (meta.workflowId && meta.workflowId !== workflowId) {
-      return NextResponse.json(
-        { error: 'Execution does not belong to this workflow' },
-        { status: 403 }
-      )
-    }
-
-    const fromParam = req.nextUrl.searchParams.get('from')
-    const parsed = fromParam ? Number.parseInt(fromParam, 10) : 0
-    const fromEventId = Number.isFinite(parsed) && parsed >= 0 ? parsed : 0
-
-    logger.info('Reconnection stream requested', {
-      workflowId,
-      executionId,
-      fromEventId,
-      metaStatus: meta.status,
-    })
-
-    const encoder = new TextEncoder()
-
-    let closed = false
-
-    const stream = new ReadableStream<Uint8Array>({
-      async start(controller) {
-        let lastEventId = fromEventId
-        const pollDeadline = Date.now() + MAX_POLL_DURATION_MS
-
-        const enqueue = (text: string) => {
-          if (closed) return
-          try {
-            controller.enqueue(encoder.encode(text))
-          } catch {
-            closed = true
-          }
-        }
-
-        try {
-          const events = await readExecutionEvents(executionId, lastEventId)
-          for (const entry of events) {
-            if (closed) return
-            enqueue(formatSSEEvent(entry.event))
-            lastEventId = entry.eventId
-          }
-
-          const currentMeta = await getExecutionMeta(executionId)
-          if (!currentMeta || isTerminalStatus(currentMeta.status)) {
-            enqueue('data: [DONE]\n\n')
-            if (!closed) controller.close()
-            return
-          }
-
-          while (!closed && Date.now() < pollDeadline) {
-            await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS))
-            if (closed) return
-
-            const newEvents = await readExecutionEvents(executionId, lastEventId)
-            for (const entry of newEvents) {
-              if (closed) return
-              enqueue(formatSSEEvent(entry.event))
-              lastEventId = entry.eventId
-            }
-
-            const polledMeta = await getExecutionMeta(executionId)
-            if (!polledMeta || isTerminalStatus(polledMeta.status)) {
-              const finalEvents = await readExecutionEvents(executionId, lastEventId)
-              for (const entry of finalEvents) {
-                if (closed) return
-                enqueue(formatSSEEvent(entry.event))
-                lastEventId = entry.eventId
-              }
-              enqueue('data: [DONE]\n\n')
-              if (!closed) controller.close()
-              return
-            }
-          }
-
-          if (!closed) {
-            logger.warn('Reconnection stream poll deadline reached', { executionId })
-            enqueue('data: [DONE]\n\n')
-            controller.close()
-          }
-        } catch (error) {
-          logger.error('Error in reconnection stream', {
-            executionId,
-            error: error instanceof Error ? error.message : String(error),
-          })
-          if (!closed) {
-            try {
-              controller.close()
-            } catch {}
-          }
-        }
-      },
-      cancel() {
-        closed = true
-        logger.info('Client disconnected from reconnection stream', { executionId })
-      },
-    })
-
-    return new NextResponse(stream, {
-      headers: {
-        ...SSE_HEADERS,
-        'X-Execution-Id': executionId,
-      },
-    })
-  } catch (error: any) {
-    logger.error('Failed to start reconnection stream', {
-      workflowId,
-      executionId,
-      error: error.message,
-    })
-    return NextResponse.json(
-      { error: error.message || 'Failed to start reconnection stream' },
-      { status: 500 }
-    )
-  }
-}

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/deploy/components/deploy-modal/components/general/components/version-description-modal.tsx

@@ -113,7 +113,7 @@ export function VersionDescriptionModal({
               className='min-h-[120px] resize-none'
               value={description}
               onChange={(e) => setDescription(e.target.value)}
-              maxLength={2000}
+              maxLength={500}
               disabled={isGenerating}
             />
             <div className='flex items-center justify-between'>
@@ -123,7 +123,7 @@ export function VersionDescriptionModal({
                 </p>
               )}
               {!updateMutation.error && !generateMutation.error && <div />}
-              <p className='text-[11px] text-[var(--text-tertiary)]'>{description.length}/2000</p>
+              <p className='text-[11px] text-[var(--text-tertiary)]'>{description.length}/500</p>
             </div>
           </ModalBody>
           <ModalFooter>

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/deploy/hooks/use-change-detection.ts

@@ -57,21 +57,6 @@ export function useChangeDetection({
         }
       }
 
-      if (block.triggerMode) {
-        const triggerConfigValue = blockSubValues?.triggerConfig
-        if (
-          triggerConfigValue &&
-          typeof triggerConfigValue === 'object' &&
-          !subBlocks.triggerConfig
-        ) {
-          subBlocks.triggerConfig = {
-            id: 'triggerConfig',
-            type: 'short-input',
-            value: triggerConfigValue,
-          }
-        }
-      }
-
       blocksWithSubBlocks[blockId] = {
         ...block,
         subBlocks,

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

@@ -1,4 +1,4 @@
-import { useCallback, useEffect, useRef, useState } from 'react'
+import { useCallback, useRef, useState } from 'react'
 import { createLogger } from '@sim/logger'
 import { useQueryClient } from '@tanstack/react-query'
 import { v4 as uuidv4 } from 'uuid'
@@ -46,13 +46,7 @@ import { useWorkflowStore } from '@/stores/workflows/workflow/store'
 
 const logger = createLogger('useWorkflowExecution')
 
-/**
- * Module-level Set tracking which workflows have an active reconnection effect.
- * Prevents multiple hook instances (from different components) from starting
- * concurrent reconnection streams for the same workflow during the same mount cycle.
- */
-const activeReconnections = new Set<string>()
-
+// Debug state validation result
 interface DebugValidationResult {
   isValid: boolean
   error?: string
@@ -60,7 +54,7 @@ interface DebugValidationResult {
 
 interface BlockEventHandlerConfig {
   workflowId?: string
-  executionIdRef: { current: string }
+  executionId?: string
   workflowEdges: Array<{ id: string; target: string; sourceHandle?: string | null }>
   activeBlocksSet: Set<string>
   accumulatedBlockLogs: BlockLog[]
@@ -114,15 +108,12 @@ export function useWorkflowExecution() {
   const queryClient = useQueryClient()
   const currentWorkflow = useCurrentWorkflow()
   const { activeWorkflowId, workflows } = useWorkflowRegistry()
-  const { toggleConsole, addConsole, updateConsole, cancelRunningEntries, clearExecutionEntries } =
+  const { toggleConsole, addConsole, updateConsole, cancelRunningEntries } =
     useTerminalConsoleStore()
-  const hasHydrated = useTerminalConsoleStore((s) => s._hasHydrated)
   const { getAllVariables } = useEnvironmentStore()
   const { getVariablesByWorkflowId, variables } = useVariablesStore()
   const { isExecuting, isDebugging, pendingBlocks, executor, debugContext } =
     useCurrentWorkflowExecution()
-  const setCurrentExecutionId = useExecutionStore((s) => s.setCurrentExecutionId)
-  const getCurrentExecutionId = useExecutionStore((s) => s.getCurrentExecutionId)
   const setIsExecuting = useExecutionStore((s) => s.setIsExecuting)
   const setIsDebugging = useExecutionStore((s) => s.setIsDebugging)
   const setPendingBlocks = useExecutionStore((s) => s.setPendingBlocks)
@@ -306,7 +297,7 @@ export function useWorkflowExecution() {
     (config: BlockEventHandlerConfig) => {
       const {
         workflowId,
-        executionIdRef,
+        executionId,
         workflowEdges,
         activeBlocksSet,
         accumulatedBlockLogs,
@@ -317,14 +308,6 @@ export function useWorkflowExecution() {
         onBlockCompleteCallback,
       } = config
 
-      /** Returns true if this execution was cancelled or superseded by another run. */
-      const isStaleExecution = () =>
-        !!(
-          workflowId &&
-          executionIdRef.current &&
-          useExecutionStore.getState().getCurrentExecutionId(workflowId) !== executionIdRef.current
-        )
-
       const updateActiveBlocks = (blockId: string, isActive: boolean) => {
         if (!workflowId) return
         if (isActive) {
@@ -377,7 +360,7 @@ export function useWorkflowExecution() {
           endedAt: data.endedAt,
           workflowId,
           blockId: data.blockId,
-          executionId: executionIdRef.current,
+          executionId,
           blockName: data.blockName || 'Unknown Block',
           blockType: data.blockType || 'unknown',
           iterationCurrent: data.iterationCurrent,
@@ -400,7 +383,7 @@ export function useWorkflowExecution() {
           endedAt: data.endedAt,
           workflowId,
           blockId: data.blockId,
-          executionId: executionIdRef.current,
+          executionId,
           blockName: data.blockName || 'Unknown Block',
           blockType: data.blockType || 'unknown',
           iterationCurrent: data.iterationCurrent,
@@ -427,7 +410,7 @@ export function useWorkflowExecution() {
             iterationType: data.iterationType,
             iterationContainerId: data.iterationContainerId,
           },
-          executionIdRef.current
+          executionId
         )
       }
 
@@ -449,12 +432,11 @@ export function useWorkflowExecution() {
             iterationType: data.iterationType,
             iterationContainerId: data.iterationContainerId,
           },
-          executionIdRef.current
+          executionId
         )
       }
 
       const onBlockStarted = (data: BlockStartedData) => {
-        if (isStaleExecution()) return
         updateActiveBlocks(data.blockId, true)
         markIncomingEdges(data.blockId)
 
@@ -471,7 +453,7 @@ export function useWorkflowExecution() {
           endedAt: undefined,
           workflowId,
           blockId: data.blockId,
-          executionId: executionIdRef.current,
+          executionId,
           blockName: data.blockName || 'Unknown Block',
           blockType: data.blockType || 'unknown',
           isRunning: true,
@@ -483,7 +465,6 @@ export function useWorkflowExecution() {
       }
 
       const onBlockCompleted = (data: BlockCompletedData) => {
-        if (isStaleExecution()) return
         updateActiveBlocks(data.blockId, false)
         if (workflowId) setBlockRunStatus(workflowId, data.blockId, 'success')
 
@@ -514,7 +495,6 @@ export function useWorkflowExecution() {
       }
 
       const onBlockError = (data: BlockErrorData) => {
-        if (isStaleExecution()) return
         updateActiveBlocks(data.blockId, false)
         if (workflowId) setBlockRunStatus(workflowId, data.blockId, 'error')
 
@@ -922,6 +902,10 @@ export function useWorkflowExecution() {
 
                 // Update block logs with actual stream completion times
                 if (result.logs && streamCompletionTimes.size > 0) {
+                  const streamCompletionEndTime = new Date(
+                    Math.max(...Array.from(streamCompletionTimes.values()))
+                  ).toISOString()
+
                   result.logs.forEach((log: BlockLog) => {
                     if (streamCompletionTimes.has(log.blockId)) {
                       const completionTime = streamCompletionTimes.get(log.blockId)!
@@ -1003,6 +987,7 @@ export function useWorkflowExecution() {
         return { success: true, stream }
       }
 
+      // For manual (non-chat) execution
       const manualExecutionId = uuidv4()
       try {
         const result = await executeWorkflow(
@@ -1017,10 +1002,29 @@ export function useWorkflowExecution() {
           if (result.metadata.pendingBlocks) {
             setPendingBlocks(activeWorkflowId, result.metadata.pendingBlocks)
           }
+        } else if (result && 'success' in result) {
+          setExecutionResult(result)
+          // Reset execution state after successful non-debug execution
+          setIsExecuting(activeWorkflowId, false)
+          setIsDebugging(activeWorkflowId, false)
+          setActiveBlocks(activeWorkflowId, new Set())
+
+          if (isChatExecution) {
+            if (!result.metadata) {
+              result.metadata = { duration: 0, startTime: new Date().toISOString() }
+            }
+            ;(result.metadata as any).source = 'chat'
+          }
+
+          // Invalidate subscription queries to update usage
+          setTimeout(() => {
+            queryClient.invalidateQueries({ queryKey: subscriptionKeys.all })
+          }, 1000)
         }
         return result
       } catch (error: any) {
         const errorResult = handleExecutionError(error, { executionId: manualExecutionId })
+        // Note: Error logs are already persisted server-side via execution-core.ts
         return errorResult
       }
     },
@@ -1271,7 +1275,7 @@ export function useWorkflowExecution() {
     if (activeWorkflowId) {
       logger.info('Using server-side executor')
 
-      const executionIdRef = { current: '' }
+      const executionId = uuidv4()
 
       let executionResult: ExecutionResult = {
         success: false,
@@ -1289,7 +1293,7 @@ export function useWorkflowExecution() {
       try {
         const blockHandlers = buildBlockEventHandlers({
           workflowId: activeWorkflowId,
-          executionIdRef,
+          executionId,
           workflowEdges,
           activeBlocksSet,
           accumulatedBlockLogs,
@@ -1322,10 +1326,6 @@ export function useWorkflowExecution() {
             loops: clientWorkflowState.loops,
             parallels: clientWorkflowState.parallels,
           },
-          onExecutionId: (id) => {
-            executionIdRef.current = id
-            setCurrentExecutionId(activeWorkflowId, id)
-          },
           callbacks: {
             onExecutionStarted: (data) => {
               logger.info('Server execution started:', data)
@@ -1368,18 +1368,6 @@ export function useWorkflowExecution() {
             },
 
             onExecutionCompleted: (data) => {
-              if (
-                activeWorkflowId &&
-                executionIdRef.current &&
-                useExecutionStore.getState().getCurrentExecutionId(activeWorkflowId) !==
-                  executionIdRef.current
-              )
-                return
-
-              if (activeWorkflowId) {
-                setCurrentExecutionId(activeWorkflowId, null)
-              }
-
               executionResult = {
                 success: data.success,
                 output: data.output,
@@ -1437,33 +1425,9 @@ export function useWorkflowExecution() {
                   })
                 }
               }
-
-              const workflowExecState = activeWorkflowId
-                ? useExecutionStore.getState().getWorkflowExecution(activeWorkflowId)
-                : null
-              if (activeWorkflowId && !workflowExecState?.isDebugging) {
-                setExecutionResult(executionResult)
-                setIsExecuting(activeWorkflowId, false)
-                setActiveBlocks(activeWorkflowId, new Set())
-                setTimeout(() => {
-                  queryClient.invalidateQueries({ queryKey: subscriptionKeys.all })
-                }, 1000)
-              }
             },
 
             onExecutionError: (data) => {
-              if (
-                activeWorkflowId &&
-                executionIdRef.current &&
-                useExecutionStore.getState().getCurrentExecutionId(activeWorkflowId) !==
-                  executionIdRef.current
-              )
-                return
-
-              if (activeWorkflowId) {
-                setCurrentExecutionId(activeWorkflowId, null)
-              }
-
               executionResult = {
                 success: false,
                 output: {},
@@ -1477,53 +1441,43 @@ export function useWorkflowExecution() {
               const isPreExecutionError = accumulatedBlockLogs.length === 0
               handleExecutionErrorConsole({
                 workflowId: activeWorkflowId,
-                executionId: executionIdRef.current,
+                executionId,
                 error: data.error,
                 durationMs: data.duration,
                 blockLogs: accumulatedBlockLogs,
                 isPreExecutionError,
               })
-
-              if (activeWorkflowId) {
-                setIsExecuting(activeWorkflowId, false)
-                setIsDebugging(activeWorkflowId, false)
-                setActiveBlocks(activeWorkflowId, new Set())
-              }
             },
 
             onExecutionCancelled: (data) => {
-              if (
-                activeWorkflowId &&
-                executionIdRef.current &&
-                useExecutionStore.getState().getCurrentExecutionId(activeWorkflowId) !==
-                  executionIdRef.current
-              )
-                return
-
-              if (activeWorkflowId) {
-                setCurrentExecutionId(activeWorkflowId, null)
-              }
-
               handleExecutionCancelledConsole({
                 workflowId: activeWorkflowId,
-                executionId: executionIdRef.current,
+                executionId,
                 durationMs: data?.duration,
               })
-
-              if (activeWorkflowId) {
-                setIsExecuting(activeWorkflowId, false)
-                setIsDebugging(activeWorkflowId, false)
-                setActiveBlocks(activeWorkflowId, new Set())
-              }
             },
           },
         })
 
         return executionResult
       } catch (error: any) {
+        // Don't log abort errors - they're intentional user actions
         if (error.name === 'AbortError' || error.message?.includes('aborted')) {
           logger.info('Execution aborted by user')
-          return executionResult
+
+          // Reset execution state
+          if (activeWorkflowId) {
+            setIsExecuting(activeWorkflowId, false)
+            setActiveBlocks(activeWorkflowId, new Set())
+          }
+
+          // Return gracefully without error
+          return {
+            success: false,
+            output: {},
+            metadata: { duration: 0 },
+            logs: [],
+          }
         }
 
         logger.error('Server-side execution failed:', error)
@@ -1531,6 +1485,7 @@ export function useWorkflowExecution() {
       }
     }
 
+    // Fallback: should never reach here
     throw new Error('Server-side execution is required')
   }
 
@@ -1762,28 +1717,25 @@ export function useWorkflowExecution() {
    * Handles cancelling the current workflow execution
    */
   const handleCancelExecution = useCallback(() => {
-    if (!activeWorkflowId) return
     logger.info('Workflow execution cancellation requested')
 
-    const storedExecutionId = getCurrentExecutionId(activeWorkflowId)
+    // Cancel the execution stream for this workflow (server-side)
+    executionStream.cancel(activeWorkflowId ?? undefined)
 
-    if (storedExecutionId) {
-      setCurrentExecutionId(activeWorkflowId, null)
-      fetch(`/api/workflows/${activeWorkflowId}/executions/${storedExecutionId}/cancel`, {
-        method: 'POST',
-      }).catch(() => {})
-      handleExecutionCancelledConsole({
-        workflowId: activeWorkflowId,
-        executionId: storedExecutionId,
-      })
+    // Mark current chat execution as superseded so its cleanup won't affect new executions
+    currentChatExecutionIdRef.current = null
+
+    // Mark all running entries as canceled in the terminal
+    if (activeWorkflowId) {
+      cancelRunningEntries(activeWorkflowId)
+
+      // Reset execution state - this triggers chat stream cleanup via useEffect in chat.tsx
+      setIsExecuting(activeWorkflowId, false)
+      setIsDebugging(activeWorkflowId, false)
+      setActiveBlocks(activeWorkflowId, new Set())
     }
 
-    executionStream.cancel(activeWorkflowId)
-    currentChatExecutionIdRef.current = null
-    setIsExecuting(activeWorkflowId, false)
-    setIsDebugging(activeWorkflowId, false)
-    setActiveBlocks(activeWorkflowId, new Set())
-
+    // If in debug mode, also reset debug state
     if (isDebugging) {
       resetDebugState()
     }
@@ -1795,9 +1747,7 @@ export function useWorkflowExecution() {
     setIsDebugging,
     setActiveBlocks,
     activeWorkflowId,
-    getCurrentExecutionId,
-    setCurrentExecutionId,
-    handleExecutionCancelledConsole,
+    cancelRunningEntries,
   ])
 
   /**
@@ -1897,7 +1847,7 @@ export function useWorkflowExecution() {
       }
 
       setIsExecuting(workflowId, true)
-      const executionIdRef = { current: '' }
+      const executionId = uuidv4()
       const accumulatedBlockLogs: BlockLog[] = []
       const accumulatedBlockStates = new Map<string, BlockState>()
       const executedBlockIds = new Set<string>()
@@ -1906,7 +1856,7 @@ export function useWorkflowExecution() {
       try {
         const blockHandlers = buildBlockEventHandlers({
           workflowId,
-          executionIdRef,
+          executionId,
           workflowEdges,
           activeBlocksSet,
           accumulatedBlockLogs,
@@ -1921,10 +1871,6 @@ export function useWorkflowExecution() {
           startBlockId: blockId,
           sourceSnapshot: effectiveSnapshot,
           input: workflowInput,
-          onExecutionId: (id) => {
-            executionIdRef.current = id
-            setCurrentExecutionId(workflowId, id)
-          },
           callbacks: {
             onBlockStarted: blockHandlers.onBlockStarted,
             onBlockCompleted: blockHandlers.onBlockCompleted,
@@ -1932,6 +1878,7 @@ export function useWorkflowExecution() {
 
             onExecutionCompleted: (data) => {
               if (data.success) {
+                // Add the start block (trigger) to executed blocks
                 executedBlockIds.add(blockId)
 
                 const mergedBlockStates: Record<string, BlockState> = {
@@ -1955,10 +1902,6 @@ export function useWorkflowExecution() {
                 }
                 setLastExecutionSnapshot(workflowId, updatedSnapshot)
               }
-
-              setCurrentExecutionId(workflowId, null)
-              setIsExecuting(workflowId, false)
-              setActiveBlocks(workflowId, new Set())
             },
 
             onExecutionError: (data) => {
@@ -1978,27 +1921,19 @@ export function useWorkflowExecution() {
 
               handleExecutionErrorConsole({
                 workflowId,
-                executionId: executionIdRef.current,
+                executionId,
                 error: data.error,
                 durationMs: data.duration,
                 blockLogs: accumulatedBlockLogs,
               })
-
-              setCurrentExecutionId(workflowId, null)
-              setIsExecuting(workflowId, false)
-              setActiveBlocks(workflowId, new Set())
             },
 
             onExecutionCancelled: (data) => {
               handleExecutionCancelledConsole({
                 workflowId,
-                executionId: executionIdRef.current,
+                executionId,
                 durationMs: data?.duration,
               })
-
-              setCurrentExecutionId(workflowId, null)
-              setIsExecuting(workflowId, false)
-              setActiveBlocks(workflowId, new Set())
             },
           },
         })
@@ -2007,20 +1942,14 @@ export function useWorkflowExecution() {
           logger.error('Run-from-block failed:', error)
         }
       } finally {
-        const currentId = getCurrentExecutionId(workflowId)
-        if (currentId === null || currentId === executionIdRef.current) {
-          setCurrentExecutionId(workflowId, null)
-          setIsExecuting(workflowId, false)
-          setActiveBlocks(workflowId, new Set())
-        }
+        setIsExecuting(workflowId, false)
+        setActiveBlocks(workflowId, new Set())
       }
     },
     [
       getLastExecutionSnapshot,
       setLastExecutionSnapshot,
       clearLastExecutionSnapshot,
-      getCurrentExecutionId,
-      setCurrentExecutionId,
       setIsExecuting,
       setActiveBlocks,
       setBlockRunStatus,
@@ -2050,213 +1979,29 @@ export function useWorkflowExecution() {
 
       const executionId = uuidv4()
       try {
-        await executeWorkflow(undefined, undefined, executionId, undefined, 'manual', blockId)
+        const result = await executeWorkflow(
+          undefined,
+          undefined,
+          executionId,
+          undefined,
+          'manual',
+          blockId
+        )
+        if (result && 'success' in result) {
+          setExecutionResult(result)
+        }
       } catch (error) {
         const errorResult = handleExecutionError(error, { executionId })
         return errorResult
       } finally {
-        setCurrentExecutionId(workflowId, null)
         setIsExecuting(workflowId, false)
         setIsDebugging(workflowId, false)
         setActiveBlocks(workflowId, new Set())
       }
     },
-    [
-      activeWorkflowId,
-      setCurrentExecutionId,
-      setExecutionResult,
-      setIsExecuting,
-      setIsDebugging,
-      setActiveBlocks,
-    ]
+    [activeWorkflowId, setExecutionResult, setIsExecuting, setIsDebugging, setActiveBlocks]
   )
 
-  useEffect(() => {
-    if (!activeWorkflowId || !hasHydrated) return
-
-    const entries = useTerminalConsoleStore.getState().entries
-    const runningEntries = entries.filter(
-      (e) => e.isRunning && e.workflowId === activeWorkflowId && e.executionId
-    )
-    if (runningEntries.length === 0) return
-
-    if (activeReconnections.has(activeWorkflowId)) return
-    activeReconnections.add(activeWorkflowId)
-
-    executionStream.cancel(activeWorkflowId)
-
-    const sorted = [...runningEntries].sort((a, b) => {
-      const aTime = a.startedAt ? new Date(a.startedAt).getTime() : 0
-      const bTime = b.startedAt ? new Date(b.startedAt).getTime() : 0
-      return bTime - aTime
-    })
-    const executionId = sorted[0].executionId!
-
-    const otherExecutionIds = new Set(
-      sorted.filter((e) => e.executionId !== executionId).map((e) => e.executionId!)
-    )
-    if (otherExecutionIds.size > 0) {
-      cancelRunningEntries(activeWorkflowId)
-    }
-
-    setCurrentExecutionId(activeWorkflowId, executionId)
-    setIsExecuting(activeWorkflowId, true)
-
-    const workflowEdges = useWorkflowStore.getState().edges
-    const activeBlocksSet = new Set<string>()
-    const accumulatedBlockLogs: BlockLog[] = []
-    const accumulatedBlockStates = new Map<string, BlockState>()
-    const executedBlockIds = new Set<string>()
-
-    const executionIdRef = { current: executionId }
-
-    const handlers = buildBlockEventHandlers({
-      workflowId: activeWorkflowId,
-      executionIdRef,
-      workflowEdges,
-      activeBlocksSet,
-      accumulatedBlockLogs,
-      accumulatedBlockStates,
-      executedBlockIds,
-      consoleMode: 'update',
-      includeStartConsoleEntry: true,
-    })
-
-    const originalEntries = entries
-      .filter((e) => e.executionId === executionId)
-      .map((e) => ({ ...e }))
-
-    let cleared = false
-    let reconnectionComplete = false
-    let cleanupRan = false
-    const clearOnce = () => {
-      if (!cleared) {
-        cleared = true
-        clearExecutionEntries(executionId)
-      }
-    }
-
-    const reconnectWorkflowId = activeWorkflowId
-
-    executionStream
-      .reconnect({
-        workflowId: reconnectWorkflowId,
-        executionId,
-        callbacks: {
-          onBlockStarted: (data) => {
-            clearOnce()
-            handlers.onBlockStarted(data)
-          },
-          onBlockCompleted: (data) => {
-            clearOnce()
-            handlers.onBlockCompleted(data)
-          },
-          onBlockError: (data) => {
-            clearOnce()
-            handlers.onBlockError(data)
-          },
-          onExecutionCompleted: () => {
-            const currentId = useExecutionStore
-              .getState()
-              .getCurrentExecutionId(reconnectWorkflowId)
-            if (currentId !== executionId) {
-              reconnectionComplete = true
-              activeReconnections.delete(reconnectWorkflowId)
-              return
-            }
-            clearOnce()
-            reconnectionComplete = true
-            activeReconnections.delete(reconnectWorkflowId)
-            setCurrentExecutionId(reconnectWorkflowId, null)
-            setIsExecuting(reconnectWorkflowId, false)
-            setActiveBlocks(reconnectWorkflowId, new Set())
-          },
-          onExecutionError: (data) => {
-            const currentId = useExecutionStore
-              .getState()
-              .getCurrentExecutionId(reconnectWorkflowId)
-            if (currentId !== executionId) {
-              reconnectionComplete = true
-              activeReconnections.delete(reconnectWorkflowId)
-              return
-            }
-            clearOnce()
-            reconnectionComplete = true
-            activeReconnections.delete(reconnectWorkflowId)
-            setCurrentExecutionId(reconnectWorkflowId, null)
-            setIsExecuting(reconnectWorkflowId, false)
-            setActiveBlocks(reconnectWorkflowId, new Set())
-            handleExecutionErrorConsole({
-              workflowId: reconnectWorkflowId,
-              executionId,
-              error: data.error,
-              blockLogs: accumulatedBlockLogs,
-            })
-          },
-          onExecutionCancelled: () => {
-            const currentId = useExecutionStore
-              .getState()
-              .getCurrentExecutionId(reconnectWorkflowId)
-            if (currentId !== executionId) {
-              reconnectionComplete = true
-              activeReconnections.delete(reconnectWorkflowId)
-              return
-            }
-            clearOnce()
-            reconnectionComplete = true
-            activeReconnections.delete(reconnectWorkflowId)
-            setCurrentExecutionId(reconnectWorkflowId, null)
-            setIsExecuting(reconnectWorkflowId, false)
-            setActiveBlocks(reconnectWorkflowId, new Set())
-            handleExecutionCancelledConsole({
-              workflowId: reconnectWorkflowId,
-              executionId,
-            })
-          },
-        },
-      })
-      .catch((error) => {
-        logger.warn('Execution reconnection failed', { executionId, error })
-      })
-      .finally(() => {
-        if (reconnectionComplete || cleanupRan) return
-        const currentId = useExecutionStore.getState().getCurrentExecutionId(reconnectWorkflowId)
-        if (currentId !== executionId) return
-        reconnectionComplete = true
-        activeReconnections.delete(reconnectWorkflowId)
-        clearExecutionEntries(executionId)
-        for (const entry of originalEntries) {
-          addConsole({
-            workflowId: entry.workflowId,
-            blockId: entry.blockId,
-            blockName: entry.blockName,
-            blockType: entry.blockType,
-            executionId: entry.executionId,
-            executionOrder: entry.executionOrder,
-            isRunning: false,
-            warning: 'Execution result unavailable — check the logs page',
-          })
-        }
-        setCurrentExecutionId(reconnectWorkflowId, null)
-        setIsExecuting(reconnectWorkflowId, false)
-        setActiveBlocks(reconnectWorkflowId, new Set())
-      })
-
-    return () => {
-      cleanupRan = true
-      executionStream.cancel(reconnectWorkflowId)
-      activeReconnections.delete(reconnectWorkflowId)
-
-      if (cleared && !reconnectionComplete) {
-        clearExecutionEntries(executionId)
-        for (const entry of originalEntries) {
-          addConsole(entry)
-        }
-      }
-    }
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [activeWorkflowId, hasHydrated])
-
   return {
     isExecuting,
     isDebugging,

apps/sim/blocks/blocks/google_books.ts

@@ -1,198 +0,0 @@
-import { GoogleBooksIcon } from '@/components/icons'
-import type { BlockConfig } from '@/blocks/types'
-
-export const GoogleBooksBlock: BlockConfig = {
-  type: 'google_books',
-  name: 'Google Books',
-  description: 'Search and retrieve book information',
-  longDescription:
-    'Search for books using the Google Books API. Find volumes by title, author, ISBN, or keywords, and retrieve detailed information about specific books including descriptions, ratings, and publication details.',
-  docsLink: 'https://docs.sim.ai/tools/google_books',
-  category: 'tools',
-  bgColor: '#4285F4',
-  icon: GoogleBooksIcon,
-
-  subBlocks: [
-    {
-      id: 'operation',
-      title: 'Operation',
-      type: 'dropdown',
-      options: [
-        { label: 'Search Volumes', id: 'volume_search' },
-        { label: 'Get Volume Details', id: 'volume_details' },
-      ],
-      value: () => 'volume_search',
-    },
-    {
-      id: 'apiKey',
-      title: 'API Key',
-      type: 'short-input',
-      password: true,
-      placeholder: 'Enter your Google Books API key',
-      required: true,
-    },
-    {
-      id: 'query',
-      title: 'Search Query',
-      type: 'short-input',
-      placeholder: 'e.g., intitle:harry potter inauthor:rowling',
-      condition: { field: 'operation', value: 'volume_search' },
-      required: { field: 'operation', value: 'volume_search' },
-    },
-    {
-      id: 'filter',
-      title: 'Filter',
-      type: 'dropdown',
-      options: [
-        { label: 'None', id: '' },
-        { label: 'Partial Preview', id: 'partial' },
-        { label: 'Full Preview', id: 'full' },
-        { label: 'Free eBooks', id: 'free-ebooks' },
-        { label: 'Paid eBooks', id: 'paid-ebooks' },
-        { label: 'All eBooks', id: 'ebooks' },
-      ],
-      condition: { field: 'operation', value: 'volume_search' },
-      mode: 'advanced',
-    },
-    {
-      id: 'printType',
-      title: 'Print Type',
-      type: 'dropdown',
-      options: [
-        { label: 'All', id: 'all' },
-        { label: 'Books', id: 'books' },
-        { label: 'Magazines', id: 'magazines' },
-      ],
-      value: () => 'all',
-      condition: { field: 'operation', value: 'volume_search' },
-      mode: 'advanced',
-    },
-    {
-      id: 'orderBy',
-      title: 'Order By',
-      type: 'dropdown',
-      options: [
-        { label: 'Relevance', id: 'relevance' },
-        { label: 'Newest', id: 'newest' },
-      ],
-      value: () => 'relevance',
-      condition: { field: 'operation', value: 'volume_search' },
-      mode: 'advanced',
-    },
-    {
-      id: 'maxResults',
-      title: 'Max Results',
-      type: 'short-input',
-      placeholder: 'Number of results (1-40)',
-      condition: { field: 'operation', value: 'volume_search' },
-      mode: 'advanced',
-    },
-    {
-      id: 'startIndex',
-      title: 'Start Index',
-      type: 'short-input',
-      placeholder: 'Starting index for pagination',
-      condition: { field: 'operation', value: 'volume_search' },
-      mode: 'advanced',
-    },
-    {
-      id: 'langRestrict',
-      title: 'Language',
-      type: 'short-input',
-      placeholder: 'ISO 639-1 code (e.g., en, es, fr)',
-      condition: { field: 'operation', value: 'volume_search' },
-      mode: 'advanced',
-    },
-    {
-      id: 'volumeId',
-      title: 'Volume ID',
-      type: 'short-input',
-      placeholder: 'Google Books volume ID',
-      condition: { field: 'operation', value: 'volume_details' },
-      required: { field: 'operation', value: 'volume_details' },
-    },
-    {
-      id: 'projection',
-      title: 'Projection',
-      type: 'dropdown',
-      options: [
-        { label: 'Full', id: 'full' },
-        { label: 'Lite', id: 'lite' },
-      ],
-      value: () => 'full',
-      mode: 'advanced',
-    },
-  ],
-
-  tools: {
-    access: ['google_books_volume_search', 'google_books_volume_details'],
-    config: {
-      tool: (params) => `google_books_${params.operation}`,
-      params: (params) => {
-        const { operation, ...rest } = params
-
-        let maxResults: number | undefined
-        if (params.maxResults) {
-          maxResults = Number.parseInt(params.maxResults, 10)
-          if (Number.isNaN(maxResults)) {
-            maxResults = undefined
-          }
-        }
-
-        let startIndex: number | undefined
-        if (params.startIndex) {
-          startIndex = Number.parseInt(params.startIndex, 10)
-          if (Number.isNaN(startIndex)) {
-            startIndex = undefined
-          }
-        }
-
-        return {
-          ...rest,
-          maxResults,
-          startIndex,
-          filter: params.filter || undefined,
-          printType: params.printType || undefined,
-          orderBy: params.orderBy || undefined,
-          projection: params.projection || undefined,
-        }
-      },
-    },
-  },
-
-  inputs: {
-    operation: { type: 'string', description: 'Operation to perform' },
-    apiKey: { type: 'string', description: 'Google Books API key' },
-    query: { type: 'string', description: 'Search query' },
-    filter: { type: 'string', description: 'Filter by availability' },
-    printType: { type: 'string', description: 'Print type filter' },
-    orderBy: { type: 'string', description: 'Sort order' },
-    maxResults: { type: 'string', description: 'Maximum number of results' },
-    startIndex: { type: 'string', description: 'Starting index for pagination' },
-    langRestrict: { type: 'string', description: 'Language restriction' },
-    volumeId: { type: 'string', description: 'Volume ID for details' },
-    projection: { type: 'string', description: 'Projection level' },
-  },
-
-  outputs: {
-    totalItems: { type: 'number', description: 'Total number of matching results' },
-    volumes: { type: 'json', description: 'List of matching volumes' },
-    id: { type: 'string', description: 'Volume ID' },
-    title: { type: 'string', description: 'Book title' },
-    subtitle: { type: 'string', description: 'Book subtitle' },
-    authors: { type: 'json', description: 'List of authors' },
-    publisher: { type: 'string', description: 'Publisher name' },
-    publishedDate: { type: 'string', description: 'Publication date' },
-    description: { type: 'string', description: 'Book description' },
-    pageCount: { type: 'number', description: 'Number of pages' },
-    categories: { type: 'json', description: 'Book categories' },
-    averageRating: { type: 'number', description: 'Average rating (1-5)' },
-    ratingsCount: { type: 'number', description: 'Number of ratings' },
-    language: { type: 'string', description: 'Language code' },
-    previewLink: { type: 'string', description: 'Link to preview on Google Books' },
-    infoLink: { type: 'string', description: 'Link to info page' },
-    thumbnailUrl: { type: 'string', description: 'Book cover thumbnail URL' },
-    isbn10: { type: 'string', description: 'ISBN-10 identifier' },
-    isbn13: { type: 'string', description: 'ISBN-13 identifier' },
-  },
-}

apps/sim/blocks/registry.ts

@@ -40,7 +40,6 @@ import { GitLabBlock } from '@/blocks/blocks/gitlab'
 import { GmailBlock, GmailV2Block } from '@/blocks/blocks/gmail'
 import { GoogleSearchBlock } from '@/blocks/blocks/google'
 import { GoogleCalendarBlock, GoogleCalendarV2Block } from '@/blocks/blocks/google_calendar'
-import { GoogleBooksBlock } from '@/blocks/blocks/google_books'
 import { GoogleDocsBlock } from '@/blocks/blocks/google_docs'
 import { GoogleDriveBlock } from '@/blocks/blocks/google_drive'
 import { GoogleFormsBlock } from '@/blocks/blocks/google_forms'
@@ -215,7 +214,6 @@ export const registry: Record<string, BlockConfig> = {
   gmail_v2: GmailV2Block,
   google_calendar: GoogleCalendarBlock,
   google_calendar_v2: GoogleCalendarV2Block,
-  google_books: GoogleBooksBlock,
   google_docs: GoogleDocsBlock,
   google_drive: GoogleDriveBlock,
   google_forms: GoogleFormsBlock,

apps/sim/components/icons.tsx

@@ -1157,19 +1157,6 @@ export function AirweaveIcon(props: SVGProps<SVGSVGElement>) {
   )
 }
 
-export function GoogleBooksIcon(props: SVGProps<SVGSVGElement>) {
-  return (
-    <svg {...props} xmlns='http://www.w3.org/2000/svg' viewBox='0 0 48 48'>
-      <path
-        fill='#4285F4'
-        d='M38 44H14c-2.2 0-4-1.8-4-4V8c0-2.2 1.8-4 4-4h18l10 10v26c0 2.2-1.8 4-4 4z'
-      />
-      <path fill='#A0C3FF' d='M32 4v10h10L32 4z' />
-      <path fill='#FFFFFF' d='M16 20h16v2H16zm0 5h16v2H16zm0 5h12v2H16z' />
-    </svg>
-  )
-}
-
 export function GoogleDocsIcon(props: SVGProps<SVGSVGElement>) {
   return (
     <svg

apps/sim/hooks/queries/deployments.ts

@@ -423,7 +423,7 @@ interface GenerateVersionDescriptionVariables {
 
 const VERSION_DESCRIPTION_SYSTEM_PROMPT = `You are writing deployment version descriptions for a workflow automation platform.
 
-Write a brief, factual description (1-3 sentences, under 2000 characters) that states what changed between versions.
+Write a brief, factual description (1-3 sentences, under 400 characters) that states what changed between versions.
 
 Guidelines:
 - Use the specific values provided (credential names, channel names, model names)

apps/sim/hooks/use-execution-stream.ts

@@ -1,4 +1,4 @@
-import { useCallback } from 'react'
+import { useCallback, useRef } from 'react'
 import { createLogger } from '@sim/logger'
 import type {
   BlockCompletedData,
@@ -16,18 +16,6 @@ import type { SerializableExecutionState } from '@/executor/execution/types'
 
 const logger = createLogger('useExecutionStream')
 
-/**
- * Detects errors caused by the browser killing a fetch (page refresh, navigation, tab close).
- * These should be treated as clean disconnects, not execution errors.
- */
-function isClientDisconnectError(error: any): boolean {
-  if (error.name === 'AbortError') return true
-  const msg = (error.message ?? '').toLowerCase()
-  return (
-    msg.includes('network error') || msg.includes('failed to fetch') || msg.includes('load failed')
-  )
-}
-
 /**
  * Processes SSE events from a response body and invokes appropriate callbacks.
  */
@@ -133,7 +121,6 @@ export interface ExecuteStreamOptions {
     parallels?: Record<string, any>
   }
   stopAfterBlockId?: string
-  onExecutionId?: (executionId: string) => void
   callbacks?: ExecutionStreamCallbacks
 }
 
@@ -142,40 +129,30 @@ export interface ExecuteFromBlockOptions {
   startBlockId: string
   sourceSnapshot: SerializableExecutionState
   input?: any
-  onExecutionId?: (executionId: string) => void
   callbacks?: ExecutionStreamCallbacks
 }
 
-export interface ReconnectStreamOptions {
-  workflowId: string
-  executionId: string
-  fromEventId?: number
-  callbacks?: ExecutionStreamCallbacks
-}
-
-/**
- * Module-level map shared across all hook instances.
- * Ensures ANY instance can cancel streams started by ANY other instance,
- * which is critical for SPA navigation where the original hook instance unmounts
- * but the SSE stream must be cancellable from the new instance.
- */
-const sharedAbortControllers = new Map<string, AbortController>()
-
 /**
  * Hook for executing workflows via server-side SSE streaming.
  * Supports concurrent executions via per-workflow AbortController maps.
  */
 export function useExecutionStream() {
-  const execute = useCallback(async (options: ExecuteStreamOptions) => {
-    const { workflowId, callbacks = {}, onExecutionId, ...payload } = options
+  const abortControllersRef = useRef<Map<string, AbortController>>(new Map())
+  const currentExecutionsRef = useRef<Map<string, { workflowId: string; executionId: string }>>(
+    new Map()
+  )
 
-    const existing = sharedAbortControllers.get(workflowId)
+  const execute = useCallback(async (options: ExecuteStreamOptions) => {
+    const { workflowId, callbacks = {}, ...payload } = options
+
+    const existing = abortControllersRef.current.get(workflowId)
     if (existing) {
       existing.abort()
     }
 
     const abortController = new AbortController()
-    sharedAbortControllers.set(workflowId, abortController)
+    abortControllersRef.current.set(workflowId, abortController)
+    currentExecutionsRef.current.delete(workflowId)
 
     try {
       const response = await fetch(`/api/workflows/${workflowId}/execute`, {
@@ -200,48 +177,42 @@ export function useExecutionStream() {
         throw new Error('No response body')
       }
 
-      const serverExecutionId = response.headers.get('X-Execution-Id')
-      if (serverExecutionId) {
-        onExecutionId?.(serverExecutionId)
+      const executionId = response.headers.get('X-Execution-Id')
+      if (executionId) {
+        currentExecutionsRef.current.set(workflowId, { workflowId, executionId })
       }
 
       const reader = response.body.getReader()
       await processSSEStream(reader, callbacks, 'Execution')
     } catch (error: any) {
-      if (isClientDisconnectError(error)) {
-        logger.info('Execution stream disconnected (page unload or abort)')
-        return
+      if (error.name === 'AbortError') {
+        logger.info('Execution stream cancelled')
+        callbacks.onExecutionCancelled?.({ duration: 0 })
+      } else {
+        logger.error('Execution stream error:', error)
+        callbacks.onExecutionError?.({
+          error: error.message || 'Unknown error',
+          duration: 0,
+        })
       }
-      logger.error('Execution stream error:', error)
-      callbacks.onExecutionError?.({
-        error: error.message || 'Unknown error',
-        duration: 0,
-      })
       throw error
     } finally {
-      if (sharedAbortControllers.get(workflowId) === abortController) {
-        sharedAbortControllers.delete(workflowId)
-      }
+      abortControllersRef.current.delete(workflowId)
+      currentExecutionsRef.current.delete(workflowId)
     }
   }, [])
 
   const executeFromBlock = useCallback(async (options: ExecuteFromBlockOptions) => {
-    const {
-      workflowId,
-      startBlockId,
-      sourceSnapshot,
-      input,
-      onExecutionId,
-      callbacks = {},
-    } = options
+    const { workflowId, startBlockId, sourceSnapshot, input, callbacks = {} } = options
 
-    const existing = sharedAbortControllers.get(workflowId)
+    const existing = abortControllersRef.current.get(workflowId)
     if (existing) {
       existing.abort()
     }
 
     const abortController = new AbortController()
-    sharedAbortControllers.set(workflowId, abortController)
+    abortControllersRef.current.set(workflowId, abortController)
+    currentExecutionsRef.current.delete(workflowId)
 
     try {
       const response = await fetch(`/api/workflows/${workflowId}/execute`, {
@@ -275,80 +246,64 @@ export function useExecutionStream() {
         throw new Error('No response body')
       }
 
-      const serverExecutionId = response.headers.get('X-Execution-Id')
-      if (serverExecutionId) {
-        onExecutionId?.(serverExecutionId)
+      const executionId = response.headers.get('X-Execution-Id')
+      if (executionId) {
+        currentExecutionsRef.current.set(workflowId, { workflowId, executionId })
       }
 
       const reader = response.body.getReader()
       await processSSEStream(reader, callbacks, 'Run-from-block')
     } catch (error: any) {
-      if (isClientDisconnectError(error)) {
-        logger.info('Run-from-block stream disconnected (page unload or abort)')
-        return
+      if (error.name === 'AbortError') {
+        logger.info('Run-from-block execution cancelled')
+        callbacks.onExecutionCancelled?.({ duration: 0 })
+      } else {
+        logger.error('Run-from-block execution error:', error)
+        callbacks.onExecutionError?.({
+          error: error.message || 'Unknown error',
+          duration: 0,
+        })
       }
-      logger.error('Run-from-block execution error:', error)
-      callbacks.onExecutionError?.({
-        error: error.message || 'Unknown error',
-        duration: 0,
-      })
       throw error
     } finally {
-      if (sharedAbortControllers.get(workflowId) === abortController) {
-        sharedAbortControllers.delete(workflowId)
-      }
-    }
-  }, [])
-
-  const reconnect = useCallback(async (options: ReconnectStreamOptions) => {
-    const { workflowId, executionId, fromEventId = 0, callbacks = {} } = options
-
-    const existing = sharedAbortControllers.get(workflowId)
-    if (existing) {
-      existing.abort()
-    }
-
-    const abortController = new AbortController()
-    sharedAbortControllers.set(workflowId, abortController)
-    try {
-      const response = await fetch(
-        `/api/workflows/${workflowId}/executions/${executionId}/stream?from=${fromEventId}`,
-        { signal: abortController.signal }
-      )
-      if (!response.ok) throw new Error(`Reconnect failed (${response.status})`)
-      if (!response.body) throw new Error('No response body')
-
-      await processSSEStream(response.body.getReader(), callbacks, 'Reconnect')
-    } catch (error: any) {
-      if (isClientDisconnectError(error)) return
-      logger.error('Reconnection stream error:', error)
-      throw error
-    } finally {
-      if (sharedAbortControllers.get(workflowId) === abortController) {
-        sharedAbortControllers.delete(workflowId)
-      }
+      abortControllersRef.current.delete(workflowId)
+      currentExecutionsRef.current.delete(workflowId)
     }
   }, [])
 
   const cancel = useCallback((workflowId?: string) => {
     if (workflowId) {
-      const controller = sharedAbortControllers.get(workflowId)
+      const execution = currentExecutionsRef.current.get(workflowId)
+      if (execution) {
+        fetch(`/api/workflows/${execution.workflowId}/executions/${execution.executionId}/cancel`, {
+          method: 'POST',
+        }).catch(() => {})
+      }
+
+      const controller = abortControllersRef.current.get(workflowId)
       if (controller) {
         controller.abort()
-        sharedAbortControllers.delete(workflowId)
+        abortControllersRef.current.delete(workflowId)
       }
+      currentExecutionsRef.current.delete(workflowId)
     } else {
-      for (const [, controller] of sharedAbortControllers) {
+      for (const [, execution] of currentExecutionsRef.current) {
+        fetch(`/api/workflows/${execution.workflowId}/executions/${execution.executionId}/cancel`, {
+          method: 'POST',
+        }).catch(() => {})
+      }
+
+      for (const [, controller] of abortControllersRef.current) {
         controller.abort()
       }
-      sharedAbortControllers.clear()
+      abortControllersRef.current.clear()
+      currentExecutionsRef.current.clear()
     }
   }, [])
 
   return {
     execute,
     executeFromBlock,
-    reconnect,
     cancel,
   }
 }

apps/sim/lib/copilot/chat-payload.ts

@@ -20,8 +20,6 @@ export interface BuildPayloadParams {
   fileAttachments?: Array<{ id: string; key: string; size: number; [key: string]: unknown }>
   commands?: string[]
   chatId?: string
-  conversationId?: string
-  prefetch?: boolean
   implicitFeedback?: string
 }
 
@@ -66,10 +64,6 @@ export async function buildCopilotRequestPayload(
     fileAttachments,
     commands,
     chatId,
-    conversationId,
-    prefetch,
-    conversationHistory,
-    implicitFeedback,
   } = params
 
   const selectedModel = options.selectedModel
@@ -160,12 +154,6 @@ export async function buildCopilotRequestPayload(
     version: SIM_AGENT_VERSION,
     ...(contexts && contexts.length > 0 ? { context: contexts } : {}),
     ...(chatId ? { chatId } : {}),
-    ...(conversationId ? { conversationId } : {}),
-    ...(Array.isArray(conversationHistory) && conversationHistory.length > 0
-      ? { conversationHistory }
-      : {}),
-    ...(typeof prefetch === 'boolean' ? { prefetch } : {}),
-    ...(implicitFeedback ? { implicitFeedback } : {}),
     ...(processedFileContents.length > 0 ? { fileAttachments: processedFileContents } : {}),
     ...(integrationTools.length > 0 ? { integrationTools } : {}),
     ...(credentials ? { credentials } : {}),

apps/sim/lib/execution/event-buffer.ts

@@ -1,246 +0,0 @@
-import { createLogger } from '@sim/logger'
-import { getRedisClient } from '@/lib/core/config/redis'
-import type { ExecutionEvent } from '@/lib/workflows/executor/execution-events'
-
-const logger = createLogger('ExecutionEventBuffer')
-
-const REDIS_PREFIX = 'execution:stream:'
-const TTL_SECONDS = 60 * 60 // 1 hour
-const EVENT_LIMIT = 1000
-const RESERVE_BATCH = 100
-const FLUSH_INTERVAL_MS = 15
-const FLUSH_MAX_BATCH = 200
-
-function getEventsKey(executionId: string) {
-  return `${REDIS_PREFIX}${executionId}:events`
-}
-
-function getSeqKey(executionId: string) {
-  return `${REDIS_PREFIX}${executionId}:seq`
-}
-
-function getMetaKey(executionId: string) {
-  return `${REDIS_PREFIX}${executionId}:meta`
-}
-
-export type ExecutionStreamStatus = 'active' | 'complete' | 'error' | 'cancelled'
-
-export interface ExecutionStreamMeta {
-  status: ExecutionStreamStatus
-  userId?: string
-  workflowId?: string
-  updatedAt?: string
-}
-
-export interface ExecutionEventEntry {
-  eventId: number
-  executionId: string
-  event: ExecutionEvent
-}
-
-export interface ExecutionEventWriter {
-  write: (event: ExecutionEvent) => Promise<ExecutionEventEntry>
-  flush: () => Promise<void>
-  close: () => Promise<void>
-}
-
-export async function setExecutionMeta(
-  executionId: string,
-  meta: Partial<ExecutionStreamMeta>
-): Promise<void> {
-  const redis = getRedisClient()
-  if (!redis) {
-    logger.warn('setExecutionMeta: Redis client unavailable', { executionId })
-    return
-  }
-  try {
-    const key = getMetaKey(executionId)
-    const payload: Record<string, string> = {
-      updatedAt: new Date().toISOString(),
-    }
-    if (meta.status) payload.status = meta.status
-    if (meta.userId) payload.userId = meta.userId
-    if (meta.workflowId) payload.workflowId = meta.workflowId
-    await redis.hset(key, payload)
-    await redis.expire(key, TTL_SECONDS)
-  } catch (error) {
-    logger.warn('Failed to update execution meta', {
-      executionId,
-      error: error instanceof Error ? error.message : String(error),
-    })
-  }
-}
-
-export async function getExecutionMeta(executionId: string): Promise<ExecutionStreamMeta | null> {
-  const redis = getRedisClient()
-  if (!redis) {
-    logger.warn('getExecutionMeta: Redis client unavailable', { executionId })
-    return null
-  }
-  try {
-    const key = getMetaKey(executionId)
-    const meta = await redis.hgetall(key)
-    if (!meta || Object.keys(meta).length === 0) return null
-    return meta as unknown as ExecutionStreamMeta
-  } catch (error) {
-    logger.warn('Failed to read execution meta', {
-      executionId,
-      error: error instanceof Error ? error.message : String(error),
-    })
-    return null
-  }
-}
-
-export async function readExecutionEvents(
-  executionId: string,
-  afterEventId: number
-): Promise<ExecutionEventEntry[]> {
-  const redis = getRedisClient()
-  if (!redis) return []
-  try {
-    const raw = await redis.zrangebyscore(getEventsKey(executionId), afterEventId + 1, '+inf')
-    return raw
-      .map((entry) => {
-        try {
-          return JSON.parse(entry) as ExecutionEventEntry
-        } catch {
-          return null
-        }
-      })
-      .filter((entry): entry is ExecutionEventEntry => Boolean(entry))
-  } catch (error) {
-    logger.warn('Failed to read execution events', {
-      executionId,
-      error: error instanceof Error ? error.message : String(error),
-    })
-    return []
-  }
-}
-
-export function createExecutionEventWriter(executionId: string): ExecutionEventWriter {
-  const redis = getRedisClient()
-  if (!redis) {
-    logger.warn(
-      'createExecutionEventWriter: Redis client unavailable, events will not be buffered',
-      {
-        executionId,
-      }
-    )
-    return {
-      write: async (event) => ({ eventId: 0, executionId, event }),
-      flush: async () => {},
-      close: async () => {},
-    }
-  }
-
-  let pending: ExecutionEventEntry[] = []
-  let nextEventId = 0
-  let maxReservedId = 0
-  let flushTimer: ReturnType<typeof setTimeout> | null = null
-
-  const scheduleFlush = () => {
-    if (flushTimer) return
-    flushTimer = setTimeout(() => {
-      flushTimer = null
-      void flush()
-    }, FLUSH_INTERVAL_MS)
-  }
-
-  const reserveIds = async (minCount: number) => {
-    const reserveCount = Math.max(RESERVE_BATCH, minCount)
-    const newMax = await redis.incrby(getSeqKey(executionId), reserveCount)
-    const startId = newMax - reserveCount + 1
-    if (nextEventId === 0 || nextEventId > maxReservedId) {
-      nextEventId = startId
-      maxReservedId = newMax
-    }
-  }
-
-  let flushPromise: Promise<void> | null = null
-  let closed = false
-  const inflightWrites = new Set<Promise<ExecutionEventEntry>>()
-
-  const doFlush = async () => {
-    if (pending.length === 0) return
-    const batch = pending
-    pending = []
-    try {
-      const key = getEventsKey(executionId)
-      const zaddArgs: (string | number)[] = []
-      for (const entry of batch) {
-        zaddArgs.push(entry.eventId, JSON.stringify(entry))
-      }
-      const pipeline = redis.pipeline()
-      pipeline.zadd(key, ...zaddArgs)
-      pipeline.expire(key, TTL_SECONDS)
-      pipeline.expire(getSeqKey(executionId), TTL_SECONDS)
-      pipeline.zremrangebyrank(key, 0, -EVENT_LIMIT - 1)
-      await pipeline.exec()
-    } catch (error) {
-      logger.warn('Failed to flush execution events', {
-        executionId,
-        batchSize: batch.length,
-        error: error instanceof Error ? error.message : String(error),
-        stack: error instanceof Error ? error.stack : undefined,
-      })
-      pending = batch.concat(pending)
-    }
-  }
-
-  const flush = async () => {
-    if (flushPromise) {
-      await flushPromise
-      return
-    }
-    flushPromise = doFlush()
-    try {
-      await flushPromise
-    } finally {
-      flushPromise = null
-      if (pending.length > 0) scheduleFlush()
-    }
-  }
-
-  const writeCore = async (event: ExecutionEvent): Promise<ExecutionEventEntry> => {
-    if (closed) return { eventId: 0, executionId, event }
-    if (nextEventId === 0 || nextEventId > maxReservedId) {
-      await reserveIds(1)
-    }
-    const eventId = nextEventId++
-    const entry: ExecutionEventEntry = { eventId, executionId, event }
-    pending.push(entry)
-    if (pending.length >= FLUSH_MAX_BATCH) {
-      await flush()
-    } else {
-      scheduleFlush()
-    }
-    return entry
-  }
-
-  const write = (event: ExecutionEvent): Promise<ExecutionEventEntry> => {
-    const p = writeCore(event)
-    inflightWrites.add(p)
-    const remove = () => inflightWrites.delete(p)
-    p.then(remove, remove)
-    return p
-  }
-
-  const close = async () => {
-    closed = true
-    if (flushTimer) {
-      clearTimeout(flushTimer)
-      flushTimer = null
-    }
-    if (inflightWrites.size > 0) {
-      await Promise.allSettled(inflightWrites)
-    }
-    if (flushPromise) {
-      await flushPromise
-    }
-    if (pending.length > 0) {
-      await doFlush()
-    }
-  }
-
-  return { write, flush, close }
-}

apps/sim/lib/workflows/comparison/compare.test.ts

@@ -2364,261 +2364,6 @@ describe('hasWorkflowChanged', () => {
     })
   })
 
-  describe('Trigger Config Normalization (False Positive Prevention)', () => {
-    it.concurrent(
-      'should not detect change when deployed has null fields but current has values from triggerConfig',
-      () => {
-        // Core scenario: deployed state has null individual fields, current state has
-        // values populated from triggerConfig at runtime by populateTriggerFieldsFromConfig
-        const deployedState = createWorkflowState({
-          blocks: {
-            block1: createBlock('block1', {
-              type: 'starter',
-              subBlocks: {
-                signingSecret: { id: 'signingSecret', type: 'short-input', value: null },
-                botToken: { id: 'botToken', type: 'short-input', value: null },
-                triggerConfig: {
-                  id: 'triggerConfig',
-                  type: 'short-input',
-                  value: { signingSecret: 'secret123', botToken: 'token456' },
-                },
-              },
-            }),
-          },
-        })
-
-        const currentState = createWorkflowState({
-          blocks: {
-            block1: createBlock('block1', {
-              type: 'starter',
-              subBlocks: {
-                signingSecret: { id: 'signingSecret', type: 'short-input', value: 'secret123' },
-                botToken: { id: 'botToken', type: 'short-input', value: 'token456' },
-                triggerConfig: {
-                  id: 'triggerConfig',
-                  type: 'short-input',
-                  value: { signingSecret: 'secret123', botToken: 'token456' },
-                },
-              },
-            }),
-          },
-        })
-
-        expect(hasWorkflowChanged(currentState, deployedState)).toBe(false)
-      }
-    )
-
-    it.concurrent(
-      'should detect change when user edits a trigger field to a different value',
-      () => {
-        const deployedState = createWorkflowState({
-          blocks: {
-            block1: createBlock('block1', {
-              type: 'starter',
-              subBlocks: {
-                signingSecret: { id: 'signingSecret', type: 'short-input', value: null },
-                triggerConfig: {
-                  id: 'triggerConfig',
-                  type: 'short-input',
-                  value: { signingSecret: 'old-secret' },
-                },
-              },
-            }),
-          },
-        })
-
-        const currentState = createWorkflowState({
-          blocks: {
-            block1: createBlock('block1', {
-              type: 'starter',
-              subBlocks: {
-                signingSecret: { id: 'signingSecret', type: 'short-input', value: 'new-secret' },
-                triggerConfig: {
-                  id: 'triggerConfig',
-                  type: 'short-input',
-                  value: { signingSecret: 'old-secret' },
-                },
-              },
-            }),
-          },
-        })
-
-        expect(hasWorkflowChanged(currentState, deployedState)).toBe(true)
-      }
-    )
-
-    it.concurrent('should not detect change when both sides have no triggerConfig', () => {
-      const deployedState = createWorkflowState({
-        blocks: {
-          block1: createBlock('block1', {
-            type: 'starter',
-            subBlocks: {
-              signingSecret: { id: 'signingSecret', type: 'short-input', value: null },
-            },
-          }),
-        },
-      })
-
-      const currentState = createWorkflowState({
-        blocks: {
-          block1: createBlock('block1', {
-            type: 'starter',
-            subBlocks: {
-              signingSecret: { id: 'signingSecret', type: 'short-input', value: null },
-            },
-          }),
-        },
-      })
-
-      expect(hasWorkflowChanged(currentState, deployedState)).toBe(false)
-    })
-
-    it.concurrent(
-      'should not detect change when deployed has empty fields and triggerConfig populates them',
-      () => {
-        // Empty string is also treated as "empty" by normalizeTriggerConfigValues
-        const deployedState = createWorkflowState({
-          blocks: {
-            block1: createBlock('block1', {
-              type: 'starter',
-              subBlocks: {
-                signingSecret: { id: 'signingSecret', type: 'short-input', value: '' },
-                triggerConfig: {
-                  id: 'triggerConfig',
-                  type: 'short-input',
-                  value: { signingSecret: 'secret123' },
-                },
-              },
-            }),
-          },
-        })
-
-        const currentState = createWorkflowState({
-          blocks: {
-            block1: createBlock('block1', {
-              type: 'starter',
-              subBlocks: {
-                signingSecret: { id: 'signingSecret', type: 'short-input', value: 'secret123' },
-                triggerConfig: {
-                  id: 'triggerConfig',
-                  type: 'short-input',
-                  value: { signingSecret: 'secret123' },
-                },
-              },
-            }),
-          },
-        })
-
-        expect(hasWorkflowChanged(currentState, deployedState)).toBe(false)
-      }
-    )
-
-    it.concurrent('should not detect change when triggerId differs', () => {
-      const deployedState = createWorkflowState({
-        blocks: {
-          block1: createBlock('block1', {
-            type: 'starter',
-            subBlocks: {
-              model: { value: 'gpt-4' },
-              triggerId: { value: null },
-            },
-          }),
-        },
-      })
-
-      const currentState = createWorkflowState({
-        blocks: {
-          block1: createBlock('block1', {
-            type: 'starter',
-            subBlocks: {
-              model: { value: 'gpt-4' },
-              triggerId: { value: 'slack_webhook' },
-            },
-          }),
-        },
-      })
-
-      expect(hasWorkflowChanged(currentState, deployedState)).toBe(false)
-    })
-
-    it.concurrent(
-      'should not detect change for namespaced system subBlock IDs like samplePayload_slack_webhook',
-      () => {
-        const deployedState = createWorkflowState({
-          blocks: {
-            block1: createBlock('block1', {
-              type: 'starter',
-              subBlocks: {
-                model: { value: 'gpt-4' },
-                samplePayload_slack_webhook: { value: 'old payload' },
-                triggerInstructions_slack_webhook: { value: 'old instructions' },
-              },
-            }),
-          },
-        })
-
-        const currentState = createWorkflowState({
-          blocks: {
-            block1: createBlock('block1', {
-              type: 'starter',
-              subBlocks: {
-                model: { value: 'gpt-4' },
-                samplePayload_slack_webhook: { value: 'new payload' },
-                triggerInstructions_slack_webhook: { value: 'new instructions' },
-              },
-            }),
-          },
-        })
-
-        expect(hasWorkflowChanged(currentState, deployedState)).toBe(false)
-      }
-    )
-
-    it.concurrent(
-      'should handle mixed scenario: some fields from triggerConfig, some user-edited',
-      () => {
-        const deployedState = createWorkflowState({
-          blocks: {
-            block1: createBlock('block1', {
-              type: 'starter',
-              subBlocks: {
-                signingSecret: { id: 'signingSecret', type: 'short-input', value: null },
-                botToken: { id: 'botToken', type: 'short-input', value: null },
-                includeFiles: { id: 'includeFiles', type: 'switch', value: false },
-                triggerConfig: {
-                  id: 'triggerConfig',
-                  type: 'short-input',
-                  value: { signingSecret: 'secret123', botToken: 'token456' },
-                },
-              },
-            }),
-          },
-        })
-
-        const currentState = createWorkflowState({
-          blocks: {
-            block1: createBlock('block1', {
-              type: 'starter',
-              subBlocks: {
-                signingSecret: { id: 'signingSecret', type: 'short-input', value: 'secret123' },
-                botToken: { id: 'botToken', type: 'short-input', value: 'token456' },
-                includeFiles: { id: 'includeFiles', type: 'switch', value: true },
-                triggerConfig: {
-                  id: 'triggerConfig',
-                  type: 'short-input',
-                  value: { signingSecret: 'secret123', botToken: 'token456' },
-                },
-              },
-            }),
-          },
-        })
-
-        // includeFiles changed from false to true — this IS a real change
-        expect(hasWorkflowChanged(currentState, deployedState)).toBe(true)
-      }
-    )
-  })
-
   describe('Trigger Runtime Metadata (Should Not Trigger Change)', () => {
     it.concurrent('should not detect change when webhookId differs', () => {
       const deployedState = createWorkflowState({

apps/sim/lib/workflows/comparison/compare.ts

@@ -9,7 +9,6 @@ import {
   normalizeLoop,
   normalizeParallel,
   normalizeSubBlockValue,
-  normalizeTriggerConfigValues,
   normalizeValue,
   normalizeVariables,
   sanitizeVariable,
@@ -173,18 +172,14 @@ export function generateWorkflowDiffSummary(
       }
     }
 
-    // Normalize trigger config values for both states before comparison
-    const normalizedCurrentSubs = normalizeTriggerConfigValues(currentSubBlocks)
-    const normalizedPreviousSubs = normalizeTriggerConfigValues(previousSubBlocks)
-
     // Compare subBlocks using shared helper for filtering (single source of truth)
     const allSubBlockIds = filterSubBlockIds([
-      ...new Set([...Object.keys(normalizedCurrentSubs), ...Object.keys(normalizedPreviousSubs)]),
+      ...new Set([...Object.keys(currentSubBlocks), ...Object.keys(previousSubBlocks)]),
     ])
 
     for (const subId of allSubBlockIds) {
-      const currentSub = normalizedCurrentSubs[subId] as Record<string, unknown> | undefined
-      const previousSub = normalizedPreviousSubs[subId] as Record<string, unknown> | undefined
+      const currentSub = currentSubBlocks[subId] as Record<string, unknown> | undefined
+      const previousSub = previousSubBlocks[subId] as Record<string, unknown> | undefined
 
       if (!currentSub || !previousSub) {
         changes.push({

apps/sim/lib/workflows/comparison/normalize.test.ts

@@ -4,12 +4,10 @@
 import { describe, expect, it } from 'vitest'
 import type { Loop, Parallel } from '@/stores/workflows/workflow/types'
 import {
-  filterSubBlockIds,
   normalizedStringify,
   normalizeEdge,
   normalizeLoop,
   normalizeParallel,
-  normalizeTriggerConfigValues,
   normalizeValue,
   sanitizeInputFormat,
   sanitizeTools,
@@ -586,214 +584,4 @@ describe('Workflow Normalization Utilities', () => {
       expect(result2).toBe(result3)
     })
   })
-
-  describe('filterSubBlockIds', () => {
-    it.concurrent('should exclude exact SYSTEM_SUBBLOCK_IDS', () => {
-      const ids = ['signingSecret', 'samplePayload', 'triggerInstructions', 'botToken']
-      const result = filterSubBlockIds(ids)
-      expect(result).toEqual(['botToken', 'signingSecret'])
-    })
-
-    it.concurrent('should exclude namespaced SYSTEM_SUBBLOCK_IDS (prefix matching)', () => {
-      const ids = [
-        'signingSecret',
-        'samplePayload_slack_webhook',
-        'triggerInstructions_slack_webhook',
-        'webhookUrlDisplay_slack_webhook',
-        'botToken',
-      ]
-      const result = filterSubBlockIds(ids)
-      expect(result).toEqual(['botToken', 'signingSecret'])
-    })
-
-    it.concurrent('should exclude exact TRIGGER_RUNTIME_SUBBLOCK_IDS', () => {
-      const ids = ['webhookId', 'triggerPath', 'triggerConfig', 'triggerId', 'signingSecret']
-      const result = filterSubBlockIds(ids)
-      expect(result).toEqual(['signingSecret'])
-    })
-
-    it.concurrent('should not exclude IDs that merely contain a system ID substring', () => {
-      const ids = ['mySamplePayload', 'notSamplePayload']
-      const result = filterSubBlockIds(ids)
-      expect(result).toEqual(['mySamplePayload', 'notSamplePayload'])
-    })
-
-    it.concurrent('should return sorted results', () => {
-      const ids = ['zebra', 'alpha', 'middle']
-      const result = filterSubBlockIds(ids)
-      expect(result).toEqual(['alpha', 'middle', 'zebra'])
-    })
-
-    it.concurrent('should handle empty array', () => {
-      expect(filterSubBlockIds([])).toEqual([])
-    })
-
-    it.concurrent('should handle all IDs being excluded', () => {
-      const ids = ['webhookId', 'triggerPath', 'samplePayload', 'triggerConfig']
-      const result = filterSubBlockIds(ids)
-      expect(result).toEqual([])
-    })
-
-    it.concurrent('should exclude setupScript and scheduleInfo namespaced variants', () => {
-      const ids = ['setupScript_google_sheets_row', 'scheduleInfo_cron_trigger', 'realField']
-      const result = filterSubBlockIds(ids)
-      expect(result).toEqual(['realField'])
-    })
-
-    it.concurrent('should exclude triggerCredentials namespaced variants', () => {
-      const ids = ['triggerCredentials_slack_webhook', 'signingSecret']
-      const result = filterSubBlockIds(ids)
-      expect(result).toEqual(['signingSecret'])
-    })
-  })
-
-  describe('normalizeTriggerConfigValues', () => {
-    it.concurrent('should return subBlocks unchanged when no triggerConfig exists', () => {
-      const subBlocks = {
-        signingSecret: { id: 'signingSecret', type: 'short-input', value: 'secret123' },
-        botToken: { id: 'botToken', type: 'short-input', value: 'token456' },
-      }
-      const result = normalizeTriggerConfigValues(subBlocks)
-      expect(result).toEqual(subBlocks)
-    })
-
-    it.concurrent('should return subBlocks unchanged when triggerConfig value is null', () => {
-      const subBlocks = {
-        triggerConfig: { id: 'triggerConfig', type: 'short-input', value: null },
-        signingSecret: { id: 'signingSecret', type: 'short-input', value: null },
-      }
-      const result = normalizeTriggerConfigValues(subBlocks)
-      expect(result).toEqual(subBlocks)
-    })
-
-    it.concurrent(
-      'should return subBlocks unchanged when triggerConfig value is not an object',
-      () => {
-        const subBlocks = {
-          triggerConfig: { id: 'triggerConfig', type: 'short-input', value: 'string-value' },
-          signingSecret: { id: 'signingSecret', type: 'short-input', value: null },
-        }
-        const result = normalizeTriggerConfigValues(subBlocks)
-        expect(result).toEqual(subBlocks)
-      }
-    )
-
-    it.concurrent('should populate null individual fields from triggerConfig', () => {
-      const subBlocks = {
-        triggerConfig: {
-          id: 'triggerConfig',
-          type: 'short-input',
-          value: { signingSecret: 'secret123', botToken: 'token456' },
-        },
-        signingSecret: { id: 'signingSecret', type: 'short-input', value: null },
-        botToken: { id: 'botToken', type: 'short-input', value: null },
-      }
-      const result = normalizeTriggerConfigValues(subBlocks)
-      expect((result.signingSecret as Record<string, unknown>).value).toBe('secret123')
-      expect((result.botToken as Record<string, unknown>).value).toBe('token456')
-    })
-
-    it.concurrent('should populate undefined individual fields from triggerConfig', () => {
-      const subBlocks = {
-        triggerConfig: {
-          id: 'triggerConfig',
-          type: 'short-input',
-          value: { signingSecret: 'secret123' },
-        },
-        signingSecret: { id: 'signingSecret', type: 'short-input', value: undefined },
-      }
-      const result = normalizeTriggerConfigValues(subBlocks)
-      expect((result.signingSecret as Record<string, unknown>).value).toBe('secret123')
-    })
-
-    it.concurrent('should populate empty string individual fields from triggerConfig', () => {
-      const subBlocks = {
-        triggerConfig: {
-          id: 'triggerConfig',
-          type: 'short-input',
-          value: { signingSecret: 'secret123' },
-        },
-        signingSecret: { id: 'signingSecret', type: 'short-input', value: '' },
-      }
-      const result = normalizeTriggerConfigValues(subBlocks)
-      expect((result.signingSecret as Record<string, unknown>).value).toBe('secret123')
-    })
-
-    it.concurrent('should NOT overwrite existing non-empty individual field values', () => {
-      const subBlocks = {
-        triggerConfig: {
-          id: 'triggerConfig',
-          type: 'short-input',
-          value: { signingSecret: 'old-secret' },
-        },
-        signingSecret: { id: 'signingSecret', type: 'short-input', value: 'user-edited-secret' },
-      }
-      const result = normalizeTriggerConfigValues(subBlocks)
-      expect((result.signingSecret as Record<string, unknown>).value).toBe('user-edited-secret')
-    })
-
-    it.concurrent('should skip triggerConfig fields that are null/undefined', () => {
-      const subBlocks = {
-        triggerConfig: {
-          id: 'triggerConfig',
-          type: 'short-input',
-          value: { signingSecret: null, botToken: undefined },
-        },
-        signingSecret: { id: 'signingSecret', type: 'short-input', value: null },
-        botToken: { id: 'botToken', type: 'short-input', value: null },
-      }
-      const result = normalizeTriggerConfigValues(subBlocks)
-      expect((result.signingSecret as Record<string, unknown>).value).toBe(null)
-      expect((result.botToken as Record<string, unknown>).value).toBe(null)
-    })
-
-    it.concurrent('should skip fields from triggerConfig that have no matching subBlock', () => {
-      const subBlocks = {
-        triggerConfig: {
-          id: 'triggerConfig',
-          type: 'short-input',
-          value: { nonExistentField: 'value123' },
-        },
-        signingSecret: { id: 'signingSecret', type: 'short-input', value: null },
-      }
-      const result = normalizeTriggerConfigValues(subBlocks)
-      expect(result.nonExistentField).toBeUndefined()
-      expect((result.signingSecret as Record<string, unknown>).value).toBe(null)
-    })
-
-    it.concurrent('should not mutate the original subBlocks object', () => {
-      const original = {
-        triggerConfig: {
-          id: 'triggerConfig',
-          type: 'short-input',
-          value: { signingSecret: 'secret123' },
-        },
-        signingSecret: { id: 'signingSecret', type: 'short-input', value: null },
-      }
-      normalizeTriggerConfigValues(original)
-      expect((original.signingSecret as Record<string, unknown>).value).toBe(null)
-    })
-
-    it.concurrent('should preserve other subBlock properties when populating value', () => {
-      const subBlocks = {
-        triggerConfig: {
-          id: 'triggerConfig',
-          type: 'short-input',
-          value: { signingSecret: 'secret123' },
-        },
-        signingSecret: {
-          id: 'signingSecret',
-          type: 'short-input',
-          value: null,
-          placeholder: 'Enter signing secret',
-        },
-      }
-      const result = normalizeTriggerConfigValues(subBlocks)
-      const normalized = result.signingSecret as Record<string, unknown>
-      expect(normalized.value).toBe('secret123')
-      expect(normalized.id).toBe('signingSecret')
-      expect(normalized.type).toBe('short-input')
-      expect(normalized.placeholder).toBe('Enter signing secret')
-    })
-  })
 })

apps/sim/lib/workflows/comparison/normalize.ts

@@ -418,48 +418,10 @@ export function extractBlockFieldsForComparison(block: BlockState): ExtractedBlo
  */
 export function filterSubBlockIds(subBlockIds: string[]): string[] {
   return subBlockIds
-    .filter((id) => {
-      if (TRIGGER_RUNTIME_SUBBLOCK_IDS.includes(id)) return false
-      if (SYSTEM_SUBBLOCK_IDS.some((sysId) => id === sysId || id.startsWith(`${sysId}_`)))
-        return false
-      return true
-    })
+    .filter((id) => !SYSTEM_SUBBLOCK_IDS.includes(id) && !TRIGGER_RUNTIME_SUBBLOCK_IDS.includes(id))
     .sort()
 }
 
-/**
- * Normalizes trigger block subBlocks by populating null/empty individual fields
- * from the triggerConfig aggregate subBlock. This compensates for the runtime
- * population done by populateTriggerFieldsFromConfig, ensuring consistent
- * comparison between client state (with populated values) and deployed state
- * (with null values from DB).
- */
-export function normalizeTriggerConfigValues(
-  subBlocks: Record<string, unknown>
-): Record<string, unknown> {
-  const triggerConfigSub = subBlocks.triggerConfig as Record<string, unknown> | undefined
-  const triggerConfigValue = triggerConfigSub?.value
-  if (!triggerConfigValue || typeof triggerConfigValue !== 'object') {
-    return subBlocks
-  }
-
-  const result = { ...subBlocks }
-  for (const [fieldId, configValue] of Object.entries(
-    triggerConfigValue as Record<string, unknown>
-  )) {
-    if (configValue === null || configValue === undefined) continue
-    const existingSub = result[fieldId] as Record<string, unknown> | undefined
-    if (
-      existingSub &&
-      (existingSub.value === null || existingSub.value === undefined || existingSub.value === '')
-    ) {
-      result[fieldId] = { ...existingSub, value: configValue }
-    }
-  }
-
-  return result
-}
-
 /**
  * Normalizes a subBlock value with sanitization for specific subBlock types.
  * Sanitizes: tools (removes isExpanded), inputFormat (removes collapsed)

apps/sim/stores/execution/store.ts

@@ -129,18 +129,6 @@ export const useExecutionStore = create<ExecutionState & ExecutionActions>()((se
     })
   },
 
-  setCurrentExecutionId: (workflowId, executionId) => {
-    set({
-      workflowExecutions: updatedMap(get().workflowExecutions, workflowId, {
-        currentExecutionId: executionId,
-      }),
-    })
-  },
-
-  getCurrentExecutionId: (workflowId) => {
-    return getOrCreate(get().workflowExecutions, workflowId).currentExecutionId
-  },
-
   clearRunPath: (workflowId) => {
     set({
       workflowExecutions: updatedMap(get().workflowExecutions, workflowId, {

apps/sim/stores/execution/types.ts

@@ -35,8 +35,6 @@ export interface WorkflowExecutionState {
   lastRunPath: Map<string, BlockRunStatus>
   /** Maps edge IDs to their run result from the last execution */
   lastRunEdges: Map<string, EdgeRunStatus>
-  /** The execution ID of the currently running execution */
-  currentExecutionId: string | null
 }
 
 /**
@@ -56,7 +54,6 @@ export const defaultWorkflowExecutionState: WorkflowExecutionState = {
   debugContext: null,
   lastRunPath: new Map(),
   lastRunEdges: new Map(),
-  currentExecutionId: null,
 }
 
 /**
@@ -99,10 +96,6 @@ export interface ExecutionActions {
   setEdgeRunStatus: (workflowId: string, edgeId: string, status: EdgeRunStatus) => void
   /** Clears the run path and run edges for a workflow */
   clearRunPath: (workflowId: string) => void
-  /** Stores the current execution ID for a workflow */
-  setCurrentExecutionId: (workflowId: string, executionId: string | null) => void
-  /** Returns the current execution ID for a workflow */
-  getCurrentExecutionId: (workflowId: string) => string | null
   /** Resets the entire store to its initial empty state */
   reset: () => void
   /** Stores a serializable execution snapshot for a workflow */

apps/sim/stores/terminal/console/store.ts

@@ -224,7 +224,7 @@ export const useTerminalConsoleStore = create<ConsoleStore>()(
 
           const newEntry = get().entries[0]
 
-          if (newEntry?.error && newEntry.blockType !== 'cancelled') {
+          if (newEntry?.error) {
             notifyBlockError({
               error: newEntry.error,
               blockName: newEntry.blockName || 'Unknown Block',
@@ -243,11 +243,6 @@ export const useTerminalConsoleStore = create<ConsoleStore>()(
           useExecutionStore.getState().clearRunPath(workflowId)
         },
 
-        clearExecutionEntries: (executionId: string) =>
-          set((state) => ({
-            entries: state.entries.filter((e) => e.executionId !== executionId),
-          })),
-
         exportConsoleCSV: (workflowId: string) => {
           const entries = get().entries.filter((entry) => entry.workflowId === workflowId)
 
@@ -475,24 +470,12 @@ export const useTerminalConsoleStore = create<ConsoleStore>()(
         },
         merge: (persistedState, currentState) => {
           const persisted = persistedState as Partial<ConsoleStore> | undefined
-          const rawEntries = persisted?.entries ?? currentState.entries
-          const oneHourAgo = Date.now() - 60 * 60 * 1000
-
-          const entries = rawEntries.map((entry, index) => {
-            let updated = entry
+          const entries = (persisted?.entries ?? currentState.entries).map((entry, index) => {
             if (entry.executionOrder === undefined) {
-              updated = { ...updated, executionOrder: index + 1 }
+              return { ...entry, executionOrder: index + 1 }
             }
-            if (
-              entry.isRunning &&
-              entry.startedAt &&
-              new Date(entry.startedAt).getTime() < oneHourAgo
-            ) {
-              updated = { ...updated, isRunning: false }
-            }
-            return updated
+            return entry
           })
-
           return {
             ...currentState,
             entries,

apps/sim/stores/terminal/console/types.ts

@@ -51,7 +51,6 @@ export interface ConsoleStore {
   isOpen: boolean
   addConsole: (entry: Omit<ConsoleEntry, 'id' | 'timestamp'>) => ConsoleEntry
   clearWorkflowConsole: (workflowId: string) => void
-  clearExecutionEntries: (executionId: string) => void
   exportConsoleCSV: (workflowId: string) => void
   getWorkflowEntries: (workflowId: string) => ConsoleEntry[]
   toggleConsole: () => void

apps/sim/tools/google_books/index.ts

@@ -1,3 +0,0 @@
-export * from './types'
-export { googleBooksVolumeDetailsTool } from './volume_details'
-export { googleBooksVolumeSearchTool } from './volume_search'

apps/sim/tools/google_books/types.ts

@@ -1,64 +0,0 @@
-import type { ToolResponse } from '@/tools/types'
-
-/**
- * Volume information structure shared between search and details responses
- */
-export interface VolumeInfo {
-  id: string
-  title: string
-  subtitle: string | null
-  authors: string[]
-  publisher: string | null
-  publishedDate: string | null
-  description: string | null
-  pageCount: number | null
-  categories: string[]
-  averageRating: number | null
-  ratingsCount: number | null
-  language: string | null
-  previewLink: string | null
-  infoLink: string | null
-  thumbnailUrl: string | null
-  isbn10: string | null
-  isbn13: string | null
-}
-
-/**
- * Parameters for searching volumes
- */
-export interface GoogleBooksVolumeSearchParams {
-  apiKey: string
-  query: string
-  filter?: 'partial' | 'full' | 'free-ebooks' | 'paid-ebooks' | 'ebooks'
-  printType?: 'all' | 'books' | 'magazines'
-  orderBy?: 'relevance' | 'newest'
-  startIndex?: number
-  maxResults?: number
-  langRestrict?: string
-}
-
-/**
- * Response from volume search
- */
-export interface GoogleBooksVolumeSearchResponse extends ToolResponse {
-  output: {
-    totalItems: number
-    volumes: VolumeInfo[]
-  }
-}
-
-/**
- * Parameters for getting volume details
- */
-export interface GoogleBooksVolumeDetailsParams {
-  apiKey: string
-  volumeId: string
-  projection?: 'full' | 'lite'
-}
-
-/**
- * Response from volume details
- */
-export interface GoogleBooksVolumeDetailsResponse extends ToolResponse {
-  output: VolumeInfo
-}

apps/sim/tools/google_books/volume_details.ts

@@ -1,205 +0,0 @@
-import type {
-  GoogleBooksVolumeDetailsParams,
-  GoogleBooksVolumeDetailsResponse,
-} from '@/tools/google_books/types'
-import type { ToolConfig } from '@/tools/types'
-
-interface GoogleBooksVolumeResponse {
-  id: string
-  volumeInfo: {
-    title?: string
-    subtitle?: string
-    authors?: string[]
-    publisher?: string
-    publishedDate?: string
-    description?: string
-    pageCount?: number
-    categories?: string[]
-    averageRating?: number
-    ratingsCount?: number
-    language?: string
-    previewLink?: string
-    infoLink?: string
-    imageLinks?: {
-      thumbnail?: string
-      smallThumbnail?: string
-    }
-    industryIdentifiers?: Array<{
-      type: string
-      identifier: string
-    }>
-  }
-  error?: {
-    message?: string
-  }
-}
-
-export const googleBooksVolumeDetailsTool: ToolConfig<
-  GoogleBooksVolumeDetailsParams,
-  GoogleBooksVolumeDetailsResponse
-> = {
-  id: 'google_books_volume_details',
-  name: 'Google Books Volume Details',
-  description: 'Get detailed information about a specific book volume',
-  version: '1.0.0',
-
-  params: {
-    apiKey: {
-      type: 'string',
-      required: true,
-      visibility: 'user-only',
-      description: 'Google Books API key',
-    },
-    volumeId: {
-      type: 'string',
-      required: true,
-      visibility: 'user-or-llm',
-      description: 'The ID of the volume to retrieve',
-    },
-    projection: {
-      type: 'string',
-      required: false,
-      visibility: 'user-or-llm',
-      description: 'Projection level (full, lite)',
-    },
-  },
-
-  request: {
-    url: (params) => {
-      const url = new URL(`https://www.googleapis.com/books/v1/volumes/${params.volumeId.trim()}`)
-      url.searchParams.set('key', params.apiKey.trim())
-
-      if (params.projection) {
-        url.searchParams.set('projection', params.projection)
-      }
-
-      return url.toString()
-    },
-    method: 'GET',
-    headers: () => ({
-      'Content-Type': 'application/json',
-    }),
-  },
-
-  transformResponse: async (response: Response) => {
-    const data: GoogleBooksVolumeResponse = await response.json()
-
-    if (data.error) {
-      throw new Error(`Google Books API error: ${data.error.message || 'Unknown error'}`)
-    }
-
-    if (!data.volumeInfo) {
-      throw new Error('Volume not found')
-    }
-
-    const info = data.volumeInfo
-    const identifiers = info.industryIdentifiers ?? []
-
-    return {
-      success: true,
-      output: {
-        id: data.id,
-        title: info.title ?? '',
-        subtitle: info.subtitle ?? null,
-        authors: info.authors ?? [],
-        publisher: info.publisher ?? null,
-        publishedDate: info.publishedDate ?? null,
-        description: info.description ?? null,
-        pageCount: info.pageCount ?? null,
-        categories: info.categories ?? [],
-        averageRating: info.averageRating ?? null,
-        ratingsCount: info.ratingsCount ?? null,
-        language: info.language ?? null,
-        previewLink: info.previewLink ?? null,
-        infoLink: info.infoLink ?? null,
-        thumbnailUrl: info.imageLinks?.thumbnail ?? info.imageLinks?.smallThumbnail ?? null,
-        isbn10: identifiers.find((id) => id.type === 'ISBN_10')?.identifier ?? null,
-        isbn13: identifiers.find((id) => id.type === 'ISBN_13')?.identifier ?? null,
-      },
-    }
-  },
-
-  outputs: {
-    id: {
-      type: 'string',
-      description: 'Volume ID',
-    },
-    title: {
-      type: 'string',
-      description: 'Book title',
-    },
-    subtitle: {
-      type: 'string',
-      description: 'Book subtitle',
-      optional: true,
-    },
-    authors: {
-      type: 'array',
-      description: 'List of authors',
-    },
-    publisher: {
-      type: 'string',
-      description: 'Publisher name',
-      optional: true,
-    },
-    publishedDate: {
-      type: 'string',
-      description: 'Publication date',
-      optional: true,
-    },
-    description: {
-      type: 'string',
-      description: 'Book description',
-      optional: true,
-    },
-    pageCount: {
-      type: 'number',
-      description: 'Number of pages',
-      optional: true,
-    },
-    categories: {
-      type: 'array',
-      description: 'Book categories',
-    },
-    averageRating: {
-      type: 'number',
-      description: 'Average rating (1-5)',
-      optional: true,
-    },
-    ratingsCount: {
-      type: 'number',
-      description: 'Number of ratings',
-      optional: true,
-    },
-    language: {
-      type: 'string',
-      description: 'Language code',
-      optional: true,
-    },
-    previewLink: {
-      type: 'string',
-      description: 'Link to preview on Google Books',
-      optional: true,
-    },
-    infoLink: {
-      type: 'string',
-      description: 'Link to info page',
-      optional: true,
-    },
-    thumbnailUrl: {
-      type: 'string',
-      description: 'Book cover thumbnail URL',
-      optional: true,
-    },
-    isbn10: {
-      type: 'string',
-      description: 'ISBN-10 identifier',
-      optional: true,
-    },
-    isbn13: {
-      type: 'string',
-      description: 'ISBN-13 identifier',
-      optional: true,
-    },
-  },
-}

apps/sim/tools/google_books/volume_search.ts

@@ -1,205 +0,0 @@
-import type {
-  GoogleBooksVolumeSearchParams,
-  GoogleBooksVolumeSearchResponse,
-  VolumeInfo,
-} from '@/tools/google_books/types'
-import type { ToolConfig } from '@/tools/types'
-
-interface GoogleBooksVolumeItem {
-  id: string
-  volumeInfo: {
-    title?: string
-    subtitle?: string
-    authors?: string[]
-    publisher?: string
-    publishedDate?: string
-    description?: string
-    pageCount?: number
-    categories?: string[]
-    averageRating?: number
-    ratingsCount?: number
-    language?: string
-    previewLink?: string
-    infoLink?: string
-    imageLinks?: {
-      thumbnail?: string
-      smallThumbnail?: string
-    }
-    industryIdentifiers?: Array<{
-      type: string
-      identifier: string
-    }>
-  }
-}
-
-function extractVolumeInfo(item: GoogleBooksVolumeItem): VolumeInfo {
-  const info = item.volumeInfo
-  const identifiers = info.industryIdentifiers ?? []
-
-  return {
-    id: item.id,
-    title: info.title ?? '',
-    subtitle: info.subtitle ?? null,
-    authors: info.authors ?? [],
-    publisher: info.publisher ?? null,
-    publishedDate: info.publishedDate ?? null,
-    description: info.description ?? null,
-    pageCount: info.pageCount ?? null,
-    categories: info.categories ?? [],
-    averageRating: info.averageRating ?? null,
-    ratingsCount: info.ratingsCount ?? null,
-    language: info.language ?? null,
-    previewLink: info.previewLink ?? null,
-    infoLink: info.infoLink ?? null,
-    thumbnailUrl: info.imageLinks?.thumbnail ?? info.imageLinks?.smallThumbnail ?? null,
-    isbn10: identifiers.find((id) => id.type === 'ISBN_10')?.identifier ?? null,
-    isbn13: identifiers.find((id) => id.type === 'ISBN_13')?.identifier ?? null,
-  }
-}
-
-export const googleBooksVolumeSearchTool: ToolConfig<
-  GoogleBooksVolumeSearchParams,
-  GoogleBooksVolumeSearchResponse
-> = {
-  id: 'google_books_volume_search',
-  name: 'Google Books Volume Search',
-  description: 'Search for books using the Google Books API',
-  version: '1.0.0',
-
-  params: {
-    apiKey: {
-      type: 'string',
-      required: true,
-      visibility: 'user-only',
-      description: 'Google Books API key',
-    },
-    query: {
-      type: 'string',
-      required: true,
-      visibility: 'user-or-llm',
-      description:
-        'Search query. Supports special keywords: intitle:, inauthor:, inpublisher:, subject:, isbn:',
-    },
-    filter: {
-      type: 'string',
-      required: false,
-      visibility: 'user-or-llm',
-      description: 'Filter results by availability (partial, full, free-ebooks, paid-ebooks, ebooks)',
-    },
-    printType: {
-      type: 'string',
-      required: false,
-      visibility: 'user-or-llm',
-      description: 'Restrict to print type (all, books, magazines)',
-    },
-    orderBy: {
-      type: 'string',
-      required: false,
-      visibility: 'user-or-llm',
-      description: 'Sort order (relevance, newest)',
-    },
-    startIndex: {
-      type: 'number',
-      required: false,
-      visibility: 'user-or-llm',
-      description: 'Index of the first result to return (for pagination)',
-    },
-    maxResults: {
-      type: 'number',
-      required: false,
-      visibility: 'user-or-llm',
-      description: 'Maximum number of results to return (1-40)',
-    },
-    langRestrict: {
-      type: 'string',
-      required: false,
-      visibility: 'user-or-llm',
-      description: 'Restrict results to a specific language (ISO 639-1 code)',
-    },
-  },
-
-  request: {
-    url: (params) => {
-      const url = new URL('https://www.googleapis.com/books/v1/volumes')
-      url.searchParams.set('q', params.query.trim())
-      url.searchParams.set('key', params.apiKey.trim())
-
-      if (params.filter) {
-        url.searchParams.set('filter', params.filter)
-      }
-      if (params.printType) {
-        url.searchParams.set('printType', params.printType)
-      }
-      if (params.orderBy) {
-        url.searchParams.set('orderBy', params.orderBy)
-      }
-      if (params.startIndex !== undefined) {
-        url.searchParams.set('startIndex', String(params.startIndex))
-      }
-      if (params.maxResults !== undefined) {
-        url.searchParams.set('maxResults', String(params.maxResults))
-      }
-      if (params.langRestrict) {
-        url.searchParams.set('langRestrict', params.langRestrict)
-      }
-
-      return url.toString()
-    },
-    method: 'GET',
-    headers: () => ({
-      'Content-Type': 'application/json',
-    }),
-  },
-
-  transformResponse: async (response: Response) => {
-    const data = await response.json()
-
-    if (data.error) {
-      throw new Error(`Google Books API error: ${data.error.message || 'Unknown error'}`)
-    }
-
-    const items: GoogleBooksVolumeItem[] = data.items ?? []
-    const volumes = items.map(extractVolumeInfo)
-
-    return {
-      success: true,
-      output: {
-        totalItems: data.totalItems ?? 0,
-        volumes,
-      },
-    }
-  },
-
-  outputs: {
-    totalItems: {
-      type: 'number',
-      description: 'Total number of matching results',
-    },
-    volumes: {
-      type: 'array',
-      description: 'List of matching volumes',
-      items: {
-        type: 'object',
-        properties: {
-          id: { type: 'string', description: 'Volume ID' },
-          title: { type: 'string', description: 'Book title' },
-          subtitle: { type: 'string', description: 'Book subtitle' },
-          authors: { type: 'array', description: 'List of authors' },
-          publisher: { type: 'string', description: 'Publisher name' },
-          publishedDate: { type: 'string', description: 'Publication date' },
-          description: { type: 'string', description: 'Book description' },
-          pageCount: { type: 'number', description: 'Number of pages' },
-          categories: { type: 'array', description: 'Book categories' },
-          averageRating: { type: 'number', description: 'Average rating (1-5)' },
-          ratingsCount: { type: 'number', description: 'Number of ratings' },
-          language: { type: 'string', description: 'Language code' },
-          previewLink: { type: 'string', description: 'Link to preview on Google Books' },
-          infoLink: { type: 'string', description: 'Link to info page' },
-          thumbnailUrl: { type: 'string', description: 'Book cover thumbnail URL' },
-          isbn10: { type: 'string', description: 'ISBN-10 identifier' },
-          isbn13: { type: 'string', description: 'ISBN-13 identifier' },
-        },
-      },
-    },
-  },
-}

apps/sim/tools/registry.ts

@@ -549,10 +549,6 @@ import {
   googleCalendarUpdateV2Tool,
 } from '@/tools/google_calendar'
 import { googleDocsCreateTool, googleDocsReadTool, googleDocsWriteTool } from '@/tools/google_docs'
-import {
-  googleBooksVolumeDetailsTool,
-  googleBooksVolumeSearchTool,
-} from '@/tools/google_books'
 import {
   googleDriveCopyTool,
   googleDriveCreateFolderTool,
@@ -2560,8 +2556,6 @@ export const tools: Record<string, ToolConfig> = {
   google_docs_read: googleDocsReadTool,
   google_docs_write: googleDocsWriteTool,
   google_docs_create: googleDocsCreateTool,
-  google_books_volume_search: googleBooksVolumeSearchTool,
-  google_books_volume_details: googleBooksVolumeDetailsTool,
   google_maps_air_quality: googleMapsAirQualityTool,
   google_maps_directions: googleMapsDirectionsTool,
   google_maps_distance_matrix: googleMapsDistanceMatrixTool,

apps/sim/triggers/constants.ts

@@ -23,12 +23,7 @@ export const SYSTEM_SUBBLOCK_IDS: string[] = [
  * with default values from the trigger definition on load, which aren't present in
  * the deployed state, causing false positive change detection.
  */
-export const TRIGGER_RUNTIME_SUBBLOCK_IDS: string[] = [
-  'webhookId',
-  'triggerPath',
-  'triggerConfig',
-  'triggerId',
-]
+export const TRIGGER_RUNTIME_SUBBLOCK_IDS: string[] = ['webhookId', 'triggerPath', 'triggerConfig']
 
 /**
  * Maximum number of consecutive failures before a trigger (schedule/webhook) is auto-disabled.