Checkpoint

apps/sim/app/api/auth/oauth/utils.test.ts

@@ -4,10 +4,20 @@
  * @vitest-environment node
  */
 
-import { databaseMock, loggerMock } from '@sim/testing'
+import { loggerMock } from '@sim/testing'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 
-vi.mock('@sim/db', () => databaseMock)
+vi.mock('@sim/db', () => ({
+  db: {
+    select: vi.fn().mockReturnThis(),
+    from: vi.fn().mockReturnThis(),
+    where: vi.fn().mockReturnThis(),
+    limit: vi.fn().mockReturnValue([]),
+    update: vi.fn().mockReturnThis(),
+    set: vi.fn().mockReturnThis(),
+    orderBy: vi.fn().mockReturnThis(),
+  },
+}))
 
 vi.mock('@/lib/oauth/oauth', () => ({
   refreshOAuthToken: vi.fn(),
@@ -24,36 +34,13 @@ import {
   refreshTokenIfNeeded,
 } from '@/app/api/auth/oauth/utils'
 
-const mockDb = db as any
+const mockDbTyped = db as any
 const mockRefreshOAuthToken = refreshOAuthToken as any
 
-/**
- * Creates a chainable mock for db.select() calls.
- * Returns a nested chain: select() -> from() -> where() -> limit() / orderBy()
- */
-function mockSelectChain(limitResult: unknown[]) {
-  const mockLimit = vi.fn().mockReturnValue(limitResult)
-  const mockOrderBy = vi.fn().mockReturnValue(limitResult)
-  const mockWhere = vi.fn().mockReturnValue({ limit: mockLimit, orderBy: mockOrderBy })
-  const mockFrom = vi.fn().mockReturnValue({ where: mockWhere })
-  mockDb.select.mockReturnValueOnce({ from: mockFrom })
-  return { mockFrom, mockWhere, mockLimit }
-}
-
-/**
- * Creates a chainable mock for db.update() calls.
- * Returns a nested chain: update() -> set() -> where()
- */
-function mockUpdateChain() {
-  const mockWhere = vi.fn().mockResolvedValue({})
-  const mockSet = vi.fn().mockReturnValue({ where: mockWhere })
-  mockDb.update.mockReturnValueOnce({ set: mockSet })
-  return { mockSet, mockWhere }
-}
-
 describe('OAuth Utils', () => {
   beforeEach(() => {
     vi.clearAllMocks()
+    mockDbTyped.limit.mockReturnValue([])
   })
 
   afterEach(() => {
@@ -63,20 +50,20 @@ describe('OAuth Utils', () => {
   describe('getCredential', () => {
     it('should return credential when found', async () => {
       const mockCredential = { id: 'credential-id', userId: 'test-user-id' }
-      const { mockFrom, mockWhere, mockLimit } = mockSelectChain([mockCredential])
+      mockDbTyped.limit.mockReturnValueOnce([mockCredential])
 
       const credential = await getCredential('request-id', 'credential-id', 'test-user-id')
 
-      expect(mockDb.select).toHaveBeenCalled()
-      expect(mockFrom).toHaveBeenCalled()
-      expect(mockWhere).toHaveBeenCalled()
-      expect(mockLimit).toHaveBeenCalledWith(1)
+      expect(mockDbTyped.select).toHaveBeenCalled()
+      expect(mockDbTyped.from).toHaveBeenCalled()
+      expect(mockDbTyped.where).toHaveBeenCalled()
+      expect(mockDbTyped.limit).toHaveBeenCalledWith(1)
 
       expect(credential).toEqual(mockCredential)
     })
 
     it('should return undefined when credential is not found', async () => {
-      mockSelectChain([])
+      mockDbTyped.limit.mockReturnValueOnce([])
 
       const credential = await getCredential('request-id', 'nonexistent-id', 'test-user-id')
 
@@ -115,12 +102,11 @@ describe('OAuth Utils', () => {
         refreshToken: 'new-refresh-token',
       })
 
-      mockUpdateChain()
-
       const result = await refreshTokenIfNeeded('request-id', mockCredential, 'credential-id')
 
       expect(mockRefreshOAuthToken).toHaveBeenCalledWith('google', 'refresh-token')
-      expect(mockDb.update).toHaveBeenCalled()
+      expect(mockDbTyped.update).toHaveBeenCalled()
+      expect(mockDbTyped.set).toHaveBeenCalled()
       expect(result).toEqual({ accessToken: 'new-token', refreshed: true })
     })
 
@@ -166,7 +152,7 @@ describe('OAuth Utils', () => {
         providerId: 'google',
         userId: 'test-user-id',
       }
-      mockSelectChain([mockCredential])
+      mockDbTyped.limit.mockReturnValueOnce([mockCredential])
 
       const token = await refreshAccessTokenIfNeeded('credential-id', 'test-user-id', 'request-id')
 
@@ -183,8 +169,7 @@ describe('OAuth Utils', () => {
         providerId: 'google',
         userId: 'test-user-id',
       }
-      mockSelectChain([mockCredential])
-      mockUpdateChain()
+      mockDbTyped.limit.mockReturnValueOnce([mockCredential])
 
       mockRefreshOAuthToken.mockResolvedValueOnce({
         accessToken: 'new-token',
@@ -195,12 +180,13 @@ describe('OAuth Utils', () => {
       const token = await refreshAccessTokenIfNeeded('credential-id', 'test-user-id', 'request-id')
 
       expect(mockRefreshOAuthToken).toHaveBeenCalledWith('google', 'refresh-token')
-      expect(mockDb.update).toHaveBeenCalled()
+      expect(mockDbTyped.update).toHaveBeenCalled()
+      expect(mockDbTyped.set).toHaveBeenCalled()
       expect(token).toBe('new-token')
     })
 
     it('should return null if credential not found', async () => {
-      mockSelectChain([])
+      mockDbTyped.limit.mockReturnValueOnce([])
 
       const token = await refreshAccessTokenIfNeeded('nonexistent-id', 'test-user-id', 'request-id')
 
@@ -216,7 +202,7 @@ describe('OAuth Utils', () => {
         providerId: 'google',
         userId: 'test-user-id',
       }
-      mockSelectChain([mockCredential])
+      mockDbTyped.limit.mockReturnValueOnce([mockCredential])
 
       mockRefreshOAuthToken.mockResolvedValueOnce(null)
 

apps/sim/app/api/copilot/auto-allowed-tools/route.ts

@@ -1,145 +1,81 @@
-import { db } from '@sim/db'
-import { settings } from '@sim/db/schema'
 import { createLogger } from '@sim/logger'
-import { eq } from 'drizzle-orm'
 import { type NextRequest, NextResponse } from 'next/server'
-import { getSession } from '@/lib/auth'
+import { SIM_AGENT_API_URL } from '@/lib/copilot/constants'
+import { authenticateCopilotRequestSessionOnly } from '@/lib/copilot/request-helpers'
+import { env } from '@/lib/core/config/env'
 
 const logger = createLogger('CopilotAutoAllowedToolsAPI')
 
-/**
- * GET - Fetch user's auto-allowed integration tools
- */
-export async function GET() {
-  try {
-    const session = await getSession()
-
-    if (!session?.user?.id) {
-      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
-    }
-
-    const userId = session.user.id
-
-    const [userSettings] = await db
-      .select()
-      .from(settings)
-      .where(eq(settings.userId, userId))
-      .limit(1)
-
-    if (userSettings) {
-      const autoAllowedTools = (userSettings.copilotAutoAllowedTools as string[]) || []
-      return NextResponse.json({ autoAllowedTools })
-    }
-
-    await db.insert(settings).values({
-      id: userId,
-      userId,
-      copilotAutoAllowedTools: [],
-    })
-
-    return NextResponse.json({ autoAllowedTools: [] })
-  } catch (error) {
-    logger.error('Failed to fetch auto-allowed tools', { error })
-    return NextResponse.json({ error: 'Internal server error' }, { status: 500 })
+function copilotHeaders(): HeadersInit {
+  const headers: Record<string, string> = {
+    'Content-Type': 'application/json',
   }
+  if (env.COPILOT_API_KEY) {
+    headers['x-api-key'] = env.COPILOT_API_KEY
+  }
+  return headers
 }
 
-/**
- * POST - Add a tool to the auto-allowed list
- */
-export async function POST(request: NextRequest) {
-  try {
-    const session = await getSession()
-
-    if (!session?.user?.id) {
-      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
-    }
-
-    const userId = session.user.id
-    const body = await request.json()
-
-    if (!body.toolId || typeof body.toolId !== 'string') {
-      return NextResponse.json({ error: 'toolId must be a string' }, { status: 400 })
-    }
-
-    const toolId = body.toolId
-
-    const [existing] = await db.select().from(settings).where(eq(settings.userId, userId)).limit(1)
-
-    if (existing) {
-      const currentTools = (existing.copilotAutoAllowedTools as string[]) || []
-
-      if (!currentTools.includes(toolId)) {
-        const updatedTools = [...currentTools, toolId]
-        await db
-          .update(settings)
-          .set({
-            copilotAutoAllowedTools: updatedTools,
-            updatedAt: new Date(),
-          })
-          .where(eq(settings.userId, userId))
-
-        logger.info('Added tool to auto-allowed list', { userId, toolId })
-        return NextResponse.json({ success: true, autoAllowedTools: updatedTools })
-      }
-
-      return NextResponse.json({ success: true, autoAllowedTools: currentTools })
-    }
-
-    await db.insert(settings).values({
-      id: userId,
-      userId,
-      copilotAutoAllowedTools: [toolId],
-    })
-
-    logger.info('Created settings and added tool to auto-allowed list', { userId, toolId })
-    return NextResponse.json({ success: true, autoAllowedTools: [toolId] })
-  } catch (error) {
-    logger.error('Failed to add auto-allowed tool', { error })
-    return NextResponse.json({ error: 'Internal server error' }, { status: 500 })
-  }
-}
-
-/**
- * DELETE - Remove a tool from the auto-allowed list
- */
 export async function DELETE(request: NextRequest) {
+  const { userId, isAuthenticated } = await authenticateCopilotRequestSessionOnly()
+  if (!isAuthenticated || !userId) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+  }
+
+  const toolIdFromQuery = new URL(request.url).searchParams.get('toolId') || undefined
+  const toolIdFromBody = await request
+    .json()
+    .then((body) => (typeof body?.toolId === 'string' ? body.toolId : undefined))
+    .catch(() => undefined)
+  const toolId = toolIdFromBody || toolIdFromQuery
+  if (!toolId) {
+    return NextResponse.json({ error: 'toolId is required' }, { status: 400 })
+  }
+
   try {
-    const session = await getSession()
+    const res = await fetch(`${SIM_AGENT_API_URL}/api/tool-preferences/auto-allowed`, {
+      method: 'DELETE',
+      headers: copilotHeaders(),
+      body: JSON.stringify({
+        userId,
+        toolId,
+      }),
+    })
 
-    if (!session?.user?.id) {
-      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+    const payload = await res.json().catch(() => ({}))
+    if (!res.ok) {
+      logger.warn('Failed to remove auto-allowed tool via copilot backend', {
+        status: res.status,
+        userId,
+        toolId,
+      })
+      return NextResponse.json(
+        {
+          success: false,
+          error: payload?.error || 'Failed to remove auto-allowed tool',
+          autoAllowedTools: [],
+        },
+        { status: res.status }
+      )
     }
 
-    const userId = session.user.id
-    const { searchParams } = new URL(request.url)
-    const toolId = searchParams.get('toolId')
-
-    if (!toolId) {
-      return NextResponse.json({ error: 'toolId query parameter is required' }, { status: 400 })
-    }
-
-    const [existing] = await db.select().from(settings).where(eq(settings.userId, userId)).limit(1)
-
-    if (existing) {
-      const currentTools = (existing.copilotAutoAllowedTools as string[]) || []
-      const updatedTools = currentTools.filter((t) => t !== toolId)
-
-      await db
-        .update(settings)
-        .set({
-          copilotAutoAllowedTools: updatedTools,
-          updatedAt: new Date(),
-        })
-        .where(eq(settings.userId, userId))
-
-      logger.info('Removed tool from auto-allowed list', { userId, toolId })
-      return NextResponse.json({ success: true, autoAllowedTools: updatedTools })
-    }
-
-    return NextResponse.json({ success: true, autoAllowedTools: [] })
+    return NextResponse.json({
+      success: true,
+      autoAllowedTools: Array.isArray(payload?.autoAllowedTools) ? payload.autoAllowedTools : [],
+    })
   } catch (error) {
-    logger.error('Failed to remove auto-allowed tool', { error })
-    return NextResponse.json({ error: 'Internal server error' }, { status: 500 })
+    logger.error('Error removing auto-allowed tool', {
+      userId,
+      toolId,
+      error: error instanceof Error ? error.message : String(error),
+    })
+    return NextResponse.json(
+      {
+        success: false,
+        error: 'Failed to remove auto-allowed tool',
+        autoAllowedTools: [],
+      },
+      { status: 500 }
+    )
   }
 }

apps/sim/app/api/copilot/chat/route.ts

@@ -28,13 +28,24 @@ import { resolveWorkflowIdForUser } from '@/lib/workflows/utils'
 
 const logger = createLogger('CopilotChatAPI')
 
+function truncateForLog(value: string, maxLength = 120): string {
+  if (!value || maxLength <= 0) return ''
+  return value.length <= maxLength ? value : `${value.slice(0, maxLength)}...`
+}
+
 async function requestChatTitleFromCopilot(params: {
   message: string
   model: string
   provider?: string
 }): Promise<string | null> {
   const { message, model, provider } = params
-  if (!message || !model) return null
+  if (!message || !model) {
+    logger.warn('Skipping chat title request because message/model is missing', {
+      hasMessage: !!message,
+      hasModel: !!model,
+    })
+    return null
+  }
 
   const headers: Record<string, string> = {
     'Content-Type': 'application/json',
@@ -44,6 +55,13 @@ async function requestChatTitleFromCopilot(params: {
   }
 
   try {
+    logger.info('Requesting chat title from copilot backend', {
+      model,
+      provider: provider || null,
+      messageLength: message.length,
+      messagePreview: truncateForLog(message),
+    })
+
     const response = await fetch(`${SIM_AGENT_API_URL}/api/generate-chat-title`, {
       method: 'POST',
       headers,
@@ -63,10 +81,32 @@ async function requestChatTitleFromCopilot(params: {
       return null
     }
 
-    const title = typeof payload?.title === 'string' ? payload.title.trim() : ''
+    const rawTitle = typeof payload?.title === 'string' ? payload.title : ''
+    const title = rawTitle.trim()
+    logger.info('Received chat title response from copilot backend', {
+      status: response.status,
+      hasRawTitle: !!rawTitle,
+      rawTitle,
+      normalizedTitle: title,
+      messagePreview: truncateForLog(message),
+    })
+
+    if (!title) {
+      logger.warn('Copilot backend returned empty chat title', {
+        payload,
+        model,
+        provider: provider || null,
+      })
+    }
+
     return title || null
   } catch (error) {
-    logger.error('Error generating chat title:', error)
+    logger.error('Error generating chat title:', {
+      error,
+      model,
+      provider: provider || null,
+      messagePreview: truncateForLog(message),
+    })
     return null
   }
 }
@@ -85,7 +125,7 @@ const ChatMessageSchema = z.object({
   chatId: z.string().optional(),
   workflowId: z.string().optional(),
   workflowName: z.string().optional(),
-  model: z.string().optional().default('claude-opus-4-5'),
+  model: z.string().optional().default('claude-opus-4-6'),
   mode: z.enum(COPILOT_REQUEST_MODES).optional().default('agent'),
   prefetch: z.boolean().optional(),
   createNewChat: z.boolean().optional().default(false),
@@ -238,7 +278,8 @@ export async function POST(req: NextRequest) {
     let currentChat: any = null
     let conversationHistory: any[] = []
     let actualChatId = chatId
-    const selectedModel = model || 'claude-opus-4-5'
+    let chatWasCreatedForRequest = false
+    const selectedModel = model || 'claude-opus-4-6'
 
     if (chatId || createNewChat) {
       const chatResult = await resolveOrCreateChat({
@@ -249,6 +290,7 @@ export async function POST(req: NextRequest) {
       })
       currentChat = chatResult.chat
       actualChatId = chatResult.chatId || chatId
+      chatWasCreatedForRequest = chatResult.isNew
       const history = buildConversationHistory(
         chatResult.conversationHistory,
         (chatResult.chat?.conversationId as string | undefined) || conversationId
@@ -256,6 +298,18 @@ export async function POST(req: NextRequest) {
       conversationHistory = history.history
     }
 
+    const shouldGenerateTitleForRequest =
+      !!actualChatId &&
+      chatWasCreatedForRequest &&
+      !currentChat?.title &&
+      conversationHistory.length === 0
+
+    const titleGenerationParams = {
+      message,
+      model: selectedModel,
+      provider,
+    }
+
     const effectiveMode = mode === 'agent' ? 'build' : mode
     const effectiveConversationId =
       (currentChat?.conversationId as string | undefined) || conversationId
@@ -348,10 +402,22 @@ export async function POST(req: NextRequest) {
             await pushEvent({ type: 'chat_id', chatId: actualChatId })
           }
 
-          if (actualChatId && !currentChat?.title && conversationHistory.length === 0) {
-            requestChatTitleFromCopilot({ message, model: selectedModel, provider })
+          if (shouldGenerateTitleForRequest) {
+            logger.info(`[${tracker.requestId}] Starting title generation for streaming response`, {
+              chatId: actualChatId,
+              model: titleGenerationParams.model,
+              provider: provider || null,
+              messageLength: message.length,
+              messagePreview: truncateForLog(message),
+              chatWasCreatedForRequest,
+            })
+            requestChatTitleFromCopilot(titleGenerationParams)
               .then(async (title) => {
                 if (title) {
+                  logger.info(`[${tracker.requestId}] Generated title for streaming response`, {
+                    chatId: actualChatId,
+                    title,
+                  })
                   await db
                     .update(copilotChats)
                     .set({
@@ -359,12 +425,30 @@ export async function POST(req: NextRequest) {
                       updatedAt: new Date(),
                     })
                     .where(eq(copilotChats.id, actualChatId!))
-                  await pushEvent({ type: 'title_updated', title })
+                  await pushEvent({ type: 'title_updated', title, chatId: actualChatId })
+                  logger.info(`[${tracker.requestId}] Emitted title_updated SSE event`, {
+                    chatId: actualChatId,
+                    title,
+                  })
+                } else {
+                  logger.warn(`[${tracker.requestId}] No title returned for streaming response`, {
+                    chatId: actualChatId,
+                    model: selectedModel,
+                  })
                 }
               })
               .catch((error) => {
                 logger.error(`[${tracker.requestId}] Title generation failed:`, error)
               })
+          } else if (actualChatId && !chatWasCreatedForRequest) {
+            logger.info(
+              `[${tracker.requestId}] Skipping title generation because chat already exists`,
+              {
+                chatId: actualChatId,
+                model: titleGenerationParams.model,
+                provider: provider || null,
+              }
+            )
           }
 
           try {
@@ -479,9 +563,9 @@ export async function POST(req: NextRequest) {
       const updatedMessages = [...conversationHistory, userMessage, assistantMessage]
 
       // Start title generation in parallel if this is first message (non-streaming)
-      if (actualChatId && !currentChat.title && conversationHistory.length === 0) {
+      if (shouldGenerateTitleForRequest) {
         logger.info(`[${tracker.requestId}] Starting title generation for non-streaming response`)
-        requestChatTitleFromCopilot({ message, model: selectedModel, provider })
+        requestChatTitleFromCopilot(titleGenerationParams)
           .then(async (title) => {
             if (title) {
               await db
@@ -492,11 +576,22 @@ export async function POST(req: NextRequest) {
                 })
                 .where(eq(copilotChats.id, actualChatId!))
               logger.info(`[${tracker.requestId}] Generated and saved title: ${title}`)
+            } else {
+              logger.warn(`[${tracker.requestId}] No title returned for non-streaming response`, {
+                chatId: actualChatId,
+                model: selectedModel,
+              })
             }
           })
           .catch((error) => {
             logger.error(`[${tracker.requestId}] Title generation failed:`, error)
           })
+      } else if (actualChatId && !chatWasCreatedForRequest) {
+        logger.info(`[${tracker.requestId}] Skipping title generation because chat already exists`, {
+          chatId: actualChatId,
+          model: titleGenerationParams.model,
+          provider: provider || null,
+        })
       }
 
       // Update chat in database immediately (without blocking for title)

apps/sim/app/api/copilot/confirm/route.ts

@@ -1,7 +1,11 @@
 import { createLogger } from '@sim/logger'
 import { type NextRequest, NextResponse } from 'next/server'
 import { z } from 'zod'
-import { REDIS_TOOL_CALL_PREFIX, REDIS_TOOL_CALL_TTL_SECONDS } from '@/lib/copilot/constants'
+import {
+  REDIS_TOOL_CALL_PREFIX,
+  REDIS_TOOL_CALL_TTL_SECONDS,
+  SIM_AGENT_API_URL,
+} from '@/lib/copilot/constants'
 import {
   authenticateCopilotRequestSessionOnly,
   createBadRequestResponse,
@@ -10,6 +14,7 @@ import {
   createUnauthorizedResponse,
   type NotificationStatus,
 } from '@/lib/copilot/request-helpers'
+import { env } from '@/lib/core/config/env'
 import { getRedisClient } from '@/lib/core/config/redis'
 
 const logger = createLogger('CopilotConfirmAPI')
@@ -21,6 +26,8 @@ const ConfirmationSchema = z.object({
     errorMap: () => ({ message: 'Invalid notification status' }),
   }),
   message: z.string().optional(), // Optional message for background moves or additional context
+  toolName: z.string().optional(),
+  remember: z.boolean().optional(),
 })
 
 /**
@@ -57,6 +64,44 @@ async function updateToolCallStatus(
   }
 }
 
+async function saveAutoAllowedToolPreference(userId: string, toolName: string): Promise<boolean> {
+  const headers: Record<string, string> = {
+    'Content-Type': 'application/json',
+  }
+  if (env.COPILOT_API_KEY) {
+    headers['x-api-key'] = env.COPILOT_API_KEY
+  }
+
+  try {
+    const response = await fetch(`${SIM_AGENT_API_URL}/api/tool-preferences/auto-allowed`, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify({
+        userId,
+        toolId: toolName,
+      }),
+    })
+
+    if (!response.ok) {
+      logger.warn('Failed to persist auto-allowed tool preference', {
+        userId,
+        toolName,
+        status: response.status,
+      })
+      return false
+    }
+
+    return true
+  } catch (error) {
+    logger.error('Error persisting auto-allowed tool preference', {
+      userId,
+      toolName,
+      error: error instanceof Error ? error.message : String(error),
+    })
+    return false
+  }
+}
+
 /**
  * POST /api/copilot/confirm
  * Update tool call status (Accept/Reject)
@@ -74,7 +119,7 @@ export async function POST(req: NextRequest) {
     }
 
     const body = await req.json()
-    const { toolCallId, status, message } = ConfirmationSchema.parse(body)
+    const { toolCallId, status, message, toolName, remember } = ConfirmationSchema.parse(body)
 
     // Update the tool call status in Redis
     const updated = await updateToolCallStatus(toolCallId, status, message)
@@ -90,14 +135,22 @@ export async function POST(req: NextRequest) {
       return createBadRequestResponse('Failed to update tool call status or tool call not found')
     }
 
-    const duration = tracker.getDuration()
+    let rememberSaved = false
+    if (status === 'accepted' && remember === true && toolName && authenticatedUserId) {
+      rememberSaved = await saveAutoAllowedToolPreference(authenticatedUserId, toolName)
+    }
 
-    return NextResponse.json({
+    const response: Record<string, unknown> = {
       success: true,
       message: message || `Tool call ${toolCallId} has been ${status.toLowerCase()}`,
       toolCallId,
       status,
-    })
+    }
+    if (remember === true) {
+      response.rememberSaved = rememberSaved
+    }
+
+    return NextResponse.json(response)
   } catch (error) {
     const duration = tracker.getDuration()
 

apps/sim/app/api/knowledge/search/utils.test.ts

@@ -4,12 +4,16 @@
  *
  * @vitest-environment node
  */
-import { createEnvMock, databaseMock, loggerMock } from '@sim/testing'
+import { createEnvMock, createMockLogger } from '@sim/testing'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 
+const loggerMock = vi.hoisted(() => ({
+  createLogger: () => createMockLogger(),
+}))
+
 vi.mock('drizzle-orm')
 vi.mock('@sim/logger', () => loggerMock)
-vi.mock('@sim/db', () => databaseMock)
+vi.mock('@sim/db')
 vi.mock('@/lib/knowledge/documents/utils', () => ({
   retryWithExponentialBackoff: (fn: any) => fn(),
 }))

apps/sim/app/api/mcp/copilot/route.test.ts

@@ -0,0 +1,89 @@
+/**
+ * @vitest-environment node
+ */
+
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+describe('mcp copilot route manifest contract', () => {
+  const previousInternalSecret = process.env.INTERNAL_API_SECRET
+  const previousAgentUrl = process.env.SIM_AGENT_API_URL
+  const previousFetch = global.fetch
+
+  beforeEach(() => {
+    vi.resetModules()
+    process.env.INTERNAL_API_SECRET = 'x'.repeat(32)
+    process.env.SIM_AGENT_API_URL = 'https://copilot.sim.ai'
+  })
+
+  afterEach(() => {
+    vi.restoreAllMocks()
+    global.fetch = previousFetch
+    if (previousInternalSecret === undefined) {
+      delete process.env.INTERNAL_API_SECRET
+    } else {
+      process.env.INTERNAL_API_SECRET = previousInternalSecret
+    }
+    if (previousAgentUrl === undefined) {
+      delete process.env.SIM_AGENT_API_URL
+    } else {
+      process.env.SIM_AGENT_API_URL = previousAgentUrl
+    }
+  })
+
+  it('loads and caches tool manifest from copilot backend', async () => {
+    const payload = {
+      directTools: [
+        {
+          name: 'list_workspaces',
+          description: 'List workspaces',
+          inputSchema: { type: 'object', properties: {} },
+          toolId: 'list_user_workspaces',
+        },
+      ],
+      subagentTools: [
+        {
+          name: 'sim_build',
+          description: 'Build workflows',
+          inputSchema: { type: 'object', properties: {} },
+          agentId: 'build',
+        },
+      ],
+      generatedAt: '2026-02-12T00:00:00Z',
+    }
+
+    const fetchSpy = vi.spyOn(global, 'fetch').mockResolvedValue(
+      new Response(JSON.stringify(payload), {
+        status: 200,
+        headers: { 'Content-Type': 'application/json' },
+      })
+    )
+
+    const mod = await import('./route')
+    mod.clearMcpToolManifestCacheForTests()
+
+    const first = await mod.getMcpToolManifest()
+    const second = await mod.getMcpToolManifest()
+
+    expect(first).toEqual(payload)
+    expect(second).toEqual(payload)
+    expect(fetchSpy).toHaveBeenCalledTimes(1)
+    expect(fetchSpy.mock.calls[0]?.[0]).toBe('https://copilot.sim.ai/api/mcp/tools/manifest')
+  })
+
+  it('rejects invalid manifest payloads from copilot backend', async () => {
+    const fetchSpy = vi.spyOn(global, 'fetch').mockResolvedValue(
+      new Response(JSON.stringify({ tools: [] }), {
+        status: 200,
+        headers: { 'Content-Type': 'application/json' },
+      })
+    )
+
+    const mod = await import('./route')
+    mod.clearMcpToolManifestCacheForTests()
+
+    await expect(mod.fetchMcpToolManifestFromCopilot()).rejects.toThrow(
+      'invalid manifest payload from copilot'
+    )
+    expect(fetchSpy).toHaveBeenCalledTimes(1)
+  })
+})

apps/sim/app/api/mcp/copilot/route.ts

@@ -28,7 +28,6 @@ import {
   executeToolServerSide,
   prepareExecutionContext,
 } from '@/lib/copilot/orchestrator/tool-executor'
-import { DIRECT_TOOL_DEFS, SUBAGENT_TOOL_DEFS } from '@/lib/copilot/tools/mcp/definitions'
 import { env } from '@/lib/core/config/env'
 import { RateLimiter } from '@/lib/core/rate-limiter'
 import {
@@ -38,7 +37,33 @@ import {
 
 const logger = createLogger('CopilotMcpAPI')
 const mcpRateLimiter = new RateLimiter()
-const DEFAULT_COPILOT_MODEL = 'claude-opus-4-5'
+const DEFAULT_COPILOT_MODEL = 'claude-opus-4-6'
+const MCP_TOOL_MANIFEST_CACHE_TTL_MS = 60_000
+
+type McpDirectToolDef = {
+  name: string
+  description: string
+  inputSchema: { type: 'object'; properties?: Record<string, unknown>; required?: string[] }
+  toolId: string
+}
+
+type McpSubagentToolDef = {
+  name: string
+  description: string
+  inputSchema: { type: 'object'; properties?: Record<string, unknown>; required?: string[] }
+  agentId: string
+}
+
+type McpToolManifest = {
+  directTools: McpDirectToolDef[]
+  subagentTools: McpSubagentToolDef[]
+  generatedAt?: string
+}
+
+let cachedMcpToolManifest: {
+  value: McpToolManifest
+  expiresAt: number
+} | null = null
 
 export const dynamic = 'force-dynamic'
 export const runtime = 'nodejs'
@@ -112,6 +137,58 @@ async function authenticateCopilotApiKey(apiKey: string): Promise<CopilotKeyAuth
   }
 }
 
+export function isMcpToolManifest(value: unknown): value is McpToolManifest {
+  if (!value || typeof value !== 'object') return false
+  const payload = value as Record<string, unknown>
+  return Array.isArray(payload.directTools) && Array.isArray(payload.subagentTools)
+}
+
+export async function fetchMcpToolManifestFromCopilot(): Promise<McpToolManifest> {
+  const internalSecret = env.INTERNAL_API_SECRET
+  if (!internalSecret) {
+    throw new Error('INTERNAL_API_SECRET not configured')
+  }
+
+  const res = await fetch(`${SIM_AGENT_API_URL}/api/mcp/tools/manifest`, {
+    method: 'GET',
+    headers: {
+      'Content-Type': 'application/json',
+      'x-api-key': internalSecret,
+    },
+    signal: AbortSignal.timeout(10_000),
+  })
+
+  if (!res.ok) {
+    const bodyText = await res.text().catch(() => '')
+    throw new Error(`manifest fetch failed (${res.status}): ${bodyText || res.statusText}`)
+  }
+
+  const payload: unknown = await res.json()
+  if (!isMcpToolManifest(payload)) {
+    throw new Error('invalid manifest payload from copilot')
+  }
+
+  return payload
+}
+
+export async function getMcpToolManifest(): Promise<McpToolManifest> {
+  const now = Date.now()
+  if (cachedMcpToolManifest && cachedMcpToolManifest.expiresAt > now) {
+    return cachedMcpToolManifest.value
+  }
+
+  const manifest = await fetchMcpToolManifestFromCopilot()
+  cachedMcpToolManifest = {
+    value: manifest,
+    expiresAt: now + MCP_TOOL_MANIFEST_CACHE_TTL_MS,
+  }
+  return manifest
+}
+
+export function clearMcpToolManifestCacheForTests(): void {
+  cachedMcpToolManifest = null
+}
+
 /**
  * MCP Server instructions that guide LLMs on how to use the Sim copilot tools.
  * This is included in the initialize response to help external LLMs understand
@@ -380,13 +457,15 @@ function buildMcpServer(abortSignal?: AbortSignal): Server {
   )
 
   server.setRequestHandler(ListToolsRequestSchema, async () => {
-    const directTools = DIRECT_TOOL_DEFS.map((tool) => ({
+    const manifest = await getMcpToolManifest()
+
+    const directTools = manifest.directTools.map((tool) => ({
       name: tool.name,
       description: tool.description,
       inputSchema: tool.inputSchema,
     }))
 
-    const subagentTools = SUBAGENT_TOOL_DEFS.map((tool) => ({
+    const subagentTools = manifest.subagentTools.map((tool) => ({
       name: tool.name,
       description: tool.description,
       inputSchema: tool.inputSchema,
@@ -455,12 +534,15 @@ function buildMcpServer(abortSignal?: AbortSignal): Server {
       throw new McpError(ErrorCode.InvalidParams, 'Tool name required')
     }
 
+    const manifest = await getMcpToolManifest()
+
     const result = await handleToolsCall(
       {
         name: params.name,
         arguments: params.arguments,
       },
       authResult.userId,
+      manifest,
       abortSignal
     )
 
@@ -556,16 +638,17 @@ function trackMcpCopilotCall(userId: string): void {
 async function handleToolsCall(
   params: { name: string; arguments?: Record<string, unknown> },
   userId: string,
+  manifest: McpToolManifest,
   abortSignal?: AbortSignal
 ): Promise<CallToolResult> {
   const args = params.arguments || {}
 
-  const directTool = DIRECT_TOOL_DEFS.find((tool) => tool.name === params.name)
+  const directTool = manifest.directTools.find((tool) => tool.name === params.name)
   if (directTool) {
     return handleDirectToolCall(directTool, args, userId)
   }
 
-  const subagentTool = SUBAGENT_TOOL_DEFS.find((tool) => tool.name === params.name)
+  const subagentTool = manifest.subagentTools.find((tool) => tool.name === params.name)
   if (subagentTool) {
     return handleSubagentToolCall(subagentTool, args, userId, abortSignal)
   }
@@ -574,7 +657,7 @@ async function handleToolsCall(
 }
 
 async function handleDirectToolCall(
-  toolDef: (typeof DIRECT_TOOL_DEFS)[number],
+  toolDef: McpDirectToolDef,
   args: Record<string, unknown>,
   userId: string
 ): Promise<CallToolResult> {
@@ -711,7 +794,7 @@ async function handleBuildToolCall(
 }
 
 async function handleSubagentToolCall(
-  toolDef: (typeof SUBAGENT_TOOL_DEFS)[number],
+  toolDef: McpSubagentToolDef,
   args: Record<string, unknown>,
   userId: string,
   abortSignal?: AbortSignal

apps/sim/app/api/schedules/[id]/route.test.ts

@@ -3,14 +3,17 @@
  *
  * @vitest-environment node
  */
-import { databaseMock, loggerMock } from '@sim/testing'
+import { loggerMock } from '@sim/testing'
 import { NextRequest } from 'next/server'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 
-const { mockGetSession, mockAuthorizeWorkflowByWorkspacePermission } = vi.hoisted(() => ({
-  mockGetSession: vi.fn(),
-  mockAuthorizeWorkflowByWorkspacePermission: vi.fn(),
-}))
+const { mockGetSession, mockAuthorizeWorkflowByWorkspacePermission, mockDbSelect, mockDbUpdate } =
+  vi.hoisted(() => ({
+    mockGetSession: vi.fn(),
+    mockAuthorizeWorkflowByWorkspacePermission: vi.fn(),
+    mockDbSelect: vi.fn(),
+    mockDbUpdate: vi.fn(),
+  }))
 
 vi.mock('@/lib/auth', () => ({
   getSession: mockGetSession,
@@ -20,7 +23,12 @@ vi.mock('@/lib/workflows/utils', () => ({
   authorizeWorkflowByWorkspacePermission: mockAuthorizeWorkflowByWorkspacePermission,
 }))
 
-vi.mock('@sim/db', () => databaseMock)
+vi.mock('@sim/db', () => ({
+  db: {
+    select: mockDbSelect,
+    update: mockDbUpdate,
+  },
+}))
 
 vi.mock('@sim/db/schema', () => ({
   workflow: { id: 'id', userId: 'userId', workspaceId: 'workspaceId' },
@@ -51,9 +59,6 @@ function createParams(id: string): { params: Promise<{ id: string }> } {
   return { params: Promise.resolve({ id }) }
 }
 
-const mockDbSelect = databaseMock.db.select as ReturnType<typeof vi.fn>
-const mockDbUpdate = databaseMock.db.update as ReturnType<typeof vi.fn>
-
 function mockDbChain(selectResults: unknown[][]) {
   let selectCallIndex = 0
   mockDbSelect.mockImplementation(() => ({

apps/sim/app/api/schedules/route.test.ts

@@ -3,14 +3,17 @@
  *
  * @vitest-environment node
  */
-import { databaseMock, loggerMock } from '@sim/testing'
+import { loggerMock } from '@sim/testing'
 import { NextRequest } from 'next/server'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 
-const { mockGetSession, mockAuthorizeWorkflowByWorkspacePermission } = vi.hoisted(() => ({
-  mockGetSession: vi.fn(),
-  mockAuthorizeWorkflowByWorkspacePermission: vi.fn(),
-}))
+const { mockGetSession, mockAuthorizeWorkflowByWorkspacePermission, mockDbSelect } = vi.hoisted(
+  () => ({
+    mockGetSession: vi.fn(),
+    mockAuthorizeWorkflowByWorkspacePermission: vi.fn(),
+    mockDbSelect: vi.fn(),
+  })
+)
 
 vi.mock('@/lib/auth', () => ({
   getSession: mockGetSession,
@@ -20,7 +23,11 @@ vi.mock('@/lib/workflows/utils', () => ({
   authorizeWorkflowByWorkspacePermission: mockAuthorizeWorkflowByWorkspacePermission,
 }))
 
-vi.mock('@sim/db', () => databaseMock)
+vi.mock('@sim/db', () => ({
+  db: {
+    select: mockDbSelect,
+  },
+}))
 
 vi.mock('@sim/db/schema', () => ({
   workflow: { id: 'id', userId: 'userId', workspaceId: 'workspaceId' },
@@ -55,8 +62,6 @@ function createRequest(url: string): NextRequest {
   return new NextRequest(new URL(url), { method: 'GET' })
 }
 
-const mockDbSelect = databaseMock.db.select as ReturnType<typeof vi.fn>
-
 function mockDbChain(results: any[]) {
   let callIndex = 0
   mockDbSelect.mockImplementation(() => ({

apps/sim/app/api/v1/copilot/chat/route.ts

@@ -8,7 +8,7 @@ import { resolveWorkflowIdForUser } from '@/lib/workflows/utils'
 import { authenticateV1Request } from '@/app/api/v1/auth'
 
 const logger = createLogger('CopilotHeadlessAPI')
-const DEFAULT_COPILOT_MODEL = 'claude-opus-4-5'
+const DEFAULT_COPILOT_MODEL = 'claude-opus-4-6'
 
 const RequestSchema = z.object({
   message: z.string().min(1, 'message is required'),

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/api/workflows/[id]/route.test.ts

@@ -5,7 +5,7 @@
  * @vitest-environment node
  */
 
-import { loggerMock, setupGlobalFetchMock } from '@sim/testing'
+import { loggerMock } from '@sim/testing'
 import { NextRequest } from 'next/server'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 
@@ -284,7 +284,9 @@ describe('Workflow By ID API Route', () => {
         where: vi.fn().mockResolvedValue([{ id: 'workflow-123' }]),
       })
 
-      setupGlobalFetchMock({ ok: true })
+      global.fetch = vi.fn().mockResolvedValue({
+        ok: true,
+      })
 
       const req = new NextRequest('http://localhost:3000/api/workflows/workflow-123', {
         method: 'DELETE',
@@ -329,7 +331,9 @@ describe('Workflow By ID API Route', () => {
         where: vi.fn().mockResolvedValue([{ id: 'workflow-123' }]),
       })
 
-      setupGlobalFetchMock({ ok: true })
+      global.fetch = vi.fn().mockResolvedValue({
+        ok: true,
+      })
 
       const req = new NextRequest('http://localhost:3000/api/workflows/workflow-123', {
         method: 'DELETE',

apps/sim/app/api/workspaces/[id]/byok-keys/route.ts

@@ -12,7 +12,7 @@ import { getUserEntityPermissions, getWorkspaceById } from '@/lib/workspaces/per
 
 const logger = createLogger('WorkspaceBYOKKeysAPI')
 
-const VALID_PROVIDERS = ['openai', 'anthropic', 'google', 'mistral', 'exa'] as const
+const VALID_PROVIDERS = ['openai', 'anthropic', 'google', 'mistral'] as const
 
 const UpsertKeySchema = z.object({
   providerId: z.enum(VALID_PROVIDERS),

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/diff-controls/diff-controls.tsx

@@ -14,6 +14,14 @@ const logger = createLogger('DiffControls')
 const NOTIFICATION_WIDTH = 240
 const NOTIFICATION_GAP = 16
 
+function isWorkflowEditToolCall(name?: string, params?: Record<string, unknown>): boolean {
+  if (name !== 'workflow_change') return false
+
+  const mode = typeof params?.mode === 'string' ? params.mode.toLowerCase() : ''
+  if (mode === 'apply') return true
+  return typeof params?.proposalId === 'string' && params.proposalId.length > 0
+}
+
 export const DiffControls = memo(function DiffControls() {
   const isTerminalResizing = useTerminalStore((state) => state.isResizing)
   const isPanelResizing = usePanelStore((state) => state.isResizing)
@@ -64,7 +72,7 @@ export const DiffControls = memo(function DiffControls() {
           const b = blocks[bi]
           if (b?.type === 'tool_call') {
             const tn = b.toolCall?.name
-            if (tn === 'edit_workflow') {
+            if (isWorkflowEditToolCall(tn, b.toolCall?.params)) {
               id = b.toolCall?.id
               break outer
             }
@@ -72,7 +80,9 @@ export const DiffControls = memo(function DiffControls() {
         }
       }
       if (!id) {
-        const candidates = Object.values(toolCallsById).filter((t) => t.name === 'edit_workflow')
+        const candidates = Object.values(toolCallsById).filter((t) =>
+          isWorkflowEditToolCall(t.name, t.params)
+        )
         id = candidates.length ? candidates[candidates.length - 1].id : undefined
       }
       if (id) updatePreviewToolCallState('accepted', id)
@@ -102,7 +112,7 @@ export const DiffControls = memo(function DiffControls() {
           const b = blocks[bi]
           if (b?.type === 'tool_call') {
             const tn = b.toolCall?.name
-            if (tn === 'edit_workflow') {
+            if (isWorkflowEditToolCall(tn, b.toolCall?.params)) {
               id = b.toolCall?.id
               break outer
             }
@@ -110,7 +120,9 @@ export const DiffControls = memo(function DiffControls() {
         }
       }
       if (!id) {
-        const candidates = Object.values(toolCallsById).filter((t) => t.name === 'edit_workflow')
+        const candidates = Object.values(toolCallsById).filter((t) =>
+          isWorkflowEditToolCall(t.name, t.params)
+        )
         id = candidates.length ? candidates[candidates.length - 1].id : undefined
       }
       if (id) updatePreviewToolCallState('rejected', id)

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/copilot/components/tool-call/tool-call.tsx

@@ -47,6 +47,27 @@ interface ParsedTags {
   cleanContent: string
 }
 
+function getToolCallParams(toolCall?: CopilotToolCall): Record<string, unknown> {
+  const candidate = ((toolCall as any)?.parameters ||
+    (toolCall as any)?.input ||
+    (toolCall as any)?.params ||
+    {}) as Record<string, unknown>
+  return candidate && typeof candidate === 'object' ? candidate : {}
+}
+
+function isWorkflowChangeApplyMode(toolCall?: CopilotToolCall): boolean {
+  if (!toolCall || toolCall.name !== 'workflow_change') return false
+  const params = getToolCallParams(toolCall)
+  const mode = typeof params.mode === 'string' ? params.mode.toLowerCase() : ''
+  if (mode === 'apply') return true
+  return typeof params.proposalId === 'string' && params.proposalId.length > 0
+}
+
+function isWorkflowEditSummaryTool(toolCall?: CopilotToolCall): boolean {
+  if (!toolCall) return false
+  return isWorkflowChangeApplyMode(toolCall)
+}
+
 /**
  * Extracts plan steps from plan_respond tool calls in subagent blocks.
  * @param blocks - The subagent content blocks to search
@@ -871,7 +892,10 @@ const SubagentContentRenderer = memo(function SubagentContentRenderer({
           )
         }
         if (segment.type === 'tool' && segment.block.toolCall) {
-          if (toolCall.name === 'edit' && segment.block.toolCall.name === 'edit_workflow') {
+          if (
+            (toolCall.name === 'edit' || toolCall.name === 'build') &&
+            isWorkflowEditSummaryTool(segment.block.toolCall)
+          ) {
             return (
               <div key={`tool-${segment.block.toolCall.id || index}`}>
                 <WorkflowEditSummary toolCall={segment.block.toolCall} />
@@ -968,12 +992,11 @@ const WorkflowEditSummary = memo(function WorkflowEditSummary({
     }
   }, [blocks])
 
-  if (toolCall.name !== 'edit_workflow') {
+  if (!isWorkflowEditSummaryTool(toolCall)) {
     return null
   }
 
-  const params =
-    (toolCall as any).parameters || (toolCall as any).input || (toolCall as any).params || {}
+  const params = getToolCallParams(toolCall)
   let operations = Array.isArray(params.operations) ? params.operations : []
 
   if (operations.length === 0 && Array.isArray((toolCall as any).operations)) {
@@ -1219,11 +1242,6 @@ const WorkflowEditSummary = memo(function WorkflowEditSummary({
   )
 })
 
-/** Checks if a tool is server-side executed (not a client tool) */
-function isIntegrationTool(toolName: string): boolean {
-  return !TOOL_DISPLAY_REGISTRY[toolName]
-}
-
 function shouldShowRunSkipButtons(toolCall: CopilotToolCall): boolean {
   if (!toolCall.name || toolCall.name === 'unknown_tool') {
     return false
@@ -1233,59 +1251,96 @@ function shouldShowRunSkipButtons(toolCall: CopilotToolCall): boolean {
     return false
   }
 
-  // Never show buttons for tools the user has marked as always-allowed
-  if (useCopilotStore.getState().isToolAutoAllowed(toolCall.name)) {
+  if (toolCall.ui?.showInterrupt !== true) {
     return false
   }
 
-  const hasInterrupt = !!TOOL_DISPLAY_REGISTRY[toolCall.name]?.uiConfig?.interrupt
-  if (hasInterrupt) {
-    return true
-  }
-
-  // Integration tools (user-installed) always require approval
-  if (isIntegrationTool(toolCall.name)) {
-    return true
-  }
-
-  return false
+  return true
 }
 
 const toolCallLogger = createLogger('CopilotToolCall')
 
 async function sendToolDecision(
   toolCallId: string,
-  status: 'accepted' | 'rejected' | 'background'
+  status: 'accepted' | 'rejected' | 'background',
+  options?: {
+    toolName?: string
+    remember?: boolean
+  }
 ) {
   try {
     await fetch('/api/copilot/confirm', {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ toolCallId, status }),
+      body: JSON.stringify({
+        toolCallId,
+        status,
+        ...(options?.toolName ? { toolName: options.toolName } : {}),
+        ...(options?.remember ? { remember: true } : {}),
+      }),
     })
   } catch (error) {
     toolCallLogger.warn('Failed to send tool decision', {
       toolCallId,
       status,
+      remember: options?.remember === true,
+      toolName: options?.toolName,
       error: error instanceof Error ? error.message : String(error),
     })
   }
 }
 
+async function removeAutoAllowedToolPreference(toolName: string): Promise<boolean> {
+  try {
+    const response = await fetch(`/api/copilot/auto-allowed-tools?toolId=${encodeURIComponent(toolName)}`, {
+      method: 'DELETE',
+    })
+    return response.ok
+  } catch (error) {
+    toolCallLogger.warn('Failed to remove auto-allowed tool preference', {
+      toolName,
+      error: error instanceof Error ? error.message : String(error),
+    })
+    return false
+  }
+}
+
+type ToolUiAction = NonNullable<NonNullable<CopilotToolCall['ui']>['actions']>[number]
+
+function actionDecision(action: ToolUiAction): 'accepted' | 'rejected' | 'background' {
+  const id = action.id.toLowerCase()
+  if (id.includes('background')) return 'background'
+  if (action.kind === 'reject') return 'rejected'
+  return 'accepted'
+}
+
+function isClientRunCapability(toolCall: CopilotToolCall): boolean {
+  if (toolCall.execution?.target === 'sim_client_capability') {
+    return toolCall.execution.capabilityId === 'workflow.run' || !toolCall.execution.capabilityId
+  }
+  return CLIENT_EXECUTABLE_RUN_TOOLS.has(toolCall.name)
+}
+
 async function handleRun(
   toolCall: CopilotToolCall,
   setToolCallState: any,
   onStateChange?: any,
-  editedParams?: any
+  editedParams?: any,
+  options?: {
+    remember?: boolean
+  }
 ) {
   setToolCallState(toolCall, 'executing', editedParams ? { params: editedParams } : undefined)
   onStateChange?.('executing')
-  await sendToolDecision(toolCall.id, 'accepted')
+  await sendToolDecision(toolCall.id, 'accepted', {
+    toolName: toolCall.name,
+    remember: options?.remember === true,
+  })
 
   // Client-executable run tools: execute on the client for real-time feedback
   // (block pulsing, console logs, stop button). The server defers execution
   // for these tools; the client reports back via mark-complete.
-  if (CLIENT_EXECUTABLE_RUN_TOOLS.has(toolCall.name)) {
+  if (isClientRunCapability(toolCall)) {
     const params = editedParams || toolCall.params || {}
     executeRunToolOnClient(toolCall.id, toolCall.name, params)
   }
@@ -1298,6 +1353,9 @@ async function handleSkip(toolCall: CopilotToolCall, setToolCallState: any, onSt
 }
 
 function getDisplayName(toolCall: CopilotToolCall): string {
+  if (toolCall.ui?.phaseLabel) return toolCall.ui.phaseLabel
+  if (toolCall.ui?.title) return `${getStateVerb(toolCall.state)} ${toolCall.ui.title}`
+
   const fromStore = (toolCall as any).display?.text
   if (fromStore) return fromStore
   const registryEntry = TOOL_DISPLAY_REGISTRY[toolCall.name]
@@ -1342,53 +1400,37 @@ function RunSkipButtons({
   toolCall,
   onStateChange,
   editedParams,
+  actions,
 }: {
   toolCall: CopilotToolCall
   onStateChange?: (state: any) => void
   editedParams?: any
+  actions: ToolUiAction[]
 }) {
   const [isProcessing, setIsProcessing] = useState(false)
   const [buttonsHidden, setButtonsHidden] = useState(false)
   const actionInProgressRef = useRef(false)
-  const { setToolCallState, addAutoAllowedTool } = useCopilotStore()
+  const { setToolCallState } = useCopilotStore()
 
-  const onRun = async () => {
+  const onAction = async (action: ToolUiAction) => {
     // Prevent race condition - check ref synchronously
     if (actionInProgressRef.current) return
     actionInProgressRef.current = true
     setIsProcessing(true)
     setButtonsHidden(true)
     try {
-      await handleRun(toolCall, setToolCallState, onStateChange, editedParams)
-    } finally {
-      setIsProcessing(false)
-      actionInProgressRef.current = false
-    }
-  }
-
-  const onAlwaysAllow = async () => {
-    // Prevent race condition - check ref synchronously
-    if (actionInProgressRef.current) return
-    actionInProgressRef.current = true
-    setIsProcessing(true)
-    setButtonsHidden(true)
-    try {
-      await addAutoAllowedTool(toolCall.name)
-      await handleRun(toolCall, setToolCallState, onStateChange, editedParams)
-    } finally {
-      setIsProcessing(false)
-      actionInProgressRef.current = false
-    }
-  }
-
-  const onSkip = async () => {
-    // Prevent race condition - check ref synchronously
-    if (actionInProgressRef.current) return
-    actionInProgressRef.current = true
-    setIsProcessing(true)
-    setButtonsHidden(true)
-    try {
-      await handleSkip(toolCall, setToolCallState, onStateChange)
+      const decision = actionDecision(action)
+      if (decision === 'accepted') {
+        await handleRun(toolCall, setToolCallState, onStateChange, editedParams, {
+          remember: action.remember === true,
+        })
+      } else if (decision === 'rejected') {
+        await handleSkip(toolCall, setToolCallState, onStateChange)
+      } else {
+        setToolCallState(toolCall, ClientToolCallState.background)
+        onStateChange?.('background')
+        await sendToolDecision(toolCall.id, 'background')
+      }
     } finally {
       setIsProcessing(false)
       actionInProgressRef.current = false
@@ -1397,23 +1439,22 @@ function RunSkipButtons({
 
   if (buttonsHidden) return null
 
-  // Show "Always Allow" for all tools that require confirmation
-  const showAlwaysAllow = true
-
-  // Standardized buttons for all interrupt tools: Allow, Always Allow, Skip
   return (
     <div className='mt-[10px] flex gap-[6px]'>
-      <Button onClick={onRun} disabled={isProcessing} variant='tertiary'>
-        {isProcessing ? 'Allowing...' : 'Allow'}
-      </Button>
-      {showAlwaysAllow && (
-        <Button onClick={onAlwaysAllow} disabled={isProcessing} variant='default'>
-          {isProcessing ? 'Allowing...' : 'Always Allow'}
-        </Button>
-      )}
-      <Button onClick={onSkip} disabled={isProcessing} variant='default'>
-        Skip
-      </Button>
+      {actions.map((action, index) => {
+        const variant =
+          action.kind === 'reject' ? 'default' : action.remember ? 'default' : 'tertiary'
+        return (
+          <Button
+            key={action.id}
+            onClick={() => onAction(action)}
+            disabled={isProcessing}
+            variant={variant}
+          >
+            {isProcessing && index === 0 ? 'Working...' : action.label}
+          </Button>
+        )
+      })}
     </div>
   )
 }
@@ -1430,10 +1471,16 @@ export function ToolCall({
   const liveToolCall = useCopilotStore((s) =>
     effectiveId ? s.toolCallsById[effectiveId] : undefined
   )
-  const toolCall = liveToolCall || toolCallProp
-
-  // Guard: nothing to render without a toolCall
-  if (!toolCall) return null
+  const rawToolCall = liveToolCall || toolCallProp
+  const hasRealToolCall = !!rawToolCall
+  const toolCall: CopilotToolCall =
+    rawToolCall ||
+    ({
+      id: effectiveId || '',
+      name: '',
+      state: ClientToolCallState.generating,
+      params: {},
+    } as CopilotToolCall)
 
   const isExpandablePending =
     toolCall?.state === 'pending' &&
@@ -1441,17 +1488,15 @@ export function ToolCall({
 
   const [expanded, setExpanded] = useState(isExpandablePending)
   const [showRemoveAutoAllow, setShowRemoveAutoAllow] = useState(false)
+  const [autoAllowRemovedForCall, setAutoAllowRemovedForCall] = useState(false)
 
   // State for editable parameters
   const params = (toolCall as any).parameters || (toolCall as any).input || toolCall.params || {}
   const [editedParams, setEditedParams] = useState(params)
   const paramsRef = useRef(params)
 
-  // Check if this integration tool is auto-allowed
-  const { removeAutoAllowedTool, setToolCallState } = useCopilotStore()
-  const isAutoAllowed = useCopilotStore(
-    (s) => isIntegrationTool(toolCall.name) && s.isToolAutoAllowed(toolCall.name)
-  )
+  const { setToolCallState } = useCopilotStore()
+  const isAutoAllowed = toolCall.ui?.autoAllowed === true && !autoAllowRemovedForCall
 
   // Update edited params when toolCall params change (deep comparison to avoid resetting user edits on ref change)
   useEffect(() => {
@@ -1461,6 +1506,14 @@ export function ToolCall({
     }
   }, [params])
 
+  useEffect(() => {
+    setAutoAllowRemovedForCall(false)
+    setShowRemoveAutoAllow(false)
+  }, [toolCall.id])
+
+  // Guard: nothing to render without a toolCall
+  if (!hasRealToolCall) return null
+
   // Skip rendering some internal tools
   if (
     toolCall.name === 'checkoff_todo' ||
@@ -1472,7 +1525,9 @@ export function ToolCall({
     return null
 
   // Special rendering for subagent tools - show as thinking text with tool calls at top level
-  const isSubagentTool = TOOL_DISPLAY_REGISTRY[toolCall.name]?.uiConfig?.subagent === true
+  const isSubagentTool =
+    toolCall.execution?.target === 'go_subagent' ||
+    TOOL_DISPLAY_REGISTRY[toolCall.name]?.uiConfig?.subagent === true
 
   // For ALL subagent tools, don't show anything until we have blocks with content
   if (isSubagentTool) {
@@ -1499,28 +1554,6 @@ export function ToolCall({
     )
   }
 
-  // Get current mode from store to determine if we should render integration tools
-  const mode = useCopilotStore.getState().mode
-
-  // Check if this is a completed/historical tool call (not pending/executing)
-  // Use string comparison to handle both enum values and string values from DB
-  const stateStr = String(toolCall.state)
-  const isCompletedToolCall =
-    stateStr === 'success' ||
-    stateStr === 'error' ||
-    stateStr === 'rejected' ||
-    stateStr === 'aborted'
-
-  // Allow rendering if:
-  // 1. Tool is in TOOL_DISPLAY_REGISTRY (client tools), OR
-  // 2. We're in build mode (integration tools are executed server-side), OR
-  // 3. Tool call is already completed (historical - should always render)
-  const isClientTool = !!TOOL_DISPLAY_REGISTRY[toolCall.name]
-  const isIntegrationToolInBuildMode = mode === 'build' && !isClientTool
-
-  if (!isClientTool && !isIntegrationToolInBuildMode && !isCompletedToolCall) {
-    return null
-  }
   const toolUIConfig = TOOL_DISPLAY_REGISTRY[toolCall.name]?.uiConfig
   // Check if tool has params table config (meaning it's expandable)
   const hasParamsTable = !!toolUIConfig?.paramsTable
@@ -1530,6 +1563,14 @@ export function ToolCall({
     toolCall.name === 'make_api_request' ||
     toolCall.name === 'set_global_workflow_variables'
 
+  const interruptActions =
+    (toolCall.ui?.actions && toolCall.ui.actions.length > 0
+      ? toolCall.ui.actions
+      : [
+          { id: 'allow_once', label: 'Allow', kind: 'accept' as const },
+          { id: 'allow_always', label: 'Always Allow', kind: 'accept' as const, remember: true },
+          { id: 'reject', label: 'Skip', kind: 'reject' as const },
+        ]) as ToolUiAction[]
   const showButtons = isCurrentMessage && shouldShowRunSkipButtons(toolCall)
 
   // Check UI config for secondary action - only show for current message tool calls
@@ -1987,9 +2028,12 @@ export function ToolCall({
           <div className='mt-[10px]'>
             <Button
               onClick={async () => {
-                await removeAutoAllowedTool(toolCall.name)
-                setShowRemoveAutoAllow(false)
-                forceUpdate({})
+                const removed = await removeAutoAllowedToolPreference(toolCall.name)
+                if (removed) {
+                  setAutoAllowRemovedForCall(true)
+                  setShowRemoveAutoAllow(false)
+                  forceUpdate({})
+                }
               }}
               variant='default'
               className='text-xs'
@@ -2003,6 +2047,7 @@ export function ToolCall({
             toolCall={toolCall}
             onStateChange={handleStateChange}
             editedParams={editedParams}
+            actions={interruptActions}
           />
         )}
         {/* Render subagent content as thinking text */}
@@ -2048,9 +2093,12 @@ export function ToolCall({
           <div className='mt-[10px]'>
             <Button
               onClick={async () => {
-                await removeAutoAllowedTool(toolCall.name)
-                setShowRemoveAutoAllow(false)
-                forceUpdate({})
+                const removed = await removeAutoAllowedToolPreference(toolCall.name)
+                if (removed) {
+                  setAutoAllowRemovedForCall(true)
+                  setShowRemoveAutoAllow(false)
+                  forceUpdate({})
+                }
               }}
               variant='default'
               className='text-xs'
@@ -2064,6 +2112,7 @@ export function ToolCall({
             toolCall={toolCall}
             onStateChange={handleStateChange}
             editedParams={editedParams}
+            actions={interruptActions}
           />
         )}
         {/* Render subagent content as thinking text */}
@@ -2087,7 +2136,7 @@ export function ToolCall({
     }
   }
 
-  const isEditWorkflow = toolCall.name === 'edit_workflow'
+  const isEditWorkflow = isWorkflowEditSummaryTool(toolCall)
   const shouldShowDetails = isRunWorkflow || (isExpandableTool && expanded)
   const hasOperations = Array.isArray(params.operations) && params.operations.length > 0
   const hideTextForEditWorkflow = isEditWorkflow && hasOperations
@@ -2109,9 +2158,12 @@ export function ToolCall({
         <div className='mt-[10px]'>
           <Button
             onClick={async () => {
-              await removeAutoAllowedTool(toolCall.name)
-              setShowRemoveAutoAllow(false)
-              forceUpdate({})
+              const removed = await removeAutoAllowedToolPreference(toolCall.name)
+              if (removed) {
+                setAutoAllowRemovedForCall(true)
+                setShowRemoveAutoAllow(false)
+                forceUpdate({})
+              }
             }}
             variant='default'
             className='text-xs'
@@ -2125,6 +2177,7 @@ export function ToolCall({
           toolCall={toolCall}
           onStateChange={handleStateChange}
           editedParams={editedParams}
+          actions={interruptActions}
         />
       ) : showMoveToBackground ? (
         <div className='mt-[10px]'>
@@ -2155,7 +2208,7 @@ export function ToolCall({
           </Button>
         </div>
       ) : null}
-      {/* Workflow edit summary - shows block changes after edit_workflow completes */}
+      {/* Workflow edit summary - shows block changes after workflow_change(apply) */}
       <WorkflowEditSummary toolCall={toolCall} />
 
       {/* Render subagent content as thinking text */}

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/copilot/copilot.tsx

@@ -113,7 +113,6 @@ export const Copilot = forwardRef<CopilotRef, CopilotProps>(({ panelWidth }, ref
     clearPlanArtifact,
     savePlanArtifact,
     loadAvailableModels,
-    loadAutoAllowedTools,
     resumeActiveStream,
   } = useCopilotStore()
 
@@ -125,8 +124,6 @@ export const Copilot = forwardRef<CopilotRef, CopilotProps>(({ panelWidth }, ref
     setCopilotWorkflowId,
     loadChats,
     loadAvailableModels,
-    loadAutoAllowedTools,
-    currentChat,
     isSendingMessage,
     resumeActiveStream,
   })
@@ -154,6 +151,8 @@ export const Copilot = forwardRef<CopilotRef, CopilotProps>(({ panelWidth }, ref
     planTodos,
   })
 
+  const renderedChatTitle = currentChat?.title || 'New Chat'
+
   /** Gets markdown content for design document section (available in all modes once created) */
   const designDocumentContent = useMemo(() => {
     if (streamingPlanContent) {
@@ -166,6 +165,14 @@ export const Copilot = forwardRef<CopilotRef, CopilotProps>(({ panelWidth }, ref
     return ''
   }, [streamingPlanContent])
 
+  useEffect(() => {
+    logger.info('[TitleRender] Copilot header title changed', {
+      currentChatId: currentChat?.id || null,
+      currentChatTitle: currentChat?.title || null,
+      renderedTitle: renderedChatTitle,
+    })
+  }, [currentChat?.id, currentChat?.title, renderedChatTitle])
+
   /** Focuses the copilot input */
   const focusInput = useCallback(() => {
     userInputRef.current?.focus()
@@ -348,7 +355,7 @@ export const Copilot = forwardRef<CopilotRef, CopilotProps>(({ panelWidth }, ref
         {/* Header */}
         <div className='mx-[-1px] flex flex-shrink-0 items-center justify-between gap-[8px] rounded-[4px] border border-[var(--border)] bg-[var(--surface-4)] px-[12px] py-[6px]'>
           <h2 className='min-w-0 flex-1 truncate font-medium text-[14px] text-[var(--text-primary)]'>
-            {currentChat?.title || 'New Chat'}
+            {renderedChatTitle}
           </h2>
           <div className='flex items-center gap-[8px]'>
             <Button variant='ghost' className='p-0' onClick={handleStartNewChat}>

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/copilot/hooks/use-copilot-initialization.ts

@@ -12,8 +12,6 @@ interface UseCopilotInitializationProps {
   setCopilotWorkflowId: (workflowId: string | null) => Promise<void>
   loadChats: (forceRefresh?: boolean) => Promise<void>
   loadAvailableModels: () => Promise<void>
-  loadAutoAllowedTools: () => Promise<void>
-  currentChat: any
   isSendingMessage: boolean
   resumeActiveStream: () => Promise<boolean>
 }
@@ -32,8 +30,6 @@ export function useCopilotInitialization(props: UseCopilotInitializationProps) {
     setCopilotWorkflowId,
     loadChats,
     loadAvailableModels,
-    loadAutoAllowedTools,
-    currentChat,
     isSendingMessage,
     resumeActiveStream,
   } = props
@@ -120,17 +116,6 @@ export function useCopilotInitialization(props: UseCopilotInitializationProps) {
     })
   }, [isSendingMessage, resumeActiveStream])
 
-  /** Load auto-allowed tools once on mount - runs immediately, independent of workflow */
-  const hasLoadedAutoAllowedToolsRef = useRef(false)
-  useEffect(() => {
-    if (!hasLoadedAutoAllowedToolsRef.current) {
-      hasLoadedAutoAllowedToolsRef.current = true
-      loadAutoAllowedTools().catch((err) => {
-        logger.warn('[Copilot] Failed to load auto-allowed tools', err)
-      })
-    }
-  }, [loadAutoAllowedTools])
-
   /** Load available models once on mount */
   const hasLoadedModelsRef = useRef(false)
   useEffect(() => {

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]/components/panel/components/editor/hooks/use-editor-subblock-layout.ts

@@ -3,7 +3,6 @@ import {
   buildCanonicalIndex,
   evaluateSubBlockCondition,
   isSubBlockFeatureEnabled,
-  isSubBlockHiddenByHostedKey,
   isSubBlockVisibleForMode,
 } from '@/lib/workflows/subblocks/visibility'
 import type { BlockConfig, SubBlockConfig, SubBlockType } from '@/blocks/types'
@@ -109,9 +108,6 @@ export function useEditorSubblockLayout(
       // Check required feature if specified - declarative feature gating
       if (!isSubBlockFeatureEnabled(block)) return false
 
-      // Hide tool API key fields when hosted key is available
-      if (isSubBlockHiddenByHostedKey(block)) return false
-
       // Special handling for trigger-config type (legacy trigger configuration UI)
       if (block.type === ('trigger-config' as SubBlockType)) {
         const isPureTriggerBlock = config?.triggers?.enabled && config.category === 'triggers'

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/workflow-block/workflow-block.tsx

@@ -15,7 +15,6 @@ import {
   evaluateSubBlockCondition,
   hasAdvancedValues,
   isSubBlockFeatureEnabled,
-  isSubBlockHiddenByHostedKey,
   isSubBlockVisibleForMode,
   resolveDependencyValue,
 } from '@/lib/workflows/subblocks/visibility'
@@ -829,7 +828,6 @@ export const WorkflowBlock = memo(function WorkflowBlock({
       if (block.hidden) return false
       if (block.hideFromPreview) return false
       if (!isSubBlockFeatureEnabled(block)) return false
-      if (isSubBlockHiddenByHostedKey(block)) return false
 
       const isPureTriggerBlock = config?.triggers?.enabled && config.category === 'triggers'
 

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/app/workspace/[workspaceId]/w/components/sidebar/components/settings-modal/components/byok/byok.tsx

@@ -13,15 +13,15 @@ import {
   ModalFooter,
   ModalHeader,
 } from '@/components/emcn'
-import { AnthropicIcon, ExaAIIcon, GeminiIcon, MistralIcon, OpenAIIcon } from '@/components/icons'
+import { AnthropicIcon, GeminiIcon, MistralIcon, OpenAIIcon } from '@/components/icons'
 import { Skeleton } from '@/components/ui'
 import {
   type BYOKKey,
+  type BYOKProviderId,
   useBYOKKeys,
   useDeleteBYOKKey,
   useUpsertBYOKKey,
 } from '@/hooks/queries/byok-keys'
-import type { BYOKProviderId } from '@/tools/types'
 
 const logger = createLogger('BYOKSettings')
 
@@ -60,13 +60,6 @@ const PROVIDERS: {
     description: 'LLM calls and Knowledge Base OCR',
     placeholder: 'Enter your API key',
   },
-  {
-    id: 'exa',
-    name: 'Exa',
-    icon: ExaAIIcon,
-    description: 'AI-powered search and research',
-    placeholder: 'Enter your Exa API key',
-  },
 ]
 
 function BYOKKeySkeleton() {

apps/sim/blocks/blocks/exa.ts

@@ -297,7 +297,6 @@ export const ExaBlock: BlockConfig<ExaResponse> = {
       placeholder: 'Enter your Exa API key',
       password: true,
       required: true,
-      hideWhenHosted: true,
     },
   ],
   tools: {

apps/sim/blocks/blocks/s3.ts

@@ -58,16 +58,6 @@ export const S3Block: BlockConfig<S3Response> = {
       },
       required: true,
     },
-    {
-      id: 'getObjectRegion',
-      title: 'AWS Region',
-      type: 'short-input',
-      placeholder: 'Used when S3 URL does not include region',
-      condition: {
-        field: 'operation',
-        value: ['get_object'],
-      },
-    },
     {
       id: 'bucketName',
       title: 'Bucket Name',
@@ -301,11 +291,34 @@ export const S3Block: BlockConfig<S3Response> = {
             if (!params.s3Uri) {
               throw new Error('S3 Object URL is required')
             }
-            return {
-              accessKeyId: params.accessKeyId,
-              secretAccessKey: params.secretAccessKey,
-              region: params.getObjectRegion || params.region,
-              s3Uri: params.s3Uri,
+
+            // Parse S3 URI for get_object
+            try {
+              const url = new URL(params.s3Uri)
+              const hostname = url.hostname
+              const bucketName = hostname.split('.')[0]
+              const regionMatch = hostname.match(/s3[.-]([^.]+)\.amazonaws\.com/)
+              const region = regionMatch ? regionMatch[1] : params.region
+              const objectKey = url.pathname.startsWith('/')
+                ? url.pathname.substring(1)
+                : url.pathname
+
+              if (!bucketName || !objectKey) {
+                throw new Error('Could not parse S3 URL')
+              }
+
+              return {
+                accessKeyId: params.accessKeyId,
+                secretAccessKey: params.secretAccessKey,
+                region,
+                bucketName,
+                objectKey,
+                s3Uri: params.s3Uri,
+              }
+            } catch (_error) {
+              throw new Error(
+                'Invalid S3 Object URL format. Expected: https://bucket-name.s3.region.amazonaws.com/path/to/file'
+              )
             }
           }
 
@@ -388,7 +401,6 @@ export const S3Block: BlockConfig<S3Response> = {
     acl: { type: 'string', description: 'Access control list' },
     // Download inputs
     s3Uri: { type: 'string', description: 'S3 object URL' },
-    getObjectRegion: { type: 'string', description: 'Optional AWS region override for downloads' },
     // List inputs
     prefix: { type: 'string', description: 'Prefix filter' },
     maxKeys: { type: 'number', description: 'Maximum results' },

apps/sim/blocks/types.ts

@@ -243,7 +243,6 @@ export interface SubBlockConfig {
   hidden?: boolean
   hideFromPreview?: boolean // Hide this subblock from the workflow block preview
   requiresFeature?: string // Environment variable name that must be truthy for this subblock to be visible
-  hideWhenHosted?: boolean // Hide this subblock when running on hosted sim
   description?: string
   tooltip?: string // Tooltip text displayed via info icon next to the title
   value?: (params: Record<string, any>) => string

apps/sim/executor/handlers/agent/agent-handler.test.ts

@@ -1,4 +1,3 @@
-import { setupGlobalFetchMock } from '@sim/testing'
 import { afterEach, beforeEach, describe, expect, it, type Mock, vi } from 'vitest'
 import { getAllBlocks } from '@/blocks'
 import { BlockType, isMcpTool } from '@/executor/constants'
@@ -62,30 +61,6 @@ vi.mock('@/providers', () => ({
   }),
 }))
 
-vi.mock('@/executor/utils/http', () => ({
-  buildAuthHeaders: vi.fn().mockResolvedValue({ 'Content-Type': 'application/json' }),
-  buildAPIUrl: vi.fn((path: string, params?: Record<string, string>) => {
-    const url = new URL(path, 'http://localhost:3000')
-    if (params) {
-      for (const [key, value] of Object.entries(params)) {
-        if (value !== undefined && value !== null) {
-          url.searchParams.set(key, value)
-        }
-      }
-    }
-    return url
-  }),
-  extractAPIErrorMessage: vi.fn(async (response: Response) => {
-    const defaultMessage = `API request failed with status ${response.status}`
-    try {
-      const errorData = await response.json()
-      return errorData.error || defaultMessage
-    } catch {
-      return defaultMessage
-    }
-  }),
-}))
-
 vi.mock('@sim/db', () => ({
   db: {
     select: vi.fn().mockReturnValue({
@@ -109,7 +84,7 @@ vi.mock('@sim/db/schema', () => ({
   },
 }))
 
-setupGlobalFetchMock()
+global.fetch = Object.assign(vi.fn(), { preconnect: vi.fn() }) as typeof fetch
 
 const mockGetAllBlocks = getAllBlocks as Mock
 const mockExecuteTool = executeTool as Mock
@@ -1926,301 +1901,5 @@ describe('AgentBlockHandler', () => {
 
       expect(discoveryCalls[0].url).toContain('serverId=mcp-legacy-server')
     })
-
-    describe('customToolId resolution - DB as source of truth', () => {
-      const staleInlineSchema = {
-        function: {
-          name: 'formatReport',
-          description: 'Formats a report',
-          parameters: {
-            type: 'object',
-            properties: {
-              title: { type: 'string', description: 'Report title' },
-              content: { type: 'string', description: 'Report content' },
-            },
-            required: ['title', 'content'],
-          },
-        },
-      }
-
-      const dbSchema = {
-        function: {
-          name: 'formatReport',
-          description: 'Formats a report',
-          parameters: {
-            type: 'object',
-            properties: {
-              title: { type: 'string', description: 'Report title' },
-              content: { type: 'string', description: 'Report content' },
-              format: { type: 'string', description: 'Output format' },
-            },
-            required: ['title', 'content', 'format'],
-          },
-        },
-      }
-
-      const staleInlineCode = 'return { title, content };'
-      const dbCode = 'return { title, content, format };'
-
-      function mockFetchForCustomTool(toolId: string) {
-        mockFetch.mockImplementation((url: string) => {
-          if (typeof url === 'string' && url.includes('/api/tools/custom')) {
-            return Promise.resolve({
-              ok: true,
-              headers: { get: () => null },
-              json: () =>
-                Promise.resolve({
-                  data: [
-                    {
-                      id: toolId,
-                      title: 'formatReport',
-                      schema: dbSchema,
-                      code: dbCode,
-                    },
-                  ],
-                }),
-            })
-          }
-          return Promise.resolve({
-            ok: true,
-            headers: { get: () => null },
-            json: () => Promise.resolve({}),
-          })
-        })
-      }
-
-      function mockFetchFailure() {
-        mockFetch.mockImplementation((url: string) => {
-          if (typeof url === 'string' && url.includes('/api/tools/custom')) {
-            return Promise.resolve({
-              ok: false,
-              status: 500,
-              headers: { get: () => null },
-              json: () => Promise.resolve({}),
-            })
-          }
-          return Promise.resolve({
-            ok: true,
-            headers: { get: () => null },
-            json: () => Promise.resolve({}),
-          })
-        })
-      }
-
-      beforeEach(() => {
-        Object.defineProperty(global, 'window', {
-          value: undefined,
-          writable: true,
-          configurable: true,
-        })
-      })
-
-      it('should always fetch latest schema from DB when customToolId is present', async () => {
-        const toolId = 'custom-tool-123'
-        mockFetchForCustomTool(toolId)
-
-        const inputs = {
-          model: 'gpt-4o',
-          userPrompt: 'Format a report',
-          apiKey: 'test-api-key',
-          tools: [
-            {
-              type: 'custom-tool',
-              customToolId: toolId,
-              title: 'formatReport',
-              schema: staleInlineSchema,
-              code: staleInlineCode,
-              usageControl: 'auto' as const,
-            },
-          ],
-        }
-
-        mockGetProviderFromModel.mockReturnValue('openai')
-
-        await handler.execute(mockContext, mockBlock, inputs)
-
-        expect(mockExecuteProviderRequest).toHaveBeenCalled()
-        const providerCall = mockExecuteProviderRequest.mock.calls[0]
-        const tools = providerCall[1].tools
-
-        expect(tools.length).toBe(1)
-        // DB schema wins over stale inline — includes format param
-        expect(tools[0].parameters.required).toContain('format')
-        expect(tools[0].parameters.properties).toHaveProperty('format')
-      })
-
-      it('should fetch from DB when customToolId has no inline schema', async () => {
-        const toolId = 'custom-tool-123'
-        mockFetchForCustomTool(toolId)
-
-        const inputs = {
-          model: 'gpt-4o',
-          userPrompt: 'Format a report',
-          apiKey: 'test-api-key',
-          tools: [
-            {
-              type: 'custom-tool',
-              customToolId: toolId,
-              usageControl: 'auto' as const,
-            },
-          ],
-        }
-
-        mockGetProviderFromModel.mockReturnValue('openai')
-
-        await handler.execute(mockContext, mockBlock, inputs)
-
-        expect(mockExecuteProviderRequest).toHaveBeenCalled()
-        const providerCall = mockExecuteProviderRequest.mock.calls[0]
-        const tools = providerCall[1].tools
-
-        expect(tools.length).toBe(1)
-        expect(tools[0].name).toBe('formatReport')
-        expect(tools[0].parameters.required).toContain('format')
-      })
-
-      it('should fall back to inline schema when DB fetch fails and inline exists', async () => {
-        mockFetchFailure()
-
-        const inputs = {
-          model: 'gpt-4o',
-          userPrompt: 'Format a report',
-          apiKey: 'test-api-key',
-          tools: [
-            {
-              type: 'custom-tool',
-              customToolId: 'custom-tool-123',
-              title: 'formatReport',
-              schema: staleInlineSchema,
-              code: staleInlineCode,
-              usageControl: 'auto' as const,
-            },
-          ],
-        }
-
-        mockGetProviderFromModel.mockReturnValue('openai')
-
-        await handler.execute(mockContext, mockBlock, inputs)
-
-        expect(mockExecuteProviderRequest).toHaveBeenCalled()
-        const providerCall = mockExecuteProviderRequest.mock.calls[0]
-        const tools = providerCall[1].tools
-
-        expect(tools.length).toBe(1)
-        expect(tools[0].name).toBe('formatReport')
-        expect(tools[0].parameters.required).not.toContain('format')
-      })
-
-      it('should return null when DB fetch fails and no inline schema exists', async () => {
-        mockFetchFailure()
-
-        const inputs = {
-          model: 'gpt-4o',
-          userPrompt: 'Format a report',
-          apiKey: 'test-api-key',
-          tools: [
-            {
-              type: 'custom-tool',
-              customToolId: 'custom-tool-123',
-              usageControl: 'auto' as const,
-            },
-          ],
-        }
-
-        mockGetProviderFromModel.mockReturnValue('openai')
-
-        await handler.execute(mockContext, mockBlock, inputs)
-
-        expect(mockExecuteProviderRequest).toHaveBeenCalled()
-        const providerCall = mockExecuteProviderRequest.mock.calls[0]
-        const tools = providerCall[1].tools
-
-        expect(tools.length).toBe(0)
-      })
-
-      it('should use DB code for executeFunction when customToolId resolves', async () => {
-        const toolId = 'custom-tool-123'
-        mockFetchForCustomTool(toolId)
-
-        let capturedTools: any[] = []
-        Promise.all = vi.fn().mockImplementation((promises: Promise<any>[]) => {
-          const result = originalPromiseAll.call(Promise, promises)
-          result.then((tools: any[]) => {
-            if (tools?.length) {
-              capturedTools = tools.filter((t) => t !== null)
-            }
-          })
-          return result
-        })
-
-        const inputs = {
-          model: 'gpt-4o',
-          userPrompt: 'Format a report',
-          apiKey: 'test-api-key',
-          tools: [
-            {
-              type: 'custom-tool',
-              customToolId: toolId,
-              title: 'formatReport',
-              schema: staleInlineSchema,
-              code: staleInlineCode,
-              usageControl: 'auto' as const,
-            },
-          ],
-        }
-
-        mockGetProviderFromModel.mockReturnValue('openai')
-
-        await handler.execute(mockContext, mockBlock, inputs)
-
-        expect(capturedTools.length).toBe(1)
-        expect(typeof capturedTools[0].executeFunction).toBe('function')
-
-        await capturedTools[0].executeFunction({ title: 'Q1', format: 'pdf' })
-
-        expect(mockExecuteTool).toHaveBeenCalledWith(
-          'function_execute',
-          expect.objectContaining({
-            code: dbCode,
-          }),
-          false,
-          expect.any(Object)
-        )
-      })
-
-      it('should not fetch from DB when no customToolId is present', async () => {
-        const inputs = {
-          model: 'gpt-4o',
-          userPrompt: 'Use the tool',
-          apiKey: 'test-api-key',
-          tools: [
-            {
-              type: 'custom-tool',
-              title: 'formatReport',
-              schema: staleInlineSchema,
-              code: staleInlineCode,
-              usageControl: 'auto' as const,
-            },
-          ],
-        }
-
-        mockGetProviderFromModel.mockReturnValue('openai')
-
-        await handler.execute(mockContext, mockBlock, inputs)
-
-        const customToolFetches = mockFetch.mock.calls.filter(
-          (call: any[]) => typeof call[0] === 'string' && call[0].includes('/api/tools/custom')
-        )
-        expect(customToolFetches.length).toBe(0)
-
-        expect(mockExecuteProviderRequest).toHaveBeenCalled()
-        const providerCall = mockExecuteProviderRequest.mock.calls[0]
-        const tools = providerCall[1].tools
-
-        expect(tools.length).toBe(1)
-        expect(tools[0].name).toBe('formatReport')
-        expect(tools[0].parameters.required).not.toContain('format')
-      })
-    })
   })
 })

apps/sim/executor/handlers/agent/agent-handler.ts

@@ -272,16 +272,15 @@ export class AgentBlockHandler implements BlockHandler {
     let code = tool.code
     let title = tool.title
 
-    if (tool.customToolId) {
+    if (tool.customToolId && !schema) {
       const resolved = await this.fetchCustomToolById(ctx, tool.customToolId)
-      if (resolved) {
-        schema = resolved.schema
-        code = resolved.code
-        title = resolved.title
-      } else if (!schema) {
+      if (!resolved) {
         logger.error(`Custom tool not found: ${tool.customToolId}`)
         return null
       }
+      schema = resolved.schema
+      code = resolved.code
+      title = resolved.title
     }
 
     if (!schema?.function) {

apps/sim/executor/handlers/generic/generic-handler.ts

@@ -98,21 +98,10 @@ export class GenericBlockHandler implements BlockHandler {
       }
 
       const output = result.output
-
-      // Merge costs from output (e.g., AI model costs) and result (e.g., hosted key costs)
-      // TODO: migrate model usage to output cost.
-      const outputCost = output?.cost
-      const resultCost = result.cost
-
       let cost = null
-      if (outputCost || resultCost) {
-        cost = {
-          input: (outputCost?.input || 0) + (resultCost?.input || 0),
-          output: (outputCost?.output || 0) + (resultCost?.output || 0),
-          total: (outputCost?.total || 0) + (resultCost?.total || 0),
-          tokens: outputCost?.tokens,
-          model: outputCost?.model,
-        }
+
+      if (output?.cost) {
+        cost = output.cost
       }
 
       if (cost) {

apps/sim/executor/handlers/workflow/workflow-handler.test.ts

@@ -1,4 +1,3 @@
-import { setupGlobalFetchMock } from '@sim/testing'
 import { beforeEach, describe, expect, it, type Mock, vi } from 'vitest'
 import { BlockType } from '@/executor/constants'
 import { WorkflowBlockHandler } from '@/executor/handlers/workflow/workflow-handler'
@@ -10,7 +9,7 @@ vi.mock('@/lib/auth/internal', () => ({
 }))
 
 // Mock fetch globally
-setupGlobalFetchMock()
+global.fetch = vi.fn()
 
 describe('WorkflowBlockHandler', () => {
   let handler: WorkflowBlockHandler

apps/sim/hooks/queries/byok-keys.ts

@@ -1,10 +1,11 @@
 import { createLogger } from '@sim/logger'
 import { keepPreviousData, useMutation, useQuery, useQueryClient } from '@tanstack/react-query'
 import { API_ENDPOINTS } from '@/stores/constants'
-import type { BYOKProviderId } from '@/tools/types'
 
 const logger = createLogger('BYOKKeysQueries')
 
+export type BYOKProviderId = 'openai' | 'anthropic' | 'google' | 'mistral'
+
 export interface BYOKKey {
   id: string
   providerId: BYOKProviderId

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/api-key/byok.ts

@@ -7,10 +7,11 @@ import { isHosted } from '@/lib/core/config/feature-flags'
 import { decryptSecret } from '@/lib/core/security/encryption'
 import { getHostedModels } from '@/providers/models'
 import { useProvidersStore } from '@/stores/providers/store'
-import type { BYOKProviderId } from '@/tools/types'
 
 const logger = createLogger('BYOKKeys')
 
+export type BYOKProviderId = 'openai' | 'anthropic' | 'google' | 'mistral'
+
 export interface BYOKKeyResult {
   apiKey: string
   isBYOK: true

apps/sim/lib/billing/core/usage-log.ts

@@ -25,9 +25,9 @@ export interface ModelUsageMetadata {
 }
 
 /**
- * Metadata for 'fixed' category charges (e.g., tool cost breakdown)
+ * Metadata for 'fixed' category charges (currently empty, extensible)
  */
-export type FixedUsageMetadata = Record<string, unknown>
+export type FixedUsageMetadata = Record<string, never>
 
 /**
  * Union type for all metadata types
@@ -60,8 +60,6 @@ export interface LogFixedUsageParams {
   workspaceId?: string
   workflowId?: string
   executionId?: string
-  /** Optional metadata (e.g., tool cost breakdown from API) */
-  metadata?: FixedUsageMetadata
 }
 
 /**
@@ -121,7 +119,7 @@ export async function logFixedUsage(params: LogFixedUsageParams): Promise<void>
       category: 'fixed',
       source: params.source,
       description: params.description,
-      metadata: params.metadata ?? null,
+      metadata: null,
       cost: params.cost.toString(),
       workspaceId: params.workspaceId ?? null,
       workflowId: params.workflowId ?? null,

apps/sim/lib/copilot/client-sse/handlers.ts

@@ -1,22 +1,21 @@
 import { createLogger } from '@sim/logger'
-import { COPILOT_CONFIRM_API_PATH, STREAM_STORAGE_KEY } from '@/lib/copilot/constants'
+import { STREAM_STORAGE_KEY } from '@/lib/copilot/constants'
 import { asRecord } from '@/lib/copilot/orchestrator/sse-utils'
 import type { SSEEvent } from '@/lib/copilot/orchestrator/types'
-import {
-  isBackgroundState,
-  isRejectedState,
-  isReviewState,
-  resolveToolDisplay,
-} from '@/lib/copilot/store-utils'
+import { isBackgroundState, isRejectedState, isReviewState } from '@/lib/copilot/store-utils'
 import { ClientToolCallState } from '@/lib/copilot/tools/client/tool-display-registry'
 import type { CopilotStore, CopilotStreamInfo, CopilotToolCall } from '@/stores/panel/copilot/types'
-import { useVariablesStore } from '@/stores/panel/variables/store'
-import { useEnvironmentStore } from '@/stores/settings/environment/store'
-import { useWorkflowDiffStore } from '@/stores/workflow-diff/store'
-import { useWorkflowRegistry } from '@/stores/workflows/registry/store'
-import type { WorkflowState } from '@/stores/workflows/workflow/types'
 import { appendTextBlock, beginThinkingBlock, finalizeThinkingBlock } from './content-blocks'
 import { CLIENT_EXECUTABLE_RUN_TOOLS, executeRunToolOnClient } from './run-tool-execution'
+import {
+  extractOperationListFromResultPayload,
+  extractToolExecutionMetadata,
+  extractToolUiMetadata,
+  isWorkflowChangeApplyCall,
+  mapServerStateToClientState,
+  resolveDisplayFromServerUi,
+} from './tool-call-helpers'
+import { applyToolEffects } from './tool-effects'
 import type { ClientContentBlock, ClientStreamingContext } from './types'
 
 const logger = createLogger('CopilotClientSseHandlers')
@@ -26,21 +25,11 @@ const MAX_BATCH_INTERVAL = 50
 const MIN_BATCH_INTERVAL = 16
 const MAX_QUEUE_SIZE = 5
 
-/**
- * Send an auto-accept confirmation to the server for auto-allowed tools.
- * The server-side orchestrator polls Redis for this decision.
- */
-export function sendAutoAcceptConfirmation(toolCallId: string): void {
-  fetch(COPILOT_CONFIRM_API_PATH, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({ toolCallId, status: 'accepted' }),
-  }).catch((error) => {
-    logger.warn('Failed to send auto-accept confirmation', {
-      toolCallId,
-      error: error instanceof Error ? error.message : String(error),
-    })
-  })
+function isClientRunCapability(toolCall: CopilotToolCall): boolean {
+  if (toolCall.execution?.target === 'sim_client_capability') {
+    return toolCall.execution.capabilityId === 'workflow.run' || !toolCall.execution.capabilityId
+  }
+  return CLIENT_EXECUTABLE_RUN_TOOLS.has(toolCall.name)
 }
 
 function writeActiveStreamToStorage(info: CopilotStreamInfo | null): void {
@@ -230,28 +219,86 @@ export const sseHandlers: Record<string, SSEHandler> = {
     }
   },
   title_updated: (_data, _context, get, set) => {
-    const title = _data.title
-    if (!title) return
+    const title = typeof _data.title === 'string' ? _data.title.trim() : ''
+    const eventChatId = typeof _data.chatId === 'string' ? _data.chatId : undefined
     const { currentChat, chats } = get()
-    if (currentChat) {
-      set({
-        currentChat: { ...currentChat, title },
-        chats: chats.map((c) => (c.id === currentChat.id ? { ...c, title } : c)),
+
+    logger.info('[Title] Received title_updated SSE event', {
+      eventTitle: title,
+      eventChatId: eventChatId || null,
+      currentChatId: currentChat?.id || null,
+      currentChatTitle: currentChat?.title || null,
+      chatCount: chats.length,
+    })
+
+    if (!title) {
+      logger.warn('[Title] Ignoring title_updated event with empty title', {
+        payload: _data,
+      })
+      return
+    }
+
+    if (!currentChat) {
+      logger.warn('[Title] Received title_updated event without an active currentChat', {
+        eventChatId: eventChatId || null,
+        title,
+      })
+      return
+    }
+
+    const targetChatId = eventChatId || currentChat.id
+    if (eventChatId && eventChatId !== currentChat.id) {
+      logger.warn('[Title] title_updated event chatId does not match currentChat', {
+        eventChatId,
+        currentChatId: currentChat.id,
       })
     }
+
+    set({
+      currentChat:
+        currentChat.id === targetChatId
+          ? {
+              ...currentChat,
+              title,
+            }
+          : currentChat,
+      chats: chats.map((c) => (c.id === targetChatId ? { ...c, title } : c)),
+    })
+
+    const updatedState = get()
+    logger.info('[Title] Applied title_updated event to copilot store', {
+      targetChatId,
+      renderedCurrentChatId: updatedState.currentChat?.id || null,
+      renderedCurrentChatTitle: updatedState.currentChat?.title || null,
+      chatListTitle: updatedState.chats.find((c) => c.id === targetChatId)?.title || null,
+    })
   },
-  tool_result: (data, context, get, set) => {
+  'copilot.tool.result': (data, context, get, set) => {
     try {
       const eventData = asRecord(data?.data)
       const toolCallId: string | undefined =
-        data?.toolCallId || (eventData.id as string | undefined)
+        data?.toolCallId ||
+        (eventData.id as string | undefined) ||
+        (eventData.callId as string | undefined)
       const success: boolean | undefined = data?.success
       const failedDependency: boolean = data?.failedDependency === true
       const resultObj = asRecord(data?.result)
       const skipped: boolean = resultObj.skipped === true
       if (!toolCallId) return
+      const uiMetadata = extractToolUiMetadata(eventData)
+      const executionMetadata = extractToolExecutionMetadata(eventData)
+      const serverState = (eventData.state as string | undefined) || undefined
+      const targetState = serverState
+        ? mapServerStateToClientState(serverState)
+        : success
+          ? ClientToolCallState.success
+          : failedDependency || skipped
+            ? ClientToolCallState.rejected
+            : ClientToolCallState.error
+      const resultPayload = asRecord(data?.result || eventData.result || eventData.data || data?.data)
       const { toolCallsById } = get()
       const current = toolCallsById[toolCallId]
+      let paramsForCurrentToolCall: Record<string, unknown> | undefined = current?.params
       if (current) {
         if (
           isRejectedState(current.state) ||
@@ -260,16 +307,33 @@ export const sseHandlers: Record<string, SSEHandler> = {
         ) {
           return
         }
-        const targetState = success
-          ? ClientToolCallState.success
-          : failedDependency || skipped
-            ? ClientToolCallState.rejected
-            : ClientToolCallState.error
+        if (
+          targetState === ClientToolCallState.success &&
+          isWorkflowChangeApplyCall(current.name, paramsForCurrentToolCall)
+        ) {
+          const operations = extractOperationListFromResultPayload(resultPayload || {})
+          if (operations && operations.length > 0) {
+            paramsForCurrentToolCall = {
+              ...(current.params || {}),
+              operations,
+            }
+          }
+        }
+
         const updatedMap = { ...toolCallsById }
         updatedMap[toolCallId] = {
           ...current,
+          ui: uiMetadata || current.ui,
+          execution: executionMetadata || current.execution,
+          params: paramsForCurrentToolCall,
           state: targetState,
-          display: resolveToolDisplay(current.name, targetState, current.id, current.params),
+          display: resolveDisplayFromServerUi(
+            current.name,
+            targetState,
+            current.id,
+            paramsForCurrentToolCall,
+            uiMetadata || current.ui
+          ),
         }
         set({ toolCallsById: updatedMap })
 
@@ -312,138 +376,11 @@ export const sseHandlers: Record<string, SSEHandler> = {
           }
         }
 
-        if (current.name === 'edit_workflow') {
-          try {
-            const resultPayload = asRecord(
-              data?.result || eventData.result || eventData.data || data?.data
-            )
-            const workflowState = asRecord(resultPayload?.workflowState)
-            const hasWorkflowState = !!resultPayload?.workflowState
-            logger.info('[SSE] edit_workflow result received', {
-              hasWorkflowState,
-              blockCount: hasWorkflowState ? Object.keys(workflowState.blocks ?? {}).length : 0,
-              edgeCount: Array.isArray(workflowState.edges) ? workflowState.edges.length : 0,
-            })
-            if (hasWorkflowState) {
-              const diffStore = useWorkflowDiffStore.getState()
-              diffStore
-                .setProposedChanges(resultPayload.workflowState as WorkflowState)
-                .catch((err) => {
-                  logger.error('[SSE] Failed to apply edit_workflow diff', {
-                    error: err instanceof Error ? err.message : String(err),
-                  })
-                })
-            }
-          } catch (err) {
-            logger.error('[SSE] edit_workflow result handling failed', {
-              error: err instanceof Error ? err.message : String(err),
-            })
-          }
-        }
-
-        // Deploy tools: update deployment status in workflow registry
-        if (
-          targetState === ClientToolCallState.success &&
-          (current.name === 'deploy_api' ||
-            current.name === 'deploy_chat' ||
-            current.name === 'deploy_mcp' ||
-            current.name === 'redeploy')
-        ) {
-          try {
-            const resultPayload = asRecord(
-              data?.result || eventData.result || eventData.data || data?.data
-            )
-            const input = asRecord(current.params)
-            const workflowId =
-              (resultPayload?.workflowId as string) ||
-              (input?.workflowId as string) ||
-              useWorkflowRegistry.getState().activeWorkflowId
-            const isDeployed = resultPayload?.isDeployed !== false
-            if (workflowId) {
-              useWorkflowRegistry
-                .getState()
-                .setDeploymentStatus(workflowId, isDeployed, isDeployed ? new Date() : undefined)
-              logger.info('[SSE] Updated deployment status from tool result', {
-                toolName: current.name,
-                workflowId,
-                isDeployed,
-              })
-            }
-          } catch (err) {
-            logger.warn('[SSE] Failed to hydrate deployment status', {
-              error: err instanceof Error ? err.message : String(err),
-            })
-          }
-        }
-
-        // Environment variables: reload store after successful set
-        if (
-          targetState === ClientToolCallState.success &&
-          current.name === 'set_environment_variables'
-        ) {
-          try {
-            useEnvironmentStore.getState().loadEnvironmentVariables()
-            logger.info('[SSE] Triggered environment variables reload')
-          } catch (err) {
-            logger.warn('[SSE] Failed to reload environment variables', {
-              error: err instanceof Error ? err.message : String(err),
-            })
-          }
-        }
-
-        // Workflow variables: reload store after successful set
-        if (
-          targetState === ClientToolCallState.success &&
-          current.name === 'set_global_workflow_variables'
-        ) {
-          try {
-            const input = asRecord(current.params)
-            const workflowId =
-              (input?.workflowId as string) || useWorkflowRegistry.getState().activeWorkflowId
-            if (workflowId) {
-              useVariablesStore.getState().loadForWorkflow(workflowId)
-              logger.info('[SSE] Triggered workflow variables reload', { workflowId })
-            }
-          } catch (err) {
-            logger.warn('[SSE] Failed to reload workflow variables', {
-              error: err instanceof Error ? err.message : String(err),
-            })
-          }
-        }
-
-        // Generate API key: update deployment status with the new key
-        if (targetState === ClientToolCallState.success && current.name === 'generate_api_key') {
-          try {
-            const resultPayload = asRecord(
-              data?.result || eventData.result || eventData.data || data?.data
-            )
-            const input = asRecord(current.params)
-            const workflowId =
-              (input?.workflowId as string) || useWorkflowRegistry.getState().activeWorkflowId
-            const apiKey = (resultPayload?.apiKey || resultPayload?.key) as string | undefined
-            if (workflowId) {
-              const existingStatus = useWorkflowRegistry
-                .getState()
-                .getWorkflowDeploymentStatus(workflowId)
-              useWorkflowRegistry
-                .getState()
-                .setDeploymentStatus(
-                  workflowId,
-                  existingStatus?.isDeployed ?? false,
-                  existingStatus?.deployedAt,
-                  apiKey
-                )
-              logger.info('[SSE] Updated deployment status with API key', {
-                workflowId,
-                hasKey: !!apiKey,
-              })
-            }
-          } catch (err) {
-            logger.warn('[SSE] Failed to hydrate API key status', {
-              error: err instanceof Error ? err.message : String(err),
-            })
-          }
-        }
+        applyToolEffects({
+          effectsRaw: eventData.effects,
+          toolCall: updatedMap[toolCallId],
+          resultPayload,
+        })
       }
 
       for (let i = 0; i < context.contentBlocks.length; i++) {
@@ -460,16 +397,24 @@ export const sseHandlers: Record<string, SSEHandler> = {
             : failedDependency || skipped
               ? ClientToolCallState.rejected
               : ClientToolCallState.error
+          const paramsForBlock =
+            b.toolCall?.id === toolCallId
+              ? paramsForCurrentToolCall || b.toolCall?.params
+              : b.toolCall?.params
           context.contentBlocks[i] = {
             ...b,
             toolCall: {
               ...b.toolCall,
+              params: paramsForBlock,
+              ui: uiMetadata || b.toolCall?.ui,
+              execution: executionMetadata || b.toolCall?.execution,
               state: targetState,
-              display: resolveToolDisplay(
+              display: resolveDisplayFromServerUi(
                 b.toolCall?.name,
                 targetState,
                 toolCallId,
-                b.toolCall?.params
+                paramsForBlock,
+                uiMetadata || b.toolCall?.ui
               ),
             },
           }
@@ -483,106 +428,29 @@ export const sseHandlers: Record<string, SSEHandler> = {
       })
     }
   },
-  tool_error: (data, context, get, set) => {
-    try {
-      const errorData = asRecord(data?.data)
-      const toolCallId: string | undefined =
-        data?.toolCallId || (errorData.id as string | undefined)
-      const failedDependency: boolean = data?.failedDependency === true
-      if (!toolCallId) return
-      const { toolCallsById } = get()
-      const current = toolCallsById[toolCallId]
-      if (current) {
-        if (
-          isRejectedState(current.state) ||
-          isReviewState(current.state) ||
-          isBackgroundState(current.state)
-        ) {
-          return
-        }
-        const targetState = failedDependency
-          ? ClientToolCallState.rejected
-          : ClientToolCallState.error
-        const updatedMap = { ...toolCallsById }
-        updatedMap[toolCallId] = {
-          ...current,
-          state: targetState,
-          display: resolveToolDisplay(current.name, targetState, current.id, current.params),
-        }
-        set({ toolCallsById: updatedMap })
-      }
-      for (let i = 0; i < context.contentBlocks.length; i++) {
-        const b = context.contentBlocks[i]
-        if (b?.type === 'tool_call' && b?.toolCall?.id === toolCallId) {
-          if (
-            isRejectedState(b.toolCall?.state) ||
-            isReviewState(b.toolCall?.state) ||
-            isBackgroundState(b.toolCall?.state)
-          )
-            break
-          const targetState = failedDependency
-            ? ClientToolCallState.rejected
-            : ClientToolCallState.error
-          context.contentBlocks[i] = {
-            ...b,
-            toolCall: {
-              ...b.toolCall,
-              state: targetState,
-              display: resolveToolDisplay(
-                b.toolCall?.name,
-                targetState,
-                toolCallId,
-                b.toolCall?.params
-              ),
-            },
-          }
-          break
-        }
-      }
-      updateStreamingMessage(set, context)
-    } catch (error) {
-      logger.warn('Failed to process tool_error SSE event', {
-        error: error instanceof Error ? error.message : String(error),
-      })
-    }
-  },
-  tool_generating: (data, context, get, set) => {
-    const { toolCallId, toolName } = data
-    if (!toolCallId || !toolName) return
-    const { toolCallsById } = get()
-
-    if (!toolCallsById[toolCallId]) {
-      const isAutoAllowed = get().isToolAutoAllowed(toolName)
-      const initialState = isAutoAllowed
-        ? ClientToolCallState.executing
-        : ClientToolCallState.pending
-      const tc: CopilotToolCall = {
-        id: toolCallId,
-        name: toolName,
-        state: initialState,
-        display: resolveToolDisplay(toolName, initialState, toolCallId),
-      }
-      const updated = { ...toolCallsById, [toolCallId]: tc }
-      set({ toolCallsById: updated })
-      logger.info('[toolCallsById] map updated', updated)
-
-      upsertToolCallBlock(context, tc)
-      updateStreamingMessage(set, context)
-    }
-  },
-  tool_call: (data, context, get, set) => {
+  'copilot.tool.call': (data, context, get, set) => {
     const toolData = asRecord(data?.data)
-    const id: string | undefined = (toolData.id as string | undefined) || data?.toolCallId
-    const name: string | undefined = (toolData.name as string | undefined) || data?.toolName
+    const id: string | undefined =
+      (toolData.id as string | undefined) ||
+      (toolData.callId as string | undefined) ||
+      data?.toolCallId
+    const name: string | undefined =
+      (toolData.name as string | undefined) ||
+      (toolData.toolName as string | undefined) ||
+      data?.toolName
     if (!id) return
     const args = toolData.arguments as Record<string, unknown> | undefined
     const isPartial = toolData.partial === true
+    const uiMetadata = extractToolUiMetadata(toolData)
+    const executionMetadata = extractToolExecutionMetadata(toolData)
+    const serverState = toolData.state
     const { toolCallsById } = get()
 
     const existing = toolCallsById[id]
     const toolName = name || existing?.name || 'unknown_tool'
-    const isAutoAllowed = get().isToolAutoAllowed(toolName)
-    let initialState = isAutoAllowed ? ClientToolCallState.executing : ClientToolCallState.pending
+    let initialState = serverState
+      ? mapServerStateToClientState(serverState)
+      : ClientToolCallState.pending
 
     // Avoid flickering back to pending on partial/duplicate events once a tool is executing.
     if (
@@ -597,15 +465,25 @@ export const sseHandlers: Record<string, SSEHandler> = {
           ...existing,
           name: toolName,
           state: initialState,
+          ui: uiMetadata || existing.ui,
+          execution: executionMetadata || existing.execution,
           ...(args ? { params: args } : {}),
-          display: resolveToolDisplay(toolName, initialState, id, args || existing.params),
+          display: resolveDisplayFromServerUi(
+            toolName,
+            initialState,
+            id,
+            args || existing.params,
+            uiMetadata || existing.ui
+          ),
         }
       : {
           id,
           name: toolName,
           state: initialState,
+          ui: uiMetadata,
+          execution: executionMetadata,
           ...(args ? { params: args } : {}),
-          display: resolveToolDisplay(toolName, initialState, id, args),
+          display: resolveDisplayFromServerUi(toolName, initialState, id, args, uiMetadata),
         }
     const updated = { ...toolCallsById, [id]: next }
     set({ toolCallsById: updated })
@@ -618,20 +496,12 @@ export const sseHandlers: Record<string, SSEHandler> = {
       return
     }
 
-    // Auto-allowed tools: send confirmation to the server so it can proceed
-    // without waiting for the user to click "Allow".
-    if (isAutoAllowed) {
-      sendAutoAcceptConfirmation(id)
-    }
+    const shouldInterrupt = next.ui?.showInterrupt === true
 
-    // Client-executable run tools: execute on the client for real-time feedback
-    // (block pulsing, console logs, stop button). The server defers execution
-    // for these tools in interactive mode; the client reports back via mark-complete.
-    if (
-      CLIENT_EXECUTABLE_RUN_TOOLS.has(toolName) &&
-      initialState === ClientToolCallState.executing
-    ) {
-      executeRunToolOnClient(id, toolName, args || existing?.params || {})
+    // Client-run capability: execution is delegated to the browser.
+    // We run immediately only when no interrupt is required.
+    if (isClientRunCapability(next) && !shouldInterrupt) {
+      executeRunToolOnClient(id, toolName, args || next.params || {})
     }
 
     // OAuth: dispatch event to open the OAuth connect modal
@@ -661,7 +531,7 @@ export const sseHandlers: Record<string, SSEHandler> = {
 
     return
   },
-  reasoning: (data, context, _get, set) => {
+  'copilot.phase.progress': (data, context, _get, set) => {
     const phase = (data && (data.phase || data?.data?.phase)) as string | undefined
     if (phase === 'start') {
       beginThinkingBlock(context)
@@ -678,7 +548,7 @@ export const sseHandlers: Record<string, SSEHandler> = {
     appendThinkingContent(context, chunk)
     updateStreamingMessage(set, context)
   },
-  content: (data, context, get, set) => {
+  'copilot.content': (data, context, get, set) => {
     if (!data.data) return
     context.pendingContent += data.data
 
@@ -893,7 +763,7 @@ export const sseHandlers: Record<string, SSEHandler> = {
       updateStreamingMessage(set, context)
     }
   },
-  done: (_data, context) => {
+  'copilot.phase.completed': (_data, context) => {
     logger.info('[SSE] DONE EVENT RECEIVED', {
       doneEventCount: context.doneEventCount,
       data: _data,
@@ -904,7 +774,7 @@ export const sseHandlers: Record<string, SSEHandler> = {
       context.streamComplete = true
     }
   },
-  error: (data, context, _get, set) => {
+  'copilot.error': (data, context, _get, set) => {
     logger.error('Stream error:', data.error)
     set((state: CopilotStore) => ({
       messages: state.messages.map((msg) =>
@@ -919,6 +789,7 @@ export const sseHandlers: Record<string, SSEHandler> = {
     }))
     context.streamComplete = true
   },
+  'copilot.phase.started': () => {},
   stream_end: (_data, context, _get, set) => {
     if (context.pendingContent) {
       if (context.isInThinkingBlock && context.currentThinkingBlock) {
@@ -933,3 +804,8 @@ export const sseHandlers: Record<string, SSEHandler> = {
   },
   default: () => {},
 }
+
+sseHandlers['copilot.tool.interrupt_required'] = sseHandlers['copilot.tool.call']
+sseHandlers['copilot.workflow.patch'] = sseHandlers['copilot.tool.result']
+sseHandlers['copilot.workflow.verify'] = sseHandlers['copilot.tool.result']
+sseHandlers['copilot.tool.interrupt_resolved'] = sseHandlers['copilot.tool.result']

apps/sim/lib/copilot/client-sse/run-tool-execution.ts

@@ -15,10 +15,7 @@ const logger = createLogger('CopilotRunToolExecution')
  * (block pulsing, logs, stop button, etc.).
  */
 export const CLIENT_EXECUTABLE_RUN_TOOLS = new Set([
-  'run_workflow',
-  'run_workflow_until_block',
-  'run_from_block',
-  'run_block',
+  'workflow_run',
 ])
 
 /**
@@ -74,21 +71,44 @@ async function doExecuteRunTool(
     | Record<string, unknown>
     | undefined
 
+  const runMode =
+    toolName === 'workflow_run' ? ((params.mode as string | undefined) || 'full').toLowerCase() : undefined
+
+  if (
+    toolName === 'workflow_run' &&
+    runMode !== 'full' &&
+    runMode !== 'until_block' &&
+    runMode !== 'from_block' &&
+    runMode !== 'block'
+  ) {
+    const error = `Unsupported workflow_run mode: ${String(params.mode)}`
+    logger.warn('[RunTool] Execution prevented: unsupported workflow_run mode', {
+      toolCallId,
+      mode: params.mode,
+    })
+    setToolState(toolCallId, ClientToolCallState.error)
+    await reportCompletion(toolCallId, false, error)
+    return
+  }
+
   const stopAfterBlockId = (() => {
-    if (toolName === 'run_workflow_until_block')
+    if (toolName === 'workflow_run' && runMode === 'until_block') {
       return params.stopAfterBlockId as string | undefined
-    if (toolName === 'run_block') return params.blockId as string | undefined
+    }
+    if (toolName === 'workflow_run' && runMode === 'block') {
+      return params.blockId as string | undefined
+    }
     return undefined
   })()
 
   const runFromBlock = (() => {
-    if (toolName === 'run_from_block' && params.startBlockId) {
+    if (toolName === 'workflow_run' && runMode === 'from_block' && params.startBlockId) {
       return {
         startBlockId: params.startBlockId as string,
         executionId: (params.executionId as string | undefined) || 'latest',
       }
     }
-    if (toolName === 'run_block' && params.blockId) {
+    if (toolName === 'workflow_run' && runMode === 'block' && params.blockId) {
       return {
         startBlockId: params.blockId as string,
         executionId: (params.executionId as string | undefined) || 'latest',

apps/sim/lib/copilot/client-sse/subagent-handlers.test.ts

@@ -0,0 +1,172 @@
+/**
+ * @vitest-environment node
+ */
+import { describe, expect, it, vi } from 'vitest'
+import { applySseEvent } from '@/lib/copilot/client-sse/subagent-handlers'
+import type { ClientStreamingContext } from '@/lib/copilot/client-sse/types'
+import { ClientToolCallState } from '@/lib/copilot/tools/client/tool-display-registry'
+import type { CopilotStore, CopilotToolCall } from '@/stores/panel/copilot/types'
+
+type StoreSet = (
+  partial: Partial<CopilotStore> | ((state: CopilotStore) => Partial<CopilotStore>)
+) => void
+
+function createTestStore(initialToolCalls: Record<string, CopilotToolCall>) {
+  const state: Partial<CopilotStore> = {
+    messages: [{ id: 'assistant-msg', role: 'assistant', content: '', timestamp: new Date().toISOString() }],
+    toolCallsById: { ...initialToolCalls },
+    currentChat: null,
+    chats: [],
+    activeStream: null,
+    updatePlanTodoStatus: vi.fn(),
+    handleNewChatCreation: vi.fn().mockResolvedValue(undefined),
+  }
+
+  const get = () => state as CopilotStore
+  const set: StoreSet = (partial) => {
+    const patch = typeof partial === 'function' ? partial(get()) : partial
+    Object.assign(state, patch)
+  }
+
+  return { get, set }
+}
+
+function createStreamingContext(): ClientStreamingContext {
+  return {
+    messageId: 'assistant-msg',
+    accumulatedContent: '',
+    contentBlocks: [],
+    currentTextBlock: null,
+    isInThinkingBlock: false,
+    currentThinkingBlock: null,
+    isInDesignWorkflowBlock: false,
+    designWorkflowContent: '',
+    pendingContent: '',
+    doneEventCount: 0,
+    streamComplete: false,
+    subAgentContent: {},
+    subAgentToolCalls: {},
+    subAgentBlocks: {},
+    suppressStreamingUpdates: true,
+  }
+}
+
+describe('client SSE copilot.* stream smoke', () => {
+  it('processes main tool call/result events with copilot.* keys', async () => {
+    const { get, set } = createTestStore({})
+    const context = createStreamingContext()
+
+    await applySseEvent(
+      {
+        type: 'copilot.tool.call',
+        data: { id: 'main-tool-1', name: 'get_user_workflow', state: 'executing', arguments: {} },
+      } as any,
+      context,
+      get,
+      set
+    )
+
+    await applySseEvent(
+      {
+        type: 'copilot.tool.result',
+        toolCallId: 'main-tool-1',
+        success: true,
+        result: { ok: true },
+        data: {
+          id: 'main-tool-1',
+          name: 'get_user_workflow',
+          phase: 'completed',
+          state: 'success',
+          success: true,
+          result: { ok: true },
+        },
+      } as any,
+      context,
+      get,
+      set
+    )
+
+    expect(get().toolCallsById['main-tool-1']).toBeDefined()
+    expect(get().toolCallsById['main-tool-1'].state).toBe(ClientToolCallState.success)
+    expect(
+      context.contentBlocks.some(
+        (block) => block.type === 'tool_call' && block.toolCall?.id === 'main-tool-1'
+      )
+    ).toBe(true)
+  })
+
+  it('processes subagent start/tool/result/end with copilot.* keys', async () => {
+    const parentToolCallId = 'parent-edit-tool'
+    const { get, set } = createTestStore({
+      [parentToolCallId]: {
+        id: parentToolCallId,
+        name: 'edit',
+        state: ClientToolCallState.executing,
+      },
+    })
+    const context = createStreamingContext()
+
+    await applySseEvent(
+      {
+        type: 'copilot.subagent.started',
+        subagent: 'edit',
+        data: { tool_call_id: parentToolCallId },
+      } as any,
+      context,
+      get,
+      set
+    )
+
+    await applySseEvent(
+      {
+        type: 'copilot.tool.call',
+        subagent: 'edit',
+        data: {
+          id: 'sub-tool-1',
+          name: 'workflow_context_get',
+          state: 'executing',
+          arguments: { includeSchemas: false },
+        },
+      } as any,
+      context,
+      get,
+      set
+    )
+
+    await applySseEvent(
+      {
+        type: 'copilot.tool.result',
+        subagent: 'edit',
+        data: {
+          id: 'sub-tool-1',
+          name: 'workflow_context_get',
+          phase: 'completed',
+          state: 'success',
+          success: true,
+          result: { contextPackId: 'pack-1' },
+        },
+      } as any,
+      context,
+      get,
+      set
+    )
+
+    await applySseEvent(
+      {
+        type: 'copilot.subagent.completed',
+        subagent: 'edit',
+        data: {},
+      } as any,
+      context,
+      get,
+      set
+    )
+
+    const parentToolCall = get().toolCallsById[parentToolCallId]
+    expect(parentToolCall).toBeDefined()
+    expect(parentToolCall.subAgentStreaming).toBe(false)
+    expect(parentToolCall.subAgentToolCalls?.length).toBe(1)
+    expect(parentToolCall.subAgentToolCalls?.[0]?.id).toBe('sub-tool-1')
+    expect(parentToolCall.subAgentToolCalls?.[0]?.state).toBe(ClientToolCallState.success)
+  })
+})

apps/sim/lib/copilot/client-sse/subagent-handlers.ts

@@ -6,16 +6,23 @@ import {
   shouldSkipToolResultEvent,
 } from '@/lib/copilot/orchestrator/sse-utils'
 import type { SSEEvent } from '@/lib/copilot/orchestrator/types'
-import { resolveToolDisplay } from '@/lib/copilot/store-utils'
 import { ClientToolCallState } from '@/lib/copilot/tools/client/tool-display-registry'
 import type { CopilotStore, CopilotToolCall } from '@/stores/panel/copilot/types'
 import {
   type SSEHandler,
-  sendAutoAcceptConfirmation,
   sseHandlers,
   updateStreamingMessage,
 } from './handlers'
 import { CLIENT_EXECUTABLE_RUN_TOOLS, executeRunToolOnClient } from './run-tool-execution'
+import {
+  extractOperationListFromResultPayload,
+  extractToolExecutionMetadata,
+  extractToolUiMetadata,
+  isWorkflowChangeApplyCall,
+  mapServerStateToClientState,
+  resolveDisplayFromServerUi,
+} from './tool-call-helpers'
+import { applyToolEffects } from './tool-effects'
 import type { ClientStreamingContext } from './types'
 
 const logger = createLogger('CopilotClientSubagentHandlers')
@@ -24,6 +31,13 @@ type StoreSet = (
   partial: Partial<CopilotStore> | ((state: CopilotStore) => Partial<CopilotStore>)
 ) => void
 
+function isClientRunCapability(toolCall: CopilotToolCall): boolean {
+  if (toolCall.execution?.target === 'sim_client_capability') {
+    return toolCall.execution.capabilityId === 'workflow.run' || !toolCall.execution.capabilityId
+  }
+  return CLIENT_EXECUTABLE_RUN_TOOLS.has(toolCall.name)
+}
+
 export function appendSubAgentContent(
   context: ClientStreamingContext,
   parentToolCallId: string,
@@ -110,11 +124,11 @@ export function updateToolCallWithSubAgentData(
 }
 
 export const subAgentSSEHandlers: Record<string, SSEHandler> = {
-  start: () => {
-    // Subagent start event - no action needed, parent is already tracked from subagent_start
+  'copilot.phase.started': () => {
+    // No-op: parent subagent association is handled by copilot.subagent.started.
   },
 
-  content: (data, context, get, set) => {
+  'copilot.content': (data, context, get, set) => {
     const parentToolCallId = context.subAgentParentToolCallId
     const contentStr = typeof data.data === 'string' ? data.data : data.content || ''
     logger.info('[SubAgent] content event', {
@@ -135,7 +149,7 @@ export const subAgentSSEHandlers: Record<string, SSEHandler> = {
     updateToolCallWithSubAgentData(context, get, set, parentToolCallId)
   },
 
-  reasoning: (data, context, get, set) => {
+  'copilot.phase.progress': (data, context, get, set) => {
     const parentToolCallId = context.subAgentParentToolCallId
     const dataObj = asRecord(data?.data)
     const phase = data?.phase || (dataObj.phase as string | undefined)
@@ -151,11 +165,7 @@ export const subAgentSSEHandlers: Record<string, SSEHandler> = {
     updateToolCallWithSubAgentData(context, get, set, parentToolCallId)
   },
 
-  tool_generating: () => {
-    // Tool generating event - no action needed, we'll handle the actual tool_call
-  },
-
-  tool_call: async (data, context, get, set) => {
+  'copilot.tool.call': async (data, context, get, set) => {
     const parentToolCallId = context.subAgentParentToolCallId
     if (!parentToolCallId) return
 
@@ -164,6 +174,8 @@ export const subAgentSSEHandlers: Record<string, SSEHandler> = {
     const name: string | undefined = (toolData.name as string | undefined) || data?.toolName
     if (!id || !name) return
     const isPartial = toolData.partial === true
+    const uiMetadata = extractToolUiMetadata(toolData)
+    const executionMetadata = extractToolExecutionMetadata(toolData)
 
     let args: Record<string, unknown> | undefined = (toolData.arguments || toolData.input) as
       | Record<string, unknown>
@@ -199,9 +211,10 @@ export const subAgentSSEHandlers: Record<string, SSEHandler> = {
     const existingToolCall =
       existingIndex >= 0 ? context.subAgentToolCalls[parentToolCallId][existingIndex] : undefined
 
-    // Auto-allowed tools skip pending state to avoid flashing interrupt buttons
-    const isAutoAllowed = get().isToolAutoAllowed(name)
-    let initialState = isAutoAllowed ? ClientToolCallState.executing : ClientToolCallState.pending
+    const serverState = toolData.state
+    let initialState = serverState
+      ? mapServerStateToClientState(serverState)
+      : ClientToolCallState.pending
 
     // Avoid flickering back to pending on partial/duplicate events once a tool is executing.
     if (
@@ -215,8 +228,10 @@ export const subAgentSSEHandlers: Record<string, SSEHandler> = {
       id,
       name,
       state: initialState,
+      ui: uiMetadata,
+      execution: executionMetadata,
       ...(args ? { params: args } : {}),
-      display: resolveToolDisplay(name, initialState, id, args),
+      display: resolveDisplayFromServerUi(name, initialState, id, args, uiMetadata),
     }
 
     if (existingIndex >= 0) {
@@ -241,21 +256,16 @@ export const subAgentSSEHandlers: Record<string, SSEHandler> = {
       return
     }
 
-    // Auto-allowed tools: send confirmation to the server so it can proceed
-    // without waiting for the user to click "Allow".
-    if (isAutoAllowed) {
-      sendAutoAcceptConfirmation(id)
-    }
+    const shouldInterrupt = subAgentToolCall.ui?.showInterrupt === true
 
-    // Client-executable run tools: if auto-allowed, execute immediately for
-    // real-time feedback. For non-auto-allowed, the user must click "Allow"
-    // first — handleRun in tool-call.tsx triggers executeRunToolOnClient.
-    if (CLIENT_EXECUTABLE_RUN_TOOLS.has(name) && isAutoAllowed) {
+    // Client-run capability: execution is delegated to the browser.
+    // Execute immediately only for non-interrupting calls.
+    if (isClientRunCapability(subAgentToolCall) && !shouldInterrupt) {
       executeRunToolOnClient(id, name, args || {})
     }
   },
 
-  tool_result: (data, context, get, set) => {
+  'copilot.tool.result': (data, context, get, set) => {
     const parentToolCallId = context.subAgentParentToolCallId
     if (!parentToolCallId) return
 
@@ -275,17 +285,51 @@ export const subAgentSSEHandlers: Record<string, SSEHandler> = {
     if (!context.subAgentToolCalls[parentToolCallId]) return
     if (!context.subAgentBlocks[parentToolCallId]) return
 
-    const targetState = success ? ClientToolCallState.success : ClientToolCallState.error
+    const serverState = resultData.state
+    const targetState = serverState
+      ? mapServerStateToClientState(serverState)
+      : success
+        ? ClientToolCallState.success
+        : ClientToolCallState.error
+    const uiMetadata = extractToolUiMetadata(resultData)
+    const executionMetadata = extractToolExecutionMetadata(resultData)
     const existingIndex = context.subAgentToolCalls[parentToolCallId].findIndex(
       (tc: CopilotToolCall) => tc.id === toolCallId
     )
 
     if (existingIndex >= 0) {
       const existing = context.subAgentToolCalls[parentToolCallId][existingIndex]
+      let nextParams = existing.params
+      const resultPayload = asRecord(
+        data?.result || resultData.result || resultData.data || data?.data
+      )
+      if (
+        targetState === ClientToolCallState.success &&
+        isWorkflowChangeApplyCall(existing.name, existing.params as Record<string, unknown>) &&
+        resultPayload
+      ) {
+        const operations = extractOperationListFromResultPayload(resultPayload)
+        if (operations && operations.length > 0) {
+          nextParams = {
+            ...(existing.params || {}),
+            operations,
+          }
+        }
+      }
+
       const updatedSubAgentToolCall = {
         ...existing,
+        params: nextParams,
+        ui: uiMetadata || existing.ui,
+        execution: executionMetadata || existing.execution,
         state: targetState,
-        display: resolveToolDisplay(existing.name, targetState, toolCallId, existing.params),
+        display: resolveDisplayFromServerUi(
+          existing.name,
+          targetState,
+          toolCallId,
+          nextParams,
+          uiMetadata || existing.ui
+        ),
       }
       context.subAgentToolCalls[parentToolCallId][existingIndex] = updatedSubAgentToolCall
 
@@ -309,12 +353,18 @@ export const subAgentSSEHandlers: Record<string, SSEHandler> = {
           state: targetState,
         })
       }
+
+      applyToolEffects({
+        effectsRaw: resultData.effects,
+        toolCall: updatedSubAgentToolCall,
+        resultPayload,
+      })
     }
 
     updateToolCallWithSubAgentData(context, get, set, parentToolCallId)
   },
 
-  done: (_data, context, get, set) => {
+  'copilot.phase.completed': (_data, context, get, set) => {
     const parentToolCallId = context.subAgentParentToolCallId
     if (!parentToolCallId) return
 
@@ -322,6 +372,11 @@ export const subAgentSSEHandlers: Record<string, SSEHandler> = {
   },
 }
 
+subAgentSSEHandlers['copilot.tool.interrupt_required'] = subAgentSSEHandlers['copilot.tool.call']
+subAgentSSEHandlers['copilot.workflow.patch'] = subAgentSSEHandlers['copilot.tool.result']
+subAgentSSEHandlers['copilot.workflow.verify'] = subAgentSSEHandlers['copilot.tool.result']
+subAgentSSEHandlers['copilot.tool.interrupt_resolved'] = subAgentSSEHandlers['copilot.tool.result']
+
 export async function applySseEvent(
   rawData: SSEEvent,
   context: ClientStreamingContext,
@@ -334,7 +389,7 @@ export async function applySseEvent(
   }
   const data = normalizedEvent
 
-  if (data.type === 'subagent_start') {
+  if (data.type === 'copilot.subagent.started') {
     const startData = asRecord(data.data)
     const toolCallId = startData.tool_call_id as string | undefined
     if (toolCallId) {
@@ -357,7 +412,7 @@ export async function applySseEvent(
     return true
   }
 
-  if (data.type === 'subagent_end') {
+  if (data.type === 'copilot.subagent.completed') {
     const parentToolCallId = context.subAgentParentToolCallId
     if (parentToolCallId) {
       const { toolCallsById } = get()

apps/sim/lib/copilot/client-sse/tool-call-helpers.ts

@@ -0,0 +1,134 @@
+import { asRecord } from '@/lib/copilot/orchestrator/sse-utils'
+import { humanizedFallback, resolveToolDisplay } from '@/lib/copilot/store-utils'
+import { ClientToolCallState } from '@/lib/copilot/tools/client/tool-display-registry'
+import type { CopilotToolCall } from '@/stores/panel/copilot/types'
+
+export function mapServerStateToClientState(state: unknown): ClientToolCallState {
+  switch (String(state || '')) {
+    case 'generating':
+      return ClientToolCallState.generating
+    case 'pending':
+    case 'awaiting_approval':
+      return ClientToolCallState.pending
+    case 'executing':
+      return ClientToolCallState.executing
+    case 'success':
+      return ClientToolCallState.success
+    case 'rejected':
+    case 'skipped':
+      return ClientToolCallState.rejected
+    case 'aborted':
+      return ClientToolCallState.aborted
+    case 'error':
+    case 'failed':
+      return ClientToolCallState.error
+    default:
+      return ClientToolCallState.pending
+  }
+}
+
+export function extractToolUiMetadata(
+  data: Record<string, unknown>
+): CopilotToolCall['ui'] | undefined {
+  const ui = asRecord(data.ui)
+  if (!ui || Object.keys(ui).length === 0) return undefined
+  const autoAllowedFromUi = ui.autoAllowed === true
+  const autoAllowedFromData = data.autoAllowed === true
+  return {
+    title: typeof ui.title === 'string' ? ui.title : undefined,
+    phaseLabel: typeof ui.phaseLabel === 'string' ? ui.phaseLabel : undefined,
+    icon: typeof ui.icon === 'string' ? ui.icon : undefined,
+    showInterrupt: ui.showInterrupt === true,
+    showRemember: ui.showRemember === true,
+    autoAllowed: autoAllowedFromUi || autoAllowedFromData,
+    actions: Array.isArray(ui.actions)
+      ? ui.actions
+          .map((action) => {
+            const a = asRecord(action)
+            const id = typeof a.id === 'string' ? a.id : undefined
+            const label = typeof a.label === 'string' ? a.label : undefined
+            const kind: 'accept' | 'reject' = a.kind === 'reject' ? 'reject' : 'accept'
+            if (!id || !label) return null
+            return {
+              id,
+              label,
+              kind,
+              remember: a.remember === true,
+            }
+          })
+          .filter((a): a is NonNullable<typeof a> => !!a)
+      : undefined,
+  }
+}
+
+export function extractToolExecutionMetadata(
+  data: Record<string, unknown>
+): CopilotToolCall['execution'] | undefined {
+  const execution = asRecord(data.execution)
+  if (!execution || Object.keys(execution).length === 0) return undefined
+  return {
+    target: typeof execution.target === 'string' ? execution.target : undefined,
+    capabilityId: typeof execution.capabilityId === 'string' ? execution.capabilityId : undefined,
+  }
+}
+
+function displayVerb(state: ClientToolCallState): string {
+  switch (state) {
+    case ClientToolCallState.success:
+      return 'Completed'
+    case ClientToolCallState.error:
+      return 'Failed'
+    case ClientToolCallState.rejected:
+      return 'Skipped'
+    case ClientToolCallState.aborted:
+      return 'Aborted'
+    case ClientToolCallState.generating:
+      return 'Preparing'
+    case ClientToolCallState.pending:
+      return 'Waiting'
+    default:
+      return 'Running'
+  }
+}
+
+export function resolveDisplayFromServerUi(
+  toolName: string,
+  state: ClientToolCallState,
+  toolCallId: string,
+  params: Record<string, unknown> | undefined,
+  ui?: CopilotToolCall['ui']
+) {
+  const fallback =
+    resolveToolDisplay(toolName, state, toolCallId, params) ||
+    humanizedFallback(toolName, state)
+  if (!fallback) return undefined
+  if (ui?.phaseLabel) {
+    return { text: ui.phaseLabel, icon: fallback.icon }
+  }
+  if (ui?.title) {
+    return { text: `${displayVerb(state)} ${ui.title}`, icon: fallback.icon }
+  }
+  return fallback
+}
+
+export function isWorkflowChangeApplyCall(
+  toolName?: string,
+  params?: Record<string, unknown>
+): boolean {
+  if (toolName !== 'workflow_change') return false
+  const mode = typeof params?.mode === 'string' ? params.mode.toLowerCase() : ''
+  if (mode === 'apply') return true
+  return typeof params?.proposalId === 'string' && params.proposalId.length > 0
+}
+
+export function extractOperationListFromResultPayload(
+  resultPayload: Record<string, unknown>
+): Array<Record<string, unknown>> | undefined {
+  const operations = resultPayload.operations
+  if (Array.isArray(operations)) return operations as Array<Record<string, unknown>>
+
+  const compiled = resultPayload.compiledOperations
+  if (Array.isArray(compiled)) return compiled as Array<Record<string, unknown>>
+
+  return undefined
+}

apps/sim/lib/copilot/client-sse/tool-effects.test.ts

@@ -0,0 +1,170 @@
+/**
+ * @vitest-environment node
+ */
+
+import { loggerMock } from '@sim/testing'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+vi.mock('@sim/logger', () => loggerMock)
+
+const mocked = vi.hoisted(() => ({
+  setProposedChanges: vi.fn().mockResolvedValue(undefined),
+  loadEnvironmentVariables: vi.fn(),
+  loadVariablesForWorkflow: vi.fn(),
+  getWorkflowDeploymentStatus: vi.fn().mockReturnValue(null),
+  setDeploymentStatus: vi.fn(),
+  registryState: {
+    activeWorkflowId: 'workflow-active',
+  },
+}))
+
+vi.mock('@/stores/workflow-diff/store', () => ({
+  useWorkflowDiffStore: {
+    getState: () => ({
+      setProposedChanges: mocked.setProposedChanges,
+    }),
+  },
+}))
+
+vi.mock('@/stores/settings/environment/store', () => ({
+  useEnvironmentStore: {
+    getState: () => ({
+      loadEnvironmentVariables: mocked.loadEnvironmentVariables,
+    }),
+  },
+}))
+
+vi.mock('@/stores/panel/variables/store', () => ({
+  useVariablesStore: {
+    getState: () => ({
+      loadForWorkflow: mocked.loadVariablesForWorkflow,
+    }),
+  },
+}))
+
+vi.mock('@/stores/workflows/registry/store', () => ({
+  useWorkflowRegistry: {
+    getState: () => ({
+      activeWorkflowId: mocked.registryState.activeWorkflowId,
+      getWorkflowDeploymentStatus: mocked.getWorkflowDeploymentStatus,
+      setDeploymentStatus: mocked.setDeploymentStatus,
+    }),
+  },
+}))
+
+import { applyToolEffects } from '@/lib/copilot/client-sse/tool-effects'
+
+describe('applyToolEffects', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    mocked.registryState.activeWorkflowId = 'workflow-active'
+  })
+
+  it('applies workflow_change fallback diff when effects are absent', () => {
+    const workflowState = {
+      blocks: {
+        start: { id: 'start', metadata: { id: 'start', type: 'start' }, inputs: {}, outputs: {} },
+      },
+      edges: [],
+      loops: {},
+      parallels: {},
+    }
+
+    applyToolEffects({
+      effectsRaw: [],
+      toolCall: {
+        id: 'tool-1',
+        name: 'workflow_change',
+        state: 'success',
+        params: { workflowId: 'workflow-123' },
+      } as any,
+      resultPayload: {
+        workflowState,
+      },
+    })
+
+    expect(mocked.setProposedChanges).toHaveBeenCalledTimes(1)
+    expect(mocked.setProposedChanges).toHaveBeenCalledWith(workflowState)
+  })
+
+  it('applies workflow_change fallback diff from nested editResult.workflowState', () => {
+    const workflowState = {
+      blocks: {
+        start: { id: 'start', metadata: { id: 'start', type: 'start' }, inputs: {}, outputs: {} },
+      },
+      edges: [],
+      loops: {},
+      parallels: {},
+    }
+
+    applyToolEffects({
+      effectsRaw: [],
+      toolCall: {
+        id: 'tool-2',
+        name: 'workflow_change',
+        state: 'success',
+      } as any,
+      resultPayload: {
+        editResult: {
+          workflowState,
+        },
+      },
+    })
+
+    expect(mocked.setProposedChanges).toHaveBeenCalledTimes(1)
+    expect(mocked.setProposedChanges).toHaveBeenCalledWith(workflowState)
+  })
+
+  it('applies explicit workflow.diff.proposed effect', () => {
+    const workflowState = {
+      blocks: {
+        start: { id: 'start', metadata: { id: 'start', type: 'start' }, inputs: {}, outputs: {} },
+      },
+      edges: [],
+      loops: {},
+      parallels: {},
+    }
+
+    applyToolEffects({
+      effectsRaw: [
+        {
+          kind: 'workflow.diff.proposed',
+          payload: {
+            workflowState,
+          },
+        },
+      ],
+      toolCall: {
+        id: 'tool-3',
+        name: 'workflow_change',
+        state: 'success',
+      } as any,
+    })
+
+    expect(mocked.setProposedChanges).toHaveBeenCalledTimes(1)
+    expect(mocked.setProposedChanges).toHaveBeenCalledWith(workflowState)
+  })
+
+  it('does not apply fallback diff for non-workflow_change tools', () => {
+    const workflowState = {
+      blocks: {},
+      edges: [],
+      loops: {},
+      parallels: {},
+    }
+
+    applyToolEffects({
+      effectsRaw: [],
+      toolCall: {
+        id: 'tool-4',
+        name: 'list_workflows',
+        state: 'success',
+      } as any,
+      resultPayload: {
+        workflowState,
+      },
+    })
+
+    expect(mocked.setProposedChanges).not.toHaveBeenCalled()
+  })
+})

apps/sim/lib/copilot/client-sse/tool-effects.ts

@@ -0,0 +1,180 @@
+import { createLogger } from '@sim/logger'
+import { asRecord } from '@/lib/copilot/orchestrator/sse-utils'
+import type { CopilotToolCall } from '@/stores/panel/copilot/types'
+import { useVariablesStore } from '@/stores/panel/variables/store'
+import { useEnvironmentStore } from '@/stores/settings/environment/store'
+import { useWorkflowDiffStore } from '@/stores/workflow-diff/store'
+import { useWorkflowRegistry } from '@/stores/workflows/registry/store'
+import type { WorkflowState } from '@/stores/workflows/workflow/types'
+
+const logger = createLogger('CopilotToolEffects')
+
+type ParsedToolEffect = {
+  kind: string
+  payload: Record<string, unknown>
+}
+
+function asNonEmptyRecord(value: unknown): Record<string, unknown> | null {
+  const record = asRecord(value)
+  return Object.keys(record).length > 0 ? record : null
+}
+
+function parseToolEffects(raw: unknown): ParsedToolEffect[] {
+  if (!Array.isArray(raw)) return []
+  const effects: ParsedToolEffect[] = []
+  for (const item of raw) {
+    const effect = asRecord(item)
+    const kind = typeof effect.kind === 'string' ? effect.kind : ''
+    if (!kind) continue
+    effects.push({
+      kind,
+      payload: asRecord(effect.payload) || {},
+    })
+  }
+  return effects
+}
+
+function resolveWorkflowId(
+  payload: Record<string, unknown>,
+  toolCall?: CopilotToolCall
+): string | undefined {
+  const payloadWorkflowId = typeof payload.workflowId === 'string' ? payload.workflowId : undefined
+  if (payloadWorkflowId) return payloadWorkflowId
+
+  const params = asRecord(toolCall?.params)
+  const paramWorkflowId = typeof params?.workflowId === 'string' ? params.workflowId : undefined
+  if (paramWorkflowId) return paramWorkflowId
+
+  return useWorkflowRegistry.getState().activeWorkflowId || undefined
+}
+
+function resolveWorkflowState(
+  payload: Record<string, unknown>,
+  resultPayload?: Record<string, unknown>
+): WorkflowState | null {
+  const payloadState = asNonEmptyRecord(payload.workflowState)
+  if (payloadState) return payloadState as unknown as WorkflowState
+
+  if (resultPayload) {
+    const directState = asNonEmptyRecord(resultPayload.workflowState)
+    if (directState) return directState as unknown as WorkflowState
+    const editResult = asRecord(resultPayload.editResult)
+    const nestedState = asNonEmptyRecord(editResult?.workflowState)
+    if (nestedState) return nestedState as unknown as WorkflowState
+  }
+
+  return null
+}
+
+function applyDeploymentSyncEffect(payload: Record<string, unknown>, toolCall?: CopilotToolCall): void {
+  const workflowId = resolveWorkflowId(payload, toolCall)
+  if (!workflowId) return
+
+  const registry = useWorkflowRegistry.getState()
+  const existingStatus = registry.getWorkflowDeploymentStatus(workflowId)
+
+  const isDeployed =
+    typeof payload.isDeployed === 'boolean'
+      ? payload.isDeployed
+      : (existingStatus?.isDeployed ?? true)
+
+  const deployedAt = (() => {
+    if (typeof payload.deployedAt === 'string' && payload.deployedAt) {
+      const parsed = new Date(payload.deployedAt)
+      if (!Number.isNaN(parsed.getTime())) return parsed
+    }
+    return existingStatus?.deployedAt
+  })()
+
+  const apiKey =
+    typeof payload.apiKey === 'string' && payload.apiKey.length > 0
+      ? payload.apiKey
+      : existingStatus?.apiKey
+
+  registry.setDeploymentStatus(workflowId, isDeployed, deployedAt, apiKey)
+}
+
+function applyApiKeySyncEffect(payload: Record<string, unknown>, toolCall?: CopilotToolCall): void {
+  const workflowId = resolveWorkflowId(payload, toolCall)
+  if (!workflowId) return
+
+  const apiKey = typeof payload.apiKey === 'string' ? payload.apiKey : undefined
+  const registry = useWorkflowRegistry.getState()
+  const existingStatus = registry.getWorkflowDeploymentStatus(workflowId)
+  registry.setDeploymentStatus(
+    workflowId,
+    existingStatus?.isDeployed ?? false,
+    existingStatus?.deployedAt,
+    apiKey || existingStatus?.apiKey
+  )
+}
+
+function applyWorkflowVariablesReload(
+  payload: Record<string, unknown>,
+  toolCall?: CopilotToolCall
+): void {
+  const workflowId = resolveWorkflowId(payload, toolCall)
+  if (!workflowId) return
+  useVariablesStore.getState().loadForWorkflow(workflowId)
+}
+
+export function applyToolEffects(params: {
+  effectsRaw: unknown
+  toolCall?: CopilotToolCall
+  resultPayload?: Record<string, unknown>
+}): void {
+  const effects = parseToolEffects(params.effectsRaw)
+  if (effects.length === 0) {
+    if (params.toolCall?.name === 'workflow_change' && params.resultPayload) {
+      const workflowState = resolveWorkflowState({}, params.resultPayload)
+      if (!workflowState) return
+      useWorkflowDiffStore
+        .getState()
+        .setProposedChanges(workflowState)
+        .catch((error) => {
+          logger.error('Failed to apply fallback workflow diff from result payload', {
+            error: error instanceof Error ? error.message : String(error),
+          })
+        })
+    }
+    return
+  }
+
+  for (const effect of effects) {
+    switch (effect.kind) {
+      case 'workflow.diff.proposed': {
+        const workflowState = resolveWorkflowState(effect.payload, params.resultPayload)
+        if (!workflowState) break
+        useWorkflowDiffStore
+          .getState()
+          .setProposedChanges(workflowState)
+          .catch((error) => {
+            logger.error('Failed to apply workflow diff effect', {
+              error: error instanceof Error ? error.message : String(error),
+            })
+          })
+        break
+      }
+
+      case 'workflow.deployment.sync':
+        applyDeploymentSyncEffect(effect.payload, params.toolCall)
+        break
+
+      case 'workflow.api_key.sync':
+        applyApiKeySyncEffect(effect.payload, params.toolCall)
+        break
+
+      case 'environment.variables.reload':
+        useEnvironmentStore.getState().loadEnvironmentVariables()
+        break
+
+      case 'workflow.variables.reload':
+        applyWorkflowVariablesReload(effect.payload, params.toolCall)
+        break
+
+      default:
+        logger.debug('Ignoring unknown tool effect', { kind: effect.kind })
+        break
+    }
+  }
+}

apps/sim/lib/copilot/constants.ts

@@ -101,9 +101,6 @@ export const COPILOT_CHECKPOINTS_API_PATH = '/api/copilot/checkpoints'
 /** POST — revert to a checkpoint. */
 export const COPILOT_CHECKPOINTS_REVERT_API_PATH = '/api/copilot/checkpoints/revert'
 
-/** GET/POST/DELETE — manage auto-allowed tools. */
-export const COPILOT_AUTO_ALLOWED_TOOLS_API_PATH = '/api/copilot/auto-allowed-tools'
-
 /** GET — fetch dynamically available copilot models. */
 export const COPILOT_MODELS_API_PATH = '/api/copilot/models'
 

apps/sim/lib/copilot/orchestrator/config.ts

@@ -1,67 +0,0 @@
-export const INTERRUPT_TOOL_NAMES = [
-  'set_global_workflow_variables',
-  'run_workflow',
-  'run_workflow_until_block',
-  'run_from_block',
-  'run_block',
-  'manage_mcp_tool',
-  'manage_custom_tool',
-  'deploy_mcp',
-  'deploy_chat',
-  'deploy_api',
-  'create_workspace_mcp_server',
-  'set_environment_variables',
-  'make_api_request',
-  'oauth_request_access',
-  'navigate_ui',
-  'knowledge_base',
-  'generate_api_key',
-] as const
-
-export const INTERRUPT_TOOL_SET = new Set<string>(INTERRUPT_TOOL_NAMES)
-
-export const SUBAGENT_TOOL_NAMES = [
-  'debug',
-  'edit',
-  'build',
-  'plan',
-  'test',
-  'deploy',
-  'auth',
-  'research',
-  'knowledge',
-  'custom_tool',
-  'tour',
-  'info',
-  'workflow',
-  'evaluate',
-  'superagent',
-  'discovery',
-] as const
-
-export const SUBAGENT_TOOL_SET = new Set<string>(SUBAGENT_TOOL_NAMES)
-
-/**
- * Respond tools are internal to the copilot's subagent system.
- * They're used by subagents to signal completion and should NOT be executed by the sim side.
- * The copilot backend handles these internally.
- */
-export const RESPOND_TOOL_NAMES = [
-  'plan_respond',
-  'edit_respond',
-  'build_respond',
-  'debug_respond',
-  'info_respond',
-  'research_respond',
-  'deploy_respond',
-  'superagent_respond',
-  'discovery_respond',
-  'tour_respond',
-  'auth_respond',
-  'workflow_respond',
-  'knowledge_respond',
-  'custom_tool_respond',
-  'test_respond',
-] as const
-
-export const RESPOND_TOOL_SET = new Set<string>(RESPOND_TOOL_NAMES)

apps/sim/lib/copilot/orchestrator/sse-handlers.test.ts

@@ -54,14 +54,14 @@ describe('sse-handlers tool lifecycle', () => {
     }
   })
 
-  it('executes tool_call and emits tool_result + mark-complete', async () => {
+  it('executes copilot.tool.call and emits copilot.tool.result + mark-complete', async () => {
     executeToolServerSide.mockResolvedValueOnce({ success: true, output: { ok: true } })
     markToolComplete.mockResolvedValueOnce(true)
     const onEvent = vi.fn()
 
-    await sseHandlers.tool_call(
+    await sseHandlers['copilot.tool.call'](
       {
-        type: 'tool_call',
+        type: 'copilot.tool.call',
         data: { id: 'tool-1', name: 'get_user_workflow', arguments: { workflowId: 'workflow-1' } },
       } as any,
       context,
@@ -73,7 +73,7 @@ describe('sse-handlers tool lifecycle', () => {
     expect(markToolComplete).toHaveBeenCalledTimes(1)
     expect(onEvent).toHaveBeenCalledWith(
       expect.objectContaining({
-        type: 'tool_result',
+        type: 'copilot.tool.result',
         toolCallId: 'tool-1',
         success: true,
       })
@@ -84,17 +84,17 @@ describe('sse-handlers tool lifecycle', () => {
     expect(updated?.result?.output).toEqual({ ok: true })
   })
 
-  it('skips duplicate tool_call after result', async () => {
+  it('skips duplicate copilot.tool.call after result', async () => {
     executeToolServerSide.mockResolvedValueOnce({ success: true, output: { ok: true } })
     markToolComplete.mockResolvedValueOnce(true)
 
     const event = {
-      type: 'tool_call',
+      type: 'copilot.tool.call',
       data: { id: 'tool-dup', name: 'get_user_workflow', arguments: { workflowId: 'workflow-1' } },
     }
 
-    await sseHandlers.tool_call(event as any, context, execContext, { interactive: false })
-    await sseHandlers.tool_call(event as any, context, execContext, { interactive: false })
+    await sseHandlers['copilot.tool.call'](event as any, context, execContext, { interactive: false })
+    await sseHandlers['copilot.tool.call'](event as any, context, execContext, { interactive: false })
 
     expect(executeToolServerSide).toHaveBeenCalledTimes(1)
     expect(markToolComplete).toHaveBeenCalledTimes(1)

apps/sim/lib/copilot/orchestrator/sse-handlers/handlers.ts

@@ -1,17 +1,12 @@
 import { createLogger } from '@sim/logger'
 import { STREAM_TIMEOUT_MS } from '@/lib/copilot/constants'
-import { RESPOND_TOOL_SET, SUBAGENT_TOOL_SET } from '@/lib/copilot/orchestrator/config'
 import {
   asRecord,
   getEventData,
   markToolResultSeen,
   wasToolResultSeen,
 } from '@/lib/copilot/orchestrator/sse-utils'
-import {
-  isIntegrationTool,
-  isToolAvailableOnSimSide,
-  markToolComplete,
-} from '@/lib/copilot/orchestrator/tool-executor'
+import { markToolComplete } from '@/lib/copilot/orchestrator/tool-executor'
 import type {
   ContentBlock,
   ExecutionContext,
@@ -22,7 +17,6 @@ import type {
 } from '@/lib/copilot/orchestrator/types'
 import {
   executeToolAndReport,
-  isInterruptToolName,
   waitForToolCompletion,
   waitForToolDecision,
 } from './tool-execution'
@@ -35,12 +29,208 @@ const logger = createLogger('CopilotSseHandlers')
  * execution to the browser client instead of running executeWorkflow directly.
  */
 const CLIENT_EXECUTABLE_RUN_TOOLS = new Set([
-  'run_workflow',
-  'run_workflow_until_block',
-  'run_from_block',
-  'run_block',
+  'workflow_run',
 ])
 
+function mapServerStateToToolStatus(state: unknown): ToolCallState['status'] {
+  switch (String(state || '')) {
+    case 'generating':
+    case 'pending':
+    case 'awaiting_approval':
+      return 'pending'
+    case 'executing':
+      return 'executing'
+    case 'success':
+      return 'success'
+    case 'rejected':
+    case 'skipped':
+      return 'rejected'
+    case 'aborted':
+      return 'skipped'
+    case 'error':
+    case 'failed':
+      return 'error'
+    default:
+      return 'pending'
+  }
+}
+
+function getExecutionTarget(
+  toolData: Record<string, unknown>,
+  toolName: string
+): { target: string; capabilityId?: string } {
+  const execution = asRecord(toolData.execution)
+  if (typeof execution.target === 'string' && execution.target.length > 0) {
+    return {
+      target: execution.target,
+      capabilityId:
+        typeof execution.capabilityId === 'string' ? execution.capabilityId : undefined,
+    }
+  }
+
+  // Fallback only when metadata is missing.
+  if (CLIENT_EXECUTABLE_RUN_TOOLS.has(toolName)) {
+    return { target: 'sim_client_capability', capabilityId: 'workflow.run' }
+  }
+  return { target: 'sim_server' }
+}
+
+function needsApproval(toolData: Record<string, unknown>): boolean {
+  const ui = asRecord(toolData.ui)
+  return ui.showInterrupt === true
+}
+
+async function waitForClientCapabilityAndReport(
+  toolCall: ToolCallState,
+  options: OrchestratorOptions,
+  logScope: string
+): Promise<void> {
+  toolCall.status = 'executing'
+  const completion = await waitForToolCompletion(
+    toolCall.id,
+    options.timeout || STREAM_TIMEOUT_MS,
+    options.abortSignal
+  )
+
+  if (completion?.status === 'background') {
+    toolCall.status = 'skipped'
+    toolCall.endTime = Date.now()
+    markToolComplete(
+      toolCall.id,
+      toolCall.name,
+      202,
+      completion.message || 'Tool execution moved to background',
+      { background: true }
+    ).catch((err) => {
+      logger.error(`markToolComplete fire-and-forget failed (${logScope} background)`, {
+        toolCallId: toolCall.id,
+        error: err instanceof Error ? err.message : String(err),
+      })
+    })
+    markToolResultSeen(toolCall.id)
+    return
+  }
+
+  if (completion?.status === 'rejected') {
+    toolCall.status = 'rejected'
+    toolCall.endTime = Date.now()
+    markToolComplete(toolCall.id, toolCall.name, 400, completion.message || 'Tool execution rejected')
+      .catch((err) => {
+        logger.error(`markToolComplete fire-and-forget failed (${logScope} rejected)`, {
+          toolCallId: toolCall.id,
+          error: err instanceof Error ? err.message : String(err),
+        })
+      })
+    markToolResultSeen(toolCall.id)
+    return
+  }
+
+  const success = completion?.status === 'success'
+  toolCall.status = success ? 'success' : 'error'
+  toolCall.endTime = Date.now()
+  const msg = completion?.message || (success ? 'Tool completed' : 'Tool failed or timed out')
+  markToolComplete(toolCall.id, toolCall.name, success ? 200 : 500, msg).catch((err) => {
+    logger.error(`markToolComplete fire-and-forget failed (${logScope})`, {
+      toolCallId: toolCall.id,
+      toolName: toolCall.name,
+      error: err instanceof Error ? err.message : String(err),
+    })
+  })
+  markToolResultSeen(toolCall.id)
+}
+
+function markToolCallAndNotify(
+  toolCall: ToolCallState,
+  statusCode: number,
+  message: string,
+  data: Record<string, unknown> | undefined,
+  logScope: string
+): void {
+  markToolComplete(toolCall.id, toolCall.name, statusCode, message, data).catch((err) => {
+    logger.error(`markToolComplete fire-and-forget failed (${logScope})`, {
+      toolCallId: toolCall.id,
+      error: err instanceof Error ? err.message : String(err),
+    })
+  })
+  markToolResultSeen(toolCall.id)
+}
+
+async function executeToolCallWithPolicy(
+  toolCall: ToolCallState,
+  toolName: string,
+  toolData: Record<string, unknown>,
+  context: StreamingContext,
+  execContext: ExecutionContext,
+  options: OrchestratorOptions,
+  logScope: string
+): Promise<void> {
+  const execution = getExecutionTarget(toolData, toolName)
+  const isInteractive = options.interactive === true
+  const requiresApproval = isInteractive && needsApproval(toolData)
+
+  if (toolData.state) {
+    toolCall.status = mapServerStateToToolStatus(toolData.state)
+  }
+
+  if (requiresApproval) {
+    const decision = await waitForToolDecision(
+      toolCall.id,
+      options.timeout || STREAM_TIMEOUT_MS,
+      options.abortSignal
+    )
+
+    if (decision?.status === 'accepted' || decision?.status === 'success') {
+      // Continue below into normal execution path.
+    } else if (decision?.status === 'rejected' || decision?.status === 'error') {
+      toolCall.status = 'rejected'
+      toolCall.endTime = Date.now()
+      markToolCallAndNotify(
+        toolCall,
+        400,
+        decision.message || 'Tool execution rejected',
+        { skipped: true, reason: 'user_rejected' },
+        `${logScope} rejected`
+      )
+      return
+    } else if (decision?.status === 'background') {
+      toolCall.status = 'skipped'
+      toolCall.endTime = Date.now()
+      markToolCallAndNotify(
+        toolCall,
+        202,
+        decision.message || 'Tool execution moved to background',
+        { background: true },
+        `${logScope} background`
+      )
+      return
+    } else {
+      // Decision was null (timeout/abort).
+      toolCall.status = 'rejected'
+      toolCall.endTime = Date.now()
+      markToolCallAndNotify(
+        toolCall,
+        408,
+        'Tool approval timed out',
+        { skipped: true, reason: 'timeout' },
+        `${logScope} timeout`
+      )
+      return
+    }
+  }
+
+  if (execution.target === 'sim_client_capability' && isInteractive) {
+    await waitForClientCapabilityAndReport(toolCall, options, logScope)
+    return
+  }
+
+  if (
+    (execution.target === 'sim_server' || execution.target === 'sim_client_capability') &&
+    options.autoExecuteTools !== false
+  ) {
+    await executeToolAndReport(toolCall.id, context, execContext, options)
+  }
+}
+
 // Normalization + dedupe helpers live in sse-utils to keep server/client in sync.
 
 function inferToolSuccess(data: Record<string, unknown> | undefined): {
@@ -76,7 +266,7 @@ export const sseHandlers: Record<string, SSEHandler> = {
     context.chatId = asRecord(event.data).chatId as string | undefined
   },
   title_updated: () => {},
-  tool_result: (event, context) => {
+  'copilot.tool.result': (event, context) => {
     const data = getEventData(event)
     const toolCallId = event.toolCallId || (data?.id as string | undefined)
     if (!toolCallId) return
@@ -85,7 +275,11 @@ export const sseHandlers: Record<string, SSEHandler> = {
 
     const { success, hasResultData, hasError } = inferToolSuccess(data)
 
-    current.status = success ? 'success' : 'error'
+    current.status = data?.state
+      ? mapServerStateToToolStatus(data.state)
+      : success
+        ? 'success'
+        : 'error'
     current.endTime = Date.now()
     if (hasResultData) {
       current.result = {
@@ -98,35 +292,7 @@ export const sseHandlers: Record<string, SSEHandler> = {
       current.error = (data?.error || resultObj.error) as string | undefined
     }
   },
-  tool_error: (event, context) => {
-    const data = getEventData(event)
-    const toolCallId = event.toolCallId || (data?.id as string | undefined)
-    if (!toolCallId) return
-    const current = context.toolCalls.get(toolCallId)
-    if (!current) return
-    current.status = 'error'
-    current.error = (data?.error as string | undefined) || 'Tool execution failed'
-    current.endTime = Date.now()
-  },
-  tool_generating: (event, context) => {
-    const data = getEventData(event)
-    const toolCallId =
-      event.toolCallId ||
-      (data?.toolCallId as string | undefined) ||
-      (data?.id as string | undefined)
-    const toolName =
-      event.toolName || (data?.toolName as string | undefined) || (data?.name as string | undefined)
-    if (!toolCallId || !toolName) return
-    if (!context.toolCalls.has(toolCallId)) {
-      context.toolCalls.set(toolCallId, {
-        id: toolCallId,
-        name: toolName,
-        status: 'pending',
-        startTime: Date.now(),
-      })
-    }
-  },
-  tool_call: async (event, context, execContext, options) => {
+  'copilot.tool.call': async (event, context, execContext, options) => {
     const toolData = getEventData(event) || ({} as Record<string, unknown>)
     const toolCallId = (toolData.id as string | undefined) || event.toolCallId
     const toolName = (toolData.name as string | undefined) || event.toolName
@@ -156,7 +322,7 @@ export const sseHandlers: Record<string, SSEHandler> = {
       context.toolCalls.set(toolCallId, {
         id: toolCallId,
         name: toolName,
-        status: 'pending',
+        status: toolData.state ? mapServerStateToToolStatus(toolData.state) : 'pending',
         params: args,
         startTime: Date.now(),
       })
@@ -170,149 +336,17 @@ export const sseHandlers: Record<string, SSEHandler> = {
     const toolCall = context.toolCalls.get(toolCallId)
     if (!toolCall) return
 
-    // Subagent tools are executed by the copilot backend, not sim side.
-    if (SUBAGENT_TOOL_SET.has(toolName)) {
-      return
-    }
-
-    // Respond tools are internal to copilot's subagent system - skip execution.
-    // The copilot backend handles these internally to signal subagent completion.
-    if (RESPOND_TOOL_SET.has(toolName)) {
-      toolCall.status = 'success'
-      toolCall.endTime = Date.now()
-      toolCall.result = {
-        success: true,
-        output: 'Internal respond tool - handled by copilot backend',
-      }
-      return
-    }
-
-    const isInterruptTool = isInterruptToolName(toolName)
-    const isInteractive = options.interactive === true
-    // Integration tools (user-installed) also require approval in interactive mode
-    const needsApproval = isInterruptTool || isIntegrationTool(toolName)
-
-    if (needsApproval && isInteractive) {
-      const decision = await waitForToolDecision(
-        toolCallId,
-        options.timeout || STREAM_TIMEOUT_MS,
-        options.abortSignal
-      )
-      if (decision?.status === 'accepted' || decision?.status === 'success') {
-        // Client-executable run tools: defer execution to the browser client.
-        // The client calls executeWorkflowWithFullLogging for real-time feedback
-        // (block pulsing, logs, stop button) and reports completion via
-        // /api/copilot/confirm with status success/error. We poll Redis for
-        // that completion signal, then fire-and-forget markToolComplete to Go.
-        if (CLIENT_EXECUTABLE_RUN_TOOLS.has(toolName)) {
-          toolCall.status = 'executing'
-          const completion = await waitForToolCompletion(
-            toolCallId,
-            options.timeout || STREAM_TIMEOUT_MS,
-            options.abortSignal
-          )
-          if (completion?.status === 'background') {
-            toolCall.status = 'skipped'
-            toolCall.endTime = Date.now()
-            markToolComplete(
-              toolCall.id,
-              toolCall.name,
-              202,
-              completion.message || 'Tool execution moved to background',
-              { background: true }
-            ).catch((err) => {
-              logger.error('markToolComplete fire-and-forget failed (run tool background)', {
-                toolCallId: toolCall.id,
-                error: err instanceof Error ? err.message : String(err),
-              })
-            })
-            markToolResultSeen(toolCallId)
-            return
-          }
-          const success = completion?.status === 'success'
-          toolCall.status = success ? 'success' : 'error'
-          toolCall.endTime = Date.now()
-          const msg =
-            completion?.message || (success ? 'Tool completed' : 'Tool failed or timed out')
-          // Fire-and-forget: tell Go backend the tool is done
-          // (must NOT await — see deadlock note in executeToolAndReport)
-          markToolComplete(toolCall.id, toolCall.name, success ? 200 : 500, msg).catch((err) => {
-            logger.error('markToolComplete fire-and-forget failed (run tool)', {
-              toolCallId: toolCall.id,
-              toolName: toolCall.name,
-              error: err instanceof Error ? err.message : String(err),
-            })
-          })
-          markToolResultSeen(toolCallId)
-          return
-        }
-        await executeToolAndReport(toolCallId, context, execContext, options)
-        return
-      }
-
-      if (decision?.status === 'rejected' || decision?.status === 'error') {
-        toolCall.status = 'rejected'
-        toolCall.endTime = Date.now()
-        // Fire-and-forget: must NOT await — see deadlock note in executeToolAndReport
-        markToolComplete(
-          toolCall.id,
-          toolCall.name,
-          400,
-          decision.message || 'Tool execution rejected',
-          { skipped: true, reason: 'user_rejected' }
-        ).catch((err) => {
-          logger.error('markToolComplete fire-and-forget failed (rejected)', {
-            toolCallId: toolCall.id,
-            error: err instanceof Error ? err.message : String(err),
-          })
-        })
-        markToolResultSeen(toolCall.id)
-        return
-      }
-
-      if (decision?.status === 'background') {
-        toolCall.status = 'skipped'
-        toolCall.endTime = Date.now()
-        // Fire-and-forget: must NOT await — see deadlock note in executeToolAndReport
-        markToolComplete(
-          toolCall.id,
-          toolCall.name,
-          202,
-          decision.message || 'Tool execution moved to background',
-          { background: true }
-        ).catch((err) => {
-          logger.error('markToolComplete fire-and-forget failed (background)', {
-            toolCallId: toolCall.id,
-            error: err instanceof Error ? err.message : String(err),
-          })
-        })
-        markToolResultSeen(toolCall.id)
-        return
-      }
-
-      // Decision was null — timed out or aborted.
-      // Do NOT fall through to auto-execute. Mark the tool as timed out
-      // and notify Go so it can unblock waitForExternalTool.
-      toolCall.status = 'rejected'
-      toolCall.endTime = Date.now()
-      markToolComplete(toolCall.id, toolCall.name, 408, 'Tool approval timed out', {
-        skipped: true,
-        reason: 'timeout',
-      }).catch((err) => {
-        logger.error('markToolComplete fire-and-forget failed (timeout)', {
-          toolCallId: toolCall.id,
-          error: err instanceof Error ? err.message : String(err),
-        })
-      })
-      markToolResultSeen(toolCall.id)
-      return
-    }
-
-    if (options.autoExecuteTools !== false) {
-      await executeToolAndReport(toolCallId, context, execContext, options)
-    }
+    await executeToolCallWithPolicy(
+      toolCall,
+      toolName,
+      toolData,
+      context,
+      execContext,
+      options,
+      'run tool'
+    )
   },
-  reasoning: (event, context) => {
+  'copilot.phase.progress': (event, context) => {
     const d = asRecord(event.data)
     const phase = d.phase || asRecord(d.data).phase
     if (phase === 'start') {
@@ -336,7 +370,7 @@ export const sseHandlers: Record<string, SSEHandler> = {
     if (!chunk || !context.currentThinkingBlock) return
     context.currentThinkingBlock.content = `${context.currentThinkingBlock.content || ''}${chunk}`
   },
-  content: (event, context) => {
+  'copilot.content': (event, context) => {
     // Go backend sends content as a plain string in event.data, not wrapped in an object.
     let chunk: string | undefined
     if (typeof event.data === 'string') {
@@ -349,20 +383,20 @@ export const sseHandlers: Record<string, SSEHandler> = {
     context.accumulatedContent += chunk
     addContentBlock(context, { type: 'text', content: chunk })
   },
-  done: (event, context) => {
+  'copilot.phase.completed': (event, context) => {
     const d = asRecord(event.data)
     if (d.responseId) {
       context.conversationId = d.responseId as string
     }
     context.streamComplete = true
   },
-  start: (event, context) => {
+  'copilot.phase.started': (event, context) => {
     const d = asRecord(event.data)
     if (d.responseId) {
       context.conversationId = d.responseId as string
     }
   },
-  error: (event, context) => {
+  'copilot.error': (event, context) => {
     const d = asRecord(event.data)
     const message = (d.message || d.error || event.error) as string | undefined
     if (message) {
@@ -373,7 +407,7 @@ export const sseHandlers: Record<string, SSEHandler> = {
 }
 
 export const subAgentHandlers: Record<string, SSEHandler> = {
-  content: (event, context) => {
+  'copilot.content': (event, context) => {
     const parentToolCallId = context.subAgentParentToolCallId
     if (!parentToolCallId || !event.data) return
     // Go backend sends content as a plain string in event.data
@@ -389,7 +423,7 @@ export const subAgentHandlers: Record<string, SSEHandler> = {
       (context.subAgentContent[parentToolCallId] || '') + chunk
     addContentBlock(context, { type: 'subagent_text', content: chunk })
   },
-  tool_call: async (event, context, execContext, options) => {
+  'copilot.tool.call': async (event, context, execContext, options) => {
     const parentToolCallId = context.subAgentParentToolCallId
     if (!parentToolCallId) return
     const toolData = getEventData(event) || ({} as Record<string, unknown>)
@@ -410,7 +444,7 @@ export const subAgentHandlers: Record<string, SSEHandler> = {
     const toolCall: ToolCallState = {
       id: toolCallId,
       name: toolName,
-      status: 'pending',
+      status: toolData.state ? mapServerStateToToolStatus(toolData.state) : 'pending',
       params: args,
       startTime: Date.now(),
     }
@@ -428,159 +462,17 @@ export const subAgentHandlers: Record<string, SSEHandler> = {
 
     if (isPartial) return
 
-    // Respond tools are internal to copilot's subagent system - skip execution.
-    if (RESPOND_TOOL_SET.has(toolName)) {
-      toolCall.status = 'success'
-      toolCall.endTime = Date.now()
-      toolCall.result = {
-        success: true,
-        output: 'Internal respond tool - handled by copilot backend',
-      }
-      return
-    }
-
-    // Tools that only exist on the Go backend (e.g. search_patterns,
-    // search_errors, remember_debug) should NOT be re-executed on the Sim side.
-    // The Go backend already executed them and will send its own tool_result
-    // SSE event with the real outcome.  Trying to execute them here would fail
-    // with "Tool not found" and incorrectly mark the tool as failed.
-    if (!isToolAvailableOnSimSide(toolName)) {
-      return
-    }
-
-    // Interrupt tools and integration tools (user-installed) require approval
-    // in interactive mode, same as top-level handler.
-    const needsSubagentApproval = isInterruptToolName(toolName) || isIntegrationTool(toolName)
-    if (options.interactive === true && needsSubagentApproval) {
-      const decision = await waitForToolDecision(
-        toolCallId,
-        options.timeout || STREAM_TIMEOUT_MS,
-        options.abortSignal
-      )
-      if (decision?.status === 'accepted' || decision?.status === 'success') {
-        await executeToolAndReport(toolCallId, context, execContext, options)
-        return
-      }
-      if (decision?.status === 'rejected' || decision?.status === 'error') {
-        toolCall.status = 'rejected'
-        toolCall.endTime = Date.now()
-        // Fire-and-forget: must NOT await — see deadlock note in executeToolAndReport
-        markToolComplete(
-          toolCall.id,
-          toolCall.name,
-          400,
-          decision.message || 'Tool execution rejected',
-          { skipped: true, reason: 'user_rejected' }
-        ).catch((err) => {
-          logger.error('markToolComplete fire-and-forget failed (subagent rejected)', {
-            toolCallId: toolCall.id,
-            error: err instanceof Error ? err.message : String(err),
-          })
-        })
-        markToolResultSeen(toolCall.id)
-        return
-      }
-      if (decision?.status === 'background') {
-        toolCall.status = 'skipped'
-        toolCall.endTime = Date.now()
-        // Fire-and-forget: must NOT await — see deadlock note in executeToolAndReport
-        markToolComplete(
-          toolCall.id,
-          toolCall.name,
-          202,
-          decision.message || 'Tool execution moved to background',
-          { background: true }
-        ).catch((err) => {
-          logger.error('markToolComplete fire-and-forget failed (subagent background)', {
-            toolCallId: toolCall.id,
-            error: err instanceof Error ? err.message : String(err),
-          })
-        })
-        markToolResultSeen(toolCall.id)
-        return
-      }
-
-      // Decision was null — timed out or aborted.
-      // Do NOT fall through to auto-execute.
-      toolCall.status = 'rejected'
-      toolCall.endTime = Date.now()
-      markToolComplete(toolCall.id, toolCall.name, 408, 'Tool approval timed out', {
-        skipped: true,
-        reason: 'timeout',
-      }).catch((err) => {
-        logger.error('markToolComplete fire-and-forget failed (subagent timeout)', {
-          toolCallId: toolCall.id,
-          error: err instanceof Error ? err.message : String(err),
-        })
-      })
-      markToolResultSeen(toolCall.id)
-      return
-    }
-
-    // Client-executable run tools in interactive mode: defer to client.
-    // Same pattern as main handler: wait for client completion, then tell Go.
-    if (options.interactive === true && CLIENT_EXECUTABLE_RUN_TOOLS.has(toolName)) {
-      toolCall.status = 'executing'
-      const completion = await waitForToolCompletion(
-        toolCallId,
-        options.timeout || STREAM_TIMEOUT_MS,
-        options.abortSignal
-      )
-      if (completion?.status === 'rejected') {
-        toolCall.status = 'rejected'
-        toolCall.endTime = Date.now()
-        markToolComplete(
-          toolCall.id,
-          toolCall.name,
-          400,
-          completion.message || 'Tool execution rejected'
-        ).catch((err) => {
-          logger.error('markToolComplete fire-and-forget failed (subagent run tool rejected)', {
-            toolCallId: toolCall.id,
-            error: err instanceof Error ? err.message : String(err),
-          })
-        })
-        markToolResultSeen(toolCallId)
-        return
-      }
-      if (completion?.status === 'background') {
-        toolCall.status = 'skipped'
-        toolCall.endTime = Date.now()
-        markToolComplete(
-          toolCall.id,
-          toolCall.name,
-          202,
-          completion.message || 'Tool execution moved to background',
-          { background: true }
-        ).catch((err) => {
-          logger.error('markToolComplete fire-and-forget failed (subagent run tool background)', {
-            toolCallId: toolCall.id,
-            error: err instanceof Error ? err.message : String(err),
-          })
-        })
-        markToolResultSeen(toolCallId)
-        return
-      }
-      const success = completion?.status === 'success'
-      toolCall.status = success ? 'success' : 'error'
-      toolCall.endTime = Date.now()
-      const msg = completion?.message || (success ? 'Tool completed' : 'Tool failed or timed out')
-      markToolComplete(toolCall.id, toolCall.name, success ? 200 : 500, msg).catch((err) => {
-        logger.error('markToolComplete fire-and-forget failed (subagent run tool)', {
-          toolCallId: toolCall.id,
-          toolName: toolCall.name,
-          error: err instanceof Error ? err.message : String(err),
-        })
-      })
-      markToolResultSeen(toolCallId)
-      return
-    }
-
-    if (options.autoExecuteTools !== false) {
-      await executeToolAndReport(toolCallId, context, execContext, options)
-    }
+    await executeToolCallWithPolicy(
+      toolCall,
+      toolName,
+      toolData,
+      context,
+      execContext,
+      options,
+      'subagent run tool'
+    )
   },
-  tool_result: (event, context) => {
+  'copilot.tool.result': (event, context) => {
     const parentToolCallId = context.subAgentParentToolCallId
     if (!parentToolCallId) return
     const data = getEventData(event)
@@ -596,7 +488,7 @@ export const subAgentHandlers: Record<string, SSEHandler> = {
 
     const { success, hasResultData, hasError } = inferToolSuccess(data)
 
-    const status = success ? 'success' : 'error'
+    const status = data?.state ? mapServerStateToToolStatus(data.state) : success ? 'success' : 'error'
     const endTime = Date.now()
     const result = hasResultData ? { success, output: data?.result || data?.data } : undefined
 
@@ -620,8 +512,22 @@ export const subAgentHandlers: Record<string, SSEHandler> = {
       }
     }
   },
+  'copilot.phase.progress': () => {
+    // Subagent reasoning chunks are surfaced via copilot.content.
+  },
+  'copilot.phase.completed': () => {},
 }
 
+sseHandlers['copilot.tool.interrupt_required'] = sseHandlers['copilot.tool.call']
+sseHandlers['copilot.workflow.patch'] = sseHandlers['copilot.tool.result']
+sseHandlers['copilot.workflow.verify'] = sseHandlers['copilot.tool.result']
+sseHandlers['copilot.tool.interrupt_resolved'] = sseHandlers['copilot.tool.result']
+
+subAgentHandlers['copilot.tool.interrupt_required'] = subAgentHandlers['copilot.tool.call']
+subAgentHandlers['copilot.workflow.patch'] = subAgentHandlers['copilot.tool.result']
+subAgentHandlers['copilot.workflow.verify'] = subAgentHandlers['copilot.tool.result']
+subAgentHandlers['copilot.tool.interrupt_resolved'] = subAgentHandlers['copilot.tool.result']
+
 export function handleSubagentRouting(event: SSEEvent, context: StreamingContext): boolean {
   if (!event.subagent) return false
   if (!context.subAgentParentToolCallId) {

apps/sim/lib/copilot/orchestrator/sse-handlers/tool-execution.ts

@@ -4,7 +4,6 @@ import {
   TOOL_DECISION_MAX_POLL_MS,
   TOOL_DECISION_POLL_BACKOFF,
 } from '@/lib/copilot/constants'
-import { INTERRUPT_TOOL_SET } from '@/lib/copilot/orchestrator/config'
 import { getToolConfirmation } from '@/lib/copilot/orchestrator/persistence'
 import {
   asRecord,
@@ -21,10 +20,6 @@ import type {
 
 const logger = createLogger('CopilotSseToolExecution')
 
-export function isInterruptToolName(toolName: string): boolean {
-  return INTERRUPT_TOOL_SET.has(toolName)
-}
-
 export async function executeToolAndReport(
   toolCallId: string,
   context: StreamingContext,
@@ -34,9 +29,11 @@ export async function executeToolAndReport(
   const toolCall = context.toolCalls.get(toolCallId)
   if (!toolCall) return
 
-  if (toolCall.status === 'executing') return
+  const lockable = toolCall as typeof toolCall & { __simExecuting?: boolean }
+  if (lockable.__simExecuting) return
   if (wasToolResultSeen(toolCall.id)) return
 
+  lockable.__simExecuting = true
   toolCall.status = 'executing'
   try {
     const result = await executeToolServerSide(toolCall, execContext)
@@ -83,7 +80,7 @@ export async function executeToolAndReport(
     })
 
     const resultEvent: SSEEvent = {
-      type: 'tool_result',
+      type: 'copilot.tool.result',
       toolCallId: toolCall.id,
       toolName: toolCall.name,
       success: result.success,
@@ -91,6 +88,8 @@ export async function executeToolAndReport(
       data: {
         id: toolCall.id,
         name: toolCall.name,
+        phase: 'completed',
+        state: result.success ? 'success' : 'error',
         success: result.success,
         result: result.output,
       },
@@ -113,15 +112,22 @@ export async function executeToolAndReport(
     })
 
     const errorEvent: SSEEvent = {
-      type: 'tool_error',
+      type: 'copilot.tool.result',
       toolCallId: toolCall.id,
+      toolName: toolCall.name,
+      success: false,
       data: {
         id: toolCall.id,
         name: toolCall.name,
+        phase: 'completed',
+        state: 'error',
+        success: false,
         error: toolCall.error,
       },
     }
     await options?.onEvent?.(errorEvent)
+  } finally {
+    delete lockable.__simExecuting
   }
 }
 

apps/sim/lib/copilot/orchestrator/sse-utils.test.ts

@@ -11,10 +11,10 @@ import {
 describe('sse-utils', () => {
   it.concurrent('normalizes tool fields from string data', () => {
     const event = {
-      type: 'tool_result',
+      type: 'copilot.tool.result',
       data: JSON.stringify({
         id: 'tool_1',
-        name: 'edit_workflow',
+        name: 'workflow_change',
         success: true,
         result: { ok: true },
       }),
@@ -22,21 +22,62 @@ describe('sse-utils', () => {
 
     const normalized = normalizeSseEvent(event as any)
 
+    expect(normalized.type).toBe('copilot.tool.result')
     expect(normalized.toolCallId).toBe('tool_1')
-    expect(normalized.toolName).toBe('edit_workflow')
+    expect(normalized.toolName).toBe('workflow_change')
     expect(normalized.success).toBe(true)
     expect(normalized.result).toEqual({ ok: true })
   })
 
-  it.concurrent('dedupes tool_call events', () => {
-    const event = { type: 'tool_call', data: { id: 'tool_call_1', name: 'plan' } }
+  it.concurrent('maps copilot tool event aliases and preserves tool metadata', () => {
+    const event = {
+      type: 'copilot.tool.interrupt_required',
+      data: {
+        id: 'tool_legacy_1',
+        name: 'workflow_run',
+        state: 'pending',
+        ui: { showInterrupt: true },
+      },
+    }
+
+    const normalized = normalizeSseEvent(event as any)
+
+    expect(normalized.type).toBe('copilot.tool.interrupt_required')
+    expect(normalized.toolCallId).toBe('tool_legacy_1')
+    expect(normalized.toolName).toBe('workflow_run')
+  })
+
+  it.concurrent('keeps copilot content event type when payload is plain string', () => {
+    const event = {
+      type: 'copilot.content',
+      data: 'hello world',
+    }
+
+    const normalized = normalizeSseEvent(event as any)
+
+    expect(normalized.type).toBe('copilot.content')
+    expect(normalized.data).toBe('hello world')
+  })
+
+  it.concurrent('dedupes copilot tool call events', () => {
+    const event = { type: 'copilot.tool.call', data: { id: 'tool_call_1', name: 'plan' } }
     expect(shouldSkipToolCallEvent(event as any)).toBe(false)
     expect(shouldSkipToolCallEvent(event as any)).toBe(true)
   })
 
-  it.concurrent('dedupes tool_result events', () => {
-    const event = { type: 'tool_result', data: { id: 'tool_result_1', name: 'plan' } }
+  it.concurrent('dedupes copilot tool result events', () => {
+    const event = { type: 'copilot.tool.result', data: { id: 'tool_result_1', name: 'plan' } }
     expect(shouldSkipToolResultEvent(event as any)).toBe(false)
     expect(shouldSkipToolResultEvent(event as any)).toBe(true)
   })
+
+  it.concurrent('dedupes copilot workflow patch result events', () => {
+    const normalized = normalizeSseEvent({
+      type: 'copilot.workflow.patch',
+      data: { id: 'tool_result_aliased_1', name: 'workflow_change' },
+    } as any)
+
+    expect(shouldSkipToolResultEvent(normalized as any)).toBe(false)
+    expect(shouldSkipToolResultEvent(normalized as any)).toBe(true)
+  })
 })

apps/sim/lib/copilot/orchestrator/sse-utils.ts

@@ -101,8 +101,21 @@ export function wasToolResultSeen(toolCallId: string): boolean {
   return seenToolResults.has(toolCallId)
 }
 
+function isToolCallEventType(type: string): boolean {
+  return type === 'copilot.tool.call' || type === 'copilot.tool.interrupt_required'
+}
+
+function isToolResultEventType(type: string): boolean {
+  return (
+    type === 'copilot.tool.result' ||
+    type === 'copilot.workflow.patch' ||
+    type === 'copilot.workflow.verify' ||
+    type === 'copilot.tool.interrupt_resolved'
+  )
+}
+
 export function shouldSkipToolCallEvent(event: SSEEvent): boolean {
-  if (event.type !== 'tool_call') return false
+  if (!isToolCallEventType(String(event.type || ''))) return false
   const toolCallId = getToolCallIdFromEvent(event)
   if (!toolCallId) return false
   const eventData = getEventData(event)
@@ -115,7 +128,7 @@ export function shouldSkipToolCallEvent(event: SSEEvent): boolean {
 }
 
 export function shouldSkipToolResultEvent(event: SSEEvent): boolean {
-  if (event.type !== 'tool_result') return false
+  if (!isToolResultEventType(String(event.type || ''))) return false
   const toolCallId = getToolCallIdFromEvent(event)
   if (!toolCallId) return false
   if (wasToolResultSeen(toolCallId)) return true

apps/sim/lib/copilot/orchestrator/stream-buffer.test.ts

@@ -97,8 +97,8 @@ describe('stream-buffer', () => {
   })
 
   it.concurrent('replays events after a given event id', async () => {
-    await appendStreamEvent('stream-1', { type: 'content', data: 'hello' })
-    await appendStreamEvent('stream-1', { type: 'content', data: 'world' })
+    await appendStreamEvent('stream-1', { type: 'copilot.content', data: 'hello' })
+    await appendStreamEvent('stream-1', { type: 'copilot.content', data: 'world' })
 
     const allEvents = await readStreamEvents('stream-1', 0)
     expect(allEvents.map((entry) => entry.event.data)).toEqual(['hello', 'world'])
@@ -109,8 +109,8 @@ describe('stream-buffer', () => {
 
   it.concurrent('flushes buffered events for resume', async () => {
     const writer = createStreamEventWriter('stream-2')
-    await writer.write({ type: 'content', data: 'a' })
-    await writer.write({ type: 'content', data: 'b' })
+    await writer.write({ type: 'copilot.content', data: 'a' })
+    await writer.write({ type: 'copilot.content', data: 'b' })
     await writer.flush()
 
     const events = await readStreamEvents('stream-2', 0)

apps/sim/lib/copilot/orchestrator/stream-core.ts

@@ -127,7 +127,7 @@ export async function runStreamLoop(
       }
 
       // Standard subagent start/end handling.
-      if (normalizedEvent.type === 'subagent_start') {
+      if (normalizedEvent.type === 'copilot.subagent.started') {
         const eventData = normalizedEvent.data as Record<string, unknown> | undefined
         const toolCallId = eventData?.tool_call_id as string | undefined
         if (toolCallId) {
@@ -138,7 +138,7 @@ export async function runStreamLoop(
         continue
       }
 
-      if (normalizedEvent.type === 'subagent_end') {
+      if (normalizedEvent.type === 'copilot.subagent.completed') {
         context.subAgentParentToolCallId = undefined
         continue
       }

apps/sim/lib/copilot/orchestrator/subagent.ts

@@ -74,7 +74,7 @@ export async function orchestrateSubagentStream(
           }
 
           // For direct subagent calls, events may have the subagent field set
-          // but no subagent_start because this IS the top-level agent.
+          // but no copilot.subagent.started because this IS the top-level agent.
           // Skip subagent routing for events where the subagent field matches
           // the current agentId - these are top-level events.
           if (event.subagent === agentId && !ctx.subAgentParentToolCallId) {

apps/sim/lib/copilot/orchestrator/tool-executor/deployment-tools/deploy.ts

@@ -220,7 +220,8 @@ export async function executeDeployMcp(
     if (!workflowRecord.isDeployed) {
       return {
         success: false,
-        error: 'Workflow must be deployed before adding as an MCP tool. Use deploy_api first.',
+        error:
+          'Workflow must be deployed before adding as an MCP tool. Use workflow_deploy(mode: "api") first.',
       }
     }
 

apps/sim/lib/copilot/orchestrator/tool-executor/index.ts

@@ -50,6 +50,8 @@ import type {
   RunWorkflowParams,
   RunWorkflowUntilBlockParams,
   SetGlobalWorkflowVariablesParams,
+  WorkflowDeployParams,
+  WorkflowRunParams,
 } from './param-types'
 import { PLATFORM_ACTIONS_CONTENT } from './platform-actions'
 import {
@@ -318,13 +320,91 @@ async function executeManageCustomTool(
   }
 }
 
+async function executeWorkflowRunUnified(
+  rawParams: Record<string, unknown>,
+  context: ExecutionContext
+): Promise<ToolCallResult> {
+  const params = rawParams as WorkflowRunParams
+  const mode = params.mode || 'full'
+
+  switch (mode) {
+    case 'full':
+      return executeRunWorkflow(params as RunWorkflowParams, context)
+    case 'until_block':
+      if (!params.stopAfterBlockId) {
+        return { success: false, error: 'stopAfterBlockId is required for mode=until_block' }
+      }
+      return executeRunWorkflowUntilBlock(params as RunWorkflowUntilBlockParams, context)
+    case 'from_block':
+      if (!params.startBlockId) {
+        return { success: false, error: 'startBlockId is required for mode=from_block' }
+      }
+      return executeRunFromBlock(params as RunFromBlockParams, context)
+    case 'block':
+      if (!params.blockId) {
+        return { success: false, error: 'blockId is required for mode=block' }
+      }
+      return executeRunBlock(params as RunBlockParams, context)
+    default:
+      return {
+        success: false,
+        error: `Unsupported workflow_run mode: ${String(mode)}`,
+      }
+  }
+}
+
+async function executeWorkflowDeployUnified(
+  rawParams: Record<string, unknown>,
+  context: ExecutionContext
+): Promise<ToolCallResult> {
+  const params = rawParams as unknown as WorkflowDeployParams
+  const mode = params.mode
+
+  if (!mode) {
+    return { success: false, error: 'mode is required for workflow_deploy' }
+  }
+
+  const scopedContext =
+    params.workflowId && params.workflowId !== context.workflowId
+      ? { ...context, workflowId: params.workflowId }
+      : context
+
+  switch (mode) {
+    case 'status':
+      return executeCheckDeploymentStatus(params as CheckDeploymentStatusParams, scopedContext)
+    case 'redeploy':
+      return executeRedeploy(scopedContext)
+    case 'api':
+      return executeDeployApi(params as DeployApiParams, scopedContext)
+    case 'chat':
+      return executeDeployChat(params as DeployChatParams, scopedContext)
+    case 'mcp':
+      return executeDeployMcp(params as DeployMcpParams, scopedContext)
+    case 'list_mcp_servers':
+      return executeListWorkspaceMcpServers(params as ListWorkspaceMcpServersParams, scopedContext)
+    case 'create_mcp_server':
+      return executeCreateWorkspaceMcpServer(
+        params as CreateWorkspaceMcpServerParams,
+        scopedContext
+      )
+    default:
+      return {
+        success: false,
+        error: `Unsupported workflow_deploy mode: ${String(mode)}`,
+      }
+  }
+}
+
 const SERVER_TOOLS = new Set<string>([
   'get_blocks_and_tools',
   'get_blocks_metadata',
   'get_block_options',
   'get_block_config',
   'get_trigger_blocks',
-  'edit_workflow',
+  'workflow_context_get',
+  'workflow_context_expand',
+  'workflow_change',
+  'workflow_verify',
   'get_workflow_console',
   'search_documentation',
   'search_online',
@@ -352,11 +432,7 @@ const SIM_WORKFLOW_TOOL_HANDLERS: Record<
   get_block_outputs: (p, c) => executeGetBlockOutputs(p as GetBlockOutputsParams, c),
   get_block_upstream_references: (p, c) =>
     executeGetBlockUpstreamReferences(p as unknown as GetBlockUpstreamReferencesParams, c),
-  run_workflow: (p, c) => executeRunWorkflow(p as RunWorkflowParams, c),
-  run_workflow_until_block: (p, c) =>
-    executeRunWorkflowUntilBlock(p as unknown as RunWorkflowUntilBlockParams, c),
-  run_from_block: (p, c) => executeRunFromBlock(p as unknown as RunFromBlockParams, c),
-  run_block: (p, c) => executeRunBlock(p as unknown as RunBlockParams, c),
+  workflow_run: (p, c) => executeWorkflowRunUnified(p, c),
   get_deployed_workflow_state: (p, c) =>
     executeGetDeployedWorkflowState(p as GetDeployedWorkflowStateParams, c),
   generate_api_key: (p, c) => executeGenerateApiKey(p as unknown as GenerateApiKeyParams, c),
@@ -367,10 +443,7 @@ const SIM_WORKFLOW_TOOL_HANDLERS: Record<
     }),
   set_global_workflow_variables: (p, c) =>
     executeSetGlobalWorkflowVariables(p as SetGlobalWorkflowVariablesParams, c),
-  deploy_api: (p, c) => executeDeployApi(p as DeployApiParams, c),
-  deploy_chat: (p, c) => executeDeployChat(p as DeployChatParams, c),
-  deploy_mcp: (p, c) => executeDeployMcp(p as DeployMcpParams, c),
-  redeploy: (_p, c) => executeRedeploy(c),
+  workflow_deploy: (p, c) => executeWorkflowDeployUnified(p, c),
   check_deployment_status: (p, c) =>
     executeCheckDeploymentStatus(p as CheckDeploymentStatusParams, c),
   list_workspace_mcp_servers: (p, c) =>

apps/sim/lib/copilot/orchestrator/tool-executor/param-types.ts

@@ -93,6 +93,18 @@ export interface RunBlockParams {
   useDeployedState?: boolean
 }
 
+export interface WorkflowRunParams {
+  mode?: 'full' | 'until_block' | 'from_block' | 'block'
+  workflowId?: string
+  workflow_input?: unknown
+  input?: unknown
+  useDeployedState?: boolean
+  stopAfterBlockId?: string
+  startBlockId?: string
+  blockId?: string
+  executionId?: string
+}
+
 export interface GetDeployedWorkflowStateParams {
   workflowId?: string
 }
@@ -169,6 +181,39 @@ export interface CreateWorkspaceMcpServerParams {
   workflowIds?: string[]
 }
 
+export interface WorkflowDeployParams {
+  mode:
+    | 'status'
+    | 'redeploy'
+    | 'api'
+    | 'chat'
+    | 'mcp'
+    | 'list_mcp_servers'
+    | 'create_mcp_server'
+  workflowId?: string
+  action?: 'deploy' | 'undeploy'
+  identifier?: string
+  title?: string
+  description?: string
+  customizations?: {
+    primaryColor?: string
+    secondaryColor?: string
+    welcomeMessage?: string
+    iconUrl?: string
+  }
+  authType?: 'none' | 'password' | 'public' | 'email' | 'sso'
+  password?: string
+  allowedEmails?: string[]
+  outputConfigs?: unknown[]
+  serverId?: string
+  toolName?: string
+  toolDescription?: string
+  parameterSchema?: Record<string, unknown>
+  name?: string
+  isPublic?: boolean
+  workflowIds?: string[]
+}
+
 // === Workflow Organization Params ===
 
 export interface RenameWorkflowParams {

apps/sim/lib/copilot/orchestrator/types.ts

@@ -1,19 +1,22 @@
 export type SSEEventType =
   | 'chat_id'
   | 'title_updated'
-  | 'content'
-  | 'reasoning'
-  | 'tool_call'
-  | 'tool_generating'
-  | 'tool_result'
-  | 'tool_error'
-  | 'subagent_start'
-  | 'subagent_end'
   | 'structured_result'
   | 'subagent_result'
-  | 'done'
-  | 'error'
-  | 'start'
+  | 'stream_end'
+  | 'copilot.phase.started'
+  | 'copilot.phase.progress'
+  | 'copilot.phase.completed'
+  | 'copilot.tool.call'
+  | 'copilot.tool.result'
+  | 'copilot.tool.interrupt_required'
+  | 'copilot.tool.interrupt_resolved'
+  | 'copilot.workflow.patch'
+  | 'copilot.workflow.verify'
+  | 'copilot.subagent.started'
+  | 'copilot.subagent.completed'
+  | 'copilot.content'
+  | 'copilot.error'
 
 export interface SSEEvent {
   type: SSEEventType

apps/sim/lib/copilot/tools/client/tool-display-registry.ts

@@ -592,16 +592,40 @@ const META_edit: ToolMetadata = {
   },
 }
 
-const META_edit_workflow: ToolMetadata = {
+const META_workflow_change: ToolMetadata = {
   displayNames: {
-    [ClientToolCallState.generating]: { text: 'Editing your workflow', icon: Loader2 },
-    [ClientToolCallState.executing]: { text: 'Editing your workflow', icon: Loader2 },
-    [ClientToolCallState.success]: { text: 'Edited your workflow', icon: Grid2x2Check },
-    [ClientToolCallState.error]: { text: 'Failed to edit your workflow', icon: XCircle },
+    [ClientToolCallState.generating]: { text: 'Planning workflow changes', icon: Loader2 },
+    [ClientToolCallState.executing]: { text: 'Applying workflow changes', icon: Loader2 },
+    [ClientToolCallState.success]: { text: 'Updated your workflow', icon: Grid2x2Check },
+    [ClientToolCallState.error]: { text: 'Failed to update your workflow', icon: XCircle },
     [ClientToolCallState.review]: { text: 'Review your workflow changes', icon: Grid2x2 },
     [ClientToolCallState.rejected]: { text: 'Rejected workflow changes', icon: Grid2x2X },
-    [ClientToolCallState.aborted]: { text: 'Aborted editing your workflow', icon: MinusCircle },
-    [ClientToolCallState.pending]: { text: 'Editing your workflow', icon: Loader2 },
+    [ClientToolCallState.aborted]: { text: 'Aborted workflow changes', icon: MinusCircle },
+    [ClientToolCallState.pending]: { text: 'Planning workflow changes', icon: Loader2 },
+  },
+  getDynamicText: (params, state) => {
+    const mode = typeof params?.mode === 'string' ? params.mode.toLowerCase() : ''
+    if (mode === 'dry_run') {
+      switch (state) {
+        case ClientToolCallState.success:
+          return 'Planned workflow changes'
+        case ClientToolCallState.executing:
+        case ClientToolCallState.generating:
+        case ClientToolCallState.pending:
+          return 'Planning workflow changes'
+      }
+    }
+    if (mode === 'apply' || typeof params?.proposalId === 'string') {
+      switch (state) {
+        case ClientToolCallState.success:
+          return 'Applied workflow changes'
+        case ClientToolCallState.executing:
+        case ClientToolCallState.generating:
+        case ClientToolCallState.pending:
+          return 'Applying workflow changes'
+      }
+    }
+    return undefined
   },
   uiConfig: {
     isSpecial: true,
@@ -609,6 +633,42 @@ const META_edit_workflow: ToolMetadata = {
   },
 }
 
+const META_workflow_context_get: ToolMetadata = {
+  displayNames: {
+    [ClientToolCallState.generating]: { text: 'Gathering workflow context', icon: Loader2 },
+    [ClientToolCallState.pending]: { text: 'Gathering workflow context', icon: Loader2 },
+    [ClientToolCallState.executing]: { text: 'Gathering workflow context', icon: Loader2 },
+    [ClientToolCallState.success]: { text: 'Gathered workflow context', icon: FileText },
+    [ClientToolCallState.error]: { text: 'Failed to gather workflow context', icon: XCircle },
+    [ClientToolCallState.rejected]: { text: 'Skipped workflow context', icon: MinusCircle },
+    [ClientToolCallState.aborted]: { text: 'Aborted workflow context', icon: MinusCircle },
+  },
+}
+
+const META_workflow_context_expand: ToolMetadata = {
+  displayNames: {
+    [ClientToolCallState.generating]: { text: 'Expanding workflow schemas', icon: Loader2 },
+    [ClientToolCallState.pending]: { text: 'Expanding workflow schemas', icon: Loader2 },
+    [ClientToolCallState.executing]: { text: 'Expanding workflow schemas', icon: Loader2 },
+    [ClientToolCallState.success]: { text: 'Expanded workflow schemas', icon: FileText },
+    [ClientToolCallState.error]: { text: 'Failed to expand workflow schemas', icon: XCircle },
+    [ClientToolCallState.rejected]: { text: 'Skipped schema expansion', icon: MinusCircle },
+    [ClientToolCallState.aborted]: { text: 'Aborted schema expansion', icon: MinusCircle },
+  },
+}
+
+const META_workflow_verify: ToolMetadata = {
+  displayNames: {
+    [ClientToolCallState.generating]: { text: 'Verifying workflow', icon: Loader2 },
+    [ClientToolCallState.pending]: { text: 'Verifying workflow', icon: Loader2 },
+    [ClientToolCallState.executing]: { text: 'Verifying workflow', icon: Loader2 },
+    [ClientToolCallState.success]: { text: 'Verified workflow', icon: CheckCircle2 },
+    [ClientToolCallState.error]: { text: 'Workflow verification failed', icon: XCircle },
+    [ClientToolCallState.rejected]: { text: 'Skipped workflow verification', icon: MinusCircle },
+    [ClientToolCallState.aborted]: { text: 'Aborted workflow verification', icon: MinusCircle },
+  },
+}
+
 const META_evaluate: ToolMetadata = {
   displayNames: {
     [ClientToolCallState.generating]: { text: 'Evaluating', icon: Loader2 },
@@ -2541,7 +2601,12 @@ const TOOL_METADATA_BY_ID: Record<string, ToolMetadata> = {
   deploy_chat: META_deploy_chat,
   deploy_mcp: META_deploy_mcp,
   edit: META_edit,
-  edit_workflow: META_edit_workflow,
+  workflow_context_get: META_workflow_context_get,
+  workflow_context_expand: META_workflow_context_expand,
+  workflow_change: META_workflow_change,
+  workflow_verify: META_workflow_verify,
+  workflow_run: META_run_workflow,
+  workflow_deploy: META_deploy_api,
   evaluate: META_evaluate,
   get_block_config: META_get_block_config,
   get_block_options: META_get_block_options,

apps/sim/lib/copilot/tools/mcp/definitions.ts

@@ -1,680 +0,0 @@
-export type DirectToolDef = {
-  name: string
-  description: string
-  inputSchema: { type: 'object'; properties?: Record<string, unknown>; required?: string[] }
-  toolId: string
-}
-
-export type SubagentToolDef = {
-  name: string
-  description: string
-  inputSchema: { type: 'object'; properties?: Record<string, unknown>; required?: string[] }
-  agentId: string
-}
-
-/**
- * Direct tools that execute immediately without LLM orchestration.
- * These are fast database queries that don't need AI reasoning.
- */
-export const DIRECT_TOOL_DEFS: DirectToolDef[] = [
-  {
-    name: 'list_workspaces',
-    toolId: 'list_user_workspaces',
-    description:
-      'List all workspaces the user has access to. Returns workspace IDs, names, and roles. Use this first to determine which workspace to operate in.',
-    inputSchema: {
-      type: 'object',
-      properties: {},
-    },
-  },
-  {
-    name: 'list_workflows',
-    toolId: 'list_user_workflows',
-    description:
-      'List all workflows the user has access to. Returns workflow IDs, names, workspace, and folder info. Use workspaceId/folderId to scope results.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        workspaceId: {
-          type: 'string',
-          description: 'Optional workspace ID to filter workflows.',
-        },
-        folderId: {
-          type: 'string',
-          description: 'Optional folder ID to filter workflows.',
-        },
-      },
-    },
-  },
-  {
-    name: 'list_folders',
-    toolId: 'list_folders',
-    description:
-      'List all folders in a workspace. Returns folder IDs, names, and parent relationships for organizing workflows.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        workspaceId: {
-          type: 'string',
-          description: 'Workspace ID to list folders from.',
-        },
-      },
-      required: ['workspaceId'],
-    },
-  },
-  {
-    name: 'get_workflow',
-    toolId: 'get_user_workflow',
-    description:
-      'Get a workflow by ID. Returns the full workflow definition including all blocks, connections, and configuration.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        workflowId: {
-          type: 'string',
-          description: 'Workflow ID to retrieve.',
-        },
-      },
-      required: ['workflowId'],
-    },
-  },
-  {
-    name: 'create_workflow',
-    toolId: 'create_workflow',
-    description:
-      'Create a new empty workflow. Returns the new workflow ID. Always call this FIRST before sim_build for new workflows. Use workspaceId to place it in a specific workspace.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        name: {
-          type: 'string',
-          description: 'Name for the new workflow.',
-        },
-        workspaceId: {
-          type: 'string',
-          description: 'Optional workspace ID. Uses default workspace if not provided.',
-        },
-        folderId: {
-          type: 'string',
-          description: 'Optional folder ID to place the workflow in.',
-        },
-        description: {
-          type: 'string',
-          description: 'Optional description for the workflow.',
-        },
-      },
-      required: ['name'],
-    },
-  },
-  {
-    name: 'create_folder',
-    toolId: 'create_folder',
-    description:
-      'Create a new folder for organizing workflows. Use parentId to create nested folder hierarchies.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        name: {
-          type: 'string',
-          description: 'Name for the new folder.',
-        },
-        workspaceId: {
-          type: 'string',
-          description: 'Optional workspace ID. Uses default workspace if not provided.',
-        },
-        parentId: {
-          type: 'string',
-          description: 'Optional parent folder ID for nested folders.',
-        },
-      },
-      required: ['name'],
-    },
-  },
-  {
-    name: 'rename_workflow',
-    toolId: 'rename_workflow',
-    description: 'Rename an existing workflow.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        workflowId: {
-          type: 'string',
-          description: 'The workflow ID to rename.',
-        },
-        name: {
-          type: 'string',
-          description: 'The new name for the workflow.',
-        },
-      },
-      required: ['workflowId', 'name'],
-    },
-  },
-  {
-    name: 'move_workflow',
-    toolId: 'move_workflow',
-    description:
-      'Move a workflow into a different folder. Omit folderId or pass empty string to move to workspace root.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        workflowId: {
-          type: 'string',
-          description: 'The workflow ID to move.',
-        },
-        folderId: {
-          type: 'string',
-          description: 'Target folder ID. Omit or pass empty string to move to workspace root.',
-        },
-      },
-      required: ['workflowId'],
-    },
-  },
-  {
-    name: 'move_folder',
-    toolId: 'move_folder',
-    description:
-      'Move a folder into another folder. Omit parentId or pass empty string to move to workspace root.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        folderId: {
-          type: 'string',
-          description: 'The folder ID to move.',
-        },
-        parentId: {
-          type: 'string',
-          description:
-            'Target parent folder ID. Omit or pass empty string to move to workspace root.',
-        },
-      },
-      required: ['folderId'],
-    },
-  },
-  {
-    name: 'run_workflow',
-    toolId: 'run_workflow',
-    description:
-      'Run a workflow and return its output. Works on both draft and deployed states. By default runs the draft (live) state.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        workflowId: {
-          type: 'string',
-          description: 'REQUIRED. The workflow ID to run.',
-        },
-        workflow_input: {
-          type: 'object',
-          description:
-            'JSON object with input values. Keys should match the workflow start block input field names.',
-        },
-        useDeployedState: {
-          type: 'boolean',
-          description: 'When true, runs the deployed version instead of the draft. Default: false.',
-        },
-      },
-      required: ['workflowId'],
-    },
-  },
-  {
-    name: 'run_workflow_until_block',
-    toolId: 'run_workflow_until_block',
-    description:
-      'Run a workflow and stop after a specific block completes. Useful for testing partial execution or debugging specific blocks.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        workflowId: {
-          type: 'string',
-          description: 'REQUIRED. The workflow ID to run.',
-        },
-        stopAfterBlockId: {
-          type: 'string',
-          description:
-            'REQUIRED. The block ID to stop after. Execution halts once this block completes.',
-        },
-        workflow_input: {
-          type: 'object',
-          description: 'JSON object with input values for the workflow.',
-        },
-        useDeployedState: {
-          type: 'boolean',
-          description: 'When true, runs the deployed version instead of the draft. Default: false.',
-        },
-      },
-      required: ['workflowId', 'stopAfterBlockId'],
-    },
-  },
-  {
-    name: 'run_from_block',
-    toolId: 'run_from_block',
-    description:
-      'Run a workflow starting from a specific block, using cached outputs from a prior execution for upstream blocks. The workflow must have been run at least once first.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        workflowId: {
-          type: 'string',
-          description: 'REQUIRED. The workflow ID to run.',
-        },
-        startBlockId: {
-          type: 'string',
-          description: 'REQUIRED. The block ID to start execution from.',
-        },
-        executionId: {
-          type: 'string',
-          description:
-            'Optional. Specific execution ID to load the snapshot from. Uses latest if omitted.',
-        },
-        workflow_input: {
-          type: 'object',
-          description: 'Optional input values for the workflow.',
-        },
-        useDeployedState: {
-          type: 'boolean',
-          description: 'When true, runs the deployed version instead of the draft. Default: false.',
-        },
-      },
-      required: ['workflowId', 'startBlockId'],
-    },
-  },
-  {
-    name: 'run_block',
-    toolId: 'run_block',
-    description:
-      'Run a single block in isolation using cached outputs from a prior execution. Only the specified block executes — nothing upstream or downstream. The workflow must have been run at least once first.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        workflowId: {
-          type: 'string',
-          description: 'REQUIRED. The workflow ID.',
-        },
-        blockId: {
-          type: 'string',
-          description: 'REQUIRED. The block ID to run in isolation.',
-        },
-        executionId: {
-          type: 'string',
-          description:
-            'Optional. Specific execution ID to load the snapshot from. Uses latest if omitted.',
-        },
-        workflow_input: {
-          type: 'object',
-          description: 'Optional input values for the workflow.',
-        },
-        useDeployedState: {
-          type: 'boolean',
-          description: 'When true, runs the deployed version instead of the draft. Default: false.',
-        },
-      },
-      required: ['workflowId', 'blockId'],
-    },
-  },
-  {
-    name: 'get_deployed_workflow_state',
-    toolId: 'get_deployed_workflow_state',
-    description:
-      'Get the deployed (production) state of a workflow. Returns the full workflow definition as deployed, or indicates if the workflow is not yet deployed.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        workflowId: {
-          type: 'string',
-          description: 'REQUIRED. The workflow ID to get the deployed state for.',
-        },
-      },
-      required: ['workflowId'],
-    },
-  },
-  {
-    name: 'generate_api_key',
-    toolId: 'generate_api_key',
-    description:
-      'Generate a new workspace API key for calling workflow API endpoints. The key is only shown once — tell the user to save it immediately.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        name: {
-          type: 'string',
-          description:
-            'A descriptive name for the API key (e.g., "production-key", "dev-testing").',
-        },
-        workspaceId: {
-          type: 'string',
-          description: "Optional workspace ID. Defaults to user's default workspace.",
-        },
-      },
-      required: ['name'],
-    },
-  },
-]
-
-export const SUBAGENT_TOOL_DEFS: SubagentToolDef[] = [
-  {
-    name: 'sim_build',
-    agentId: 'build',
-    description: `Build a workflow end-to-end in a single step. This is the fast mode equivalent for headless/MCP usage.
-
-USE THIS WHEN:
-- Building a new workflow from scratch
-- Modifying an existing workflow
-- You want to gather information and build in one pass without separate plan→edit steps
-
-WORKFLOW ID (REQUIRED):
-- For NEW workflows: First call create_workflow to get a workflowId, then pass it here
-- For EXISTING workflows: Always pass the workflowId parameter
-
-CAN DO:
-- Gather information about blocks, credentials, patterns
-- Search documentation and patterns for best practices
-- Add, modify, or remove blocks
-- Configure block settings and connections
-- Set environment variables and workflow variables
-
-CANNOT DO:
-- Run or test workflows (use sim_test separately)
-- Deploy workflows (use sim_deploy separately)
-
-WORKFLOW:
-1. Call create_workflow to get a workflowId (for new workflows)
-2. Call sim_build with the request and workflowId
-3. Build agent gathers info and builds in one pass
-4. Call sim_test to verify it works
-5. Optionally call sim_deploy to make it externally accessible`,
-    inputSchema: {
-      type: 'object',
-      properties: {
-        request: {
-          type: 'string',
-          description: 'What you want to build or modify in the workflow.',
-        },
-        workflowId: {
-          type: 'string',
-          description:
-            'REQUIRED. The workflow ID. For new workflows, call create_workflow first to get this.',
-        },
-        context: { type: 'object' },
-      },
-      required: ['request', 'workflowId'],
-    },
-  },
-  {
-    name: 'sim_discovery',
-    agentId: 'discovery',
-    description: `Find workflows by their contents or functionality when the user doesn't know the exact name or ID.
-
-USE THIS WHEN:
-- User describes a workflow by what it does: "the one that sends emails", "my Slack notification workflow"
-- User refers to workflow contents: "the workflow with the OpenAI block"
-- User needs to search/match workflows by functionality or description
-
-DO NOT USE (use direct tools instead):
-- User knows the workflow name → use get_workflow
-- User wants to list all workflows → use list_workflows
-- User wants to list workspaces → use list_workspaces
-- User wants to list folders → use list_folders`,
-    inputSchema: {
-      type: 'object',
-      properties: {
-        request: { type: 'string' },
-        workspaceId: { type: 'string' },
-        context: { type: 'object' },
-      },
-      required: ['request'],
-    },
-  },
-  {
-    name: 'sim_plan',
-    agentId: 'plan',
-    description: `Plan workflow changes by gathering required information. For most cases, prefer sim_build which combines planning and editing in one step.
-
-USE THIS WHEN:
-- You need fine-grained control over the build process
-- You want to inspect the plan before executing it
-
-WORKFLOW ID (REQUIRED):
-- For NEW workflows: First call create_workflow to get a workflowId, then pass it here
-- For EXISTING workflows: Always pass the workflowId parameter
-
-This tool gathers information about available blocks, credentials, and the current workflow state.
-
-RETURNS: A plan object containing block configurations, connections, and technical details.
-IMPORTANT: Pass the returned plan EXACTLY to sim_edit - do not modify or summarize it.`,
-    inputSchema: {
-      type: 'object',
-      properties: {
-        request: {
-          type: 'string',
-          description: 'What you want to build or modify in the workflow.',
-        },
-        workflowId: {
-          type: 'string',
-          description:
-            'REQUIRED. The workflow ID. For new workflows, call create_workflow first to get this.',
-        },
-        context: { type: 'object' },
-      },
-      required: ['request', 'workflowId'],
-    },
-  },
-  {
-    name: 'sim_edit',
-    agentId: 'edit',
-    description: `Execute a workflow plan from sim_plan. For most cases, prefer sim_build which combines planning and editing in one step.
-
-WORKFLOW ID (REQUIRED):
-- You MUST provide the workflowId parameter
-
-PLAN (REQUIRED):
-- Pass the EXACT plan object from sim_plan in the context.plan field
-- Do NOT modify, summarize, or interpret the plan - pass it verbatim
-
-After sim_edit completes, you can test immediately with sim_test, or deploy with sim_deploy to make it accessible externally.`,
-    inputSchema: {
-      type: 'object',
-      properties: {
-        message: { type: 'string', description: 'Optional additional instructions for the edit.' },
-        workflowId: {
-          type: 'string',
-          description:
-            'REQUIRED. The workflow ID to edit. Get this from create_workflow for new workflows.',
-        },
-        plan: {
-          type: 'object',
-          description: 'The plan object from sim_plan. Pass it EXACTLY as returned, do not modify.',
-        },
-        context: {
-          type: 'object',
-          description:
-            'Additional context. Put the plan in context.plan if not using the plan field directly.',
-        },
-      },
-      required: ['workflowId'],
-    },
-  },
-  {
-    name: 'sim_deploy',
-    agentId: 'deploy',
-    description: `Deploy a workflow to make it accessible externally. Workflows can be tested without deploying, but deployment is needed for API access, chat UIs, or MCP exposure.
-
-DEPLOYMENT TYPES:
-- "deploy as api" - REST API endpoint for programmatic access
-- "deploy as chat" - Managed chat UI with auth options
-- "deploy as mcp" - Expose as MCP tool on an MCP server for AI agents to call
-
-MCP DEPLOYMENT FLOW:
-The deploy subagent will automatically: list available MCP servers → create one if needed → deploy the workflow as an MCP tool to that server. You can specify server name, tool name, and tool description.
-
-ALSO CAN:
-- Get the deployed (production) state to compare with draft
-- Generate workspace API keys for calling deployed workflows
-- List and create MCP servers in the workspace`,
-    inputSchema: {
-      type: 'object',
-      properties: {
-        request: {
-          type: 'string',
-          description: 'The deployment request, e.g. "deploy as api" or "deploy as chat"',
-        },
-        workflowId: {
-          type: 'string',
-          description: 'REQUIRED. The workflow ID to deploy.',
-        },
-        context: { type: 'object' },
-      },
-      required: ['request', 'workflowId'],
-    },
-  },
-  {
-    name: 'sim_test',
-    agentId: 'test',
-    description: `Run a workflow and verify its outputs. Works on both deployed and undeployed (draft) workflows. Use after building to verify correctness.
-
-Supports full and partial execution:
-- Full run with test inputs
-- Stop after a specific block (run_workflow_until_block)
-- Run a single block in isolation (run_block)
-- Resume from a specific block (run_from_block)`,
-    inputSchema: {
-      type: 'object',
-      properties: {
-        request: { type: 'string' },
-        workflowId: {
-          type: 'string',
-          description: 'REQUIRED. The workflow ID to test.',
-        },
-        context: { type: 'object' },
-      },
-      required: ['request', 'workflowId'],
-    },
-  },
-  {
-    name: 'sim_debug',
-    agentId: 'debug',
-    description:
-      'Diagnose errors or unexpected workflow behavior. Provide the error message and workflowId. Returns root cause analysis and fix suggestions.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        error: { type: 'string', description: 'The error message or description of the issue.' },
-        workflowId: { type: 'string', description: 'REQUIRED. The workflow ID to debug.' },
-        context: { type: 'object' },
-      },
-      required: ['error', 'workflowId'],
-    },
-  },
-  {
-    name: 'sim_auth',
-    agentId: 'auth',
-    description:
-      'Check OAuth connection status, list connected services, and initiate new OAuth connections. Use when a workflow needs third-party service access (Google, Slack, GitHub, etc.). In MCP/headless mode, returns an authorization URL the user must open in their browser to complete the OAuth flow.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        request: { type: 'string' },
-        context: { type: 'object' },
-      },
-      required: ['request'],
-    },
-  },
-  {
-    name: 'sim_knowledge',
-    agentId: 'knowledge',
-    description:
-      'Manage knowledge bases for RAG-powered document retrieval. Supports listing, creating, updating, and deleting knowledge bases. Knowledge bases can be attached to agent blocks for context-aware responses.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        request: { type: 'string' },
-        context: { type: 'object' },
-      },
-      required: ['request'],
-    },
-  },
-  {
-    name: 'sim_custom_tool',
-    agentId: 'custom_tool',
-    description:
-      'Manage custom tools (reusable API integrations). Supports listing, creating, updating, and deleting custom tools. Custom tools can be added to agent blocks as callable functions.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        request: { type: 'string' },
-        context: { type: 'object' },
-      },
-      required: ['request'],
-    },
-  },
-  {
-    name: 'sim_info',
-    agentId: 'info',
-    description:
-      "Inspect a workflow's blocks, connections, outputs, variables, and metadata. Use for questions about the Sim platform itself — how blocks work, what integrations are available, platform concepts, etc. Always provide workflowId to scope results to a specific workflow.",
-    inputSchema: {
-      type: 'object',
-      properties: {
-        request: { type: 'string' },
-        workflowId: { type: 'string' },
-        context: { type: 'object' },
-      },
-      required: ['request'],
-    },
-  },
-  {
-    name: 'sim_workflow',
-    agentId: 'workflow',
-    description:
-      'Manage workflow-level configuration: environment variables, settings, scheduling, and deployment status. Use for any data about a specific workflow — its settings, credentials, variables, or deployment state.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        request: { type: 'string' },
-        workflowId: { type: 'string' },
-        context: { type: 'object' },
-      },
-      required: ['request'],
-    },
-  },
-  {
-    name: 'sim_research',
-    agentId: 'research',
-    description:
-      'Research external APIs and documentation. Use when you need to understand third-party services, external APIs, authentication flows, or data formats OUTSIDE of Sim. For questions about Sim itself, use sim_info instead.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        request: { type: 'string' },
-        context: { type: 'object' },
-      },
-      required: ['request'],
-    },
-  },
-  {
-    name: 'sim_superagent',
-    agentId: 'superagent',
-    description:
-      'Execute direct actions NOW: send an email, post to Slack, make an API call, etc. Use when the user wants to DO something immediately rather than build a workflow for it.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        request: { type: 'string' },
-        context: { type: 'object' },
-      },
-      required: ['request'],
-    },
-  },
-  {
-    name: 'sim_platform',
-    agentId: 'tour',
-    description:
-      'Get help with Sim platform navigation, keyboard shortcuts, and UI actions. Use when the user asks "how do I..." about the Sim editor, wants keyboard shortcuts, or needs to know what actions are available in the UI.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        request: { type: 'string' },
-        context: { type: 'object' },
-      },
-      required: ['request'],
-    },
-  },
-]

apps/sim/lib/copilot/tools/server/blocks/get-block-config.ts

@@ -109,7 +109,7 @@ function resolveSubBlockOptions(sb: SubBlockConfig): string[] | undefined {
     return undefined
   }
 
-  // Return the actual option ID/value that edit_workflow expects, not the display label
+  // Return canonical option IDs/values expected by workflow_change compilation and apply
   return rawOptions
     .map((opt: any) => {
       if (!opt) return undefined

apps/sim/lib/copilot/tools/server/router.ts

@@ -11,8 +11,13 @@ import { makeApiRequestServerTool } from '@/lib/copilot/tools/server/other/make-
 import { searchOnlineServerTool } from '@/lib/copilot/tools/server/other/search-online'
 import { getCredentialsServerTool } from '@/lib/copilot/tools/server/user/get-credentials'
 import { setEnvironmentVariablesServerTool } from '@/lib/copilot/tools/server/user/set-environment-variables'
-import { editWorkflowServerTool } from '@/lib/copilot/tools/server/workflow/edit-workflow'
 import { getWorkflowConsoleServerTool } from '@/lib/copilot/tools/server/workflow/get-workflow-console'
+import { workflowChangeServerTool } from '@/lib/copilot/tools/server/workflow/workflow-change'
+import {
+  workflowContextExpandServerTool,
+  workflowContextGetServerTool,
+} from '@/lib/copilot/tools/server/workflow/workflow-context'
+import { workflowVerifyServerTool } from '@/lib/copilot/tools/server/workflow/workflow-verify'
 import { ExecuteResponseSuccessSchema } from '@/lib/copilot/tools/shared/schemas'
 
 export { ExecuteResponseSuccessSchema }
@@ -27,7 +32,6 @@ const serverToolRegistry: Record<string, BaseServerTool> = {
   [getBlockOptionsServerTool.name]: getBlockOptionsServerTool,
   [getBlockConfigServerTool.name]: getBlockConfigServerTool,
   [getTriggerBlocksServerTool.name]: getTriggerBlocksServerTool,
-  [editWorkflowServerTool.name]: editWorkflowServerTool,
   [getWorkflowConsoleServerTool.name]: getWorkflowConsoleServerTool,
   [searchDocumentationServerTool.name]: searchDocumentationServerTool,
   [searchOnlineServerTool.name]: searchOnlineServerTool,
@@ -35,6 +39,10 @@ const serverToolRegistry: Record<string, BaseServerTool> = {
   [getCredentialsServerTool.name]: getCredentialsServerTool,
   [makeApiRequestServerTool.name]: makeApiRequestServerTool,
   [knowledgeBaseServerTool.name]: knowledgeBaseServerTool,
+  [workflowContextGetServerTool.name]: workflowContextGetServerTool,
+  [workflowContextExpandServerTool.name]: workflowContextExpandServerTool,
+  [workflowChangeServerTool.name]: workflowChangeServerTool,
+  [workflowVerifyServerTool.name]: workflowVerifyServerTool,
 }
 
 /**

apps/sim/lib/copilot/tools/server/workflow/change-store.ts

@@ -0,0 +1,225 @@
+import crypto from 'crypto'
+import { createLogger } from '@sim/logger'
+import { getRedisClient } from '@/lib/core/config/redis'
+
+type StoreEntry<T> = {
+  value: T
+  expiresAt: number
+}
+
+const DEFAULT_TTL_MS = 30 * 60 * 1000
+const MAX_ENTRIES = 500
+const DEFAULT_TTL_SECONDS = Math.floor(DEFAULT_TTL_MS / 1000)
+const CONTEXT_PREFIX = 'copilot:workflow_change:context'
+const PROPOSAL_PREFIX = 'copilot:workflow_change:proposal'
+
+const logger = createLogger('WorkflowChangeStore')
+
+class TTLStore<T> {
+  private readonly data = new Map<string, StoreEntry<T>>()
+
+  constructor(private readonly ttlMs = DEFAULT_TTL_MS) {}
+
+  set(value: T): string {
+    this.gc()
+    if (this.data.size >= MAX_ENTRIES) {
+      const firstKey = this.data.keys().next().value as string | undefined
+      if (firstKey) {
+        this.data.delete(firstKey)
+      }
+    }
+    const id = crypto.randomUUID()
+    this.data.set(id, {
+      value,
+      expiresAt: Date.now() + this.ttlMs,
+    })
+    return id
+  }
+
+  get(id: string): T | null {
+    const entry = this.data.get(id)
+    if (!entry) return null
+    if (entry.expiresAt <= Date.now()) {
+      this.data.delete(id)
+      return null
+    }
+    return entry.value
+  }
+
+  upsert(id: string, value: T): void {
+    this.gc()
+    this.data.set(id, {
+      value,
+      expiresAt: Date.now() + this.ttlMs,
+    })
+  }
+
+  private gc(): void {
+    const now = Date.now()
+    for (const [key, entry] of this.data.entries()) {
+      if (entry.expiresAt <= now) {
+        this.data.delete(key)
+      }
+    }
+  }
+}
+
+export type WorkflowContextPack = {
+  workflowId: string
+  snapshotHash: string
+  workflowState: {
+    blocks: Record<string, any>
+    edges: Array<Record<string, any>>
+    loops: Record<string, any>
+    parallels: Record<string, any>
+  }
+  schemasByType: Record<string, any>
+  schemaRefsByType: Record<string, string>
+  summary: Record<string, any>
+}
+
+export type WorkflowChangeProposal = {
+  workflowId: string
+  baseSnapshotHash: string
+  compiledOperations: Array<Record<string, any>>
+  diffSummary: Record<string, any>
+  warnings: string[]
+  diagnostics: string[]
+  touchedBlocks: string[]
+  resolvedIds?: Record<string, string>
+  acceptanceAssertions: string[]
+  postApply?: {
+    verify?: boolean
+    run?: Record<string, any>
+    evaluator?: Record<string, any>
+  }
+  handoff?: {
+    objective?: string
+    constraints?: string[]
+    resolvedIds?: Record<string, string>
+    assumptions?: string[]
+    unresolvedRisks?: string[]
+  }
+}
+
+const contextPackStore = new TTLStore<WorkflowContextPack>()
+const proposalStore = new TTLStore<WorkflowChangeProposal>()
+
+function getContextRedisKey(id: string): string {
+  return `${CONTEXT_PREFIX}:${id}`
+}
+
+function getProposalRedisKey(id: string): string {
+  return `${PROPOSAL_PREFIX}:${id}`
+}
+
+async function writeRedisJson(key: string, value: unknown): Promise<void> {
+  const redis = getRedisClient()!
+  await redis.set(key, JSON.stringify(value), 'EX', DEFAULT_TTL_SECONDS)
+}
+
+async function readRedisJson<T>(key: string): Promise<T | null> {
+  const redis = getRedisClient()!
+
+  const raw = await redis.get(key)
+  if (!raw) {
+    return null
+  }
+
+  try {
+    return JSON.parse(raw) as T
+  } catch (error) {
+    logger.warn('Failed parsing workflow change store JSON payload', { key, error })
+    await redis.del(key).catch(() => {})
+    return null
+  }
+}
+
+export async function saveContextPack(pack: WorkflowContextPack): Promise<string> {
+  if (!getRedisClient()) {
+    return contextPackStore.set(pack)
+  }
+  const id = crypto.randomUUID()
+  try {
+    await writeRedisJson(getContextRedisKey(id), pack)
+    return id
+  } catch (error) {
+    logger.warn('Redis write failed for workflow context pack, using memory fallback', { error })
+    return contextPackStore.set(pack)
+  }
+}
+
+export async function getContextPack(id: string): Promise<WorkflowContextPack | null> {
+  if (!getRedisClient()) {
+    return contextPackStore.get(id)
+  }
+  try {
+    const redisPayload = await readRedisJson<WorkflowContextPack>(getContextRedisKey(id))
+    if (redisPayload) {
+      return redisPayload
+    }
+  } catch (error) {
+    logger.warn('Redis read failed for workflow context pack, using memory fallback', { error })
+  }
+  return contextPackStore.get(id)
+}
+
+export async function updateContextPack(
+  id: string,
+  patch: Partial<WorkflowContextPack>
+): Promise<WorkflowContextPack | null> {
+  const existing = await getContextPack(id)
+  if (!existing) return null
+  const merged: WorkflowContextPack = {
+    ...existing,
+    ...patch,
+    workflowState: patch.workflowState || existing.workflowState,
+    schemasByType: patch.schemasByType || existing.schemasByType,
+    schemaRefsByType: patch.schemaRefsByType || existing.schemaRefsByType,
+    summary: patch.summary || existing.summary,
+  }
+
+  if (!getRedisClient()) {
+    contextPackStore.upsert(id, merged)
+    return merged
+  }
+
+  try {
+    await writeRedisJson(getContextRedisKey(id), merged)
+    contextPackStore.upsert(id, merged)
+    return merged
+  } catch (error) {
+    logger.warn('Redis update failed for workflow context pack, using memory fallback', { error })
+    contextPackStore.upsert(id, merged)
+    return merged
+  }
+}
+
+export async function saveProposal(proposal: WorkflowChangeProposal): Promise<string> {
+  if (!getRedisClient()) {
+    return proposalStore.set(proposal)
+  }
+  const id = crypto.randomUUID()
+  try {
+    await writeRedisJson(getProposalRedisKey(id), proposal)
+    return id
+  } catch (error) {
+    logger.warn('Redis write failed for workflow proposal, using memory fallback', { error })
+    return proposalStore.set(proposal)
+  }
+}
+
+export async function getProposal(id: string): Promise<WorkflowChangeProposal | null> {
+  if (!getRedisClient()) {
+    return proposalStore.get(id)
+  }
+  try {
+    const redisPayload = await readRedisJson<WorkflowChangeProposal>(getProposalRedisKey(id))
+    if (redisPayload) {
+      return redisPayload
+    }
+  } catch (error) {
+    logger.warn('Redis read failed for workflow proposal, using memory fallback', { error })
+  }
+  return proposalStore.get(id)
+}

apps/sim/lib/copilot/tools/server/workflow/edit-workflow/index.ts

@@ -1,298 +0,0 @@
-import { db } from '@sim/db'
-import { workflow as workflowTable } from '@sim/db/schema'
-import { createLogger } from '@sim/logger'
-import { eq } from 'drizzle-orm'
-import type { BaseServerTool } from '@/lib/copilot/tools/server/base-tool'
-import { applyAutoLayout } from '@/lib/workflows/autolayout'
-import { extractAndPersistCustomTools } from '@/lib/workflows/persistence/custom-tools-persistence'
-import {
-  loadWorkflowFromNormalizedTables,
-  saveWorkflowToNormalizedTables,
-} from '@/lib/workflows/persistence/utils'
-import { validateWorkflowState } from '@/lib/workflows/sanitization/validation'
-import { authorizeWorkflowByWorkspacePermission } from '@/lib/workflows/utils'
-import { getUserPermissionConfig } from '@/ee/access-control/utils/permission-check'
-import { generateLoopBlocks, generateParallelBlocks } from '@/stores/workflows/workflow/utils'
-import { applyOperationsToWorkflowState } from './engine'
-import type { EditWorkflowParams, ValidationError } from './types'
-import { preValidateCredentialInputs, validateWorkflowSelectorIds } from './validation'
-
-async function getCurrentWorkflowStateFromDb(
-  workflowId: string
-): Promise<{ workflowState: any; subBlockValues: Record<string, Record<string, any>> }> {
-  const logger = createLogger('EditWorkflowServerTool')
-  const [workflowRecord] = await db
-    .select()
-    .from(workflowTable)
-    .where(eq(workflowTable.id, workflowId))
-    .limit(1)
-  if (!workflowRecord) throw new Error(`Workflow ${workflowId} not found in database`)
-  const normalized = await loadWorkflowFromNormalizedTables(workflowId)
-  if (!normalized) throw new Error('Workflow has no normalized data')
-
-  // Validate and fix blocks without types
-  const blocks = { ...normalized.blocks }
-  const invalidBlocks: string[] = []
-
-  Object.entries(blocks).forEach(([id, block]: [string, any]) => {
-    if (!block.type) {
-      logger.warn(`Block ${id} loaded without type from database`, {
-        blockKeys: Object.keys(block),
-        blockName: block.name,
-      })
-      invalidBlocks.push(id)
-    }
-  })
-
-  // Remove invalid blocks
-  invalidBlocks.forEach((id) => delete blocks[id])
-
-  // Remove edges connected to invalid blocks
-  const edges = normalized.edges.filter(
-    (edge: any) => !invalidBlocks.includes(edge.source) && !invalidBlocks.includes(edge.target)
-  )
-
-  const workflowState: any = {
-    blocks,
-    edges,
-    loops: normalized.loops || {},
-    parallels: normalized.parallels || {},
-  }
-  const subBlockValues: Record<string, Record<string, any>> = {}
-  Object.entries(normalized.blocks).forEach(([blockId, block]) => {
-    subBlockValues[blockId] = {}
-    Object.entries((block as any).subBlocks || {}).forEach(([subId, sub]) => {
-      if ((sub as any).value !== undefined) subBlockValues[blockId][subId] = (sub as any).value
-    })
-  })
-  return { workflowState, subBlockValues }
-}
-
-export const editWorkflowServerTool: BaseServerTool<EditWorkflowParams, unknown> = {
-  name: 'edit_workflow',
-  async execute(params: EditWorkflowParams, context?: { userId: string }): Promise<unknown> {
-    const logger = createLogger('EditWorkflowServerTool')
-    const { operations, workflowId, currentUserWorkflow } = params
-    if (!Array.isArray(operations) || operations.length === 0) {
-      throw new Error('operations are required and must be an array')
-    }
-    if (!workflowId) throw new Error('workflowId is required')
-    if (!context?.userId) {
-      throw new Error('Unauthorized workflow access')
-    }
-
-    const authorization = await authorizeWorkflowByWorkspacePermission({
-      workflowId,
-      userId: context.userId,
-      action: 'write',
-    })
-    if (!authorization.allowed) {
-      throw new Error(authorization.message || 'Unauthorized workflow access')
-    }
-
-    logger.info('Executing edit_workflow', {
-      operationCount: operations.length,
-      workflowId,
-      hasCurrentUserWorkflow: !!currentUserWorkflow,
-    })
-
-    // Get current workflow state
-    let workflowState: any
-    if (currentUserWorkflow) {
-      try {
-        workflowState = JSON.parse(currentUserWorkflow)
-      } catch (error) {
-        logger.error('Failed to parse currentUserWorkflow', error)
-        throw new Error('Invalid currentUserWorkflow format')
-      }
-    } else {
-      const fromDb = await getCurrentWorkflowStateFromDb(workflowId)
-      workflowState = fromDb.workflowState
-    }
-
-    // Get permission config for the user
-    const permissionConfig = context?.userId ? await getUserPermissionConfig(context.userId) : null
-
-    // Pre-validate credential and apiKey inputs before applying operations
-    // This filters out invalid credentials and apiKeys for hosted models
-    let operationsToApply = operations
-    const credentialErrors: ValidationError[] = []
-    if (context?.userId) {
-      const { filteredOperations, errors: credErrors } = await preValidateCredentialInputs(
-        operations,
-        { userId: context.userId },
-        workflowState
-      )
-      operationsToApply = filteredOperations
-      credentialErrors.push(...credErrors)
-    }
-
-    // Apply operations directly to the workflow state
-    const {
-      state: modifiedWorkflowState,
-      validationErrors,
-      skippedItems,
-    } = applyOperationsToWorkflowState(workflowState, operationsToApply, permissionConfig)
-
-    // Add credential validation errors
-    validationErrors.push(...credentialErrors)
-
-    // Get workspaceId for selector validation
-    let workspaceId: string | undefined
-    try {
-      const [workflowRecord] = await db
-        .select({ workspaceId: workflowTable.workspaceId })
-        .from(workflowTable)
-        .where(eq(workflowTable.id, workflowId))
-        .limit(1)
-      workspaceId = workflowRecord?.workspaceId ?? undefined
-    } catch (error) {
-      logger.warn('Failed to get workspaceId for selector validation', { error, workflowId })
-    }
-
-    // Validate selector IDs exist in the database
-    if (context?.userId) {
-      try {
-        const selectorErrors = await validateWorkflowSelectorIds(modifiedWorkflowState, {
-          userId: context.userId,
-          workspaceId,
-        })
-        validationErrors.push(...selectorErrors)
-      } catch (error) {
-        logger.warn('Selector ID validation failed', {
-          error: error instanceof Error ? error.message : String(error),
-        })
-      }
-    }
-
-    // Validate the workflow state
-    const validation = validateWorkflowState(modifiedWorkflowState, { sanitize: true })
-
-    if (!validation.valid) {
-      logger.error('Edited workflow state is invalid', {
-        errors: validation.errors,
-        warnings: validation.warnings,
-      })
-      throw new Error(`Invalid edited workflow: ${validation.errors.join('; ')}`)
-    }
-
-    if (validation.warnings.length > 0) {
-      logger.warn('Edited workflow validation warnings', {
-        warnings: validation.warnings,
-      })
-    }
-
-    // Extract and persist custom tools to database (reuse workspaceId from selector validation)
-    if (context?.userId && workspaceId) {
-      try {
-        const finalWorkflowState = validation.sanitizedState || modifiedWorkflowState
-        const { saved, errors } = await extractAndPersistCustomTools(
-          finalWorkflowState,
-          workspaceId,
-          context.userId
-        )
-
-        if (saved > 0) {
-          logger.info(`Persisted ${saved} custom tool(s) to database`, { workflowId })
-        }
-
-        if (errors.length > 0) {
-          logger.warn('Some custom tools failed to persist', { errors, workflowId })
-        }
-      } catch (error) {
-        logger.error('Failed to persist custom tools', { error, workflowId })
-      }
-    } else if (context?.userId && !workspaceId) {
-      logger.warn('Workflow has no workspaceId, skipping custom tools persistence', {
-        workflowId,
-      })
-    } else {
-      logger.warn('No userId in context - skipping custom tools persistence', { workflowId })
-    }
-
-    logger.info('edit_workflow successfully applied operations', {
-      operationCount: operations.length,
-      blocksCount: Object.keys(modifiedWorkflowState.blocks).length,
-      edgesCount: modifiedWorkflowState.edges.length,
-      inputValidationErrors: validationErrors.length,
-      skippedItemsCount: skippedItems.length,
-      schemaValidationErrors: validation.errors.length,
-      validationWarnings: validation.warnings.length,
-    })
-
-    // Format validation errors for LLM feedback
-    const inputErrors =
-      validationErrors.length > 0
-        ? validationErrors.map((e) => `Block "${e.blockId}" (${e.blockType}): ${e.error}`)
-        : undefined
-
-    // Format skipped items for LLM feedback
-    const skippedMessages =
-      skippedItems.length > 0 ? skippedItems.map((item) => item.reason) : undefined
-
-    // Persist the workflow state to the database
-    const finalWorkflowState = validation.sanitizedState || modifiedWorkflowState
-
-    // Apply autolayout to position blocks properly
-    const layoutResult = applyAutoLayout(finalWorkflowState.blocks, finalWorkflowState.edges, {
-      horizontalSpacing: 250,
-      verticalSpacing: 100,
-      padding: { x: 100, y: 100 },
-    })
-
-    const layoutedBlocks =
-      layoutResult.success && layoutResult.blocks ? layoutResult.blocks : finalWorkflowState.blocks
-
-    if (!layoutResult.success) {
-      logger.warn('Autolayout failed, using default positions', {
-        workflowId,
-        error: layoutResult.error,
-      })
-    }
-
-    const workflowStateForDb = {
-      blocks: layoutedBlocks,
-      edges: finalWorkflowState.edges,
-      loops: generateLoopBlocks(layoutedBlocks as any),
-      parallels: generateParallelBlocks(layoutedBlocks as any),
-      lastSaved: Date.now(),
-      isDeployed: false,
-    }
-
-    const saveResult = await saveWorkflowToNormalizedTables(workflowId, workflowStateForDb as any)
-    if (!saveResult.success) {
-      logger.error('Failed to persist workflow state to database', {
-        workflowId,
-        error: saveResult.error,
-      })
-      throw new Error(`Failed to save workflow: ${saveResult.error}`)
-    }
-
-    // Update workflow's lastSynced timestamp
-    await db
-      .update(workflowTable)
-      .set({
-        lastSynced: new Date(),
-        updatedAt: new Date(),
-      })
-      .where(eq(workflowTable.id, workflowId))
-
-    logger.info('Workflow state persisted to database', { workflowId })
-
-    // Return the modified workflow state with autolayout applied
-    return {
-      success: true,
-      workflowState: { ...finalWorkflowState, blocks: layoutedBlocks },
-      // Include input validation errors so the LLM can see what was rejected
-      ...(inputErrors && {
-        inputValidationErrors: inputErrors,
-        inputValidationMessage: `${inputErrors.length} input(s) were rejected due to validation errors. The workflow was still updated with valid inputs only. Errors: ${inputErrors.join('; ')}`,
-      }),
-      // Include skipped items so the LLM can see what operations were skipped
-      ...(skippedMessages && {
-        skippedItems: skippedMessages,
-        skippedItemsMessage: `${skippedItems.length} operation(s) were skipped due to invalid references. Details: ${skippedMessages.join('; ')}`,
-      }),
-    }
-  },
-}

apps/sim/lib/copilot/tools/server/workflow/workflow-context.ts

@@ -0,0 +1,272 @@
+import { createLogger } from '@sim/logger'
+import { z } from 'zod'
+import type { BaseServerTool } from '@/lib/copilot/tools/server/base-tool'
+import { authorizeWorkflowByWorkspacePermission } from '@/lib/workflows/utils'
+import { getBlock } from '@/blocks/registry'
+import { getContextPack, saveContextPack, updateContextPack } from './change-store'
+import {
+  buildSchemasByType,
+  getAllKnownBlockTypes,
+  hashWorkflowState,
+  loadWorkflowStateFromDb,
+  summarizeWorkflowState,
+} from './workflow-state'
+
+const logger = createLogger('WorkflowContextServerTool')
+
+const WorkflowContextGetInputSchema = z.object({
+  workflowId: z.string(),
+  objective: z.string().optional(),
+  includeBlockTypes: z.array(z.string()).optional(),
+  includeAllSchemas: z.boolean().optional(),
+  schemaMode: z.enum(['minimal', 'workflow', 'all']).optional(),
+})
+
+type WorkflowContextGetParams = z.infer<typeof WorkflowContextGetInputSchema>
+
+const WorkflowContextExpandInputSchema = z.object({
+  contextPackId: z.string(),
+  blockTypes: z.array(z.string()).optional(),
+  schemaRefs: z.array(z.string()).optional(),
+})
+
+type WorkflowContextExpandParams = z.infer<typeof WorkflowContextExpandInputSchema>
+
+const BLOCK_TYPE_ALIAS_MAP: Record<string, string> = {
+  start: 'start_trigger',
+  starttrigger: 'start_trigger',
+  starter: 'start_trigger',
+  trigger: 'start_trigger',
+  loop: 'loop',
+  parallel: 'parallel',
+  parallelai: 'parallel',
+  hitl: 'human_in_the_loop',
+  humanintheloop: 'human_in_the_loop',
+  routerv2: 'router_v2',
+}
+
+function normalizeToken(value: string): string {
+  return value
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '')
+}
+
+function buildBlockTypeIndex(knownTypes: string[]): Map<string, string> {
+  const index = new Map<string, string>()
+  for (const blockType of knownTypes) {
+    const canonicalType = String(blockType || '').trim()
+    if (!canonicalType) continue
+
+    const normalizedType = normalizeToken(canonicalType)
+    if (normalizedType && !index.has(normalizedType)) {
+      index.set(normalizedType, canonicalType)
+    }
+
+    const blockConfig = getBlock(canonicalType)
+    const displayName = String(blockConfig?.name || '').trim()
+    const normalizedDisplayName = normalizeToken(displayName)
+    if (normalizedDisplayName && !index.has(normalizedDisplayName)) {
+      index.set(normalizedDisplayName, canonicalType)
+    }
+  }
+  return index
+}
+
+function resolveBlockTypes(
+  requestedBlockTypes: string[],
+  knownTypes: string[]
+): { resolved: string[]; unresolved: string[] } {
+  const index = buildBlockTypeIndex(knownTypes)
+  const resolved = new Set<string>()
+  const unresolved = new Set<string>()
+
+  for (const rawType of requestedBlockTypes) {
+    const normalized = normalizeToken(String(rawType || ''))
+    if (!normalized) continue
+
+    const aliasResolved = BLOCK_TYPE_ALIAS_MAP[normalized]
+    if (aliasResolved) {
+      resolved.add(aliasResolved)
+      continue
+    }
+
+    const direct = index.get(normalized)
+    if (direct) {
+      resolved.add(direct)
+      continue
+    }
+
+    unresolved.add(String(rawType))
+  }
+
+  return {
+    resolved: [...resolved],
+    unresolved: [...unresolved],
+  }
+}
+
+function parseSchemaRefToBlockType(schemaRef: string): string | null {
+  if (!schemaRef) return null
+  const [blockType] = schemaRef.split('@')
+  return blockType || null
+}
+
+function buildAvailableBlockCatalog(
+  schemaRefsByType: Record<string, string>
+): Array<Record<string, any>> {
+  return Object.entries(schemaRefsByType)
+    .sort((a, b) => a[0].localeCompare(b[0]))
+    .map(([blockType, schemaRef]) => ({
+      blockType,
+      schemaRef,
+    }))
+}
+
+export const workflowContextGetServerTool: BaseServerTool<WorkflowContextGetParams, any> = {
+  name: 'workflow_context_get',
+  inputSchema: WorkflowContextGetInputSchema,
+  async execute(params: WorkflowContextGetParams, context?: { userId: string }): Promise<any> {
+    if (!context?.userId) {
+      throw new Error('Unauthorized workflow access')
+    }
+
+    const authorization = await authorizeWorkflowByWorkspacePermission({
+      workflowId: params.workflowId,
+      userId: context.userId,
+      action: 'read',
+    })
+    if (!authorization.allowed) {
+      throw new Error(authorization.message || 'Unauthorized workflow access')
+    }
+
+    const { workflowState } = await loadWorkflowStateFromDb(params.workflowId)
+    const snapshotHash = hashWorkflowState(workflowState as unknown as Record<string, unknown>)
+
+    const knownTypes = getAllKnownBlockTypes()
+    const blockTypesInWorkflowRaw = Object.values(workflowState.blocks || {}).map((block: any) =>
+      String(block?.type || '')
+    )
+    const requestedTypesRaw = params.includeBlockTypes || []
+    const resolvedWorkflowTypes = resolveBlockTypes(blockTypesInWorkflowRaw, knownTypes).resolved
+    const resolvedRequestedTypes = resolveBlockTypes(requestedTypesRaw, knownTypes)
+    const schemaMode =
+      params.includeAllSchemas === true ? 'all' : (params.schemaMode || 'minimal')
+    const candidateTypes =
+      schemaMode === 'all'
+        ? knownTypes
+        : schemaMode === 'workflow'
+          ? [...resolvedWorkflowTypes, ...resolvedRequestedTypes.resolved]
+          : [...resolvedRequestedTypes.resolved]
+    const { schemasByType, schemaRefsByType } = buildSchemasByType(candidateTypes)
+    const suggestedSchemaTypes = [...new Set(resolvedWorkflowTypes.filter(Boolean))]
+
+    const summary = summarizeWorkflowState(workflowState)
+    const packId = await saveContextPack({
+      workflowId: params.workflowId,
+      snapshotHash,
+      workflowState,
+      schemasByType,
+      schemaRefsByType,
+      summary: {
+        ...summary,
+        objective: params.objective || null,
+      },
+    })
+
+    logger.info('Generated workflow context pack', {
+      workflowId: params.workflowId,
+      contextPackId: packId,
+      schemaCount: Object.keys(schemaRefsByType).length,
+    })
+
+    return {
+      success: true,
+      contextPackId: packId,
+      workflowId: params.workflowId,
+      snapshotHash,
+      schemaMode,
+      summary: {
+        ...summary,
+        objective: params.objective || null,
+      },
+      schemaRefsByType,
+      availableBlockCatalog: buildAvailableBlockCatalog(schemaRefsByType),
+      suggestedSchemaTypes,
+      unresolvedRequestedBlockTypes: resolvedRequestedTypes.unresolved,
+      knownBlockTypes: knownTypes,
+      inScopeSchemas: schemasByType,
+    }
+  },
+}
+
+export const workflowContextExpandServerTool: BaseServerTool<WorkflowContextExpandParams, any> = {
+  name: 'workflow_context_expand',
+  inputSchema: WorkflowContextExpandInputSchema,
+  async execute(params: WorkflowContextExpandParams, context?: { userId: string }): Promise<any> {
+    if (!context?.userId) {
+      throw new Error('Unauthorized workflow access')
+    }
+
+    const contextPack = await getContextPack(params.contextPackId)
+    if (!contextPack) {
+      throw new Error(`Context pack not found or expired: ${params.contextPackId}`)
+    }
+
+    const authorization = await authorizeWorkflowByWorkspacePermission({
+      workflowId: contextPack.workflowId,
+      userId: context.userId,
+      action: 'read',
+    })
+    if (!authorization.allowed) {
+      throw new Error(authorization.message || 'Unauthorized workflow access')
+    }
+
+    const knownTypes = getAllKnownBlockTypes()
+    const requestedBlockTypesRaw = new Set<string>()
+    for (const blockType of params.blockTypes || []) {
+      if (blockType) requestedBlockTypesRaw.add(String(blockType))
+    }
+    for (const schemaRef of params.schemaRefs || []) {
+      const blockType = parseSchemaRefToBlockType(schemaRef)
+      if (blockType) requestedBlockTypesRaw.add(blockType)
+    }
+
+    const resolvedTypes = resolveBlockTypes([...requestedBlockTypesRaw], knownTypes)
+    const typesToExpand = resolvedTypes.resolved
+    const { schemasByType, schemaRefsByType } = buildSchemasByType(typesToExpand)
+    const mergedSchemasByType = {
+      ...(contextPack.schemasByType || {}),
+      ...schemasByType,
+    }
+    const mergedSchemaRefsByType = {
+      ...(contextPack.schemaRefsByType || {}),
+      ...schemaRefsByType,
+    }
+    const updatedContextPack = await updateContextPack(params.contextPackId, {
+      schemasByType: mergedSchemasByType,
+      schemaRefsByType: mergedSchemaRefsByType,
+    })
+    const warnings =
+      resolvedTypes.unresolved.length > 0
+        ? [
+            `Unknown block type(s): ${resolvedTypes.unresolved.join(', ')}. ` +
+              'Use known block type IDs from knownBlockTypes.',
+          ]
+        : []
+
+    return {
+      success: true,
+      contextPackId: params.contextPackId,
+      workflowId: contextPack.workflowId,
+      snapshotHash: contextPack.snapshotHash,
+      schemasByType,
+      schemaRefsByType,
+      loadedSchemaTypes: Object.keys(updatedContextPack?.schemasByType || mergedSchemasByType).sort(),
+      resolvedBlockTypes: resolvedTypes.resolved,
+      unresolvedBlockTypes: resolvedTypes.unresolved,
+      knownBlockTypes: knownTypes,
+      warnings,
+    }
+  },
+}

apps/sim/lib/copilot/tools/server/workflow/workflow-operations/apply.ts

@@ -0,0 +1,286 @@
+import { db } from '@sim/db'
+import { workflow as workflowTable } from '@sim/db/schema'
+import { createLogger } from '@sim/logger'
+import { eq } from 'drizzle-orm'
+import { applyAutoLayout } from '@/lib/workflows/autolayout'
+import { extractAndPersistCustomTools } from '@/lib/workflows/persistence/custom-tools-persistence'
+import {
+  loadWorkflowFromNormalizedTables,
+  saveWorkflowToNormalizedTables,
+} from '@/lib/workflows/persistence/utils'
+import { validateWorkflowState } from '@/lib/workflows/sanitization/validation'
+import { authorizeWorkflowByWorkspacePermission } from '@/lib/workflows/utils'
+import { getUserPermissionConfig } from '@/ee/access-control/utils/permission-check'
+import { generateLoopBlocks, generateParallelBlocks } from '@/stores/workflows/workflow/utils'
+import { applyOperationsToWorkflowState } from './engine'
+import type { EditWorkflowOperation, ValidationError } from './types'
+import { preValidateCredentialInputs, validateWorkflowSelectorIds } from './validation'
+
+type ApplyWorkflowOperationsParams = {
+  operations: EditWorkflowOperation[]
+  workflowId: string
+  userId: string
+  currentUserWorkflow?: string
+}
+
+async function getCurrentWorkflowStateFromDb(
+  workflowId: string
+): Promise<{ workflowState: any; subBlockValues: Record<string, Record<string, any>> }> {
+  const logger = createLogger('WorkflowOperationApply')
+  const [workflowRecord] = await db
+    .select()
+    .from(workflowTable)
+    .where(eq(workflowTable.id, workflowId))
+    .limit(1)
+  if (!workflowRecord) throw new Error(`Workflow ${workflowId} not found in database`)
+  const normalized = await loadWorkflowFromNormalizedTables(workflowId)
+  if (!normalized) throw new Error('Workflow has no normalized data')
+
+  // Validate and fix blocks without types
+  const blocks = { ...normalized.blocks }
+  const invalidBlocks: string[] = []
+
+  Object.entries(blocks).forEach(([id, block]: [string, any]) => {
+    if (!block.type) {
+      logger.warn(`Block ${id} loaded without type from database`, {
+        blockKeys: Object.keys(block),
+        blockName: block.name,
+      })
+      invalidBlocks.push(id)
+    }
+  })
+
+  // Remove invalid blocks
+  invalidBlocks.forEach((id) => delete blocks[id])
+
+  // Remove edges connected to invalid blocks
+  const edges = normalized.edges.filter(
+    (edge: any) => !invalidBlocks.includes(edge.source) && !invalidBlocks.includes(edge.target)
+  )
+
+  const workflowState: any = {
+    blocks,
+    edges,
+    loops: normalized.loops || {},
+    parallels: normalized.parallels || {},
+  }
+  const subBlockValues: Record<string, Record<string, any>> = {}
+  Object.entries(normalized.blocks).forEach(([blockId, block]) => {
+    subBlockValues[blockId] = {}
+    Object.entries((block as any).subBlocks || {}).forEach(([subId, sub]) => {
+      if ((sub as any).value !== undefined) subBlockValues[blockId][subId] = (sub as any).value
+    })
+  })
+  return { workflowState, subBlockValues }
+}
+
+export async function applyWorkflowOperations(params: ApplyWorkflowOperationsParams): Promise<any> {
+  const logger = createLogger('WorkflowOperationApply')
+  const { operations, workflowId, currentUserWorkflow, userId } = params
+  if (!Array.isArray(operations) || operations.length === 0) {
+    throw new Error('operations are required and must be an array')
+  }
+  if (!workflowId) throw new Error('workflowId is required')
+  if (!userId) throw new Error('Unauthorized workflow access')
+
+  const authorization = await authorizeWorkflowByWorkspacePermission({
+    workflowId,
+    userId,
+    action: 'write',
+  })
+  if (!authorization.allowed) {
+    throw new Error(authorization.message || 'Unauthorized workflow access')
+  }
+
+  logger.info('Executing workflow operation apply', {
+    operationCount: operations.length,
+    workflowId,
+    hasCurrentUserWorkflow: !!currentUserWorkflow,
+  })
+
+  // Get current workflow state
+  let workflowState: any
+  if (currentUserWorkflow) {
+    try {
+      workflowState = JSON.parse(currentUserWorkflow)
+    } catch (error) {
+      logger.error('Failed to parse currentUserWorkflow', error)
+      throw new Error('Invalid currentUserWorkflow format')
+    }
+  } else {
+    const fromDb = await getCurrentWorkflowStateFromDb(workflowId)
+    workflowState = fromDb.workflowState
+  }
+
+  // Get permission config for the user
+  const permissionConfig = await getUserPermissionConfig(userId)
+
+  // Pre-validate credential and apiKey inputs before applying operations
+  // This filters out invalid credentials and apiKeys for hosted models
+  let operationsToApply = operations
+  const credentialErrors: ValidationError[] = []
+  const { filteredOperations, errors: credErrors } = await preValidateCredentialInputs(
+    operations,
+    { userId },
+    workflowState
+  )
+  operationsToApply = filteredOperations
+  credentialErrors.push(...credErrors)
+
+  // Apply operations directly to the workflow state
+  const {
+    state: modifiedWorkflowState,
+    validationErrors,
+    skippedItems,
+  } = applyOperationsToWorkflowState(workflowState, operationsToApply, permissionConfig)
+
+  // Add credential validation errors
+  validationErrors.push(...credentialErrors)
+
+  // Get workspaceId for selector validation
+  let workspaceId: string | undefined
+  try {
+    const [workflowRecord] = await db
+      .select({ workspaceId: workflowTable.workspaceId })
+      .from(workflowTable)
+      .where(eq(workflowTable.id, workflowId))
+      .limit(1)
+    workspaceId = workflowRecord?.workspaceId ?? undefined
+  } catch (error) {
+    logger.warn('Failed to get workspaceId for selector validation', { error, workflowId })
+  }
+
+  // Validate selector IDs exist in the database
+  try {
+    const selectorErrors = await validateWorkflowSelectorIds(modifiedWorkflowState, {
+      userId,
+      workspaceId,
+    })
+    validationErrors.push(...selectorErrors)
+  } catch (error) {
+    logger.warn('Selector ID validation failed', {
+      error: error instanceof Error ? error.message : String(error),
+    })
+  }
+
+  // Validate the workflow state
+  const validation = validateWorkflowState(modifiedWorkflowState, { sanitize: true })
+
+  if (!validation.valid) {
+    logger.error('Edited workflow state is invalid', {
+      errors: validation.errors,
+      warnings: validation.warnings,
+    })
+    throw new Error(`Invalid edited workflow: ${validation.errors.join('; ')}`)
+  }
+
+  if (validation.warnings.length > 0) {
+    logger.warn('Edited workflow validation warnings', {
+      warnings: validation.warnings,
+    })
+  }
+
+  // Extract and persist custom tools to database (reuse workspaceId from selector validation)
+  if (workspaceId) {
+    try {
+      const finalWorkflowState = validation.sanitizedState || modifiedWorkflowState
+      const { saved, errors } = await extractAndPersistCustomTools(finalWorkflowState, workspaceId, userId)
+
+      if (saved > 0) {
+        logger.info(`Persisted ${saved} custom tool(s) to database`, { workflowId })
+      }
+
+      if (errors.length > 0) {
+        logger.warn('Some custom tools failed to persist', { errors, workflowId })
+      }
+    } catch (error) {
+      logger.error('Failed to persist custom tools', { error, workflowId })
+    }
+  } else {
+    logger.warn('Workflow has no workspaceId, skipping custom tools persistence', {
+      workflowId,
+    })
+  }
+
+  logger.info('Workflow operation apply succeeded', {
+    operationCount: operations.length,
+    blocksCount: Object.keys(modifiedWorkflowState.blocks).length,
+    edgesCount: modifiedWorkflowState.edges.length,
+    inputValidationErrors: validationErrors.length,
+    skippedItemsCount: skippedItems.length,
+    schemaValidationErrors: validation.errors.length,
+    validationWarnings: validation.warnings.length,
+  })
+
+  // Format validation errors for LLM feedback
+  const inputErrors =
+    validationErrors.length > 0
+      ? validationErrors.map((e) => `Block "${e.blockId}" (${e.blockType}): ${e.error}`)
+      : undefined
+
+  // Format skipped items for LLM feedback
+  const skippedMessages =
+    skippedItems.length > 0 ? skippedItems.map((item) => item.reason) : undefined
+
+  // Persist the workflow state to the database
+  const finalWorkflowState = validation.sanitizedState || modifiedWorkflowState
+
+  // Apply autolayout to position blocks properly
+  const layoutResult = applyAutoLayout(finalWorkflowState.blocks, finalWorkflowState.edges, {
+    horizontalSpacing: 250,
+    verticalSpacing: 100,
+    padding: { x: 100, y: 100 },
+  })
+
+  const layoutedBlocks =
+    layoutResult.success && layoutResult.blocks ? layoutResult.blocks : finalWorkflowState.blocks
+
+  if (!layoutResult.success) {
+    logger.warn('Autolayout failed, using default positions', {
+      workflowId,
+      error: layoutResult.error,
+    })
+  }
+
+  const workflowStateForDb = {
+    blocks: layoutedBlocks,
+    edges: finalWorkflowState.edges,
+    loops: generateLoopBlocks(layoutedBlocks as any),
+    parallels: generateParallelBlocks(layoutedBlocks as any),
+    lastSaved: Date.now(),
+    isDeployed: false,
+  }
+
+  const saveResult = await saveWorkflowToNormalizedTables(workflowId, workflowStateForDb as any)
+  if (!saveResult.success) {
+    logger.error('Failed to persist workflow state to database', {
+      workflowId,
+      error: saveResult.error,
+    })
+    throw new Error(`Failed to save workflow: ${saveResult.error}`)
+  }
+
+  // Update workflow's lastSynced timestamp
+  await db
+    .update(workflowTable)
+    .set({
+      lastSynced: new Date(),
+      updatedAt: new Date(),
+    })
+    .where(eq(workflowTable.id, workflowId))
+
+  logger.info('Workflow state persisted to database', { workflowId })
+
+  return {
+    success: true,
+    workflowState: { ...finalWorkflowState, blocks: layoutedBlocks },
+    ...(inputErrors && {
+      inputValidationErrors: inputErrors,
+      inputValidationMessage: `${inputErrors.length} input(s) were rejected due to validation errors. The workflow was still updated with valid inputs only. Errors: ${inputErrors.join('; ')}`,
+    }),
+    ...(skippedMessages && {
+      skippedItems: skippedMessages,
+      skippedItemsMessage: `${skippedItems.length} operation(s) were skipped due to invalid references. Details: ${skippedMessages.join('; ')}`,
+    }),
+  }
+}

apps/sim/lib/copilot/tools/server/workflow/workflow-state.ts

@@ -0,0 +1,497 @@
+import crypto from 'crypto'
+import { db } from '@sim/db'
+import { workflow as workflowTable } from '@sim/db/schema'
+import { createLogger } from '@sim/logger'
+import { eq } from 'drizzle-orm'
+import { loadWorkflowFromNormalizedTables } from '@/lib/workflows/persistence/utils'
+import { getAllBlockTypes, getBlock } from '@/blocks/registry'
+import type { SubBlockConfig } from '@/blocks/types'
+
+const logger = createLogger('WorkflowContextState')
+const CONTAINER_BLOCK_TYPES = ['loop', 'parallel'] as const
+
+function stableSortValue(value: any): any {
+  if (Array.isArray(value)) {
+    return value.map(stableSortValue)
+  }
+  if (value && typeof value === 'object') {
+    const sorted: Record<string, any> = {}
+    for (const key of Object.keys(value).sort()) {
+      sorted[key] = stableSortValue(value[key])
+    }
+    return sorted
+  }
+  return value
+}
+
+export function hashWorkflowState(state: Record<string, unknown>): string {
+  const stable = stableSortValue(state)
+  const payload = JSON.stringify(stable)
+  return `sha256:${crypto.createHash('sha256').update(payload).digest('hex')}`
+}
+
+function normalizeOptions(options: unknown): string[] | null {
+  if (!Array.isArray(options)) return null
+  const normalized = options
+    .map((option) => {
+      if (option == null) return null
+      if (typeof option === 'object') {
+        const optionRecord = option as Record<string, unknown>
+        const id = optionRecord.id
+        if (typeof id === 'string') return id
+        const label = optionRecord.label
+        if (typeof label === 'string') return label
+        return null
+      }
+      return String(option)
+    })
+    .filter((value): value is string => Boolean(value))
+  return normalized.length > 0 ? normalized : null
+}
+
+function serializeRequired(required: SubBlockConfig['required']): boolean | Record<string, any> {
+  if (typeof required === 'boolean') return required
+  if (!required) return false
+  if (typeof required === 'object') {
+    const out: Record<string, any> = {}
+    const record = required as Record<string, unknown>
+    for (const key of ['field', 'operator', 'value']) {
+      if (record[key] !== undefined) {
+        out[key] = record[key]
+      }
+    }
+    return out
+  }
+  return false
+}
+
+function serializeSubBlock(subBlock: SubBlockConfig): Record<string, unknown> {
+  const staticOptions =
+    typeof subBlock.options === 'function' ? null : normalizeOptions(subBlock.options)
+  return {
+    id: subBlock.id,
+    type: subBlock.type,
+    title: subBlock.title,
+    description: subBlock.description || null,
+    mode: subBlock.mode || null,
+    placeholder: subBlock.placeholder || null,
+    hidden: Boolean(subBlock.hidden),
+    multiSelect: Boolean(subBlock.multiSelect),
+    required: serializeRequired(subBlock.required),
+    hasDynamicOptions: typeof subBlock.options === 'function',
+    options: staticOptions,
+    defaultValue: subBlock.defaultValue ?? null,
+    min: subBlock.min ?? null,
+    max: subBlock.max ?? null,
+  }
+}
+
+function serializeBlockSchema(blockType: string): Record<string, unknown> | null {
+  if (blockType === 'loop') {
+    return {
+      blockType: 'loop',
+      blockName: 'Loop',
+      category: 'blocks',
+      triggerAllowed: false,
+      hasTriggersConfig: false,
+      subBlocks: [
+        {
+          id: 'loopType',
+          type: 'dropdown',
+          title: 'Loop Type',
+          description: 'Loop mode: for, forEach, while, doWhile',
+          mode: null,
+          placeholder: null,
+          hidden: false,
+          multiSelect: false,
+          required: false,
+          hasDynamicOptions: false,
+          options: ['for', 'forEach', 'while', 'doWhile'],
+          defaultValue: 'for',
+          min: null,
+          max: null,
+        },
+        {
+          id: 'iterations',
+          type: 'short-input',
+          title: 'Iterations',
+          description: 'Iteration count for for-loops',
+          mode: null,
+          placeholder: null,
+          hidden: false,
+          multiSelect: false,
+          required: false,
+          hasDynamicOptions: false,
+          options: null,
+          defaultValue: 1,
+          min: 1,
+          max: null,
+        },
+        {
+          id: 'collection',
+          type: 'long-input',
+          title: 'Collection',
+          description: 'Collection expression for forEach loops',
+          mode: null,
+          placeholder: null,
+          hidden: false,
+          multiSelect: false,
+          required: false,
+          hasDynamicOptions: false,
+          options: null,
+          defaultValue: null,
+          min: null,
+          max: null,
+        },
+        {
+          id: 'condition',
+          type: 'long-input',
+          title: 'Condition',
+          description: 'Condition expression for while/doWhile loops',
+          mode: null,
+          placeholder: null,
+          hidden: false,
+          multiSelect: false,
+          required: false,
+          hasDynamicOptions: false,
+          options: null,
+          defaultValue: null,
+          min: null,
+          max: null,
+        },
+      ],
+      outputKeys: ['index', 'item', 'items'],
+      longDescription: null,
+    }
+  }
+
+  if (blockType === 'parallel') {
+    return {
+      blockType: 'parallel',
+      blockName: 'Parallel',
+      category: 'blocks',
+      triggerAllowed: false,
+      hasTriggersConfig: false,
+      subBlocks: [
+        {
+          id: 'parallelType',
+          type: 'dropdown',
+          title: 'Parallel Type',
+          description: 'Parallel mode: count or collection',
+          mode: null,
+          placeholder: null,
+          hidden: false,
+          multiSelect: false,
+          required: false,
+          hasDynamicOptions: false,
+          options: ['count', 'collection'],
+          defaultValue: 'count',
+          min: null,
+          max: null,
+        },
+        {
+          id: 'count',
+          type: 'short-input',
+          title: 'Count',
+          description: 'Branch count when parallelType is count',
+          mode: null,
+          placeholder: null,
+          hidden: false,
+          multiSelect: false,
+          required: false,
+          hasDynamicOptions: false,
+          options: null,
+          defaultValue: 1,
+          min: 1,
+          max: null,
+        },
+        {
+          id: 'collection',
+          type: 'long-input',
+          title: 'Collection',
+          description: 'Collection expression when parallelType is collection',
+          mode: null,
+          placeholder: null,
+          hidden: false,
+          multiSelect: false,
+          required: false,
+          hasDynamicOptions: false,
+          options: null,
+          defaultValue: null,
+          min: null,
+          max: null,
+        },
+      ],
+      outputKeys: ['index', 'currentItem', 'items'],
+      longDescription: null,
+    }
+  }
+
+  const blockConfig = getBlock(blockType)
+  if (!blockConfig) return null
+
+  const subBlocks = Array.isArray(blockConfig.subBlocks)
+    ? blockConfig.subBlocks.map(serializeSubBlock)
+    : []
+  const outputs = blockConfig.outputs || {}
+  const outputKeys = Object.keys(outputs)
+
+  return {
+    blockType,
+    blockName: blockConfig.name || blockType,
+    category: blockConfig.category,
+    triggerAllowed: Boolean(blockConfig.triggerAllowed || blockConfig.triggers?.enabled),
+    hasTriggersConfig: Boolean(blockConfig.triggers?.enabled),
+    subBlocks,
+    outputKeys,
+    longDescription: blockConfig.longDescription || null,
+  }
+}
+
+export function buildSchemasByType(blockTypes: string[]): {
+  schemasByType: Record<string, any>
+  schemaRefsByType: Record<string, string>
+} {
+  const schemasByType: Record<string, any> = {}
+  const schemaRefsByType: Record<string, string> = {}
+
+  const uniqueTypes = [...new Set(blockTypes.filter(Boolean))]
+  for (const blockType of uniqueTypes) {
+    const schema = serializeBlockSchema(blockType)
+    if (!schema) continue
+    const stableSchema = stableSortValue(schema)
+    const schemaHash = crypto
+      .createHash('sha256')
+      .update(JSON.stringify(stableSchema))
+      .digest('hex')
+    schemasByType[blockType] = stableSchema
+    schemaRefsByType[blockType] = `${blockType}@sha256:${schemaHash}`
+  }
+
+  return { schemasByType, schemaRefsByType }
+}
+
+export async function loadWorkflowStateFromDb(workflowId: string): Promise<{
+  workflowState: {
+    blocks: Record<string, any>
+    edges: Array<Record<string, any>>
+    loops: Record<string, any>
+    parallels: Record<string, any>
+  }
+  workspaceId?: string
+}> {
+  const [workflowRecord] = await db
+    .select({ workspaceId: workflowTable.workspaceId })
+    .from(workflowTable)
+    .where(eq(workflowTable.id, workflowId))
+    .limit(1)
+  if (!workflowRecord) {
+    throw new Error(`Workflow ${workflowId} not found`)
+  }
+
+  const normalized = await loadWorkflowFromNormalizedTables(workflowId)
+  if (!normalized) {
+    throw new Error(`Workflow ${workflowId} has no normalized data`)
+  }
+
+  const blocks = { ...normalized.blocks }
+  const invalidBlockIds: string[] = []
+  for (const [blockId, block] of Object.entries(blocks)) {
+    if (!(block as { type?: unknown })?.type) {
+      invalidBlockIds.push(blockId)
+    }
+  }
+
+  for (const blockId of invalidBlockIds) {
+    delete blocks[blockId]
+  }
+
+  const invalidSet = new Set(invalidBlockIds)
+  const edges = (normalized.edges || []).filter(
+    (edge: any) => !invalidSet.has(edge.source) && !invalidSet.has(edge.target)
+  )
+
+  if (invalidBlockIds.length > 0) {
+    logger.warn('Dropped blocks without type while loading workflow state', {
+      workflowId,
+      dropped: invalidBlockIds,
+    })
+  }
+
+  return {
+    workflowState: {
+      blocks,
+      edges,
+      loops: normalized.loops || {},
+      parallels: normalized.parallels || {},
+    },
+    workspaceId: workflowRecord.workspaceId || undefined,
+  }
+}
+
+export function summarizeWorkflowState(workflowState: {
+  blocks: Record<string, any>
+  edges: Array<Record<string, any>>
+  loops: Record<string, any>
+  parallels: Record<string, any>
+}): Record<string, unknown> {
+  const MAX_BLOCK_INVENTORY = 160
+  const MAX_EDGE_INVENTORY = 240
+  const blocks = workflowState.blocks || {}
+  const edges = workflowState.edges || []
+  const blockTypes: Record<string, number> = {}
+  const triggerBlocks: Array<{ id: string; name: string; type: string }> = []
+  const blockInventoryRaw: Array<{
+    id: string
+    name: string
+    type: string
+    parentId: string | null
+    triggerMode: boolean
+    enabled: boolean
+  }> = []
+
+  const normalizeReferenceToken = (value: string): string =>
+    value
+      .toLowerCase()
+      .replace(/[^a-z0-9]+/g, '')
+      .trim()
+
+  const dedupeStrings = (values: string[]): string[] => [...new Set(values.filter(Boolean))]
+  const startOutputKeys = ['input', 'files', 'conversationId']
+  const duplicateNameIndex = new Map<string, { name: string; blockIds: string[] }>()
+
+  for (const [blockId, block] of Object.entries(blocks)) {
+    const blockRecord = block as Record<string, unknown>
+    const dataRecord = (blockRecord.data as Record<string, unknown> | undefined) || undefined
+    const blockType = String(blockRecord.type || 'unknown')
+    const blockName = String(blockRecord.name || blockType)
+    const parentId = String(dataRecord?.parentId || '').trim() || null
+    const normalizedName = normalizeReferenceToken(blockName)
+
+    blockTypes[blockType] = (blockTypes[blockType] || 0) + 1
+    if (blockRecord.triggerMode === true) {
+      triggerBlocks.push({
+        id: blockId,
+        name: blockName,
+        type: blockType,
+      })
+    }
+
+    blockInventoryRaw.push({
+      id: blockId,
+      name: blockName,
+      type: blockType,
+      parentId,
+      triggerMode: blockRecord.triggerMode === true,
+      enabled: blockRecord.enabled !== false,
+    })
+
+    if (normalizedName) {
+      const existing = duplicateNameIndex.get(normalizedName)
+      if (existing) {
+        existing.blockIds.push(blockId)
+      } else {
+        duplicateNameIndex.set(normalizedName, { name: blockName, blockIds: [blockId] })
+      }
+    }
+  }
+
+  const blockInventory = [...blockInventoryRaw]
+    .sort((a, b) => a.name.localeCompare(b.name) || a.id.localeCompare(b.id))
+    .slice(0, MAX_BLOCK_INVENTORY)
+  const blockInventoryTruncated = blockInventoryRaw.length > MAX_BLOCK_INVENTORY
+
+  const blockNameById = new Map(blockInventoryRaw.map((entry) => [entry.id, entry.name]))
+  const edgeInventoryRaw = edges.map((edge: any) => {
+    const source = String(edge.source || '')
+    const target = String(edge.target || '')
+    const sourceHandle = String(edge.sourceHandle || '').trim() || null
+    const targetHandle = String(edge.targetHandle || '').trim() || null
+    return {
+      source,
+      sourceName: blockNameById.get(source) || source,
+      sourceHandle,
+      target,
+      targetName: blockNameById.get(target) || target,
+      targetHandle,
+    }
+  })
+  const edgeInventory = edgeInventoryRaw
+    .sort((a, b) => {
+      const bySource = a.sourceName.localeCompare(b.sourceName)
+      if (bySource !== 0) return bySource
+      const byTarget = a.targetName.localeCompare(b.targetName)
+      if (byTarget !== 0) return byTarget
+      return a.source.localeCompare(b.source)
+    })
+    .slice(0, MAX_EDGE_INVENTORY)
+  const edgeInventoryTruncated = edgeInventoryRaw.length > MAX_EDGE_INVENTORY
+
+  const duplicateBlockNames = [...duplicateNameIndex.values()]
+    .filter((entry) => entry.blockIds.length > 1)
+    .map((entry) => ({
+      name: entry.name,
+      count: entry.blockIds.length,
+      blockIds: entry.blockIds.sort(),
+    }))
+    .sort((a, b) => b.count - a.count || a.name.localeCompare(b.name))
+
+  const subflowChildrenMap = new Map<string, string[]>()
+  for (const block of blockInventoryRaw) {
+    if (!block.parentId) continue
+    const existing = subflowChildrenMap.get(block.parentId) || []
+    existing.push(block.id)
+    subflowChildrenMap.set(block.parentId, existing)
+  }
+  const subflowChildren = [...subflowChildrenMap.entries()]
+    .map(([subflowId, childBlockIds]) => {
+      const subflowBlock = blockInventoryRaw.find((block) => block.id === subflowId)
+      return {
+        subflowId,
+        subflowName: subflowBlock?.name || subflowId,
+        subflowType: subflowBlock?.type || 'unknown',
+        childBlockIds: childBlockIds.sort(),
+      }
+    })
+    .sort((a, b) => a.subflowName.localeCompare(b.subflowName))
+
+  const referenceGuide = blockInventory.map((entry) => {
+    const blockSchema = getBlock(entry.type)
+    const schemaOutputKeys = Object.keys(blockSchema?.outputs || {})
+    const outputKeys =
+      entry.type === 'start'
+        ? dedupeStrings([...schemaOutputKeys, ...startOutputKeys])
+        : dedupeStrings(schemaOutputKeys)
+    const referenceToken =
+      normalizeReferenceToken(entry.name) || normalizeReferenceToken(entry.type) || entry.id
+    return {
+      blockId: entry.id,
+      blockName: entry.name,
+      blockType: entry.type,
+      parentId: entry.parentId,
+      referenceToken,
+      outputKeys,
+      examples: outputKeys.slice(0, 4).map((key) => `<${referenceToken}.${key}>`),
+    }
+  })
+
+  return {
+    blockCount: Object.keys(blocks).length,
+    edgeCount: edges.length,
+    loopCount: Object.keys(workflowState.loops || {}).length,
+    parallelCount: Object.keys(workflowState.parallels || {}).length,
+    blockTypes,
+    triggerBlocks,
+    blockInventory,
+    blockInventoryTruncated,
+    edgeInventory,
+    edgeInventoryTruncated,
+    duplicateBlockNames,
+    subflowChildren,
+    referenceGuide,
+  }
+}
+
+export function getAllKnownBlockTypes(): string[] {
+  return [...new Set([...getAllBlockTypes(), ...CONTAINER_BLOCK_TYPES])]
+}

apps/sim/lib/copilot/tools/server/workflow/workflow-verify.ts

@@ -0,0 +1,230 @@
+import { createLogger } from '@sim/logger'
+import { z } from 'zod'
+import type { BaseServerTool } from '@/lib/copilot/tools/server/base-tool'
+import { validateWorkflowState } from '@/lib/workflows/sanitization/validation'
+import { authorizeWorkflowByWorkspacePermission } from '@/lib/workflows/utils'
+import { hashWorkflowState, loadWorkflowStateFromDb } from './workflow-state'
+
+const logger = createLogger('WorkflowVerifyServerTool')
+
+const AcceptanceItemSchema = z.union([
+  z.string(),
+  z.object({
+    kind: z.string().optional(),
+    assert: z.string(),
+  }),
+])
+
+const WorkflowVerifyInputSchema = z
+  .object({
+    workflowId: z.string(),
+    acceptance: z.array(AcceptanceItemSchema).optional(),
+    baseSnapshotHash: z.string().optional(),
+  })
+  .strict()
+
+type WorkflowVerifyParams = z.infer<typeof WorkflowVerifyInputSchema>
+
+function normalizeName(value: string): string {
+  return value.trim().toLowerCase()
+}
+
+function canonicalizeToken(value: string): string {
+  return normalizeName(value).replace(/[^a-z0-9]/g, '')
+}
+
+function resolveBlockToken(
+  workflowState: { blocks: Record<string, any> },
+  token: string
+): string | null {
+  if (!token) return null
+  if (workflowState.blocks[token]) return token
+  const normalized = normalizeName(token)
+  const canonical = canonicalizeToken(token)
+  for (const [blockId, block] of Object.entries(workflowState.blocks || {})) {
+    const blockName = normalizeName(String((block as Record<string, unknown>).name || ''))
+    if (blockName === normalized) return blockId
+    if (canonicalizeToken(blockName) === canonical) return blockId
+  }
+  return null
+}
+
+function resolveBlocksByType(
+  workflowState: { blocks: Record<string, any> },
+  token: string
+): string[] {
+  const normalized = normalizeName(token)
+  const canonical = canonicalizeToken(token)
+  const matches: string[] = []
+  for (const [blockId, block] of Object.entries(workflowState.blocks || {})) {
+    const blockType = normalizeName(String((block as Record<string, unknown>).type || ''))
+    if (!blockType) continue
+    if (blockType === normalized || canonicalizeToken(blockType) === canonical) {
+      matches.push(blockId)
+    }
+  }
+  return matches
+}
+
+function hasPath(
+  workflowState: { edges: Array<Record<string, any>> },
+  blockPath: string[]
+): boolean {
+  if (blockPath.length < 2) return true
+  const adjacency = new Map<string, string[]>()
+  for (const edge of workflowState.edges || []) {
+    const source = String(edge.source || '')
+    const target = String(edge.target || '')
+    if (!source || !target) continue
+    const existing = adjacency.get(source) || []
+    existing.push(target)
+    adjacency.set(source, existing)
+  }
+
+  for (let i = 0; i < blockPath.length - 1; i++) {
+    const from = blockPath[i]
+    const to = blockPath[i + 1]
+    const next = adjacency.get(from) || []
+    if (!next.includes(to)) return false
+  }
+  return true
+}
+
+function evaluateAssertions(params: {
+  workflowState: {
+    blocks: Record<string, any>
+    edges: Array<Record<string, any>>
+  }
+  assertions: string[]
+}): { failures: string[]; warnings: string[]; checks: Array<Record<string, any>> } {
+  const failures: string[] = []
+  const warnings: string[] = []
+  const checks: Array<Record<string, any>> = []
+
+  for (const assertion of params.assertions) {
+    if (assertion.startsWith('block_exists:')) {
+      const token = assertion.slice('block_exists:'.length).trim()
+      const blockId = resolveBlockToken(params.workflowState, token)
+      const passed = Boolean(blockId)
+      checks.push({ assert: assertion, passed, resolvedBlockId: blockId || null })
+      if (!passed) failures.push(`Assertion failed: ${assertion}`)
+      continue
+    }
+
+    if (assertion.startsWith('block_type_exists:')) {
+      const token = assertion.slice('block_type_exists:'.length).trim()
+      const matchedBlockIds = resolveBlocksByType(params.workflowState, token)
+      const passed = matchedBlockIds.length > 0
+      checks.push({ assert: assertion, passed, matchedBlockIds })
+      if (!passed) failures.push(`Assertion failed: ${assertion}`)
+      continue
+    }
+
+    if (assertion.startsWith('trigger_exists:')) {
+      const triggerType = normalizeName(assertion.slice('trigger_exists:'.length))
+      const triggerBlock = Object.values(params.workflowState.blocks || {}).find((block: any) => {
+        if (block?.triggerMode !== true) return false
+        return normalizeName(String(block?.type || '')) === triggerType
+      })
+      const passed = Boolean(triggerBlock)
+      checks.push({ assert: assertion, passed })
+      if (!passed) failures.push(`Assertion failed: ${assertion}`)
+      continue
+    }
+
+    if (assertion.startsWith('path_exists:')) {
+      const rawPath = assertion.slice('path_exists:'.length).trim()
+      const tokens = rawPath
+        .split('->')
+        .map((token) => token.trim())
+        .filter(Boolean)
+      const resolvedPath = tokens
+        .map((token) => resolveBlockToken(params.workflowState, token))
+        .filter((value): value is string => Boolean(value))
+
+      const resolvedAll = resolvedPath.length === tokens.length
+      const passed = resolvedAll && hasPath(params.workflowState, resolvedPath)
+      checks.push({
+        assert: assertion,
+        passed,
+        resolvedPath,
+      })
+      if (!passed) failures.push(`Assertion failed: ${assertion}`)
+      continue
+    }
+
+    // Unknown assertion format should not fail structural verification.
+    // Keep explicit visibility via warnings/check metadata.
+    checks.push({ assert: assertion, passed: false, reason: 'unknown_assertion_type' })
+    warnings.push(`Unknown assertion format: ${assertion}`)
+  }
+
+  return { failures, warnings, checks }
+}
+
+export const workflowVerifyServerTool: BaseServerTool<WorkflowVerifyParams, any> = {
+  name: 'workflow_verify',
+  inputSchema: WorkflowVerifyInputSchema,
+  async execute(params: WorkflowVerifyParams, context?: { userId: string }): Promise<any> {
+    if (!context?.userId) {
+      throw new Error('Unauthorized workflow access')
+    }
+
+    const authorization = await authorizeWorkflowByWorkspacePermission({
+      workflowId: params.workflowId,
+      userId: context.userId,
+      action: 'read',
+    })
+    if (!authorization.allowed) {
+      throw new Error(authorization.message || 'Unauthorized workflow access')
+    }
+
+    const { workflowState } = await loadWorkflowStateFromDb(params.workflowId)
+    const snapshotHash = hashWorkflowState(workflowState as unknown as Record<string, unknown>)
+    if (params.baseSnapshotHash && params.baseSnapshotHash !== snapshotHash) {
+      return {
+        success: false,
+        verified: false,
+        reason: 'snapshot_mismatch',
+        expected: params.baseSnapshotHash,
+        current: snapshotHash,
+      }
+    }
+
+    const validation = validateWorkflowState(workflowState as any, { sanitize: false })
+
+    const assertions = (params.acceptance || []).map((item) =>
+      typeof item === 'string' ? item : item.assert
+    )
+    const assertionResults = evaluateAssertions({
+      workflowState,
+      assertions,
+    })
+
+    const verified =
+      validation.valid && assertionResults.failures.length === 0 && validation.errors.length === 0
+
+    logger.info('Workflow verification complete', {
+      workflowId: params.workflowId,
+      verified,
+      errorCount: validation.errors.length,
+      warningCount: validation.warnings.length,
+      assertionFailures: assertionResults.failures.length,
+      assertionWarnings: assertionResults.warnings.length,
+    })
+
+    return {
+      success: true,
+      verified,
+      snapshotHash,
+      validation: {
+        valid: validation.valid,
+        errors: validation.errors,
+        warnings: validation.warnings,
+      },
+      assertions: assertionResults.checks,
+      failures: assertionResults.failures,
+      warnings: assertionResults.warnings,
+    }
+  },
+}

apps/sim/lib/core/telemetry.ts

@@ -934,31 +934,6 @@ export const PlatformEvents = {
     })
   },
 
-  /**
-   * Track hosted key throttled (rate limited)
-   */
-  hostedKeyThrottled: (attrs: {
-    toolId: string
-    envVarName: string
-    attempt: number
-    maxRetries: number
-    delayMs: number
-    userId?: string
-    workspaceId?: string
-    workflowId?: string
-  }) => {
-    trackPlatformEvent('platform.hosted_key.throttled', {
-      'tool.id': attrs.toolId,
-      'hosted_key.env_var': attrs.envVarName,
-      'throttle.attempt': attrs.attempt,
-      'throttle.max_retries': attrs.maxRetries,
-      'throttle.delay_ms': attrs.delayMs,
-      ...(attrs.userId && { 'user.id': attrs.userId }),
-      ...(attrs.workspaceId && { 'workspace.id': attrs.workspaceId }),
-      ...(attrs.workflowId && { 'workflow.id': attrs.workflowId }),
-    })
-  },
-
   /**
    * Track chat deployed (workflow deployed as chat interface)
    */

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/messaging/email/mailer.test.ts

@@ -1,4 +1,4 @@
-import { createEnvMock, loggerMock } from '@sim/testing'
+import { createEnvMock, createMockLogger } from '@sim/testing'
 import { beforeEach, describe, expect, it, type Mock, vi } from 'vitest'
 
 /**
@@ -10,6 +10,10 @@ import { beforeEach, describe, expect, it, type Mock, vi } from 'vitest'
  * mock functions can intercept.
  */
 
+const loggerMock = vi.hoisted(() => ({
+  createLogger: () => createMockLogger(),
+}))
+
 const mockSend = vi.fn()
 const mockBatchSend = vi.fn()
 const mockAzureBeginSend = vi.fn()

apps/sim/lib/messaging/email/unsubscribe.test.ts

@@ -1,8 +1,20 @@
-import { createEnvMock, databaseMock, loggerMock } from '@sim/testing'
+import { createEnvMock, createMockLogger } from '@sim/testing'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 import type { EmailType } from '@/lib/messaging/email/mailer'
 
-vi.mock('@sim/db', () => databaseMock)
+const loggerMock = vi.hoisted(() => ({
+  createLogger: () => createMockLogger(),
+}))
+
+const mockDb = vi.hoisted(() => ({
+  select: vi.fn(),
+  insert: vi.fn(),
+  update: vi.fn(),
+}))
+
+vi.mock('@sim/db', () => ({
+  db: mockDb,
+}))
 
 vi.mock('@sim/db/schema', () => ({
   user: { id: 'id', email: 'email' },
@@ -18,8 +30,6 @@ vi.mock('drizzle-orm', () => ({
   eq: vi.fn((a, b) => ({ type: 'eq', left: a, right: b })),
 }))
 
-const mockDb = databaseMock.db as Record<string, ReturnType<typeof vi.fn>>
-
 vi.mock('@/lib/core/config/env', () => createEnvMock({ BETTER_AUTH_SECRET: 'test-secret-key' }))
 
 vi.mock('@sim/logger', () => loggerMock)

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/lib/workflows/diff/diff-engine.test.ts

@@ -1,11 +1,18 @@
 /**
  * @vitest-environment node
  */
-import { loggerMock } from '@sim/testing'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 import type { BlockState, WorkflowState } from '@/stores/workflows/workflow/types'
 
-vi.mock('@sim/logger', () => loggerMock)
+// Mock all external dependencies before imports
+vi.mock('@sim/logger', () => ({
+  createLogger: () => ({
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    debug: vi.fn(),
+  }),
+}))
 
 vi.mock('@/stores/workflows/workflow/store', () => ({
   useWorkflowStore: {

apps/sim/lib/workflows/subblocks/visibility.ts

@@ -1,5 +1,4 @@
 import { getEnv, isTruthy } from '@/lib/core/config/env'
-import { isHosted } from '@/lib/core/config/feature-flags'
 import type { SubBlockConfig } from '@/blocks/types'
 
 export type CanonicalMode = 'basic' | 'advanced'
@@ -271,12 +270,3 @@ export function isSubBlockFeatureEnabled(subBlock: SubBlockConfig): boolean {
   if (!subBlock.requiresFeature) return true
   return isTruthy(getEnv(subBlock.requiresFeature))
 }
-
-/**
- * Check if a subblock should be hidden because we're running on hosted Sim.
- * Used for tool API key fields that should be hidden when Sim provides hosted keys.
- */
-export function isSubBlockHiddenByHostedKey(subBlock: SubBlockConfig): boolean {
-  if (!subBlock.hideWhenHosted) return false
-  return isHosted
-}

apps/sim/lib/workflows/utils.test.ts

@@ -14,15 +14,22 @@ import {
   databaseMock,
   expectWorkflowAccessDenied,
   expectWorkflowAccessGranted,
-  mockAuth,
 } from '@sim/testing'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 
-const mockDb = databaseMock.db
+vi.mock('@sim/db', () => databaseMock)
+
+// Mock the auth module
+vi.mock('@/lib/auth', () => ({
+  getSession: vi.fn(),
+}))
+
+import { db } from '@sim/db'
+import { getSession } from '@/lib/auth'
+// Import after mocks are set up
+import { validateWorkflowPermissions } from '@/lib/workflows/utils'
 
 describe('validateWorkflowPermissions', () => {
-  const auth = mockAuth()
-
   const mockSession = createSession({ userId: 'user-1', email: 'user1@test.com' })
   const mockWorkflow = createWorkflowRecord({
     id: 'wf-1',
@@ -35,17 +42,13 @@ describe('validateWorkflowPermissions', () => {
   })
 
   beforeEach(() => {
-    vi.resetModules()
     vi.clearAllMocks()
-
-    vi.doMock('@sim/db', () => databaseMock)
   })
 
   describe('authentication', () => {
     it('should return 401 when no session exists', async () => {
-      auth.setUnauthenticated()
+      vi.mocked(getSession).mockResolvedValue(null)
 
-      const { validateWorkflowPermissions } = await import('@/lib/workflows/utils')
       const result = await validateWorkflowPermissions('wf-1', 'req-1', 'read')
 
       expectWorkflowAccessDenied(result, 401)
@@ -53,9 +56,8 @@ describe('validateWorkflowPermissions', () => {
     })
 
     it('should return 401 when session has no user id', async () => {
-      auth.mockGetSession.mockResolvedValue({ user: {} } as any)
+      vi.mocked(getSession).mockResolvedValue({ user: {} } as any)
 
-      const { validateWorkflowPermissions } = await import('@/lib/workflows/utils')
       const result = await validateWorkflowPermissions('wf-1', 'req-1', 'read')
 
       expectWorkflowAccessDenied(result, 401)
@@ -64,14 +66,14 @@ describe('validateWorkflowPermissions', () => {
 
   describe('workflow not found', () => {
     it('should return 404 when workflow does not exist', async () => {
-      auth.mockGetSession.mockResolvedValue(mockSession as any)
+      vi.mocked(getSession).mockResolvedValue(mockSession as any)
 
+      // Mock workflow query to return empty
       const mockLimit = vi.fn().mockResolvedValue([])
       const mockWhere = vi.fn(() => ({ limit: mockLimit }))
       const mockFrom = vi.fn(() => ({ where: mockWhere }))
-      vi.mocked(mockDb.select).mockReturnValue({ from: mockFrom } as any)
+      vi.mocked(db.select).mockReturnValue({ from: mockFrom } as any)
 
-      const { validateWorkflowPermissions } = await import('@/lib/workflows/utils')
       const result = await validateWorkflowPermissions('non-existent', 'req-1', 'read')
 
       expectWorkflowAccessDenied(result, 404)
@@ -81,42 +83,43 @@ describe('validateWorkflowPermissions', () => {
 
   describe('owner access', () => {
     it('should deny access to workflow owner without workspace permissions for read action', async () => {
-      auth.setAuthenticated({ id: 'owner-1', email: 'owner-1@test.com' })
+      const ownerSession = createSession({ userId: 'owner-1' })
+      vi.mocked(getSession).mockResolvedValue(ownerSession as any)
 
+      // Mock workflow query
       const mockLimit = vi.fn().mockResolvedValue([mockWorkflow])
       const mockWhere = vi.fn(() => ({ limit: mockLimit }))
       const mockFrom = vi.fn(() => ({ where: mockWhere }))
-      vi.mocked(mockDb.select).mockReturnValue({ from: mockFrom } as any)
+      vi.mocked(db.select).mockReturnValue({ from: mockFrom } as any)
 
-      const { validateWorkflowPermissions } = await import('@/lib/workflows/utils')
       const result = await validateWorkflowPermissions('wf-1', 'req-1', 'read')
 
       expectWorkflowAccessDenied(result, 403)
     })
 
     it('should deny access to workflow owner without workspace permissions for write action', async () => {
-      auth.setAuthenticated({ id: 'owner-1', email: 'owner-1@test.com' })
+      const ownerSession = createSession({ userId: 'owner-1' })
+      vi.mocked(getSession).mockResolvedValue(ownerSession as any)
 
       const mockLimit = vi.fn().mockResolvedValue([mockWorkflow])
       const mockWhere = vi.fn(() => ({ limit: mockLimit }))
       const mockFrom = vi.fn(() => ({ where: mockWhere }))
-      vi.mocked(mockDb.select).mockReturnValue({ from: mockFrom } as any)
+      vi.mocked(db.select).mockReturnValue({ from: mockFrom } as any)
 
-      const { validateWorkflowPermissions } = await import('@/lib/workflows/utils')
       const result = await validateWorkflowPermissions('wf-1', 'req-1', 'write')
 
       expectWorkflowAccessDenied(result, 403)
     })
 
     it('should deny access to workflow owner without workspace permissions for admin action', async () => {
-      auth.setAuthenticated({ id: 'owner-1', email: 'owner-1@test.com' })
+      const ownerSession = createSession({ userId: 'owner-1' })
+      vi.mocked(getSession).mockResolvedValue(ownerSession as any)
 
       const mockLimit = vi.fn().mockResolvedValue([mockWorkflow])
       const mockWhere = vi.fn(() => ({ limit: mockLimit }))
       const mockFrom = vi.fn(() => ({ where: mockWhere }))
-      vi.mocked(mockDb.select).mockReturnValue({ from: mockFrom } as any)
+      vi.mocked(db.select).mockReturnValue({ from: mockFrom } as any)
 
-      const { validateWorkflowPermissions } = await import('@/lib/workflows/utils')
       const result = await validateWorkflowPermissions('wf-1', 'req-1', 'admin')
 
       expectWorkflowAccessDenied(result, 403)
@@ -125,10 +128,11 @@ describe('validateWorkflowPermissions', () => {
 
   describe('workspace member access with permissions', () => {
     beforeEach(() => {
-      auth.mockGetSession.mockResolvedValue(mockSession as any)
+      vi.mocked(getSession).mockResolvedValue(mockSession as any)
     })
 
     it('should grant read access to user with read permission', async () => {
+      // First call: workflow query, second call: workspace owner, third call: permission
       let callCount = 0
       const mockLimit = vi.fn().mockImplementation(() => {
         callCount++
@@ -137,9 +141,8 @@ describe('validateWorkflowPermissions', () => {
       })
       const mockWhere = vi.fn(() => ({ limit: mockLimit }))
       const mockFrom = vi.fn(() => ({ where: mockWhere }))
-      vi.mocked(mockDb.select).mockReturnValue({ from: mockFrom } as any)
+      vi.mocked(db.select).mockReturnValue({ from: mockFrom } as any)
 
-      const { validateWorkflowPermissions } = await import('@/lib/workflows/utils')
       const result = await validateWorkflowPermissions('wf-1', 'req-1', 'read')
 
       expectWorkflowAccessGranted(result)
@@ -154,9 +157,8 @@ describe('validateWorkflowPermissions', () => {
       })
       const mockWhere = vi.fn(() => ({ limit: mockLimit }))
       const mockFrom = vi.fn(() => ({ where: mockWhere }))
-      vi.mocked(mockDb.select).mockReturnValue({ from: mockFrom } as any)
+      vi.mocked(db.select).mockReturnValue({ from: mockFrom } as any)
 
-      const { validateWorkflowPermissions } = await import('@/lib/workflows/utils')
       const result = await validateWorkflowPermissions('wf-1', 'req-1', 'write')
 
       expectWorkflowAccessDenied(result, 403)
@@ -172,9 +174,8 @@ describe('validateWorkflowPermissions', () => {
       })
       const mockWhere = vi.fn(() => ({ limit: mockLimit }))
       const mockFrom = vi.fn(() => ({ where: mockWhere }))
-      vi.mocked(mockDb.select).mockReturnValue({ from: mockFrom } as any)
+      vi.mocked(db.select).mockReturnValue({ from: mockFrom } as any)
 
-      const { validateWorkflowPermissions } = await import('@/lib/workflows/utils')
       const result = await validateWorkflowPermissions('wf-1', 'req-1', 'write')
 
       expectWorkflowAccessGranted(result)
@@ -189,9 +190,8 @@ describe('validateWorkflowPermissions', () => {
       })
       const mockWhere = vi.fn(() => ({ limit: mockLimit }))
       const mockFrom = vi.fn(() => ({ where: mockWhere }))
-      vi.mocked(mockDb.select).mockReturnValue({ from: mockFrom } as any)
+      vi.mocked(db.select).mockReturnValue({ from: mockFrom } as any)
 
-      const { validateWorkflowPermissions } = await import('@/lib/workflows/utils')
       const result = await validateWorkflowPermissions('wf-1', 'req-1', 'write')
 
       expectWorkflowAccessGranted(result)
@@ -206,9 +206,8 @@ describe('validateWorkflowPermissions', () => {
       })
       const mockWhere = vi.fn(() => ({ limit: mockLimit }))
       const mockFrom = vi.fn(() => ({ where: mockWhere }))
-      vi.mocked(mockDb.select).mockReturnValue({ from: mockFrom } as any)
+      vi.mocked(db.select).mockReturnValue({ from: mockFrom } as any)
 
-      const { validateWorkflowPermissions } = await import('@/lib/workflows/utils')
       const result = await validateWorkflowPermissions('wf-1', 'req-1', 'admin')
 
       expectWorkflowAccessDenied(result, 403)
@@ -224,9 +223,8 @@ describe('validateWorkflowPermissions', () => {
       })
       const mockWhere = vi.fn(() => ({ limit: mockLimit }))
       const mockFrom = vi.fn(() => ({ where: mockWhere }))
-      vi.mocked(mockDb.select).mockReturnValue({ from: mockFrom } as any)
+      vi.mocked(db.select).mockReturnValue({ from: mockFrom } as any)
 
-      const { validateWorkflowPermissions } = await import('@/lib/workflows/utils')
       const result = await validateWorkflowPermissions('wf-1', 'req-1', 'admin')
 
       expectWorkflowAccessGranted(result)
@@ -235,19 +233,18 @@ describe('validateWorkflowPermissions', () => {
 
   describe('no workspace permission', () => {
     it('should deny access to user without any workspace permission', async () => {
-      auth.mockGetSession.mockResolvedValue(mockSession as any)
+      vi.mocked(getSession).mockResolvedValue(mockSession as any)
 
       let callCount = 0
       const mockLimit = vi.fn().mockImplementation(() => {
         callCount++
         if (callCount === 1) return Promise.resolve([mockWorkflow])
-        return Promise.resolve([])
+        return Promise.resolve([]) // No permission record
       })
       const mockWhere = vi.fn(() => ({ limit: mockLimit }))
       const mockFrom = vi.fn(() => ({ where: mockWhere }))
-      vi.mocked(mockDb.select).mockReturnValue({ from: mockFrom } as any)
+      vi.mocked(db.select).mockReturnValue({ from: mockFrom } as any)
 
-      const { validateWorkflowPermissions } = await import('@/lib/workflows/utils')
       const result = await validateWorkflowPermissions('wf-1', 'req-1', 'read')
 
       expectWorkflowAccessDenied(result, 403)
@@ -262,14 +259,13 @@ describe('validateWorkflowPermissions', () => {
         workspaceId: null,
       })
 
-      auth.mockGetSession.mockResolvedValue(mockSession as any)
+      vi.mocked(getSession).mockResolvedValue(mockSession as any)
 
       const mockLimit = vi.fn().mockResolvedValue([workflowWithoutWorkspace])
       const mockWhere = vi.fn(() => ({ limit: mockLimit }))
       const mockFrom = vi.fn(() => ({ where: mockWhere }))
-      vi.mocked(mockDb.select).mockReturnValue({ from: mockFrom } as any)
+      vi.mocked(db.select).mockReturnValue({ from: mockFrom } as any)
 
-      const { validateWorkflowPermissions } = await import('@/lib/workflows/utils')
       const result = await validateWorkflowPermissions('wf-2', 'req-1', 'read')
 
       expectWorkflowAccessDenied(result, 403)
@@ -282,14 +278,13 @@ describe('validateWorkflowPermissions', () => {
         workspaceId: null,
       })
 
-      auth.mockGetSession.mockResolvedValue(mockSession as any)
+      vi.mocked(getSession).mockResolvedValue(mockSession as any)
 
       const mockLimit = vi.fn().mockResolvedValue([workflowWithoutWorkspace])
       const mockWhere = vi.fn(() => ({ limit: mockLimit }))
       const mockFrom = vi.fn(() => ({ where: mockWhere }))
-      vi.mocked(mockDb.select).mockReturnValue({ from: mockFrom } as any)
+      vi.mocked(db.select).mockReturnValue({ from: mockFrom } as any)
 
-      const { validateWorkflowPermissions } = await import('@/lib/workflows/utils')
       const result = await validateWorkflowPermissions('wf-2', 'req-1', 'read')
 
       expectWorkflowAccessDenied(result, 403)
@@ -298,7 +293,7 @@ describe('validateWorkflowPermissions', () => {
 
   describe('default action', () => {
     it('should default to read action when not specified', async () => {
-      auth.mockGetSession.mockResolvedValue(mockSession as any)
+      vi.mocked(getSession).mockResolvedValue(mockSession as any)
 
       let callCount = 0
       const mockLimit = vi.fn().mockImplementation(() => {
@@ -308,9 +303,8 @@ describe('validateWorkflowPermissions', () => {
       })
       const mockWhere = vi.fn(() => ({ limit: mockLimit }))
       const mockFrom = vi.fn(() => ({ where: mockWhere }))
-      vi.mocked(mockDb.select).mockReturnValue({ from: mockFrom } as any)
+      vi.mocked(db.select).mockReturnValue({ from: mockFrom } as any)
 
-      const { validateWorkflowPermissions } = await import('@/lib/workflows/utils')
       const result = await validateWorkflowPermissions('wf-1', 'req-1')
 
       expectWorkflowAccessGranted(result)

apps/sim/lib/workspaces/permissions/utils.test.ts

@@ -1,7 +1,17 @@
-import { databaseMock, drizzleOrmMock } from '@sim/testing'
+import { drizzleOrmMock } from '@sim/testing/mocks'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 
-vi.mock('@sim/db', () => databaseMock)
+vi.mock('@sim/db', () => ({
+  db: {
+    select: vi.fn(),
+    from: vi.fn(),
+    where: vi.fn(),
+    limit: vi.fn(),
+    innerJoin: vi.fn(),
+    leftJoin: vi.fn(),
+    orderBy: vi.fn(),
+  },
+}))
 
 vi.mock('@sim/db/schema', () => ({
   permissions: {

apps/sim/serializer/index.ts

@@ -10,7 +10,6 @@ import {
   isCanonicalPair,
   isNonEmptyValue,
   isSubBlockFeatureEnabled,
-  isSubBlockHiddenByHostedKey,
   resolveCanonicalMode,
 } from '@/lib/workflows/subblocks/visibility'
 import { getBlock } from '@/blocks'
@@ -50,7 +49,6 @@ function shouldSerializeSubBlock(
   canonicalModeOverrides?: CanonicalModeOverrides
 ): boolean {
   if (!isSubBlockFeatureEnabled(subBlockConfig)) return false
-  if (isSubBlockHiddenByHostedKey(subBlockConfig)) return false
 
   if (subBlockConfig.mode === 'trigger') {
     if (!isTriggerContext && !isTriggerCategory) return false

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/panel/copilot/store.ts

@@ -18,7 +18,6 @@ import {
 import { flushStreamingUpdates, stopStreamingUpdates } from '@/lib/copilot/client-sse/handlers'
 import type { ClientContentBlock, ClientStreamingContext } from '@/lib/copilot/client-sse/types'
 import {
-  COPILOT_AUTO_ALLOWED_TOOLS_API_PATH,
   COPILOT_CHAT_API_PATH,
   COPILOT_CHAT_STREAM_API_PATH,
   COPILOT_CHECKPOINTS_API_PATH,
@@ -84,6 +83,14 @@ function isPageUnloading(): boolean {
   return _isPageUnloading
 }
 
+function isWorkflowEditToolCall(name?: string, params?: Record<string, unknown>): boolean {
+  if (name !== 'workflow_change') return false
+
+  const mode = typeof params?.mode === 'string' ? params.mode.toLowerCase() : ''
+  if (mode === 'apply') return true
+  return typeof params?.proposalId === 'string' && params.proposalId.length > 0
+}
+
 function readActiveStreamFromStorage(): CopilotStreamInfo | null {
   if (typeof window === 'undefined') return null
   try {
@@ -140,41 +147,6 @@ function updateActiveStreamEventId(
   writeActiveStreamToStorage(next)
 }
 
-const AUTO_ALLOWED_TOOLS_STORAGE_KEY = 'copilot_auto_allowed_tools'
-
-function readAutoAllowedToolsFromStorage(): string[] | null {
-  if (typeof window === 'undefined') return null
-  try {
-    const raw = window.localStorage.getItem(AUTO_ALLOWED_TOOLS_STORAGE_KEY)
-    if (!raw) return null
-    const parsed = JSON.parse(raw)
-    if (!Array.isArray(parsed)) return null
-    return parsed.filter((item): item is string => typeof item === 'string')
-  } catch (error) {
-    logger.warn('[AutoAllowedTools] Failed to read local cache', {
-      error: error instanceof Error ? error.message : String(error),
-    })
-    return null
-  }
-}
-
-function writeAutoAllowedToolsToStorage(tools: string[]): void {
-  if (typeof window === 'undefined') return
-  try {
-    window.localStorage.setItem(AUTO_ALLOWED_TOOLS_STORAGE_KEY, JSON.stringify(tools))
-  } catch (error) {
-    logger.warn('[AutoAllowedTools] Failed to write local cache', {
-      error: error instanceof Error ? error.message : String(error),
-    })
-  }
-}
-
-function isToolAutoAllowedByList(toolId: string, autoAllowedTools: string[]): boolean {
-  if (!toolId) return false
-  const normalizedTarget = toolId.trim()
-  return autoAllowedTools.some((allowed) => allowed?.trim() === normalizedTarget)
-}
-
 /**
  * Clear any lingering diff preview from a previous session.
  * Called lazily when the store is first activated (setWorkflowId).
@@ -480,11 +452,6 @@ function prepareSendContext(
     .catch((err) => {
       logger.warn('[Copilot] Failed to load sensitive credential IDs', err)
     })
-  get()
-    .loadAutoAllowedTools()
-    .catch((err) => {
-      logger.warn('[Copilot] Failed to load auto-allowed tools', err)
-    })
 
   let newMessages: CopilotMessage[]
   if (revertState) {
@@ -1037,12 +1004,10 @@ async function resumeFromLiveStream(
   return false
 }
 
-const cachedAutoAllowedTools = readAutoAllowedToolsFromStorage()
-
 // Initial state (subset required for UI/streaming)
 const initialState = {
   mode: 'build' as const,
-  selectedModel: 'anthropic/claude-opus-4-5' as CopilotStore['selectedModel'],
+  selectedModel: 'anthropic/claude-opus-4-6' as CopilotStore['selectedModel'],
   agentPrefetch: false,
   availableModels: [] as AvailableModel[],
   isLoadingModels: false,
@@ -1073,8 +1038,6 @@ const initialState = {
   streamingPlanContent: '',
   toolCallsById: {} as Record<string, CopilotToolCall>,
   suppressAutoSelect: false,
-  autoAllowedTools: cachedAutoAllowedTools ?? ([] as string[]),
-  autoAllowedToolsLoaded: cachedAutoAllowedTools !== null,
   activeStream: null as CopilotStreamInfo | null,
   messageQueue: [] as import('./types').QueuedMessage[],
   suppressAbortContinueOption: false,
@@ -1113,8 +1076,6 @@ export const useCopilotStore = create<CopilotStore>()(
         agentPrefetch: get().agentPrefetch,
         availableModels: get().availableModels,
         isLoadingModels: get().isLoadingModels,
-        autoAllowedTools: get().autoAllowedTools,
-        autoAllowedToolsLoaded: get().autoAllowedToolsLoaded,
       })
     },
 
@@ -1429,16 +1390,6 @@ export const useCopilotStore = create<CopilotStore>()(
 
     // Send a message (streaming only)
     sendMessage: async (message: string, options = {}) => {
-      if (!get().autoAllowedToolsLoaded) {
-        try {
-          await get().loadAutoAllowedTools()
-        } catch (error) {
-          logger.warn('[Copilot] Failed to preload auto-allowed tools before send', {
-            error: error instanceof Error ? error.message : String(error),
-          })
-        }
-      }
-
       const prepared = prepareSendContext(get, set, message, options as SendMessageOptionsInput)
       if (!prepared) return
 
@@ -1705,7 +1656,7 @@ export const useCopilotStore = create<CopilotStore>()(
             const b = blocks[bi]
             if (b?.type === 'tool_call') {
               const tn = b.toolCall?.name
-              if (tn === 'edit_workflow') {
+              if (isWorkflowEditToolCall(tn, b.toolCall?.params)) {
                 id = b.toolCall?.id
                 break outer
               }
@@ -1714,7 +1665,9 @@ export const useCopilotStore = create<CopilotStore>()(
         }
         // Fallback to map if not found in messages
         if (!id) {
-          const candidates = Object.values(toolCallsById).filter((t) => t.name === 'edit_workflow')
+          const candidates = Object.values(toolCallsById).filter((t) =>
+            isWorkflowEditToolCall(t.name, t.params)
+          )
           id = candidates.length ? candidates[candidates.length - 1].id : undefined
         }
       }
@@ -2009,7 +1962,7 @@ export const useCopilotStore = create<CopilotStore>()(
         }
 
         if (!context.wasAborted && sseHandlers.stream_end) {
-          sseHandlers.stream_end({ type: 'done' }, context, get, set)
+          sseHandlers.stream_end({ type: 'copilot.phase.completed' }, context, get, set)
         }
 
         stopStreamingUpdates()
@@ -2381,17 +2334,17 @@ export const useCopilotStore = create<CopilotStore>()(
           (model) => model.id === normalizedSelectedModel
         )
 
-        // Pick the best default: prefer claude-opus-4-5 with provider priority:
+        // Pick the best default: prefer claude-opus-4-6 with provider priority:
         // direct anthropic > bedrock > azure-anthropic > any other.
         let nextSelectedModel = normalizedSelectedModel
         if (!selectedModelExists && normalizedModels.length > 0) {
-          let opus45: AvailableModel | undefined
+          let opus46: AvailableModel | undefined
           for (const prov of MODEL_PROVIDER_PRIORITY) {
-            opus45 = normalizedModels.find((m) => m.id === `${prov}/claude-opus-4-5`)
-            if (opus45) break
+            opus46 = normalizedModels.find((m) => m.id === `${prov}/claude-opus-4-6`)
+            if (opus46) break
           }
-          if (!opus45) opus45 = normalizedModels.find((m) => m.id.endsWith('/claude-opus-4-5'))
-          nextSelectedModel = opus45 ? opus45.id : normalizedModels[0].id
+          if (!opus46) opus46 = normalizedModels.find((m) => m.id.endsWith('/claude-opus-4-6'))
+          nextSelectedModel = opus46 ? opus46.id : normalizedModels[0].id
         }
 
         set({
@@ -2407,74 +2360,6 @@ export const useCopilotStore = create<CopilotStore>()(
       }
     },
 
-    loadAutoAllowedTools: async () => {
-      try {
-        logger.debug('[AutoAllowedTools] Loading from API...')
-        const res = await fetch(COPILOT_AUTO_ALLOWED_TOOLS_API_PATH)
-        logger.debug('[AutoAllowedTools] Load response', { status: res.status, ok: res.ok })
-        if (res.ok) {
-          const data = await res.json()
-          const tools = data.autoAllowedTools ?? []
-          set({ autoAllowedTools: tools, autoAllowedToolsLoaded: true })
-          writeAutoAllowedToolsToStorage(tools)
-          logger.debug('[AutoAllowedTools] Loaded successfully', { count: tools.length, tools })
-        } else {
-          set({ autoAllowedToolsLoaded: true })
-          logger.warn('[AutoAllowedTools] Load failed with status', { status: res.status })
-        }
-      } catch (err) {
-        set({ autoAllowedToolsLoaded: true })
-        logger.error('[AutoAllowedTools] Failed to load', { error: err })
-      }
-    },
-
-    addAutoAllowedTool: async (toolId: string) => {
-      try {
-        logger.debug('[AutoAllowedTools] Adding tool...', { toolId })
-        const res = await fetch(COPILOT_AUTO_ALLOWED_TOOLS_API_PATH, {
-          method: 'POST',
-          headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify({ toolId }),
-        })
-        logger.debug('[AutoAllowedTools] API response', { toolId, status: res.status, ok: res.ok })
-        if (res.ok) {
-          const data = await res.json()
-          logger.debug('[AutoAllowedTools] API returned', { toolId, tools: data.autoAllowedTools })
-          const tools = data.autoAllowedTools ?? []
-          set({ autoAllowedTools: tools, autoAllowedToolsLoaded: true })
-          writeAutoAllowedToolsToStorage(tools)
-          logger.debug('[AutoAllowedTools] Added tool to store', { toolId })
-        }
-      } catch (err) {
-        logger.error('[AutoAllowedTools] Failed to add tool', { toolId, error: err })
-      }
-    },
-
-    removeAutoAllowedTool: async (toolId: string) => {
-      try {
-        const res = await fetch(
-          `${COPILOT_AUTO_ALLOWED_TOOLS_API_PATH}?toolId=${encodeURIComponent(toolId)}`,
-          {
-            method: 'DELETE',
-          }
-        )
-        if (res.ok) {
-          const data = await res.json()
-          const tools = data.autoAllowedTools ?? []
-          set({ autoAllowedTools: tools, autoAllowedToolsLoaded: true })
-          writeAutoAllowedToolsToStorage(tools)
-          logger.debug('[AutoAllowedTools] Removed tool', { toolId })
-        }
-      } catch (err) {
-        logger.error('[AutoAllowedTools] Failed to remove tool', { toolId, error: err })
-      }
-    },
-
-    isToolAutoAllowed: (toolId: string) => {
-      const { autoAllowedTools } = get()
-      return isToolAutoAllowedByList(toolId, autoAllowedTools)
-    },
-
     // Credential masking
     loadSensitiveCredentialIds: async () => {
       try {

apps/sim/stores/panel/copilot/types.ts

@@ -26,6 +26,26 @@ export interface CopilotToolCall {
   params?: Record<string, unknown>
   input?: Record<string, unknown>
   display?: ClientToolDisplay
+  /** Server-provided UI contract for this tool call phase */
+  ui?: {
+    title?: string
+    phaseLabel?: string
+    icon?: string
+    showInterrupt?: boolean
+    showRemember?: boolean
+    autoAllowed?: boolean
+    actions?: Array<{
+      id: string
+      label: string
+      kind: 'accept' | 'reject'
+      remember?: boolean
+    }>
+  }
+  /** Server-provided execution routing contract */
+  execution?: {
+    target?: 'go' | 'go_subagent' | 'sim_server' | 'sim_client_capability' | string
+    capabilityId?: string
+  }
   /** Content streamed from a subagent (e.g., debug agent) */
   subAgentContent?: string
   /** Tool calls made by the subagent */
@@ -167,10 +187,6 @@ export interface CopilotState {
 
   // Per-message metadata captured at send-time for reliable stats
 
-  // Auto-allowed integration tools (tools that can run without confirmation)
-  autoAllowedTools: string[]
-  autoAllowedToolsLoaded: boolean
-
   // Active stream metadata for reconnect/replay
   activeStream: CopilotStreamInfo | null
 
@@ -247,11 +263,6 @@ export interface CopilotActions {
     abortSignal?: AbortSignal
   ) => Promise<void>
   handleNewChatCreation: (newChatId: string) => Promise<void>
-  loadAutoAllowedTools: () => Promise<void>
-  addAutoAllowedTool: (toolId: string) => Promise<void>
-  removeAutoAllowedTool: (toolId: string) => Promise<void>
-  isToolAutoAllowed: (toolId: string) => boolean
-
   // Credential masking
   loadSensitiveCredentialIds: () => Promise<void>
   maskCredentialValue: (value: string) => string

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/stores/workflow-diff/store.ts

@@ -15,7 +15,7 @@ import {
   captureBaselineSnapshot,
   cloneWorkflowState,
   createBatchedUpdater,
-  findLatestEditWorkflowToolCallId,
+  findLatestWorkflowEditToolCallId,
   getLatestUserMessageId,
   persistWorkflowStateToServer,
 } from './utils'
@@ -334,7 +334,7 @@ export const useWorkflowDiffStore = create<WorkflowDiffState & WorkflowDiffActio
             })
           }
 
-          findLatestEditWorkflowToolCallId().then((toolCallId) => {
+          findLatestWorkflowEditToolCallId().then((toolCallId) => {
             if (toolCallId) {
               import('@/stores/panel/copilot/store')
                 .then(({ useCopilotStore }) => {
@@ -439,7 +439,7 @@ export const useWorkflowDiffStore = create<WorkflowDiffState & WorkflowDiffActio
             })
           }
 
-          findLatestEditWorkflowToolCallId().then((toolCallId) => {
+          findLatestWorkflowEditToolCallId().then((toolCallId) => {
             if (toolCallId) {
               import('@/stores/panel/copilot/store')
                 .then(({ useCopilotStore }) => {

apps/sim/stores/workflow-diff/utils.ts

@@ -126,6 +126,20 @@ export async function getLatestUserMessageId(): Promise<string | null> {
 }
 
 export async function findLatestEditWorkflowToolCallId(): Promise<string | undefined> {
+  return findLatestWorkflowEditToolCallId()
+}
+
+function isWorkflowEditToolCall(name?: string, params?: Record<string, unknown>): boolean {
+  if (name !== 'workflow_change') return false
+
+  const mode = typeof params?.mode === 'string' ? params.mode.toLowerCase() : ''
+  if (mode === 'apply') return true
+
+  // Be permissive for incomplete events: apply calls always include proposalId.
+  return typeof params?.proposalId === 'string' && params.proposalId.length > 0
+}
+
+export async function findLatestWorkflowEditToolCallId(): Promise<string | undefined> {
   try {
     const { useCopilotStore } = await import('@/stores/panel/copilot/store')
     const { messages, toolCallsById } = useCopilotStore.getState()
@@ -134,17 +148,22 @@ export async function findLatestEditWorkflowToolCallId(): Promise<string | undef
       const message = messages[mi]
       if (message.role !== 'assistant' || !message.contentBlocks) continue
       for (const block of message.contentBlocks) {
-        if (block?.type === 'tool_call' && block.toolCall?.name === 'edit_workflow') {
+        if (
+          block?.type === 'tool_call' &&
+          isWorkflowEditToolCall(block.toolCall?.name, block.toolCall?.params)
+        ) {
           return block.toolCall?.id
         }
       }
     }
 
-    const fallback = Object.values(toolCallsById).filter((call) => call.name === 'edit_workflow')
+    const fallback = Object.values(toolCallsById).filter((call) =>
+      isWorkflowEditToolCall(call.name, call.params)
+    )
 
     return fallback.length ? fallback[fallback.length - 1].id : undefined
   } catch (error) {
-    logger.warn('Failed to resolve edit_workflow tool call id', { error })
+    logger.warn('Failed to resolve workflow edit tool call id', { error })
     return undefined
   }
 }

apps/sim/tools/exa/answer.ts

@@ -1,9 +1,6 @@
-import { createLogger } from '@sim/logger'
 import type { ExaAnswerParams, ExaAnswerResponse } from '@/tools/exa/types'
 import type { ToolConfig } from '@/tools/types'
 
-const logger = createLogger('ExaAnswerTool')
-
 export const answerTool: ToolConfig<ExaAnswerParams, ExaAnswerResponse> = {
   id: 'exa_answer',
   name: 'Exa Answer',
@@ -30,23 +27,6 @@ export const answerTool: ToolConfig<ExaAnswerParams, ExaAnswerResponse> = {
       description: 'Exa AI API Key',
     },
   },
-  hosting: {
-    envKeys: ['EXA_API_KEY'],
-    apiKeyParam: 'apiKey',
-    byokProviderId: 'exa',
-    pricing: {
-      type: 'custom',
-      getCost: (_params, response) => {
-        // Use costDollars from Exa API response
-        if (response.costDollars?.total) {
-          return { cost: response.costDollars.total, metadata: { costDollars: response.costDollars } }
-        }
-        // Fallback: $5/1000 requests
-        logger.warn('Exa answer response missing costDollars, using fallback pricing')
-        return 0.005
-      },
-    },
-  },
 
   request: {
     url: 'https://api.exa.ai/answer',
@@ -81,7 +61,6 @@ export const answerTool: ToolConfig<ExaAnswerParams, ExaAnswerResponse> = {
             url: citation.url,
             text: citation.text || '',
           })) || [],
-        costDollars: data.costDollars,
       },
     }
   },

apps/sim/tools/exa/find_similar_links.ts

@@ -1,9 +1,6 @@
-import { createLogger } from '@sim/logger'
 import type { ExaFindSimilarLinksParams, ExaFindSimilarLinksResponse } from '@/tools/exa/types'
 import type { ToolConfig } from '@/tools/types'
 
-const logger = createLogger('ExaFindSimilarLinksTool')
-
 export const findSimilarLinksTool: ToolConfig<
   ExaFindSimilarLinksParams,
   ExaFindSimilarLinksResponse
@@ -79,24 +76,6 @@ export const findSimilarLinksTool: ToolConfig<
       description: 'Exa AI API Key',
     },
   },
-  hosting: {
-    envKeys: ['EXA_API_KEY'],
-    apiKeyParam: 'apiKey',
-    byokProviderId: 'exa',
-    pricing: {
-      type: 'custom',
-      getCost: (_params, response) => {
-        // Use costDollars from Exa API response
-        if (response.costDollars?.total) {
-          return { cost: response.costDollars.total, metadata: { costDollars: response.costDollars } }
-        }
-        // Fallback: $5/1000 (1-25 results) or $25/1000 (26-100 results)
-        logger.warn('Exa find_similar_links response missing costDollars, using fallback pricing')
-        const resultCount = response.similarLinks?.length || 0
-        return resultCount <= 25 ? 0.005 : 0.025
-      },
-    },
-  },
 
   request: {
     url: 'https://api.exa.ai/findSimilar',
@@ -161,7 +140,6 @@ export const findSimilarLinksTool: ToolConfig<
           highlights: result.highlights,
           score: result.score || 0,
         })),
-        costDollars: data.costDollars,
       },
     }
   },

apps/sim/tools/exa/get_contents.ts

@@ -1,9 +1,6 @@
-import { createLogger } from '@sim/logger'
 import type { ExaGetContentsParams, ExaGetContentsResponse } from '@/tools/exa/types'
 import type { ToolConfig } from '@/tools/types'
 
-const logger = createLogger('ExaGetContentsTool')
-
 export const getContentsTool: ToolConfig<ExaGetContentsParams, ExaGetContentsResponse> = {
   id: 'exa_get_contents',
   name: 'Exa Get Contents',
@@ -64,23 +61,6 @@ export const getContentsTool: ToolConfig<ExaGetContentsParams, ExaGetContentsRes
       description: 'Exa AI API Key',
     },
   },
-  hosting: {
-    envKeys: ['EXA_API_KEY'],
-    apiKeyParam: 'apiKey',
-    byokProviderId: 'exa',
-    pricing: {
-      type: 'custom',
-      getCost: (_params, response) => {
-        // Use costDollars from Exa API response
-        if (response.costDollars?.total) {
-          return { cost: response.costDollars.total, metadata: { costDollars: response.costDollars } }
-        }
-        // Fallback: $1/1000 pages
-        logger.warn('Exa get_contents response missing costDollars, using fallback pricing')
-        return (response.results?.length || 0) * 0.001
-      },
-    },
-  },
 
   request: {
     url: 'https://api.exa.ai/contents',
@@ -152,7 +132,6 @@ export const getContentsTool: ToolConfig<ExaGetContentsParams, ExaGetContentsRes
           summary: result.summary || '',
           highlights: result.highlights,
         })),
-        costDollars: data.costDollars,
       },
     }
   },

apps/sim/tools/exa/research.ts

@@ -34,25 +34,6 @@ export const researchTool: ToolConfig<ExaResearchParams, ExaResearchResponse> =
       description: 'Exa AI API Key',
     },
   },
-  hosting: {
-    envKeys: ['EXA_API_KEY'],
-    apiKeyParam: 'apiKey',
-    byokProviderId: 'exa',
-    pricing: {
-      type: 'custom',
-      getCost: (params, response) => {
-        // Use costDollars from Exa API response
-        if (response.costDollars?.total) {
-          return { cost: response.costDollars.total, metadata: { costDollars: response.costDollars } }
-        }
-
-        // Fallback to estimate if cost not available
-        logger.warn('Exa research response missing costDollars, using fallback pricing')
-        const model = params.model || 'exa-research'
-        return model === 'exa-research-pro' ? 0.055 : 0.03
-      },
-    },
-  },
 
   request: {
     url: 'https://api.exa.ai/research/v1',
@@ -130,8 +111,6 @@ export const researchTool: ToolConfig<ExaResearchParams, ExaResearchResponse> =
                 score: 1.0,
               },
             ],
-            // Include cost breakdown for pricing calculation
-            costDollars: taskData.costDollars,
           }
           return result
         }