use unused var

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

@@ -1,81 +1,145 @@
+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 { SIM_AGENT_API_URL } from '@/lib/copilot/constants'
+import { getSession } from '@/lib/auth'
-import { authenticateCopilotRequestSessionOnly } from '@/lib/copilot/request-helpers'
-import { env } from '@/lib/core/config/env'
 
 const logger = createLogger('CopilotAutoAllowedToolsAPI')
 
-function copilotHeaders(): HeadersInit {
+/**
-  const headers: Record<string, string> = {
+ * GET - Fetch user's auto-allowed integration tools
-    'Content-Type': 'application/json',
+ */
-  }
+export async function GET() {
-  if (env.COPILOT_API_KEY) {
+  try {
-    headers['x-api-key'] = env.COPILOT_API_KEY
+    const session = await getSession()
-  }
-  return headers
-}
 
-export async function DELETE(request: NextRequest) {
+    if (!session?.user?.id) {
-  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 userId = session.user.id
-  const toolIdFromBody = await request
+
-    .json()
+    const [userSettings] = await db
-    .then((body) => (typeof body?.toolId === 'string' ? body.toolId : undefined))
+      .select()
-    .catch(() => undefined)
+      .from(settings)
-  const toolId = toolIdFromBody || toolIdFromQuery
+      .where(eq(settings.userId, userId))
-  if (!toolId) {
+      .limit(1)
-    return NextResponse.json({ error: 'toolId is required' }, { status: 400 })
+
+    if (userSettings) {
+      const autoAllowedTools = (userSettings.copilotAutoAllowedTools as string[]) || []
+      return NextResponse.json({ autoAllowedTools })
     }
 
-  try {
+    await db.insert(settings).values({
-    const res = await fetch(`${SIM_AGENT_API_URL}/api/tool-preferences/auto-allowed`, {
+      id: userId,
-      method: 'DELETE',
-      headers: copilotHeaders(),
-      body: JSON.stringify({
       userId,
-        toolId,
+      copilotAutoAllowedTools: [],
-      }),
     })
 
-    const payload = await res.json().catch(() => ({}))
+    return NextResponse.json({ autoAllowedTools: [] })
-    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 }
-      )
-    }
-
-    return NextResponse.json({
-      success: true,
-      autoAllowedTools: Array.isArray(payload?.autoAllowedTools) ? payload.autoAllowedTools : [],
-    })
   } catch (error) {
-    logger.error('Error removing auto-allowed tool', {
+    logger.error('Failed to fetch auto-allowed tools', { error })
-      userId,
+    return NextResponse.json({ error: 'Internal server error' }, { status: 500 })
-      toolId,
+  }
-      error: error instanceof Error ? error.message : String(error),
+}
-    })
+
-    return NextResponse.json(
+/**
-      {
+ * POST - Add a tool to the auto-allowed list
-        success: false,
+ */
-        error: 'Failed to remove auto-allowed tool',
+export async function POST(request: NextRequest) {
-        autoAllowedTools: [],
+  try {
-      },
+    const session = await getSession()
-      { status: 500 }
+
-    )
+    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) {
+  try {
+    const session = await getSession()
+
+    if (!session?.user?.id) {
+      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+    }
+
+    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: [] })
+  } catch (error) {
+    logger.error('Failed to remove auto-allowed tool', { error })
+    return NextResponse.json({ error: 'Internal server error' }, { status: 500 })
   }
 }

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

@@ -28,24 +28,13 @@ 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) {
+  if (!message || !model) return null
-    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',
@@ -55,13 +44,6 @@ 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,
@@ -81,32 +63,10 @@ async function requestChatTitleFromCopilot(params: {
       return null
     }
 
-    const rawTitle = typeof payload?.title === 'string' ? payload.title : ''
+    const title = typeof payload?.title === 'string' ? payload.title.trim() : ''
-    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:', {
+    logger.error('Error generating chat title:', error)
-      error,
-      model,
-      provider: provider || null,
-      messagePreview: truncateForLog(message),
-    })
     return null
   }
 }
@@ -278,7 +238,6 @@ export async function POST(req: NextRequest) {
     let currentChat: any = null
     let conversationHistory: any[] = []
     let actualChatId = chatId
-    let chatWasCreatedForRequest = false
     const selectedModel = model || 'claude-opus-4-6'
 
     if (chatId || createNewChat) {
@@ -290,7 +249,6 @@ 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
@@ -298,18 +256,6 @@ 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
@@ -402,22 +348,10 @@ export async function POST(req: NextRequest) {
             await pushEvent({ type: 'chat_id', chatId: actualChatId })
           }
 
-          if (shouldGenerateTitleForRequest) {
+          if (actualChatId && !currentChat?.title && conversationHistory.length === 0) {
-            logger.info(`[${tracker.requestId}] Starting title generation for streaming response`, {
+            requestChatTitleFromCopilot({ message, model: selectedModel, provider })
-              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({
@@ -425,30 +359,12 @@ export async function POST(req: NextRequest) {
                       updatedAt: new Date(),
                     })
                     .where(eq(copilotChats.id, actualChatId!))
-                  await pushEvent({ type: 'title_updated', title, chatId: actualChatId })
+                  await pushEvent({ type: 'title_updated', title })
-                  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 {
@@ -563,9 +479,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 (shouldGenerateTitleForRequest) {
+      if (actualChatId && !currentChat.title && conversationHistory.length === 0) {
         logger.info(`[${tracker.requestId}] Starting title generation for non-streaming response`)
-        requestChatTitleFromCopilot(titleGenerationParams)
+        requestChatTitleFromCopilot({ message, model: selectedModel, provider })
           .then(async (title) => {
             if (title) {
               await db
@@ -576,22 +492,11 @@ 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,11 +1,7 @@
 import { createLogger } from '@sim/logger'
 import { type NextRequest, NextResponse } from 'next/server'
 import { z } from 'zod'
-import {
+import { REDIS_TOOL_CALL_PREFIX, REDIS_TOOL_CALL_TTL_SECONDS } from '@/lib/copilot/constants'
-  REDIS_TOOL_CALL_PREFIX,
-  REDIS_TOOL_CALL_TTL_SECONDS,
-  SIM_AGENT_API_URL,
-} from '@/lib/copilot/constants'
 import {
   authenticateCopilotRequestSessionOnly,
   createBadRequestResponse,
@@ -14,7 +10,6 @@ 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')
@@ -26,8 +21,6 @@ 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(),
 })
 
 /**
@@ -64,44 +57,6 @@ 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)
@@ -119,7 +74,7 @@ export async function POST(req: NextRequest) {
     }
 
     const body = await req.json()
-    const { toolCallId, status, message, toolName, remember } = ConfirmationSchema.parse(body)
+    const { toolCallId, status, message } = ConfirmationSchema.parse(body)
 
     // Update the tool call status in Redis
     const updated = await updateToolCallStatus(toolCallId, status, message)
@@ -135,22 +90,14 @@ export async function POST(req: NextRequest) {
       return createBadRequestResponse('Failed to update tool call status or tool call not found')
     }
 
-    let rememberSaved = false
+    const duration = tracker.getDuration()
-    if (status === 'accepted' && remember === true && toolName && authenticatedUserId) {
-      rememberSaved = await saveAutoAllowedToolPreference(authenticatedUserId, toolName)
-    }
 
-    const response: Record<string, unknown> = {
+    return NextResponse.json({
       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/workspace/[workspaceId]/w/[workflowId]/components/diff-controls/diff-controls.tsx

@@ -14,14 +14,6 @@ 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)
@@ -72,7 +64,7 @@ export const DiffControls = memo(function DiffControls() {
           const b = blocks[bi]
           if (b?.type === 'tool_call') {
             const tn = b.toolCall?.name
-            if (isWorkflowEditToolCall(tn, b.toolCall?.params)) {
+            if (tn === 'edit_workflow') {
               id = b.toolCall?.id
               break outer
             }
@@ -80,9 +72,7 @@ export const DiffControls = memo(function DiffControls() {
         }
       }
       if (!id) {
-        const candidates = Object.values(toolCallsById).filter((t) =>
+        const candidates = Object.values(toolCallsById).filter((t) => t.name === 'edit_workflow')
-          isWorkflowEditToolCall(t.name, t.params)
-        )
         id = candidates.length ? candidates[candidates.length - 1].id : undefined
       }
       if (id) updatePreviewToolCallState('accepted', id)
@@ -112,7 +102,7 @@ export const DiffControls = memo(function DiffControls() {
           const b = blocks[bi]
           if (b?.type === 'tool_call') {
             const tn = b.toolCall?.name
-            if (isWorkflowEditToolCall(tn, b.toolCall?.params)) {
+            if (tn === 'edit_workflow') {
               id = b.toolCall?.id
               break outer
             }
@@ -120,9 +110,7 @@ export const DiffControls = memo(function DiffControls() {
         }
       }
       if (!id) {
-        const candidates = Object.values(toolCallsById).filter((t) =>
+        const candidates = Object.values(toolCallsById).filter((t) => t.name === 'edit_workflow')
-          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,27 +47,6 @@ 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
@@ -892,10 +871,7 @@ const SubagentContentRenderer = memo(function SubagentContentRenderer({
           )
         }
         if (segment.type === 'tool' && segment.block.toolCall) {
-          if (
+          if (toolCall.name === 'edit' && segment.block.toolCall.name === 'edit_workflow') {
-            (toolCall.name === 'edit' || toolCall.name === 'build') &&
-            isWorkflowEditSummaryTool(segment.block.toolCall)
-          ) {
             return (
               <div key={`tool-${segment.block.toolCall.id || index}`}>
                 <WorkflowEditSummary toolCall={segment.block.toolCall} />
@@ -992,11 +968,12 @@ const WorkflowEditSummary = memo(function WorkflowEditSummary({
     }
   }, [blocks])
 
-  if (!isWorkflowEditSummaryTool(toolCall)) {
+  if (toolCall.name !== 'edit_workflow') {
     return null
   }
 
-  const params = getToolCallParams(toolCall)
+  const params =
+    (toolCall as any).parameters || (toolCall as any).input || (toolCall as any).params || {}
   let operations = Array.isArray(params.operations) ? params.operations : []
 
   if (operations.length === 0 && Array.isArray((toolCall as any).operations)) {
@@ -1242,6 +1219,11 @@ 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
@@ -1251,96 +1233,59 @@ function shouldShowRunSkipButtons(toolCall: CopilotToolCall): boolean {
     return false
   }
 
-  if (toolCall.ui?.showInterrupt !== true) {
+  // Never show buttons for tools the user has marked as always-allowed
+  if (useCopilotStore.getState().isToolAutoAllowed(toolCall.name)) {
     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
 }
 
 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({
+      body: JSON.stringify({ toolCallId, status }),
-        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 (isClientRunCapability(toolCall)) {
+  if (CLIENT_EXECUTABLE_RUN_TOOLS.has(toolCall.name)) {
     const params = editedParams || toolCall.params || {}
     executeRunToolOnClient(toolCall.id, toolCall.name, params)
   }
@@ -1353,9 +1298,6 @@ 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]
@@ -1400,37 +1342,53 @@ 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 } = useCopilotStore()
+  const { setToolCallState, addAutoAllowedTool } = useCopilotStore()
 
-  const onAction = async (action: ToolUiAction) => {
+  const onRun = async () => {
     // Prevent race condition - check ref synchronously
     if (actionInProgressRef.current) return
     actionInProgressRef.current = true
     setIsProcessing(true)
     setButtonsHidden(true)
     try {
-      const decision = actionDecision(action)
+      await handleRun(toolCall, setToolCallState, onStateChange, editedParams)
-      if (decision === 'accepted') {
+    } finally {
-        await handleRun(toolCall, setToolCallState, onStateChange, editedParams, {
+      setIsProcessing(false)
-          remember: action.remember === true,
+      actionInProgressRef.current = false
-        })
-      } else if (decision === 'rejected') {
-        await handleSkip(toolCall, setToolCallState, onStateChange)
-      } else {
-        setToolCallState(toolCall, ClientToolCallState.background)
-        onStateChange?.('background')
-        await sendToolDecision(toolCall.id, 'background')
     }
+  }
+
+  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)
     } finally {
       setIsProcessing(false)
       actionInProgressRef.current = false
@@ -1439,22 +1397,23 @@ 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]'>
-      {actions.map((action, index) => {
+      <Button onClick={onRun} disabled={isProcessing} variant='tertiary'>
-        const variant =
+        {isProcessing ? 'Allowing...' : 'Allow'}
-          action.kind === 'reject' ? 'default' : action.remember ? 'default' : 'tertiary'
+      </Button>
-        return (
+      {showAlwaysAllow && (
-          <Button
+        <Button onClick={onAlwaysAllow} disabled={isProcessing} variant='default'>
-            key={action.id}
+          {isProcessing ? 'Allowing...' : 'Always Allow'}
-            onClick={() => onAction(action)}
+        </Button>
-            disabled={isProcessing}
+      )}
-            variant={variant}
+      <Button onClick={onSkip} disabled={isProcessing} variant='default'>
-          >
+        Skip
-            {isProcessing && index === 0 ? 'Working...' : action.label}
       </Button>
-        )
-      })}
     </div>
   )
 }
@@ -1471,16 +1430,10 @@ export function ToolCall({
   const liveToolCall = useCopilotStore((s) =>
     effectiveId ? s.toolCallsById[effectiveId] : undefined
   )
-  const rawToolCall = liveToolCall || toolCallProp
+  const toolCall = liveToolCall || toolCallProp
-  const hasRealToolCall = !!rawToolCall
+
-  const toolCall: CopilotToolCall =
+  // Guard: nothing to render without a toolCall
-    rawToolCall ||
+  if (!toolCall) return null
-    ({
-      id: effectiveId || '',
-      name: '',
-      state: ClientToolCallState.generating,
-      params: {},
-    } as CopilotToolCall)
 
   const isExpandablePending =
     toolCall?.state === 'pending' &&
@@ -1488,15 +1441,17 @@ 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)
 
-  const { setToolCallState } = useCopilotStore()
+  // Check if this integration tool is auto-allowed
-  const isAutoAllowed = toolCall.ui?.autoAllowed === true && !autoAllowRemovedForCall
+  const { removeAutoAllowedTool, setToolCallState } = useCopilotStore()
+  const isAutoAllowed = useCopilotStore(
+    (s) => isIntegrationTool(toolCall.name) && s.isToolAutoAllowed(toolCall.name)
+  )
 
   // Update edited params when toolCall params change (deep comparison to avoid resetting user edits on ref change)
   useEffect(() => {
@@ -1506,14 +1461,6 @@ 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' ||
@@ -1525,9 +1472,7 @@ export function ToolCall({
     return null
 
   // Special rendering for subagent tools - show as thinking text with tool calls at top level
-  const isSubagentTool =
+  const isSubagentTool = TOOL_DISPLAY_REGISTRY[toolCall.name]?.uiConfig?.subagent === true
-    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) {
@@ -1554,6 +1499,28 @@ 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
@@ -1563,14 +1530,6 @@ 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
@@ -2028,12 +1987,9 @@ export function ToolCall({
           <div className='mt-[10px]'>
             <Button
               onClick={async () => {
-                const removed = await removeAutoAllowedToolPreference(toolCall.name)
+                await removeAutoAllowedTool(toolCall.name)
-                if (removed) {
-                  setAutoAllowRemovedForCall(true)
                 setShowRemoveAutoAllow(false)
                 forceUpdate({})
-                }
               }}
               variant='default'
               className='text-xs'
@@ -2047,7 +2003,6 @@ export function ToolCall({
             toolCall={toolCall}
             onStateChange={handleStateChange}
             editedParams={editedParams}
-            actions={interruptActions}
           />
         )}
         {/* Render subagent content as thinking text */}
@@ -2093,12 +2048,9 @@ export function ToolCall({
           <div className='mt-[10px]'>
             <Button
               onClick={async () => {
-                const removed = await removeAutoAllowedToolPreference(toolCall.name)
+                await removeAutoAllowedTool(toolCall.name)
-                if (removed) {
-                  setAutoAllowRemovedForCall(true)
                 setShowRemoveAutoAllow(false)
                 forceUpdate({})
-                }
               }}
               variant='default'
               className='text-xs'
@@ -2112,7 +2064,6 @@ export function ToolCall({
             toolCall={toolCall}
             onStateChange={handleStateChange}
             editedParams={editedParams}
-            actions={interruptActions}
           />
         )}
         {/* Render subagent content as thinking text */}
@@ -2136,7 +2087,7 @@ export function ToolCall({
     }
   }
 
-  const isEditWorkflow = isWorkflowEditSummaryTool(toolCall)
+  const isEditWorkflow = toolCall.name === 'edit_workflow'
   const shouldShowDetails = isRunWorkflow || (isExpandableTool && expanded)
   const hasOperations = Array.isArray(params.operations) && params.operations.length > 0
   const hideTextForEditWorkflow = isEditWorkflow && hasOperations
@@ -2158,12 +2109,9 @@ export function ToolCall({
         <div className='mt-[10px]'>
           <Button
             onClick={async () => {
-              const removed = await removeAutoAllowedToolPreference(toolCall.name)
+              await removeAutoAllowedTool(toolCall.name)
-              if (removed) {
-                setAutoAllowRemovedForCall(true)
               setShowRemoveAutoAllow(false)
               forceUpdate({})
-              }
             }}
             variant='default'
             className='text-xs'
@@ -2177,7 +2125,6 @@ export function ToolCall({
           toolCall={toolCall}
           onStateChange={handleStateChange}
           editedParams={editedParams}
-          actions={interruptActions}
         />
       ) : showMoveToBackground ? (
         <div className='mt-[10px]'>
@@ -2208,7 +2155,7 @@ export function ToolCall({
           </Button>
         </div>
       ) : null}
-      {/* Workflow edit summary - shows block changes after workflow_change(apply) */}
+      {/* Workflow edit summary - shows block changes after edit_workflow completes */}
       <WorkflowEditSummary toolCall={toolCall} />
 
       {/* Render subagent content as thinking text */}

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

@@ -113,6 +113,7 @@ export const Copilot = forwardRef<CopilotRef, CopilotProps>(({ panelWidth }, ref
     clearPlanArtifact,
     savePlanArtifact,
     loadAvailableModels,
+    loadAutoAllowedTools,
     resumeActiveStream,
   } = useCopilotStore()
 
@@ -124,6 +125,8 @@ export const Copilot = forwardRef<CopilotRef, CopilotProps>(({ panelWidth }, ref
     setCopilotWorkflowId,
     loadChats,
     loadAvailableModels,
+    loadAutoAllowedTools,
+    currentChat,
     isSendingMessage,
     resumeActiveStream,
   })
@@ -151,8 +154,6 @@ 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) {
@@ -165,14 +166,6 @@ 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()
@@ -355,7 +348,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)]'>
-            {renderedChatTitle}
+            {currentChat?.title || 'New Chat'}
           </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,6 +12,8 @@ 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>
 }
@@ -30,6 +32,8 @@ export function useCopilotInitialization(props: UseCopilotInitializationProps) {
     setCopilotWorkflowId,
     loadChats,
     loadAvailableModels,
+    loadAutoAllowedTools,
+    currentChat,
     isSendingMessage,
     resumeActiveStream,
   } = props
@@ -116,6 +120,17 @@ 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/lib/copilot/chat-payload.ts

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

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

@@ -1,21 +1,22 @@
 import { createLogger } from '@sim/logger'
-import { STREAM_STORAGE_KEY } from '@/lib/copilot/constants'
+import { COPILOT_CONFIRM_API_PATH, 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 } from '@/lib/copilot/store-utils'
+import {
+  isBackgroundState,
+  isRejectedState,
+  isReviewState,
+  resolveToolDisplay,
+} 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')
@@ -25,11 +26,21 @@ const MAX_BATCH_INTERVAL = 50
 const MIN_BATCH_INTERVAL = 16
 const MAX_QUEUE_SIZE = 5
 
-function isClientRunCapability(toolCall: CopilotToolCall): boolean {
+/**
-  if (toolCall.execution?.target === 'sim_client_capability') {
+ * Send an auto-accept confirmation to the server for auto-allowed tools.
-    return toolCall.execution.capabilityId === 'workflow.run' || !toolCall.execution.capabilityId
+ * The server-side orchestrator polls Redis for this decision.
-  }
+ */
-  return CLIENT_EXECUTABLE_RUN_TOOLS.has(toolCall.name)
+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 writeActiveStreamToStorage(info: CopilotStreamInfo | null): void {
@@ -219,86 +230,28 @@ export const sseHandlers: Record<string, SSEHandler> = {
     }
   },
   title_updated: (_data, _context, get, set) => {
-    const title = typeof _data.title === 'string' ? _data.title.trim() : ''
+    const title = _data.title
-    const eventChatId = typeof _data.chatId === 'string' ? _data.chatId : undefined
+    if (!title) return
     const { currentChat, chats } = get()
-
+    if (currentChat) {
-    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: { ...currentChat, title },
-        currentChat.id === targetChatId
+        chats: chats.map((c) => (c.id === currentChat.id ? { ...c, title } : c)),
-          ? {
+      })
-              ...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) => {
     try {
       const eventData = asRecord(data?.data)
       const toolCallId: string | undefined =
-        data?.toolCallId ||
+        data?.toolCallId || (eventData.id as string | undefined)
-        (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) ||
@@ -307,33 +260,16 @@ export const sseHandlers: Record<string, SSEHandler> = {
         ) {
           return
         }
-        if (
+        const targetState = success
-          targetState === ClientToolCallState.success &&
+          ? ClientToolCallState.success
-          isWorkflowChangeApplyCall(current.name, paramsForCurrentToolCall)
+          : failedDependency || skipped
-        ) {
+            ? ClientToolCallState.rejected
-          const operations = extractOperationListFromResultPayload(resultPayload || {})
+            : ClientToolCallState.error
-          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: resolveDisplayFromServerUi(
+          display: resolveToolDisplay(current.name, targetState, current.id, current.params),
-            current.name,
-            targetState,
-            current.id,
-            paramsForCurrentToolCall,
-            uiMetadata || current.ui
-          ),
         }
         set({ toolCallsById: updatedMap })
 
@@ -376,11 +312,138 @@ export const sseHandlers: Record<string, SSEHandler> = {
           }
         }
 
-        applyToolEffects({
+        if (current.name === 'edit_workflow') {
-          effectsRaw: eventData.effects,
+          try {
-          toolCall: updatedMap[toolCallId],
+            const resultPayload = asRecord(
-          resultPayload,
+              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),
+            })
+          }
+        }
       }
 
       for (let i = 0; i < context.contentBlocks.length; i++) {
@@ -397,24 +460,16 @@ 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: resolveDisplayFromServerUi(
+              display: resolveToolDisplay(
                 b.toolCall?.name,
                 targetState,
                 toolCallId,
-                paramsForBlock,
+                b.toolCall?.params
-                uiMetadata || b.toolCall?.ui
               ),
             },
           }
@@ -432,9 +487,7 @@ export const sseHandlers: Record<string, SSEHandler> = {
     try {
       const errorData = asRecord(data?.data)
       const toolCallId: string | undefined =
-        data?.toolCallId ||
+        data?.toolCallId || (errorData.id as string | undefined)
-        (errorData.id as string | undefined) ||
-        (errorData.callId as string | undefined)
       const failedDependency: boolean = data?.failedDependency === true
       if (!toolCallId) return
       const { toolCallsById } = get()
@@ -447,26 +500,14 @@ export const sseHandlers: Record<string, SSEHandler> = {
         ) {
           return
         }
-        const targetState = errorData.state
+        const targetState = failedDependency
-          ? mapServerStateToClientState(errorData.state)
-          : failedDependency
           ? ClientToolCallState.rejected
           : ClientToolCallState.error
-        const uiMetadata = extractToolUiMetadata(errorData)
-        const executionMetadata = extractToolExecutionMetadata(errorData)
         const updatedMap = { ...toolCallsById }
         updatedMap[toolCallId] = {
           ...current,
-          ui: uiMetadata || current.ui,
-          execution: executionMetadata || current.execution,
           state: targetState,
-          display: resolveDisplayFromServerUi(
+          display: resolveToolDisplay(current.name, targetState, current.id, current.params),
-            current.name,
-            targetState,
-            current.id,
-            current.params,
-            uiMetadata || current.ui
-          ),
         }
         set({ toolCallsById: updatedMap })
       }
@@ -479,26 +520,19 @@ export const sseHandlers: Record<string, SSEHandler> = {
             isBackgroundState(b.toolCall?.state)
           )
             break
-          const targetState = errorData.state
+          const targetState = failedDependency
-            ? mapServerStateToClientState(errorData.state)
-            : failedDependency
             ? ClientToolCallState.rejected
             : ClientToolCallState.error
-          const uiMetadata = extractToolUiMetadata(errorData)
-          const executionMetadata = extractToolExecutionMetadata(errorData)
           context.contentBlocks[i] = {
             ...b,
             toolCall: {
               ...b.toolCall,
-              ui: uiMetadata || b.toolCall?.ui,
-              execution: executionMetadata || b.toolCall?.execution,
               state: targetState,
-              display: resolveDisplayFromServerUi(
+              display: resolveToolDisplay(
                 b.toolCall?.name,
                 targetState,
                 toolCallId,
-                b.toolCall?.params,
+                b.toolCall?.params
-                uiMetadata || b.toolCall?.ui
               ),
             },
           }
@@ -513,28 +547,20 @@ export const sseHandlers: Record<string, SSEHandler> = {
     }
   },
   tool_generating: (data, context, get, set) => {
-    const eventData = asRecord(data?.data)
+    const { toolCallId, toolName } = data
-    const toolCallId =
-      data?.toolCallId ||
-      (eventData.id as string | undefined) ||
-      (eventData.callId as string | undefined)
-    const toolName =
-      data?.toolName ||
-      (eventData.name as string | undefined) ||
-      (eventData.toolName as string | undefined)
     if (!toolCallId || !toolName) return
     const { toolCallsById } = get()
 
     if (!toolCallsById[toolCallId]) {
-      const initialState = ClientToolCallState.generating
+      const isAutoAllowed = get().isToolAutoAllowed(toolName)
-      const uiMetadata = extractToolUiMetadata(eventData)
+      const initialState = isAutoAllowed
+        ? ClientToolCallState.executing
+        : ClientToolCallState.pending
       const tc: CopilotToolCall = {
         id: toolCallId,
         name: toolName,
         state: initialState,
-        ui: uiMetadata,
+        display: resolveToolDisplay(toolName, initialState, toolCallId),
-        execution: extractToolExecutionMetadata(eventData),
-        display: resolveDisplayFromServerUi(toolName, initialState, toolCallId, undefined, uiMetadata),
       }
       const updated = { ...toolCallsById, [toolCallId]: tc }
       set({ toolCallsById: updated })
@@ -546,27 +572,17 @@ export const sseHandlers: Record<string, SSEHandler> = {
   },
   tool_call: (data, context, get, set) => {
     const toolData = asRecord(data?.data)
-    const id: string | undefined =
+    const id: string | undefined = (toolData.id as string | undefined) || data?.toolCallId
-      (toolData.id as string | undefined) ||
+    const name: string | undefined = (toolData.name as string | undefined) || data?.toolName
-      (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'
-    let initialState = serverState
+    const isAutoAllowed = get().isToolAutoAllowed(toolName)
-      ? mapServerStateToClientState(serverState)
+    let initialState = isAutoAllowed ? ClientToolCallState.executing : ClientToolCallState.pending
-      : ClientToolCallState.pending
 
     // Avoid flickering back to pending on partial/duplicate events once a tool is executing.
     if (
@@ -581,25 +597,15 @@ export const sseHandlers: Record<string, SSEHandler> = {
           ...existing,
           name: toolName,
           state: initialState,
-          ui: uiMetadata || existing.ui,
-          execution: executionMetadata || existing.execution,
           ...(args ? { params: args } : {}),
-          display: resolveDisplayFromServerUi(
+          display: resolveToolDisplay(toolName, initialState, id, args || existing.params),
-            toolName,
-            initialState,
-            id,
-            args || existing.params,
-            uiMetadata || existing.ui
-          ),
         }
       : {
           id,
           name: toolName,
           state: initialState,
-          ui: uiMetadata,
-          execution: executionMetadata,
           ...(args ? { params: args } : {}),
-          display: resolveDisplayFromServerUi(toolName, initialState, id, args, uiMetadata),
+          display: resolveToolDisplay(toolName, initialState, id, args),
         }
     const updated = { ...toolCallsById, [id]: next }
     set({ toolCallsById: updated })
@@ -612,12 +618,20 @@ export const sseHandlers: Record<string, SSEHandler> = {
       return
     }
 
-    const shouldInterrupt = next.ui?.showInterrupt === true
+    // Auto-allowed tools: send confirmation to the server so it can proceed
+    // without waiting for the user to click "Allow".
+    if (isAutoAllowed) {
+      sendAutoAcceptConfirmation(id)
+    }
 
-    // Client-run capability: execution is delegated to the browser.
+    // Client-executable run tools: execute on the client for real-time feedback
-    // We run immediately only when no interrupt is required.
+    // (block pulsing, console logs, stop button). The server defers execution
-    if (isClientRunCapability(next) && !shouldInterrupt) {
+    // for these tools in interactive mode; the client reports back via mark-complete.
-      executeRunToolOnClient(id, toolName, args || next.params || {})
+    if (
+      CLIENT_EXECUTABLE_RUN_TOOLS.has(toolName) &&
+      initialState === ClientToolCallState.executing
+    ) {
+      executeRunToolOnClient(id, toolName, args || existing?.params || {})
     }
 
     // OAuth: dispatch event to open the OAuth connect modal

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

@@ -15,7 +15,10 @@ const logger = createLogger('CopilotRunToolExecution')
  * (block pulsing, logs, stop button, etc.).
  */
 export const CLIENT_EXECUTABLE_RUN_TOOLS = new Set([
-  'workflow_run',
+  'run_workflow',
+  'run_workflow_until_block',
+  'run_from_block',
+  'run_block',
 ])
 
 /**
@@ -71,44 +74,21 @@ 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 === 'workflow_run' && runMode === 'until_block') {
+    if (toolName === 'run_workflow_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 === 'workflow_run' && runMode === 'from_block' && params.startBlockId) {
+    if (toolName === 'run_from_block' && params.startBlockId) {
       return {
         startBlockId: params.startBlockId as string,
         executionId: (params.executionId as string | undefined) || 'latest',
       }
     }
-    if (toolName === 'workflow_run' && runMode === 'block' && params.blockId) {
+    if (toolName === 'run_block' && params.blockId) {
       return {
         startBlockId: params.blockId as string,
         executionId: (params.executionId as string | undefined) || 'latest',

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

@@ -6,23 +6,16 @@ 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')
@@ -31,13 +24,6 @@ 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,
@@ -178,8 +164,6 @@ 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>
@@ -215,10 +199,9 @@ export const subAgentSSEHandlers: Record<string, SSEHandler> = {
     const existingToolCall =
       existingIndex >= 0 ? context.subAgentToolCalls[parentToolCallId][existingIndex] : undefined
 
-    const serverState = toolData.state
+    // Auto-allowed tools skip pending state to avoid flashing interrupt buttons
-    let initialState = serverState
+    const isAutoAllowed = get().isToolAutoAllowed(name)
-      ? mapServerStateToClientState(serverState)
+    let initialState = isAutoAllowed ? ClientToolCallState.executing : ClientToolCallState.pending
-      : ClientToolCallState.pending
 
     // Avoid flickering back to pending on partial/duplicate events once a tool is executing.
     if (
@@ -232,10 +215,8 @@ export const subAgentSSEHandlers: Record<string, SSEHandler> = {
       id,
       name,
       state: initialState,
-      ui: uiMetadata,
-      execution: executionMetadata,
       ...(args ? { params: args } : {}),
-      display: resolveDisplayFromServerUi(name, initialState, id, args, uiMetadata),
+      display: resolveToolDisplay(name, initialState, id, args),
     }
 
     if (existingIndex >= 0) {
@@ -260,11 +241,16 @@ export const subAgentSSEHandlers: Record<string, SSEHandler> = {
       return
     }
 
-    const shouldInterrupt = subAgentToolCall.ui?.showInterrupt === true
+    // Auto-allowed tools: send confirmation to the server so it can proceed
+    // without waiting for the user to click "Allow".
+    if (isAutoAllowed) {
+      sendAutoAcceptConfirmation(id)
+    }
 
-    // Client-run capability: execution is delegated to the browser.
+    // Client-executable run tools: if auto-allowed, execute immediately for
-    // Execute immediately only for non-interrupting calls.
+    // real-time feedback. For non-auto-allowed, the user must click "Allow"
-    if (isClientRunCapability(subAgentToolCall) && !shouldInterrupt) {
+    // first — handleRun in tool-call.tsx triggers executeRunToolOnClient.
+    if (CLIENT_EXECUTABLE_RUN_TOOLS.has(name) && isAutoAllowed) {
       executeRunToolOnClient(id, name, args || {})
     }
   },
@@ -289,51 +275,17 @@ export const subAgentSSEHandlers: Record<string, SSEHandler> = {
     if (!context.subAgentToolCalls[parentToolCallId]) return
     if (!context.subAgentBlocks[parentToolCallId]) return
 
-    const serverState = resultData.state
+    const targetState = success ? ClientToolCallState.success : ClientToolCallState.error
-    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: resolveDisplayFromServerUi(
+        display: resolveToolDisplay(existing.name, targetState, toolCallId, existing.params),
-          existing.name,
-          targetState,
-          toolCallId,
-          nextParams,
-          uiMetadata || existing.ui
-        ),
       }
       context.subAgentToolCalls[parentToolCallId][existingIndex] = updatedSubAgentToolCall
 
@@ -357,12 +309,6 @@ export const subAgentSSEHandlers: Record<string, SSEHandler> = {
           state: targetState,
         })
       }
-
-      applyToolEffects({
-        effectsRaw: resultData.effects,
-        toolCall: updatedSubAgentToolCall,
-        resultPayload,
-      })
     }
 
     updateToolCallWithSubAgentData(context, get, set, parentToolCallId)

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

@@ -1,134 +0,0 @@
-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.ts

@@ -1,175 +0,0 @@
-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 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 = asRecord(payload.workflowState)
-  if (payloadState) return payloadState as unknown as WorkflowState
-
-  if (resultPayload) {
-    const directState = asRecord(resultPayload.workflowState)
-    if (directState) return directState as unknown as WorkflowState
-    const editResult = asRecord(resultPayload.editResult)
-    const nestedState = asRecord(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,6 +101,9 @@ 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

@@ -0,0 +1,67 @@
+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/handlers.ts

@@ -1,12 +1,17 @@
 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 { markToolComplete } from '@/lib/copilot/orchestrator/tool-executor'
+import {
+  isIntegrationTool,
+  isToolAvailableOnSimSide,
+  markToolComplete,
+} from '@/lib/copilot/orchestrator/tool-executor'
 import type {
   ContentBlock,
   ExecutionContext,
@@ -17,6 +22,7 @@ import type {
 } from '@/lib/copilot/orchestrator/types'
 import {
   executeToolAndReport,
+  isInterruptToolName,
   waitForToolCompletion,
   waitForToolDecision,
 } from './tool-execution'
@@ -29,208 +35,12 @@ const logger = createLogger('CopilotSseHandlers')
  * execution to the browser client instead of running executeWorkflow directly.
  */
 const CLIENT_EXECUTABLE_RUN_TOOLS = new Set([
-  'workflow_run',
+  'run_workflow',
+  'run_workflow_until_block',
+  'run_from_block',
+  'run_block',
 ])
 
-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): {
@@ -275,11 +85,7 @@ export const sseHandlers: Record<string, SSEHandler> = {
 
     const { success, hasResultData, hasError } = inferToolSuccess(data)
 
-    current.status = data?.state
+    current.status = success ? 'success' : 'error'
-      ? mapServerStateToToolStatus(data.state)
-      : success
-        ? 'success'
-        : 'error'
     current.endTime = Date.now()
     if (hasResultData) {
       current.result = {
@@ -298,7 +104,7 @@ export const sseHandlers: Record<string, SSEHandler> = {
     if (!toolCallId) return
     const current = context.toolCalls.get(toolCallId)
     if (!current) return
-    current.status = data?.state ? mapServerStateToToolStatus(data.state) : 'error'
+    current.status = 'error'
     current.error = (data?.error as string | undefined) || 'Tool execution failed'
     current.endTime = Date.now()
   },
@@ -315,7 +121,7 @@ export const sseHandlers: Record<string, SSEHandler> = {
       context.toolCalls.set(toolCallId, {
         id: toolCallId,
         name: toolName,
-        status: data?.state ? mapServerStateToToolStatus(data.state) : 'pending',
+        status: 'pending',
         startTime: Date.now(),
       })
     }
@@ -350,7 +156,7 @@ export const sseHandlers: Record<string, SSEHandler> = {
       context.toolCalls.set(toolCallId, {
         id: toolCallId,
         name: toolName,
-        status: toolData.state ? mapServerStateToToolStatus(toolData.state) : 'pending',
+        status: 'pending',
         params: args,
         startTime: Date.now(),
       })
@@ -364,15 +170,147 @@ export const sseHandlers: Record<string, SSEHandler> = {
     const toolCall = context.toolCalls.get(toolCallId)
     if (!toolCall) return
 
-    await executeToolCallWithPolicy(
+    // Subagent tools are executed by the copilot backend, not sim side.
-      toolCall,
+    if (SUBAGENT_TOOL_SET.has(toolName)) {
-      toolName,
+      return
-      toolData,
+    }
-      context,
+
-      execContext,
+    // Respond tools are internal to copilot's subagent system - skip execution.
-      options,
+    // The copilot backend handles these internally to signal subagent completion.
-      'run tool'
+    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)
+    }
   },
   reasoning: (event, context) => {
     const d = asRecord(event.data)
@@ -472,7 +410,7 @@ export const subAgentHandlers: Record<string, SSEHandler> = {
     const toolCall: ToolCallState = {
       id: toolCallId,
       name: toolName,
-      status: toolData.state ? mapServerStateToToolStatus(toolData.state) : 'pending',
+      status: 'pending',
       params: args,
       startTime: Date.now(),
     }
@@ -490,15 +428,157 @@ export const subAgentHandlers: Record<string, SSEHandler> = {
 
     if (isPartial) return
 
-    await executeToolCallWithPolicy(
+    // Respond tools are internal to copilot's subagent system - skip execution.
-      toolCall,
+    if (RESPOND_TOOL_SET.has(toolName)) {
-      toolName,
+      toolCall.status = 'success'
-      toolData,
+      toolCall.endTime = Date.now()
-      context,
+      toolCall.result = {
-      execContext,
+        success: true,
-      options,
+        output: 'Internal respond tool - handled by copilot backend',
-      'subagent run tool'
+      }
+      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)
+    }
   },
   tool_result: (event, context) => {
     const parentToolCallId = context.subAgentParentToolCallId
@@ -516,7 +596,7 @@ export const subAgentHandlers: Record<string, SSEHandler> = {
 
     const { success, hasResultData, hasError } = inferToolSuccess(data)
 
-    const status = data?.state ? mapServerStateToToolStatus(data.state) : success ? 'success' : 'error'
+    const status = success ? 'success' : 'error'
     const endTime = Date.now()
     const result = hasResultData ? { success, output: data?.result || data?.data } : undefined
 

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

@@ -4,6 +4,7 @@ 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,
@@ -20,6 +21,10 @@ 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,
@@ -29,11 +34,9 @@ export async function executeToolAndReport(
   const toolCall = context.toolCalls.get(toolCallId)
   if (!toolCall) return
 
-  const lockable = toolCall as typeof toolCall & { __simExecuting?: boolean }
+  if (toolCall.status === 'executing') return
-  if (lockable.__simExecuting) return
   if (wasToolResultSeen(toolCall.id)) return
 
-  lockable.__simExecuting = true
   toolCall.status = 'executing'
   try {
     const result = await executeToolServerSide(toolCall, execContext)
@@ -119,8 +122,6 @@ export async function executeToolAndReport(
       },
     }
     await options?.onEvent?.(errorEvent)
-  } finally {
-    delete lockable.__simExecuting
   }
 }
 

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

@@ -14,7 +14,7 @@ describe('sse-utils', () => {
       type: 'tool_result',
       data: JSON.stringify({
         id: 'tool_1',
-        name: 'workflow_change',
+        name: 'edit_workflow',
         success: true,
         result: { ok: true },
       }),
@@ -23,7 +23,7 @@ describe('sse-utils', () => {
     const normalized = normalizeSseEvent(event as any)
 
     expect(normalized.toolCallId).toBe('tool_1')
-    expect(normalized.toolName).toBe('workflow_change')
+    expect(normalized.toolName).toBe('edit_workflow')
     expect(normalized.success).toBe(true)
     expect(normalized.result).toEqual({ ok: true })
   })

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

@@ -220,8 +220,7 @@ export async function executeDeployMcp(
     if (!workflowRecord.isDeployed) {
       return {
         success: false,
-        error:
+        error: 'Workflow must be deployed before adding as an MCP tool. Use deploy_api first.',
-          '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,8 +50,6 @@ import type {
   RunWorkflowParams,
   RunWorkflowUntilBlockParams,
   SetGlobalWorkflowVariablesParams,
-  WorkflowDeployParams,
-  WorkflowRunParams,
 } from './param-types'
 import { PLATFORM_ACTIONS_CONTENT } from './platform-actions'
 import {
@@ -320,91 +318,13 @@ 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',
-  'workflow_context_get',
+  'edit_workflow',
-  'workflow_context_expand',
-  'workflow_change',
-  'workflow_verify',
   'get_workflow_console',
   'search_documentation',
   'search_online',
@@ -432,7 +352,11 @@ 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),
-  workflow_run: (p, c) => executeWorkflowRunUnified(p, 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),
   get_deployed_workflow_state: (p, c) =>
     executeGetDeployedWorkflowState(p as GetDeployedWorkflowStateParams, c),
   generate_api_key: (p, c) => executeGenerateApiKey(p as unknown as GenerateApiKeyParams, c),
@@ -443,7 +367,10 @@ const SIM_WORKFLOW_TOOL_HANDLERS: Record<
     }),
   set_global_workflow_variables: (p, c) =>
     executeSetGlobalWorkflowVariables(p as SetGlobalWorkflowVariablesParams, c),
-  workflow_deploy: (p, c) => executeWorkflowDeployUnified(p, 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),
   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,18 +93,6 @@ 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
 }
@@ -181,39 +169,6 @@ 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/tools/client/tool-display-registry.ts

@@ -592,40 +592,16 @@ const META_edit: ToolMetadata = {
   },
 }
 
-const META_workflow_change: ToolMetadata = {
+const META_edit_workflow: ToolMetadata = {
   displayNames: {
-    [ClientToolCallState.generating]: { text: 'Planning workflow changes', icon: Loader2 },
+    [ClientToolCallState.generating]: { text: 'Editing your workflow', icon: Loader2 },
-    [ClientToolCallState.executing]: { text: 'Applying workflow changes', icon: Loader2 },
+    [ClientToolCallState.executing]: { text: 'Editing your workflow', icon: Loader2 },
-    [ClientToolCallState.success]: { text: 'Updated your workflow', icon: Grid2x2Check },
+    [ClientToolCallState.success]: { text: 'Edited your workflow', icon: Grid2x2Check },
-    [ClientToolCallState.error]: { text: 'Failed to update your workflow', icon: XCircle },
+    [ClientToolCallState.error]: { text: 'Failed to edit 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 workflow changes', icon: MinusCircle },
+    [ClientToolCallState.aborted]: { text: 'Aborted editing your workflow', icon: MinusCircle },
-    [ClientToolCallState.pending]: { text: 'Planning workflow changes', icon: Loader2 },
+    [ClientToolCallState.pending]: { text: 'Editing your workflow', 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,
@@ -633,42 +609,6 @@ const META_workflow_change: 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 },
@@ -2601,12 +2541,7 @@ const TOOL_METADATA_BY_ID: Record<string, ToolMetadata> = {
   deploy_chat: META_deploy_chat,
   deploy_mcp: META_deploy_mcp,
   edit: META_edit,
-  workflow_context_get: META_workflow_context_get,
+  edit_workflow: META_edit_workflow,
-  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

@@ -191,10 +191,10 @@ export const DIRECT_TOOL_DEFS: DirectToolDef[] = [
     },
   },
   {
-    name: 'workflow_run',
+    name: 'run_workflow',
-    toolId: 'workflow_run',
+    toolId: 'run_workflow',
     description:
-      'Run a workflow using one unified interface. Supports full runs and partial execution modes.',
+      '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: {
@@ -202,40 +202,114 @@ export const DIRECT_TOOL_DEFS: DirectToolDef[] = [
           type: 'string',
           description: 'REQUIRED. The workflow ID to run.',
         },
-        mode: {
-          type: 'string',
-          description: 'Execution mode: full, until_block, from_block, or block. Default: full.',
-          enum: ['full', 'until_block', 'from_block', 'block'],
-        },
         workflow_input: {
           type: 'object',
           description:
-            'JSON object with input values. Keys should match workflow start block input names.',
+            'JSON object with input values. Keys should match the workflow start block input field names.',
-        },
-        stopAfterBlockId: {
-          type: 'string',
-          description: 'Required when mode is until_block.',
-        },
-        startBlockId: {
-          type: 'string',
-          description: 'Required when mode is from_block.',
-        },
-        blockId: {
-          type: 'string',
-          description: 'Required when mode is block.',
-        },
-        executionId: {
-          type: 'string',
-          description: 'Optional execution snapshot ID for from_block or block modes.',
         },
         useDeployedState: {
           type: 'boolean',
-          description: 'When true, runs deployed state instead of draft. Default: false.',
+          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',
@@ -457,10 +531,10 @@ ALSO CAN:
     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 using workflow_run mode "full"
+- Full run with test inputs
-- Stop after a specific block using workflow_run mode "until_block"
+- Stop after a specific block (run_workflow_until_block)
-- Run a single block in isolation using workflow_run mode "block"
+- Run a single block in isolation (run_block)
-- Resume from a specific block using workflow_run mode "from_block"`,
+- Resume from a specific block (run_from_block)`,
     inputSchema: {
       type: 'object',
       properties: {

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

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

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

@@ -11,13 +11,8 @@ 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 }
@@ -32,6 +27,7 @@ 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,
@@ -39,10 +35,6 @@ 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

@@ -1,185 +0,0 @@
-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
-  }
-
-  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[]
-  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 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

@@ -68,8 +68,8 @@ async function getCurrentWorkflowStateFromDb(
   return { workflowState, subBlockValues }
 }
 
-export const applyWorkflowOperationsServerTool: BaseServerTool<EditWorkflowParams, unknown> = {
+export const editWorkflowServerTool: BaseServerTool<EditWorkflowParams, unknown> = {
-  name: '__internal_apply_workflow_operations',
+  name: 'edit_workflow',
   async execute(params: EditWorkflowParams, context?: { userId: string }): Promise<unknown> {
     const logger = createLogger('EditWorkflowServerTool')
     const { operations, workflowId, currentUserWorkflow } = params
@@ -90,7 +90,7 @@ export const applyWorkflowOperationsServerTool: BaseServerTool<EditWorkflowParam
       throw new Error(authorization.message || 'Unauthorized workflow access')
     }
 
-    logger.info('Executing internal workflow operation apply', {
+    logger.info('Executing edit_workflow', {
       operationCount: operations.length,
       workflowId,
       hasCurrentUserWorkflow: !!currentUserWorkflow,
@@ -210,7 +210,7 @@ export const applyWorkflowOperationsServerTool: BaseServerTool<EditWorkflowParam
       logger.warn('No userId in context - skipping custom tools persistence', { workflowId })
     }
 
-    logger.info('Internal workflow operation apply succeeded', {
+    logger.info('edit_workflow successfully applied operations', {
       operationCount: operations.length,
       blocksCount: Object.keys(modifiedWorkflowState.blocks).length,
       edgesCount: modifiedWorkflowState.edges.length,

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

@@ -1,166 +0,0 @@
-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 { getContextPack, saveContextPack } 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>
-
-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 blockTypesInWorkflow = Object.values(workflowState.blocks || {}).map((block: any) =>
-      String(block?.type || '')
-    )
-    const requestedTypes = params.includeBlockTypes || []
-    const schemaMode =
-      params.includeAllSchemas === true ? 'all' : (params.schemaMode || 'minimal')
-    const candidateTypes =
-      schemaMode === 'all'
-        ? getAllKnownBlockTypes()
-        : schemaMode === 'workflow'
-          ? [...blockTypesInWorkflow, ...requestedTypes]
-          : [...requestedTypes]
-    const { schemasByType, schemaRefsByType } = buildSchemasByType(candidateTypes)
-    const suggestedSchemaTypes = [...new Set(blockTypesInWorkflow.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,
-      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 requestedBlockTypes = new Set<string>()
-    for (const blockType of params.blockTypes || []) {
-      if (blockType) requestedBlockTypes.add(blockType)
-    }
-    for (const schemaRef of params.schemaRefs || []) {
-      const blockType = parseSchemaRefToBlockType(schemaRef)
-      if (blockType) requestedBlockTypes.add(blockType)
-    }
-
-    const typesToExpand = [...requestedBlockTypes]
-    const { schemasByType, schemaRefsByType } = buildSchemasByType(typesToExpand)
-
-    return {
-      success: true,
-      contextPackId: params.contextPackId,
-      workflowId: contextPack.workflowId,
-      snapshotHash: contextPack.snapshotHash,
-      schemasByType,
-      schemaRefsByType,
-    }
-  },
-}

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

@@ -1,226 +0,0 @@
-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')
-
-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 {
-  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 blocks = workflowState.blocks || {}
-  const edges = workflowState.edges || []
-  const blockTypes: Record<string, number> = {}
-  const triggerBlocks: Array<{ id: string; name: string; type: string }> = []
-
-  for (const [blockId, block] of Object.entries(blocks)) {
-    const blockType = String((block as Record<string, unknown>).type || 'unknown')
-    blockTypes[blockType] = (blockTypes[blockType] || 0) + 1
-    if ((block as Record<string, unknown>).triggerMode === true) {
-      triggerBlocks.push({
-        id: blockId,
-        name: String((block as Record<string, unknown>).name || blockType),
-        type: blockType,
-      })
-    }
-  }
-
-  return {
-    blockCount: Object.keys(blocks).length,
-    edgeCount: edges.length,
-    loopCount: Object.keys(workflowState.loops || {}).length,
-    parallelCount: Object.keys(workflowState.parallels || {}).length,
-    blockTypes,
-    triggerBlocks,
-  }
-}
-
-export function getAllKnownBlockTypes(): string[] {
-  return getAllBlockTypes()
-}

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

@@ -1,194 +0,0 @@
-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 resolveBlockToken(
-  workflowState: { blocks: Record<string, any> },
-  token: string
-): string | null {
-  if (!token) return null
-  if (workflowState.blocks[token]) return token
-  const normalized = normalizeName(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
-  }
-  return null
-}
-
-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[]; checks: Array<Record<string, any>> } {
-  const failures: 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('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 - mark as warning failure for explicit visibility.
-    checks.push({ assert: assertion, passed: false, reason: 'unknown_assertion_type' })
-    failures.push(`Unknown assertion format: ${assertion}`)
-  }
-
-  return { failures, 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,
-    })
-
-    return {
-      success: true,
-      verified,
-      snapshotHash,
-      validation: {
-        valid: validation.valid,
-        errors: validation.errors,
-        warnings: validation.warnings,
-      },
-      assertions: assertionResults.checks,
-      failures: assertionResults.failures,
-    }
-  },
-}

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

@@ -18,6 +18,7 @@ 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,
@@ -83,14 +84,6 @@ 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 {
@@ -147,6 +140,41 @@ 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).
@@ -452,6 +480,11 @@ 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) {
@@ -1004,6 +1037,8 @@ async function resumeFromLiveStream(
   return false
 }
 
+const cachedAutoAllowedTools = readAutoAllowedToolsFromStorage()
+
 // Initial state (subset required for UI/streaming)
 const initialState = {
   mode: 'build' as const,
@@ -1038,6 +1073,8 @@ 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,
@@ -1076,6 +1113,8 @@ export const useCopilotStore = create<CopilotStore>()(
         agentPrefetch: get().agentPrefetch,
         availableModels: get().availableModels,
         isLoadingModels: get().isLoadingModels,
+        autoAllowedTools: get().autoAllowedTools,
+        autoAllowedToolsLoaded: get().autoAllowedToolsLoaded,
       })
     },
 
@@ -1390,6 +1429,16 @@ 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
 
@@ -1656,7 +1705,7 @@ export const useCopilotStore = create<CopilotStore>()(
             const b = blocks[bi]
             if (b?.type === 'tool_call') {
               const tn = b.toolCall?.name
-              if (isWorkflowEditToolCall(tn, b.toolCall?.params)) {
+              if (tn === 'edit_workflow') {
                 id = b.toolCall?.id
                 break outer
               }
@@ -1665,9 +1714,7 @@ export const useCopilotStore = create<CopilotStore>()(
         }
         // Fallback to map if not found in messages
         if (!id) {
-          const candidates = Object.values(toolCallsById).filter((t) =>
+          const candidates = Object.values(toolCallsById).filter((t) => t.name === 'edit_workflow')
-            isWorkflowEditToolCall(t.name, t.params)
-          )
           id = candidates.length ? candidates[candidates.length - 1].id : undefined
         }
       }
@@ -2360,6 +2407,74 @@ 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,26 +26,6 @@ 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 */
@@ -187,6 +167,10 @@ 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
 
@@ -263,6 +247,11 @@ 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/workflow-diff/store.ts

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

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

@@ -126,20 +126,6 @@ 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()
@@ -148,22 +134,17 @@ export async function findLatestWorkflowEditToolCallId(): Promise<string | undef
       const message = messages[mi]
       if (message.role !== 'assistant' || !message.contentBlocks) continue
       for (const block of message.contentBlocks) {
-        if (
+        if (block?.type === 'tool_call' && block.toolCall?.name === 'edit_workflow') {
-          block?.type === 'tool_call' &&
-          isWorkflowEditToolCall(block.toolCall?.name, block.toolCall?.params)
-        ) {
           return block.toolCall?.id
         }
       }
     }
 
-    const fallback = Object.values(toolCallsById).filter((call) =>
+    const fallback = Object.values(toolCallsById).filter((call) => call.name === 'edit_workflow')
-      isWorkflowEditToolCall(call.name, call.params)
-    )
 
     return fallback.length ? fallback[fallback.length - 1].id : undefined
   } catch (error) {
-    logger.warn('Failed to resolve workflow edit tool call id', { error })
+    logger.warn('Failed to resolve edit_workflow tool call id', { error })
     return undefined
   }
 }