v0.5.80: lock feature, enterprise modules, time formatting consolidation, files, UX and UI improvements, longer timeouts

v0.5.79: longer MCP tools timeout, optimize loop/parallel regeneration, enrich.so integration
v0.5.78: billing fixes, mcp timeout increase, reactquery migrations, updated tool param visibilities, DSPy and Google Maps integrations
2026-02-05 04:05:14 -05:00 · 2026-02-04 18:27:05 -08:00 · 2026-01-31 21:57:56 -08:00 · 2026-01-31 13:48:22 -08:00 · 2026-01-30 14:57:17 -08:00 · 2026-01-29 00:13:19 -08:00
28 changed files with 1135 additions and 6773 deletions
--- a/apps/sim/app/api/copilot/chat/route.ts
+++ b/apps/sim/app/api/copilot/chat/route.ts
@@ -7,14 +7,8 @@ import { z } from 'zod'
 import { getSession } from '@/lib/auth'
 import { generateChatTitle } from '@/lib/copilot/chat-title'
 import { getCopilotModel } from '@/lib/copilot/config'
-import { SIM_AGENT_VERSION } from '@/lib/copilot/constants'
+import { SIM_AGENT_API_URL_DEFAULT, SIM_AGENT_VERSION } from '@/lib/copilot/constants'
 import { COPILOT_MODEL_IDS, COPILOT_REQUEST_MODES } from '@/lib/copilot/models'
-import { orchestrateCopilotStream } from '@/lib/copilot/orchestrator'
-import {
-  createStreamEventWriter,
-  resetStreamBuffer,
-  setStreamMeta,
-} from '@/lib/copilot/orchestrator/stream-buffer'
 import {
  authenticateCopilotRequestSessionOnly,
  createBadRequestResponse,
@@ -27,12 +21,13 @@ import type { CopilotProviderConfig } from '@/lib/copilot/types'
 import { env } from '@/lib/core/config/env'
 import { CopilotFiles } from '@/lib/uploads'
 import { createFileContent } from '@/lib/uploads/utils/file-utils'
-import { resolveWorkflowIdForUser } from '@/lib/workflows/utils'
 import { tools } from '@/tools/registry'
 import { getLatestVersionTools, stripVersionSuffix } from '@/tools/utils'

 const logger = createLogger('CopilotChatAPI')

+const SIM_AGENT_API_URL = env.SIM_AGENT_API_URL || SIM_AGENT_API_URL_DEFAULT
+
 const FileAttachmentSchema = z.object({
  id: z.string(),
  key: z.string(),
@@ -45,8 +40,7 @@ const ChatMessageSchema = z.object({
  message: z.string().min(1, 'Message is required'),
  userMessageId: z.string().optional(), // ID from frontend for the user message
  chatId: z.string().optional(),
-  workflowId: z.string().optional(),
-  workflowName: z.string().optional(),
+  workflowId: z.string().min(1, 'Workflow ID is required'),
  model: z.enum(COPILOT_MODEL_IDS).optional().default('claude-4.5-opus'),
  mode: z.enum(COPILOT_REQUEST_MODES).optional().default('agent'),
  prefetch: z.boolean().optional(),
@@ -106,8 +100,7 @@ export async function POST(req: NextRequest) {
      message,
      userMessageId,
      chatId,
-      workflowId: providedWorkflowId,
-      workflowName,
+      workflowId,
      model,
      mode,
      prefetch,
@@ -120,20 +113,6 @@ export async function POST(req: NextRequest) {
      contexts,
      commands,
    } = ChatMessageSchema.parse(body)
-
-    // Resolve workflowId - if not provided, use first workflow or find by name
-    const resolved = await resolveWorkflowIdForUser(
-      authenticatedUserId,
-      providedWorkflowId,
-      workflowName
-    )
-    if (!resolved) {
-      return createBadRequestResponse(
-        'No workflows found. Create a workflow first or provide a valid workflowId.'
-      )
-    }
-    const workflowId = resolved.workflowId
-
    // Ensure we have a consistent user message ID for this request
    const userMessageIdToUse = userMessageId || crypto.randomUUID()
    try {
@@ -486,53 +465,77 @@ export async function POST(req: NextRequest) {
      })
    } catch {}

-    if (stream) {
-      const streamId = userMessageIdToUse
-      let eventWriter: ReturnType<typeof createStreamEventWriter> | null = null
-      let clientDisconnected = false
+    const simAgentResponse = await fetch(`${SIM_AGENT_API_URL}/api/chat-completion-streaming`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        ...(env.COPILOT_API_KEY ? { 'x-api-key': env.COPILOT_API_KEY } : {}),
+      },
+      body: JSON.stringify(requestPayload),
+    })
+
+    if (!simAgentResponse.ok) {
+      if (simAgentResponse.status === 401 || simAgentResponse.status === 402) {
+        // Rethrow status only; client will render appropriate assistant message
+        return new NextResponse(null, { status: simAgentResponse.status })
+      }
+
+      const errorText = await simAgentResponse.text().catch(() => '')
+      logger.error(`[${tracker.requestId}] Sim agent API error:`, {
+        status: simAgentResponse.status,
+        error: errorText,
+      })
+
+      return NextResponse.json(
+        { error: `Sim agent API error: ${simAgentResponse.statusText}` },
+        { status: simAgentResponse.status }
+      )
+    }
+
+    // If streaming is requested, forward the stream and update chat later
+    if (stream && simAgentResponse.body) {
+      // Create user message to save
+      const userMessage = {
+        id: userMessageIdToUse, // Consistent ID used for request and persistence
+        role: 'user',
+        content: message,
+        timestamp: new Date().toISOString(),
+        ...(fileAttachments && fileAttachments.length > 0 && { fileAttachments }),
+        ...(Array.isArray(contexts) && contexts.length > 0 && { contexts }),
+        ...(Array.isArray(contexts) &&
+          contexts.length > 0 && {
+            contentBlocks: [{ type: 'contexts', contexts: contexts as any, timestamp: Date.now() }],
+          }),
+      }
+
+      // Create a pass-through stream that captures the response
      const transformedStream = new ReadableStream({
        async start(controller) {
          const encoder = new TextEncoder()
+          let assistantContent = ''
+          const toolCalls: any[] = []
+          let buffer = ''
+          const isFirstDone = true
+          let responseIdFromStart: string | undefined
+          let responseIdFromDone: string | undefined
+          // Track tool call progress to identify a safe done event
+          const announcedToolCallIds = new Set<string>()
+          const startedToolExecutionIds = new Set<string>()
+          const completedToolExecutionIds = new Set<string>()
+          let lastDoneResponseId: string | undefined
+          let lastSafeDoneResponseId: string | undefined

-          await resetStreamBuffer(streamId)
-          await setStreamMeta(streamId, { status: 'active', userId: authenticatedUserId })
-          eventWriter = createStreamEventWriter(streamId)
-
-          const shouldFlushEvent = (event: Record<string, any>) =>
-            event.type === 'tool_call' ||
-            event.type === 'tool_result' ||
-            event.type === 'tool_error' ||
-            event.type === 'subagent_end' ||
-            event.type === 'structured_result' ||
-            event.type === 'subagent_result' ||
-            event.type === 'done' ||
-            event.type === 'error'
-
-          const pushEvent = async (event: Record<string, any>) => {
-            if (!eventWriter) return
-            const entry = await eventWriter.write(event)
-            if (shouldFlushEvent(event)) {
-              await eventWriter.flush()
-            }
-            const payload = {
-              ...event,
-              eventId: entry.eventId,
-              streamId,
-            }
-            try {
-              if (!clientDisconnected) {
-                controller.enqueue(encoder.encode(`data: ${JSON.stringify(payload)}\n\n`))
-              }
-            } catch {
-              clientDisconnected = true
-              await eventWriter.flush()
-            }
-          }
-
+          // Send chatId as first event
          if (actualChatId) {
-            await pushEvent({ type: 'chat_id', chatId: actualChatId })
+            const chatIdEvent = `data: ${JSON.stringify({
+              type: 'chat_id',
+              chatId: actualChatId,
+            })}\n\n`
+            controller.enqueue(encoder.encode(chatIdEvent))
+            logger.debug(`[${tracker.requestId}] Sent initial chatId event to client`)
          }

+          // Start title generation in parallel if needed
          if (actualChatId && !currentChat?.title && conversationHistory.length === 0) {
            generateChatTitle(message)
              .then(async (title) => {
@@ -544,64 +547,311 @@ export async function POST(req: NextRequest) {
                      updatedAt: new Date(),
                    })
                    .where(eq(copilotChats.id, actualChatId!))
-                  await pushEvent({ type: 'title_updated', title })
+
+                  const titleEvent = `data: ${JSON.stringify({
+                    type: 'title_updated',
+                    title: title,
+                  })}\n\n`
+                  controller.enqueue(encoder.encode(titleEvent))
+                  logger.info(`[${tracker.requestId}] Generated and saved title: ${title}`)
                }
              })
              .catch((error) => {
                logger.error(`[${tracker.requestId}] Title generation failed:`, error)
              })
+          } else {
+            logger.debug(`[${tracker.requestId}] Skipping title generation`)
          }

+          // Forward the sim agent stream and capture assistant response
+          const reader = simAgentResponse.body!.getReader()
+          const decoder = new TextDecoder()
+
          try {
-            const result = await orchestrateCopilotStream(requestPayload, {
-              userId: authenticatedUserId,
-              workflowId,
-              chatId: actualChatId,
-              autoExecuteTools: true,
-              interactive: true,
-              onEvent: async (event) => {
-                await pushEvent(event)
-              },
+            while (true) {
+              const { done, value } = await reader.read()
+              if (done) {
+                break
+              }
+
+              // Decode and parse SSE events for logging and capturing content
+              const decodedChunk = decoder.decode(value, { stream: true })
+              buffer += decodedChunk
+
+              const lines = buffer.split('\n')
+              buffer = lines.pop() || '' // Keep incomplete line in buffer
+
+              for (const line of lines) {
+                if (line.trim() === '') continue // Skip empty lines
+
+                if (line.startsWith('data: ') && line.length > 6) {
+                  try {
+                    const jsonStr = line.slice(6)
+
+                    // Check if the JSON string is unusually large (potential streaming issue)
+                    if (jsonStr.length > 50000) {
+                      // 50KB limit
+                      logger.warn(`[${tracker.requestId}] Large SSE event detected`, {
+                        size: jsonStr.length,
+                        preview: `${jsonStr.substring(0, 100)}...`,
+                      })
+                    }
+
+                    const event = JSON.parse(jsonStr)
+
+                    // Log different event types comprehensively
+                    switch (event.type) {
+                      case 'content':
+                        if (event.data) {
+                          assistantContent += event.data
+                        }
+                        break
+
+                      case 'reasoning':
+                        logger.debug(
+                          `[${tracker.requestId}] Reasoning chunk received (${(event.data || event.content || '').length} chars)`
+                        )
+                        break
+
+                      case 'tool_call':
+                        if (!event.data?.partial) {
+                          toolCalls.push(event.data)
+                          if (event.data?.id) {
+                            announcedToolCallIds.add(event.data.id)
+                          }
+                        }
+                        break
+
+                      case 'tool_generating':
+                        if (event.toolCallId) {
+                          startedToolExecutionIds.add(event.toolCallId)
+                        }
+                        break
+
+                      case 'tool_result':
+                        if (event.toolCallId) {
+                          completedToolExecutionIds.add(event.toolCallId)
+                        }
+                        break
+
+                      case 'tool_error':
+                        logger.error(`[${tracker.requestId}] Tool error:`, {
+                          toolCallId: event.toolCallId,
+                          toolName: event.toolName,
+                          error: event.error,
+                          success: event.success,
+                        })
+                        if (event.toolCallId) {
+                          completedToolExecutionIds.add(event.toolCallId)
+                        }
+                        break
+
+                      case 'start':
+                        if (event.data?.responseId) {
+                          responseIdFromStart = event.data.responseId
+                        }
+                        break
+
+                      case 'done':
+                        if (event.data?.responseId) {
+                          responseIdFromDone = event.data.responseId
+                          lastDoneResponseId = responseIdFromDone
+
+                          // Mark this done as safe only if no tool call is currently in progress or pending
+                          const announced = announcedToolCallIds.size
+                          const completed = completedToolExecutionIds.size
+                          const started = startedToolExecutionIds.size
+                          const hasToolInProgress = announced > completed || started > completed
+                          if (!hasToolInProgress) {
+                            lastSafeDoneResponseId = responseIdFromDone
+                          }
+                        }
+                        break
+
+                      case 'error':
+                        break
+
+                      default:
+                    }
+
+                    // Emit to client: rewrite 'error' events into user-friendly assistant message
+                    if (event?.type === 'error') {
+                      try {
+                        const displayMessage: string =
+                          (event?.data && (event.data.displayMessage as string)) ||
+                          'Sorry, I encountered an error. Please try again.'
+                        const formatted = `_${displayMessage}_`
+                        // Accumulate so it persists to DB as assistant content
+                        assistantContent += formatted
+                        // Send as content chunk
+                        try {
+                          controller.enqueue(
+                            encoder.encode(
+                              `data: ${JSON.stringify({ type: 'content', data: formatted })}\n\n`
+                            )
+                          )
+                        } catch (enqueueErr) {
+                          reader.cancel()
+                          break
+                        }
+                        // Then close this response cleanly for the client
+                        try {
+                          controller.enqueue(
+                            encoder.encode(`data: ${JSON.stringify({ type: 'done' })}\n\n`)
+                          )
+                        } catch (enqueueErr) {
+                          reader.cancel()
+                          break
+                        }
+                      } catch {}
+                      // Do not forward the original error event
+                    } else {
+                      // Forward original event to client
+                      try {
+                        controller.enqueue(encoder.encode(`data: ${jsonStr}\n\n`))
+                      } catch (enqueueErr) {
+                        reader.cancel()
+                        break
+                      }
+                    }
+                  } catch (e) {
+                    // Enhanced error handling for large payloads and parsing issues
+                    const lineLength = line.length
+                    const isLargePayload = lineLength > 10000
+
+                    if (isLargePayload) {
+                      logger.error(
+                        `[${tracker.requestId}] Failed to parse large SSE event (${lineLength} chars)`,
+                        {
+                          error: e,
+                          preview: `${line.substring(0, 200)}...`,
+                          size: lineLength,
+                        }
+                      )
+                    } else {
+                      logger.warn(
+                        `[${tracker.requestId}] Failed to parse SSE event: "${line.substring(0, 200)}..."`,
+                        e
+                      )
+                    }
+                  }
+                } else if (line.trim() && line !== 'data: [DONE]') {
+                  logger.debug(`[${tracker.requestId}] Non-SSE line from sim agent: "${line}"`)
+                }
+              }
+            }
+
+            // Process any remaining buffer
+            if (buffer.trim()) {
+              logger.debug(`[${tracker.requestId}] Processing remaining buffer: "${buffer}"`)
+              if (buffer.startsWith('data: ')) {
+                try {
+                  const jsonStr = buffer.slice(6)
+                  const event = JSON.parse(jsonStr)
+                  if (event.type === 'content' && event.data) {
+                    assistantContent += event.data
+                  }
+                  // Forward remaining event, applying same error rewrite behavior
+                  if (event?.type === 'error') {
+                    const displayMessage: string =
+                      (event?.data && (event.data.displayMessage as string)) ||
+                      'Sorry, I encountered an error. Please try again.'
+                    const formatted = `_${displayMessage}_`
+                    assistantContent += formatted
+                    try {
+                      controller.enqueue(
+                        encoder.encode(
+                          `data: ${JSON.stringify({ type: 'content', data: formatted })}\n\n`
+                        )
+                      )
+                      controller.enqueue(
+                        encoder.encode(`data: ${JSON.stringify({ type: 'done' })}\n\n`)
+                      )
+                    } catch (enqueueErr) {
+                      reader.cancel()
+                    }
+                  } else {
+                    try {
+                      controller.enqueue(encoder.encode(`data: ${jsonStr}\n\n`))
+                    } catch (enqueueErr) {
+                      reader.cancel()
+                    }
+                  }
+                } catch (e) {
+                  logger.warn(`[${tracker.requestId}] Failed to parse final buffer: "${buffer}"`)
+                }
+              }
+            }
+
+            // Log final streaming summary
+            logger.info(`[${tracker.requestId}] Streaming complete summary:`, {
+              totalContentLength: assistantContent.length,
+              toolCallsCount: toolCalls.length,
+              hasContent: assistantContent.length > 0,
+              toolNames: toolCalls.map((tc) => tc?.name).filter(Boolean),
            })

-            if (currentChat && result.conversationId) {
-              await db
-                .update(copilotChats)
-                .set({
-                  updatedAt: new Date(),
-                  conversationId: result.conversationId,
-                })
-                .where(eq(copilotChats.id, actualChatId!))
+            // NOTE: Messages are saved by the client via update-messages endpoint with full contentBlocks.
+            // Server only updates conversationId here to avoid overwriting client's richer save.
+            if (currentChat) {
+              // Persist only a safe conversationId to avoid continuing from a state that expects tool outputs
+              const previousConversationId = currentChat?.conversationId as string | undefined
+              const responseId = lastSafeDoneResponseId || previousConversationId || undefined
+
+              if (responseId) {
+                await db
+                  .update(copilotChats)
+                  .set({
+                    updatedAt: new Date(),
+                    conversationId: responseId,
+                  })
+                  .where(eq(copilotChats.id, actualChatId!))
+
+                logger.info(
+                  `[${tracker.requestId}] Updated conversationId for chat ${actualChatId}`,
+                  {
+                    updatedConversationId: responseId,
+                  }
+                )
+              }
            }
-            await eventWriter.close()
-            await setStreamMeta(streamId, { status: 'complete', userId: authenticatedUserId })
          } catch (error) {
-            logger.error(`[${tracker.requestId}] Orchestration error:`, error)
-            await eventWriter.close()
-            await setStreamMeta(streamId, {
-              status: 'error',
-              userId: authenticatedUserId,
-              error: error instanceof Error ? error.message : 'Stream error',
-            })
-            await pushEvent({
-              type: 'error',
-              data: {
-                displayMessage: 'An unexpected error occurred while processing the response.',
-              },
-            })
+            logger.error(`[${tracker.requestId}] Error processing stream:`, error)
+
+            // Send an error event to the client before closing so it knows what happened
+            try {
+              const errorMessage =
+                error instanceof Error && error.message === 'terminated'
+                  ? 'Connection to AI service was interrupted. Please try again.'
+                  : 'An unexpected error occurred while processing the response.'
+              const encoder = new TextEncoder()
+
+              // Send error as content so it shows in the chat
+              controller.enqueue(
+                encoder.encode(
+                  `data: ${JSON.stringify({ type: 'content', data: `\n\n_${errorMessage}_` })}\n\n`
+                )
+              )
+              // Send done event to properly close the stream on client
+              controller.enqueue(encoder.encode(`data: ${JSON.stringify({ type: 'done' })}\n\n`))
+            } catch (enqueueError) {
+              // Stream might already be closed, that's ok
+              logger.warn(
+                `[${tracker.requestId}] Could not send error event to client:`,
+                enqueueError
+              )
+            }
          } finally {
-            controller.close()
-          }
-        },
-        async cancel() {
-          clientDisconnected = true
-          if (eventWriter) {
-            await eventWriter.flush()
+            try {
+              controller.close()
+            } catch {
+              // Controller might already be closed
+            }
          }
        },
      })

-      return new Response(transformedStream, {
+      const response = new Response(transformedStream, {
        headers: {
          'Content-Type': 'text/event-stream',
          'Cache-Control': 'no-cache',
@@ -609,31 +859,43 @@ export async function POST(req: NextRequest) {
          'X-Accel-Buffering': 'no',
        },
      })
+
+      logger.info(`[${tracker.requestId}] Returning streaming response to client`, {
+        duration: tracker.getDuration(),
+        chatId: actualChatId,
+        headers: {
+          'Content-Type': 'text/event-stream',
+          'Cache-Control': 'no-cache',
+          Connection: 'keep-alive',
+        },
+      })
+
+      return response
    }

-    const nonStreamingResult = await orchestrateCopilotStream(requestPayload, {
-      userId: authenticatedUserId,
-      workflowId,
-      chatId: actualChatId,
-      autoExecuteTools: true,
-      interactive: true,
-    })
-
-    const responseData = {
-      content: nonStreamingResult.content,
-      toolCalls: nonStreamingResult.toolCalls,
-      model: selectedModel,
-      provider: providerConfig?.provider || env.COPILOT_PROVIDER || 'openai',
-    }
-
-    logger.info(`[${tracker.requestId}] Non-streaming response from orchestrator:`, {
+    // For non-streaming responses
+    const responseData = await simAgentResponse.json()
+    logger.info(`[${tracker.requestId}] Non-streaming response from sim agent:`, {
      hasContent: !!responseData.content,
      contentLength: responseData.content?.length || 0,
      model: responseData.model,
      provider: responseData.provider,
      toolCallsCount: responseData.toolCalls?.length || 0,
+      hasTokens: !!responseData.tokens,
    })

+    // Log tool calls if present
+    if (responseData.toolCalls?.length > 0) {
+      responseData.toolCalls.forEach((toolCall: any) => {
+        logger.info(`[${tracker.requestId}] Tool call in response:`, {
+          id: toolCall.id,
+          name: toolCall.name,
+          success: toolCall.success,
+          result: `${JSON.stringify(toolCall.result).substring(0, 200)}...`,
+        })
+      })
+    }
+
    // Save messages if we have a chat
    if (currentChat && responseData.content) {
      const userMessage = {
@@ -685,9 +947,6 @@ export async function POST(req: NextRequest) {
        .set({
          messages: updatedMessages,
          updatedAt: new Date(),
-          ...(nonStreamingResult.conversationId
-            ? { conversationId: nonStreamingResult.conversationId }
-            : {}),
        })
        .where(eq(copilotChats.id, actualChatId!))
    }
@@ -739,7 +998,10 @@ export async function GET(req: NextRequest) {
  try {
    const { searchParams } = new URL(req.url)
    const workflowId = searchParams.get('workflowId')
-    const chatId = searchParams.get('chatId')
+
+    if (!workflowId) {
+      return createBadRequestResponse('workflowId is required')
+    }

    // Get authenticated user using consolidated helper
    const { userId: authenticatedUserId, isAuthenticated } =
@@ -748,47 +1010,6 @@ export async function GET(req: NextRequest) {
      return createUnauthorizedResponse()
    }

-    // If chatId is provided, fetch a single chat
-    if (chatId) {
-      const [chat] = await db
-        .select({
-          id: copilotChats.id,
-          title: copilotChats.title,
-          model: copilotChats.model,
-          messages: copilotChats.messages,
-          planArtifact: copilotChats.planArtifact,
-          config: copilotChats.config,
-          createdAt: copilotChats.createdAt,
-          updatedAt: copilotChats.updatedAt,
-        })
-        .from(copilotChats)
-        .where(and(eq(copilotChats.id, chatId), eq(copilotChats.userId, authenticatedUserId)))
-        .limit(1)
-
-      if (!chat) {
-        return NextResponse.json({ success: false, error: 'Chat not found' }, { status: 404 })
-      }
-
-      const transformedChat = {
-        id: chat.id,
-        title: chat.title,
-        model: chat.model,
-        messages: Array.isArray(chat.messages) ? chat.messages : [],
-        messageCount: Array.isArray(chat.messages) ? chat.messages.length : 0,
-        planArtifact: chat.planArtifact || null,
-        config: chat.config || null,
-        createdAt: chat.createdAt,
-        updatedAt: chat.updatedAt,
-      }
-
-      logger.info(`Retrieved chat ${chatId}`)
-      return NextResponse.json({ success: true, chat: transformedChat })
-    }
-
-    if (!workflowId) {
-      return createBadRequestResponse('workflowId or chatId is required')
-    }
-
    // Fetch chats for this user and workflow
    const chats = await db
      .select({
--- a/apps/sim/app/api/copilot/chat/stream/route.ts
+++ b/apps/sim/app/api/copilot/chat/stream/route.ts
@@ -1,130 +0,0 @@
-import { createLogger } from '@sim/logger'
-import { type NextRequest, NextResponse } from 'next/server'
-import {
-  getStreamMeta,
-  readStreamEvents,
-  type StreamMeta,
-} from '@/lib/copilot/orchestrator/stream-buffer'
-import { authenticateCopilotRequestSessionOnly } from '@/lib/copilot/request-helpers'
-import { SSE_HEADERS } from '@/lib/core/utils/sse'
-
-const logger = createLogger('CopilotChatStreamAPI')
-const POLL_INTERVAL_MS = 250
-const MAX_STREAM_MS = 10 * 60 * 1000
-
-function encodeEvent(event: Record<string, any>): Uint8Array {
-  return new TextEncoder().encode(`data: ${JSON.stringify(event)}\n\n`)
-}
-
-export async function GET(request: NextRequest) {
-  const { userId: authenticatedUserId, isAuthenticated } =
-    await authenticateCopilotRequestSessionOnly()
-
-  if (!isAuthenticated || !authenticatedUserId) {
-    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
-  }
-
-  const url = new URL(request.url)
-  const streamId = url.searchParams.get('streamId') || ''
-  const fromParam = url.searchParams.get('from') || '0'
-  const fromEventId = Number(fromParam || 0)
-  // If batch=true, return buffered events as JSON instead of SSE
-  const batchMode = url.searchParams.get('batch') === 'true'
-  const toParam = url.searchParams.get('to')
-  const toEventId = toParam ? Number(toParam) : undefined
-
-  if (!streamId) {
-    return NextResponse.json({ error: 'streamId is required' }, { status: 400 })
-  }
-
-  const meta = (await getStreamMeta(streamId)) as StreamMeta | null
-  logger.info('[Resume] Stream lookup', {
-    streamId,
-    fromEventId,
-    toEventId,
-    batchMode,
-    hasMeta: !!meta,
-    metaStatus: meta?.status,
-  })
-  if (!meta) {
-    return NextResponse.json({ error: 'Stream not found' }, { status: 404 })
-  }
-  if (meta.userId && meta.userId !== authenticatedUserId) {
-    return NextResponse.json({ error: 'Unauthorized' }, { status: 403 })
-  }
-
-  // Batch mode: return all buffered events as JSON
-  if (batchMode) {
-    const events = await readStreamEvents(streamId, fromEventId)
-    const filteredEvents = toEventId ? events.filter((e) => e.eventId <= toEventId) : events
-    logger.info('[Resume] Batch response', {
-      streamId,
-      fromEventId,
-      toEventId,
-      eventCount: filteredEvents.length,
-    })
-    return NextResponse.json({
-      success: true,
-      events: filteredEvents,
-      status: meta.status,
-    })
-  }
-
-  const startTime = Date.now()
-
-  const stream = new ReadableStream({
-    async start(controller) {
-      let lastEventId = Number.isFinite(fromEventId) ? fromEventId : 0
-
-      const flushEvents = async () => {
-        const events = await readStreamEvents(streamId, lastEventId)
-        if (events.length > 0) {
-          logger.info('[Resume] Flushing events', {
-            streamId,
-            fromEventId: lastEventId,
-            eventCount: events.length,
-          })
-        }
-        for (const entry of events) {
-          lastEventId = entry.eventId
-          const payload = {
-            ...entry.event,
-            eventId: entry.eventId,
-            streamId: entry.streamId,
-          }
-          controller.enqueue(encodeEvent(payload))
-        }
-      }
-
-      try {
-        await flushEvents()
-
-        while (Date.now() - startTime < MAX_STREAM_MS) {
-          const currentMeta = await getStreamMeta(streamId)
-          if (!currentMeta) break
-
-          await flushEvents()
-
-          if (currentMeta.status === 'complete' || currentMeta.status === 'error') {
-            break
-          }
-
-          if (request.signal.aborted) {
-            break
-          }
-
-          await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS))
-        }
-      } catch (error) {
-        logger.warn('Stream replay failed', {
-          streamId,
-          error: error instanceof Error ? error.message : String(error),
-        })
-      } finally {
-        controller.close()
-      }
-    },
-  })
-
-  return new Response(stream, { headers: SSE_HEADERS })
-}
--- a/apps/sim/app/api/mcp/copilot/route.ts
+++ b/apps/sim/app/api/mcp/copilot/route.ts
@@ -1,413 +0,0 @@
-import {
-  type CallToolResult,
-  ErrorCode,
-  type InitializeResult,
-  isJSONRPCNotification,
-  isJSONRPCRequest,
-  type JSONRPCError,
-  type JSONRPCMessage,
-  type JSONRPCResponse,
-  type ListToolsResult,
-  type RequestId,
-} from '@modelcontextprotocol/sdk/types.js'
-import { createLogger } from '@sim/logger'
-import { type NextRequest, NextResponse } from 'next/server'
-import { checkHybridAuth } from '@/lib/auth/hybrid'
-import { getCopilotModel } from '@/lib/copilot/config'
-import { orchestrateSubagentStream } from '@/lib/copilot/orchestrator/subagent'
-import {
-  executeToolServerSide,
-  prepareExecutionContext,
-} from '@/lib/copilot/orchestrator/tool-executor'
-import { DIRECT_TOOL_DEFS, SUBAGENT_TOOL_DEFS } from '@/lib/copilot/tools/mcp/definitions'
-
-const logger = createLogger('CopilotMcpAPI')
-
-export const dynamic = 'force-dynamic'
-
-/**
- * MCP Server instructions that guide LLMs on how to use the Sim copilot tools.
- * This is included in the initialize response to help external LLMs understand
- * the workflow lifecycle and best practices.
- */
-const MCP_SERVER_INSTRUCTIONS = `
-## Sim Workflow Copilot - Usage Guide
-
-You are interacting with Sim's workflow automation platform. These tools orchestrate specialized AI agents that build workflows. Follow these guidelines carefully.
-
---
-
-## Platform Knowledge
-
-Sim is a workflow automation platform. Workflows are visual pipelines of blocks.
-
-### Block Types
-
-**Core Logic:**
- **Agent** - The heart of Sim (LLM block with tools, memory, structured output, knowledge bases)
- **Function** - JavaScript code execution
- **Condition** - If/else branching
- **Router** - AI-powered content-based routing
- **Loop** - While/do-while iteration
- **Parallel** - Simultaneous execution
- **API** - HTTP requests
-
-**Integrations (3rd Party):**
- OAuth: Slack, Gmail, Google Calendar, Sheets, Outlook, Linear, GitHub, Notion
- API: Stripe, Twilio, SendGrid, any REST API
-
-### The Agent Block
-
-The Agent block is the core of intelligent workflows:
- **Tools** - Add integrations, custom tools, web search to give it capabilities
- **Memory** - Multi-turn conversations with persistent context
- **Structured Output** - JSON schema for reliable parsing
- **Knowledge Bases** - RAG-powered document retrieval
-
-**Design principle:** Put tools INSIDE agents rather than using standalone tool blocks.
-
-### Triggers
-
-| Type | Description |
-|------|-------------|
-| Manual/Chat | User sends message in UI (start block: input, files, conversationId) |
-| API | REST endpoint with custom input schema |
-| Webhook | External services POST to trigger URL |
-| Schedule | Cron-based (hourly, daily, weekly) |
-
-### Deployments
-
-| Type | Trigger | Use Case |
-|------|---------|----------|
-| API | Start block | REST endpoint for programmatic access |
-| Chat | Start block | Managed chat UI with auth options |
-| MCP | Start block | Expose as MCP tool for AI agents |
-| General | Schedule/Webhook | Activate triggers to run automatically |
-
-**Undeployed workflows only run in the builder UI.**
-
-### Variable Syntax
-
-Reference outputs from previous blocks: \`<blockname.field>\`
-Reference environment variables: \`{{ENV_VAR_NAME}}\`
-
-Rules:
- Block names must be lowercase, no spaces, no special characters
- Use dot notation for nested fields: \`<blockname.field.subfield>\`
-
---
-
-## Workflow Lifecycle
-
-1. **Create**: For NEW workflows, FIRST call create_workflow to get a workflowId
-2. **Plan**: Use copilot_plan with the workflowId to plan the workflow
-3. **Edit**: Use copilot_edit with the workflowId AND the plan to build the workflow
-4. **Deploy**: ALWAYS deploy after building using copilot_deploy before testing/running
-5. **Test**: Use copilot_test to verify the workflow works correctly
-6. **Share**: Provide the user with the workflow URL after completion
-
---
-
-## CRITICAL: Always Pass workflowId
-
- For NEW workflows: Call create_workflow FIRST, then use the returned workflowId
- For EXISTING workflows: Pass the workflowId to all copilot tools
- copilot_plan, copilot_edit, copilot_deploy, copilot_test, copilot_debug all REQUIRE workflowId
-
---
-
-## CRITICAL: How to Handle Plans
-
-The copilot_plan tool returns a structured plan object. You MUST:
-
-1. **Do NOT modify the plan**: Pass the plan object EXACTLY as returned to copilot_edit
-2. **Do NOT interpret or summarize the plan**: The edit agent needs the raw plan data
-3. **Pass the plan in the context.plan field**: \`{ "context": { "plan": <plan_object> } }\`
-4. **Include ALL plan data**: Block configurations, connections, credentials, everything
-
-Example flow:
-\`\`\`
-1. copilot_plan({ request: "build a workflow...", workflowId: "abc123" })
-   -> Returns: { "plan": { "blocks": [...], "connections": [...], ... } }
-
-2. copilot_edit({ 
-     workflowId: "abc123",
-     message: "Execute the plan",
-     context: { "plan": <EXACT plan object from step 1> }
-   })
-\`\`\`
-
-**Why this matters**: The plan contains technical details (block IDs, field mappings, API schemas) that the edit agent needs verbatim. Summarizing or rephrasing loses critical information.
-
---
-
-## CRITICAL: Error Handling
-
-**If the user says "doesn't work", "broke", "failed", "error" → ALWAYS use copilot_debug FIRST.**
-
-Don't guess. Don't plan. Debug first to find the actual problem.
-
---
-
-## Important Rules
-
- ALWAYS deploy a workflow before attempting to run or test it
- Workflows must be deployed to have an "active deployment" for execution
- After building, call copilot_deploy with the appropriate deployment type (api, chat, or mcp)
- Return the workflow URL to the user so they can access it in Sim
-
---
-
-## Quick Operations (use direct tools)
- list_workflows, list_workspaces, list_folders, get_workflow: Fast database queries
- create_workflow: Create new workflow and get workflowId (CALL THIS FIRST for new workflows)
- create_folder: Create new resources
-
-## Workflow Building (use copilot tools)
- copilot_plan: Plan workflow changes (REQUIRES workflowId) - returns a plan object
- copilot_edit: Execute the plan (REQUIRES workflowId AND plan from copilot_plan)
- copilot_deploy: Deploy workflows (REQUIRES workflowId)
- copilot_test: Test workflow execution (REQUIRES workflowId)
- copilot_debug: Diagnose errors (REQUIRES workflowId) - USE THIS FIRST for issues
-`
-
-function createResponse(id: RequestId, result: unknown): JSONRPCResponse {
-  return {
-    jsonrpc: '2.0',
-    id,
-    result: result as JSONRPCResponse['result'],
-  }
-}
-
-function createError(id: RequestId, code: ErrorCode | number, message: string): JSONRPCError {
-  return {
-    jsonrpc: '2.0',
-    id,
-    error: { code, message },
-  }
-}
-
-export async function GET() {
-  return NextResponse.json({
-    name: 'copilot-subagents',
-    version: '1.0.0',
-    protocolVersion: '2024-11-05',
-    capabilities: { tools: {} },
-  })
-}
-
-export async function POST(request: NextRequest) {
-  try {
-    const auth = await checkHybridAuth(request, { requireWorkflowId: false })
-    if (!auth.success || !auth.userId) {
-      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
-    }
-
-    const body = (await request.json()) as JSONRPCMessage
-
-    if (isJSONRPCNotification(body)) {
-      return new NextResponse(null, { status: 202 })
-    }
-
-    if (!isJSONRPCRequest(body)) {
-      return NextResponse.json(
-        createError(0, ErrorCode.InvalidRequest, 'Invalid JSON-RPC message'),
-        { status: 400 }
-      )
-    }
-
-    const { id, method, params } = body
-
-    switch (method) {
-      case 'initialize': {
-        const result: InitializeResult = {
-          protocolVersion: '2024-11-05',
-          capabilities: { tools: {} },
-          serverInfo: { name: 'sim-copilot', version: '1.0.0' },
-          instructions: MCP_SERVER_INSTRUCTIONS,
-        }
-        return NextResponse.json(createResponse(id, result))
-      }
-      case 'ping':
-        return NextResponse.json(createResponse(id, {}))
-      case 'tools/list':
-        return handleToolsList(id)
-      case 'tools/call':
-        return handleToolsCall(
-          id,
-          params as { name: string; arguments?: Record<string, unknown> },
-          auth.userId
-        )
-      default:
-        return NextResponse.json(
-          createError(id, ErrorCode.MethodNotFound, `Method not found: ${method}`),
-          { status: 404 }
-        )
-    }
-  } catch (error) {
-    logger.error('Error handling MCP request', { error })
-    return NextResponse.json(createError(0, ErrorCode.InternalError, 'Internal error'), {
-      status: 500,
-    })
-  }
-}
-
-async function handleToolsList(id: RequestId): Promise<NextResponse> {
-  const directTools = DIRECT_TOOL_DEFS.map((tool) => ({
-    name: tool.name,
-    description: tool.description,
-    inputSchema: tool.inputSchema,
-  }))
-
-  const subagentTools = SUBAGENT_TOOL_DEFS.map((tool) => ({
-    name: tool.name,
-    description: tool.description,
-    inputSchema: tool.inputSchema,
-  }))
-
-  const result: ListToolsResult = {
-    tools: [...directTools, ...subagentTools],
-  }
-
-  return NextResponse.json(createResponse(id, result))
-}
-
-async function handleToolsCall(
-  id: RequestId,
-  params: { name: string; arguments?: Record<string, unknown> },
-  userId: string
-): Promise<NextResponse> {
-  const args = params.arguments || {}
-
-  // Check if this is a direct tool (fast, no LLM)
-  const directTool = DIRECT_TOOL_DEFS.find((tool) => tool.name === params.name)
-  if (directTool) {
-    return handleDirectToolCall(id, directTool, args, userId)
-  }
-
-  // Check if this is a subagent tool (uses LLM orchestration)
-  const subagentTool = SUBAGENT_TOOL_DEFS.find((tool) => tool.name === params.name)
-  if (subagentTool) {
-    return handleSubagentToolCall(id, subagentTool, args, userId)
-  }
-
-  return NextResponse.json(
-    createError(id, ErrorCode.MethodNotFound, `Tool not found: ${params.name}`),
-    { status: 404 }
-  )
-}
-
-async function handleDirectToolCall(
-  id: RequestId,
-  toolDef: (typeof DIRECT_TOOL_DEFS)[number],
-  args: Record<string, unknown>,
-  userId: string
-): Promise<NextResponse> {
-  try {
-    const execContext = await prepareExecutionContext(userId, (args.workflowId as string) || '')
-
-    const toolCall = {
-      id: crypto.randomUUID(),
-      name: toolDef.toolId,
-      status: 'pending' as const,
-      params: args as Record<string, any>,
-      startTime: Date.now(),
-    }
-
-    const result = await executeToolServerSide(toolCall, execContext)
-
-    const response: CallToolResult = {
-      content: [
-        {
-          type: 'text',
-          text: JSON.stringify(result.output ?? result, null, 2),
-        },
-      ],
-      isError: !result.success,
-    }
-
-    return NextResponse.json(createResponse(id, response))
-  } catch (error) {
-    logger.error('Direct tool execution failed', { tool: toolDef.name, error })
-    return NextResponse.json(
-      createError(id, ErrorCode.InternalError, `Tool execution failed: ${error}`),
-      { status: 500 }
-    )
-  }
-}
-
-async function handleSubagentToolCall(
-  id: RequestId,
-  toolDef: (typeof SUBAGENT_TOOL_DEFS)[number],
-  args: Record<string, unknown>,
-  userId: string
-): Promise<NextResponse> {
-  const requestText =
-    (args.request as string) ||
-    (args.message as string) ||
-    (args.error as string) ||
-    JSON.stringify(args)
-
-  const context = (args.context as Record<string, unknown>) || {}
-  if (args.plan && !context.plan) {
-    context.plan = args.plan
-  }
-
-  const { model } = getCopilotModel('chat')
-
-  const result = await orchestrateSubagentStream(
-    toolDef.agentId,
-    {
-      message: requestText,
-      workflowId: args.workflowId,
-      workspaceId: args.workspaceId,
-      context,
-      model,
-      // Signal to the copilot backend that this is a headless request
-      // so it can enforce workflowId requirements on tools
-      headless: true,
-    },
-    {
-      userId,
-      workflowId: args.workflowId as string | undefined,
-      workspaceId: args.workspaceId as string | undefined,
-    }
-  )
-
-  // When a respond tool (plan_respond, edit_respond, etc.) was used,
-  // return only the structured result - not the full result with all internal tool calls.
-  // This provides clean output for MCP consumers.
-  let responseData: unknown
-  if (result.structuredResult) {
-    responseData = {
-      success: result.structuredResult.success ?? result.success,
-      type: result.structuredResult.type,
-      summary: result.structuredResult.summary,
-      data: result.structuredResult.data,
-    }
-  } else if (result.error) {
-    responseData = {
-      success: false,
-      error: result.error,
-      errors: result.errors,
-    }
-  } else {
-    // Fallback: return content if no structured result
-    responseData = {
-      success: result.success,
-      content: result.content,
-    }
-  }
-
-  const response: CallToolResult = {
-    content: [
-      {
-        type: 'text',
-        text: JSON.stringify(responseData, null, 2),
-      },
-    ],
-    isError: !result.success,
-  }
-
-  return NextResponse.json(createResponse(id, response))
-}
--- a/apps/sim/app/api/v1/copilot/chat/route.ts
+++ b/apps/sim/app/api/v1/copilot/chat/route.ts
@@ -1,116 +0,0 @@
-import { createLogger } from '@sim/logger'
-import { type NextRequest, NextResponse } from 'next/server'
-import { z } from 'zod'
-import { getCopilotModel } from '@/lib/copilot/config'
-import { SIM_AGENT_VERSION } from '@/lib/copilot/constants'
-import { COPILOT_REQUEST_MODES } from '@/lib/copilot/models'
-import { orchestrateCopilotStream } from '@/lib/copilot/orchestrator'
-import { resolveWorkflowIdForUser } from '@/lib/workflows/utils'
-import { authenticateV1Request } from '@/app/api/v1/auth'
-
-const logger = createLogger('CopilotHeadlessAPI')
-
-const RequestSchema = z.object({
-  message: z.string().min(1, 'message is required'),
-  workflowId: z.string().optional(),
-  workflowName: z.string().optional(),
-  chatId: z.string().optional(),
-  mode: z.enum(COPILOT_REQUEST_MODES).optional().default('agent'),
-  model: z.string().optional(),
-  autoExecuteTools: z.boolean().optional().default(true),
-  timeout: z.number().optional().default(300000),
-})
-
-/**
- * POST /api/v1/copilot/chat
- * Headless copilot endpoint for server-side orchestration.
- *
- * workflowId is optional - if not provided:
- * - If workflowName is provided, finds that workflow
- * - Otherwise uses the user's first workflow as context
- * - The copilot can still operate on any workflow using list_user_workflows
- */
-export async function POST(req: NextRequest) {
-  const auth = await authenticateV1Request(req)
-  if (!auth.authenticated || !auth.userId) {
-    return NextResponse.json(
-      { success: false, error: auth.error || 'Unauthorized' },
-      { status: 401 }
-    )
-  }
-
-  try {
-    const body = await req.json()
-    const parsed = RequestSchema.parse(body)
-    const defaults = getCopilotModel('chat')
-    const selectedModel = parsed.model || defaults.model
-
-    // Resolve workflow ID
-    const resolved = await resolveWorkflowIdForUser(
-      auth.userId,
-      parsed.workflowId,
-      parsed.workflowName
-    )
-    if (!resolved) {
-      return NextResponse.json(
-        {
-          success: false,
-          error: 'No workflows found. Create a workflow first or provide a valid workflowId.',
-        },
-        { status: 400 }
-      )
-    }
-
-    // Transform mode to transport mode (same as client API)
-    // build and agent both map to 'agent' on the backend
-    const effectiveMode = parsed.mode === 'agent' ? 'build' : parsed.mode
-    const transportMode = effectiveMode === 'build' ? 'agent' : effectiveMode
-
-    // Always generate a chatId - required for artifacts system to work with subagents
-    const chatId = parsed.chatId || crypto.randomUUID()
-
-    const requestPayload = {
-      message: parsed.message,
-      workflowId: resolved.workflowId,
-      userId: auth.userId,
-      stream: true,
-      streamToolCalls: true,
-      model: selectedModel,
-      mode: transportMode,
-      messageId: crypto.randomUUID(),
-      version: SIM_AGENT_VERSION,
-      headless: true, // Enable cross-workflow operations via workflowId params
-      chatId,
-    }
-
-    const result = await orchestrateCopilotStream(requestPayload, {
-      userId: auth.userId,
-      workflowId: resolved.workflowId,
-      chatId,
-      autoExecuteTools: parsed.autoExecuteTools,
-      timeout: parsed.timeout,
-      interactive: false,
-    })
-
-    return NextResponse.json({
-      success: result.success,
-      content: result.content,
-      toolCalls: result.toolCalls,
-      chatId: result.chatId || chatId, // Return the chatId for conversation continuity
-      conversationId: result.conversationId,
-      error: result.error,
-    })
-  } catch (error) {
-    if (error instanceof z.ZodError) {
-      return NextResponse.json(
-        { success: false, error: 'Invalid request', details: error.errors },
-        { status: 400 }
-      )
-    }
-
-    logger.error('Headless copilot request failed', {
-      error: error instanceof Error ? error.message : String(error),
-    })
-    return NextResponse.json({ success: false, error: 'Internal server error' }, { status: 500 })
-  }
-}
--- a/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/copilot/components/tool-call/tool-call.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/copilot/components/tool-call/tool-call.tsx
@@ -1,7 +1,6 @@
 'use client'

 import { memo, useEffect, useMemo, useRef, useState } from 'react'
-import { createLogger } from '@sim/logger'
 import clsx from 'clsx'
 import { ChevronUp, LayoutList } from 'lucide-react'
 import Editor from 'react-simple-code-editor'
@@ -1258,42 +1257,99 @@ function shouldShowRunSkipButtons(toolCall: CopilotToolCall): boolean {
  return false
 }

-const toolCallLogger = createLogger('CopilotToolCall')
-
-async function sendToolDecision(
-  toolCallId: string,
-  status: 'accepted' | 'rejected' | 'background'
-) {
-  try {
-    await fetch('/api/copilot/confirm', {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ toolCallId, status }),
-    })
-  } catch (error) {
-    toolCallLogger.warn('Failed to send tool decision', {
-      toolCallId,
-      status,
-      error: error instanceof Error ? error.message : String(error),
-    })
-  }
-}
-
 async function handleRun(
  toolCall: CopilotToolCall,
  setToolCallState: any,
  onStateChange?: any,
  editedParams?: any
 ) {
-  setToolCallState(toolCall, 'executing', editedParams ? { params: editedParams } : undefined)
-  onStateChange?.('executing')
-  await sendToolDecision(toolCall.id, 'accepted')
+  const instance = getClientTool(toolCall.id)
+
+  if (!instance && isIntegrationTool(toolCall.name)) {
+    onStateChange?.('executing')
+    try {
+      await useCopilotStore.getState().executeIntegrationTool(toolCall.id)
+    } catch (e) {
+      setToolCallState(toolCall, 'error', { error: e instanceof Error ? e.message : String(e) })
+      onStateChange?.('error')
+      try {
+        await fetch('/api/copilot/tools/mark-complete', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({
+            id: toolCall.id,
+            name: toolCall.name,
+            status: 500,
+            message: e instanceof Error ? e.message : 'Tool execution failed',
+            data: { error: e instanceof Error ? e.message : String(e) },
+          }),
+        })
+      } catch {
+        console.error('[handleRun] Failed to notify backend of tool error:', toolCall.id)
+      }
+    }
+    return
+  }
+
+  if (!instance) return
+  try {
+    const mergedParams =
+      editedParams ||
+      (toolCall as any).params ||
+      (toolCall as any).parameters ||
+      (toolCall as any).input ||
+      {}
+    await instance.handleAccept?.(mergedParams)
+    onStateChange?.('executing')
+  } catch (e) {
+    setToolCallState(toolCall, 'error', { error: e instanceof Error ? e.message : String(e) })
+  }
 }

 async function handleSkip(toolCall: CopilotToolCall, setToolCallState: any, onStateChange?: any) {
+  const instance = getClientTool(toolCall.id)
+
+  if (!instance && isIntegrationTool(toolCall.name)) {
+    setToolCallState(toolCall, 'rejected')
+    onStateChange?.('rejected')
+
+    let notified = false
+    for (let attempt = 0; attempt < 3 && !notified; attempt++) {
+      try {
+        const res = await fetch('/api/copilot/tools/mark-complete', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({
+            id: toolCall.id,
+            name: toolCall.name,
+            status: 400,
+            message: 'Tool execution skipped by user',
+            data: { skipped: true, reason: 'user_skipped' },
+          }),
+        })
+        if (res.ok) {
+          notified = true
+        }
+      } catch (e) {
+        if (attempt < 2) {
+          await new Promise((resolve) => setTimeout(resolve, 500))
+        }
+      }
+    }
+
+    if (!notified) {
+      console.error('[handleSkip] Failed to notify backend after 3 attempts:', toolCall.id)
+    }
+    return
+  }
+
+  if (instance) {
+    try {
+      await instance.handleReject?.()
+    } catch {}
+  }
  setToolCallState(toolCall, 'rejected')
  onStateChange?.('rejected')
-  await sendToolDecision(toolCall.id, 'rejected')
 }

 function getDisplayName(toolCall: CopilotToolCall): string {
@@ -1453,7 +1509,7 @@ export function ToolCall({
  // Check if this integration tool is auto-allowed
  // Subscribe to autoAllowedTools so we re-render when it changes
  const autoAllowedTools = useCopilotStore((s) => s.autoAllowedTools)
-  const { removeAutoAllowedTool, setToolCallState } = useCopilotStore()
+  const { removeAutoAllowedTool } = useCopilotStore()
  const isAutoAllowed = isIntegrationTool(toolCall.name) && autoAllowedTools.includes(toolCall.name)

  // Update edited params when toolCall params change (deep comparison to avoid resetting user edits on ref change)
@@ -2155,9 +2211,16 @@ export function ToolCall({
        <div className='mt-[10px]'>
          <Button
            onClick={async () => {
-              setToolCallState(toolCall, ClientToolCallState.background)
-              onStateChange?.('background')
-              await sendToolDecision(toolCall.id, 'background')
+              try {
+                const instance = getClientTool(toolCall.id)
+                instance?.setState?.((ClientToolCallState as any).background)
+                await instance?.markToolComplete?.(
+                  200,
+                  'The user has chosen to move the workflow execution to the background. Check back with them later to know when the workflow execution is complete'
+                )
+                forceUpdate({})
+                onStateChange?.('background')
+              } catch {}
            }}
            variant='tertiary'
            title='Move to Background'
@@ -2169,9 +2232,21 @@ export function ToolCall({
        <div className='mt-[10px]'>
          <Button
            onClick={async () => {
-              setToolCallState(toolCall, ClientToolCallState.background)
-              onStateChange?.('background')
-              await sendToolDecision(toolCall.id, 'background')
+              try {
+                const instance = getClientTool(toolCall.id)
+                const elapsedSeconds = instance?.getElapsedSeconds?.() || 0
+                instance?.setState?.((ClientToolCallState as any).background, {
+                  result: { _elapsedSeconds: elapsedSeconds },
+                })
+                const { updateToolCallParams } = useCopilotStore.getState()
+                updateToolCallParams?.(toolCall.id, { _elapsedSeconds: Math.round(elapsedSeconds) })
+                await instance?.markToolComplete?.(
+                  200,
+                  `User woke you up after ${Math.round(elapsedSeconds)} seconds`
+                )
+                forceUpdate({})
+                onStateChange?.('background')
+              } catch {}
            }}
            variant='tertiary'
            title='Wake'
--- a/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/copilot/copilot.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/copilot/copilot.tsx
@@ -114,7 +114,6 @@ export const Copilot = forwardRef<CopilotRef, CopilotProps>(({ panelWidth }, ref
    clearPlanArtifact,
    savePlanArtifact,
    loadAutoAllowedTools,
-    resumeActiveStream,
  } = useCopilotStore()

  // Initialize copilot
@@ -127,7 +126,6 @@ export const Copilot = forwardRef<CopilotRef, CopilotProps>(({ panelWidth }, ref
    loadAutoAllowedTools,
    currentChat,
    isSendingMessage,
-    resumeActiveStream,
  })

  // Handle scroll management (80px stickiness for copilot)
@@ -423,8 +421,8 @@ export const Copilot = forwardRef<CopilotRef, CopilotProps>(({ panelWidth }, ref
          </div>
        </div>

-        {/* Show loading state until fully initialized, but skip if actively streaming (resume case) */}
-        {!isInitialized && !isSendingMessage ? (
+        {/* Show loading state until fully initialized */}
+        {!isInitialized ? (
          <div className='flex h-full w-full items-center justify-center'>
            <div className='flex flex-col items-center gap-3'>
              <p className='text-muted-foreground text-sm'>Loading copilot</p>
--- a/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/copilot/hooks/use-copilot-initialization.ts
+++ b/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/copilot/hooks/use-copilot-initialization.ts
@@ -14,7 +14,6 @@ interface UseCopilotInitializationProps {
  loadAutoAllowedTools: () => Promise<void>
  currentChat: any
  isSendingMessage: boolean
-  resumeActiveStream: () => Promise<boolean>
 }

 /**
@@ -33,13 +32,11 @@ export function useCopilotInitialization(props: UseCopilotInitializationProps) {
    loadAutoAllowedTools,
    currentChat,
    isSendingMessage,
-    resumeActiveStream,
  } = props

  const [isInitialized, setIsInitialized] = useState(false)
  const lastWorkflowIdRef = useRef<string | null>(null)
  const hasMountedRef = useRef(false)
-  const hasResumedRef = useRef(false)

  /** Initialize on mount - loads chats if needed. Never loads during streaming */
  useEffect(() => {
@@ -108,16 +105,6 @@ export function useCopilotInitialization(props: UseCopilotInitializationProps) {
    isSendingMessage,
  ])

-  /** Try to resume active stream on mount - runs early, before waiting for chats */
-  useEffect(() => {
-    if (hasResumedRef.current || isSendingMessage) return
-    hasResumedRef.current = true
-    // Resume immediately on mount - don't wait for isInitialized
-    resumeActiveStream().catch((err) => {
-      logger.warn('[Copilot] Failed to resume active stream', err)
-    })
-  }, [isSendingMessage, resumeActiveStream])
-
  /** Load auto-allowed tools once on mount - runs immediately, independent of workflow */
  const hasLoadedAutoAllowedToolsRef = useRef(false)
  useEffect(() => {
--- a/apps/sim/lib/copilot/api.ts
+++ b/apps/sim/lib/copilot/api.ts
@@ -82,7 +82,6 @@ export interface SendMessageRequest {
    executionId?: string
  }>
  commands?: string[]
-  resumeFromEventId?: number
 }

 /**
@@ -121,7 +120,7 @@ export async function sendStreamingMessage(
  request: SendMessageRequest
 ): Promise<StreamingResponse> {
  try {
-    const { abortSignal, resumeFromEventId, ...requestBody } = request
+    const { abortSignal, ...requestBody } = request
    try {
      const preview = Array.isArray((requestBody as any).contexts)
        ? (requestBody as any).contexts.map((c: any) => ({
@@ -137,51 +136,8 @@ export async function sendStreamingMessage(
          ? (requestBody as any).contexts.length
          : 0,
        contextsPreview: preview,
-        resumeFromEventId,
      })
    } catch {}
-
-    const streamId = request.userMessageId
-    if (typeof resumeFromEventId === 'number') {
-      if (!streamId) {
-        return {
-          success: false,
-          error: 'streamId is required to resume a stream',
-          status: 400,
-        }
-      }
-      const url = `/api/copilot/chat/stream?streamId=${encodeURIComponent(
-        streamId
-      )}&from=${encodeURIComponent(String(resumeFromEventId))}`
-      const response = await fetch(url, {
-        method: 'GET',
-        signal: abortSignal,
-        credentials: 'include',
-      })
-
-      if (!response.ok) {
-        const errorMessage = await handleApiError(response, 'Failed to resume streaming message')
-        return {
-          success: false,
-          error: errorMessage,
-          status: response.status,
-        }
-      }
-
-      if (!response.body) {
-        return {
-          success: false,
-          error: 'No response body received',
-          status: 500,
-        }
-      }
-
-      return {
-        success: true,
-        stream: response.body,
-      }
-    }
-
    const response = await fetch('/api/copilot/chat', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
--- a/apps/sim/lib/copilot/orchestrator/config.ts
+++ b/apps/sim/lib/copilot/orchestrator/config.ts
@@ -1,36 +0,0 @@
-export const INTERRUPT_TOOL_NAMES = [
-  'set_global_workflow_variables',
-  'run_workflow',
-  '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',
-] as const
-
-export const INTERRUPT_TOOL_SET = new Set<string>(INTERRUPT_TOOL_NAMES)
-
-export const SUBAGENT_TOOL_NAMES = [
-  'debug',
-  'edit',
-  'plan',
-  'test',
-  'deploy',
-  'auth',
-  'research',
-  'knowledge',
-  'custom_tool',
-  'tour',
-  'info',
-  'workflow',
-  'evaluate',
-  'superagent',
-] as const
-
-export const SUBAGENT_TOOL_SET = new Set<string>(SUBAGENT_TOOL_NAMES)
--- a/apps/sim/lib/copilot/orchestrator/index.ts
+++ b/apps/sim/lib/copilot/orchestrator/index.ts
@@ -1,224 +0,0 @@
-import { createLogger } from '@sim/logger'
-import { SIM_AGENT_API_URL_DEFAULT } from '@/lib/copilot/constants'
-import {
-  getToolCallIdFromEvent,
-  handleSubagentRouting,
-  markToolCallSeen,
-  markToolResultSeen,
-  normalizeSseEvent,
-  sseHandlers,
-  subAgentHandlers,
-  wasToolCallSeen,
-  wasToolResultSeen,
-} from '@/lib/copilot/orchestrator/sse-handlers'
-import { parseSSEStream } from '@/lib/copilot/orchestrator/sse-parser'
-import { prepareExecutionContext } from '@/lib/copilot/orchestrator/tool-executor'
-import type {
-  OrchestratorOptions,
-  OrchestratorResult,
-  SSEEvent,
-  StreamingContext,
-  ToolCallSummary,
-} from '@/lib/copilot/orchestrator/types'
-import { env } from '@/lib/core/config/env'
-
-const logger = createLogger('CopilotOrchestrator')
-const SIM_AGENT_API_URL = env.SIM_AGENT_API_URL || SIM_AGENT_API_URL_DEFAULT
-
-export interface OrchestrateStreamOptions extends OrchestratorOptions {
-  userId: string
-  workflowId: string
-  chatId?: string
-}
-
-/**
- * Orchestrate a copilot SSE stream and execute tool calls server-side.
- */
-export async function orchestrateCopilotStream(
-  requestPayload: Record<string, any>,
-  options: OrchestrateStreamOptions
-): Promise<OrchestratorResult> {
-  const { userId, workflowId, chatId, timeout = 300000, abortSignal } = options
-  const execContext = await prepareExecutionContext(userId, workflowId)
-
-  const context: StreamingContext = {
-    chatId,
-    conversationId: undefined,
-    messageId: requestPayload?.messageId || crypto.randomUUID(),
-    accumulatedContent: '',
-    contentBlocks: [],
-    toolCalls: new Map(),
-    currentThinkingBlock: null,
-    isInThinkingBlock: false,
-    subAgentParentToolCallId: undefined,
-    subAgentContent: {},
-    subAgentToolCalls: {},
-    pendingContent: '',
-    streamComplete: false,
-    wasAborted: false,
-    errors: [],
-  }
-
-  try {
-    const response = await fetch(`${SIM_AGENT_API_URL}/api/chat-completion-streaming`, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        ...(env.COPILOT_API_KEY ? { 'x-api-key': env.COPILOT_API_KEY } : {}),
-      },
-      body: JSON.stringify(requestPayload),
-      signal: abortSignal,
-    })
-
-    if (!response.ok) {
-      const errorText = await response.text().catch(() => '')
-      throw new Error(
-        `Copilot backend error (${response.status}): ${errorText || response.statusText}`
-      )
-    }
-
-    if (!response.body) {
-      throw new Error('Copilot backend response missing body')
-    }
-
-    const reader = response.body.getReader()
-    const decoder = new TextDecoder()
-
-    const timeoutId = setTimeout(() => {
-      context.errors.push('Request timed out')
-      context.streamComplete = true
-      reader.cancel().catch(() => {})
-    }, timeout)
-
-    try {
-      for await (const event of parseSSEStream(reader, decoder, abortSignal)) {
-        if (abortSignal?.aborted) {
-          context.wasAborted = true
-          break
-        }
-
-        const normalizedEvent = normalizeSseEvent(event)
-
-        // Skip tool_result events for tools the sim-side already executed.
-        // The sim-side emits its own tool_result with complete data.
-        // For server-side tools (not executed by sim), we still forward the Go backend's tool_result.
-        const toolCallId = getToolCallIdFromEvent(normalizedEvent)
-        const eventData = normalizedEvent.data
-
-        const isPartialToolCall =
-          normalizedEvent.type === 'tool_call' && eventData?.partial === true
-
-        const shouldSkipToolCall =
-          normalizedEvent.type === 'tool_call' &&
-          !!toolCallId &&
-          !isPartialToolCall &&
-          (wasToolResultSeen(toolCallId) || wasToolCallSeen(toolCallId))
-
-        if (
-          normalizedEvent.type === 'tool_call' &&
-          toolCallId &&
-          !isPartialToolCall &&
-          !shouldSkipToolCall
-        ) {
-          markToolCallSeen(toolCallId)
-        }
-
-        const shouldSkipToolResult =
-          normalizedEvent.type === 'tool_result' &&
-          (() => {
-            if (!toolCallId) return false
-            if (wasToolResultSeen(toolCallId)) return true
-            markToolResultSeen(toolCallId)
-            return false
-          })()
-
-        if (!shouldSkipToolCall && !shouldSkipToolResult) {
-          await forwardEvent(normalizedEvent, options)
-        }
-
-        if (normalizedEvent.type === 'subagent_start') {
-          const toolCallId = normalizedEvent.data?.tool_call_id
-          if (toolCallId) {
-            context.subAgentParentToolCallId = toolCallId
-            context.subAgentContent[toolCallId] = ''
-            context.subAgentToolCalls[toolCallId] = []
-          }
-          continue
-        }
-
-        if (normalizedEvent.type === 'subagent_end') {
-          context.subAgentParentToolCallId = undefined
-          continue
-        }
-
-        if (handleSubagentRouting(normalizedEvent, context)) {
-          const handler = subAgentHandlers[normalizedEvent.type]
-          if (handler) {
-            await handler(normalizedEvent, context, execContext, options)
-          }
-          if (context.streamComplete) break
-          continue
-        }
-
-        const handler = sseHandlers[normalizedEvent.type]
-        if (handler) {
-          await handler(normalizedEvent, context, execContext, options)
-        }
-        if (context.streamComplete) break
-      }
-    } finally {
-      clearTimeout(timeoutId)
-    }
-
-    const result = buildResult(context)
-    await options.onComplete?.(result)
-    return result
-  } catch (error) {
-    const err = error instanceof Error ? error : new Error('Copilot orchestration failed')
-    logger.error('Copilot orchestration failed', { error: err.message })
-    await options.onError?.(err)
-    return {
-      success: false,
-      content: '',
-      contentBlocks: [],
-      toolCalls: [],
-      chatId: context.chatId,
-      conversationId: context.conversationId,
-      error: err.message,
-    }
-  }
-}
-
-async function forwardEvent(event: SSEEvent, options: OrchestratorOptions): Promise<void> {
-  try {
-    await options.onEvent?.(event)
-  } catch (error) {
-    logger.warn('Failed to forward SSE event', {
-      type: event.type,
-      error: error instanceof Error ? error.message : String(error),
-    })
-  }
-}
-
-function buildResult(context: StreamingContext): OrchestratorResult {
-  const toolCalls: ToolCallSummary[] = Array.from(context.toolCalls.values()).map((toolCall) => ({
-    id: toolCall.id,
-    name: toolCall.name,
-    status: toolCall.status,
-    params: toolCall.params,
-    result: toolCall.result?.output,
-    error: toolCall.error,
-    durationMs:
-      toolCall.endTime && toolCall.startTime ? toolCall.endTime - toolCall.startTime : undefined,
-  }))
-
-  return {
-    success: context.errors.length === 0,
-    content: context.accumulatedContent,
-    contentBlocks: context.contentBlocks,
-    toolCalls,
-    chatId: context.chatId,
-    conversationId: context.conversationId,
-    errors: context.errors.length ? context.errors : undefined,
-  }
-}
--- a/apps/sim/lib/copilot/orchestrator/persistence.ts
+++ b/apps/sim/lib/copilot/orchestrator/persistence.ts
@@ -1,140 +0,0 @@
-import { db } from '@sim/db'
-import { copilotChats } from '@sim/db/schema'
-import { createLogger } from '@sim/logger'
-import { and, eq } from 'drizzle-orm'
-import { getRedisClient } from '@/lib/core/config/redis'
-
-const logger = createLogger('CopilotOrchestratorPersistence')
-
-/**
- * Create a new copilot chat record.
- */
-export async function createChat(params: {
-  userId: string
-  workflowId: string
-  model: string
-}): Promise<{ id: string }> {
-  const [chat] = await db
-    .insert(copilotChats)
-    .values({
-      userId: params.userId,
-      workflowId: params.workflowId,
-      model: params.model,
-      messages: [],
-    })
-    .returning({ id: copilotChats.id })
-
-  return { id: chat.id }
-}
-
-/**
- * Load an existing chat for a user.
- */
-export async function loadChat(chatId: string, userId: string) {
-  const [chat] = await db
-    .select()
-    .from(copilotChats)
-    .where(and(eq(copilotChats.id, chatId), eq(copilotChats.userId, userId)))
-    .limit(1)
-
-  return chat || null
-}
-
-/**
- * Save chat messages and metadata.
- */
-export async function saveMessages(
-  chatId: string,
-  messages: any[],
-  options?: {
-    title?: string
-    conversationId?: string
-    planArtifact?: string | null
-    config?: { mode?: string; model?: string }
-  }
-): Promise<void> {
-  await db
-    .update(copilotChats)
-    .set({
-      messages,
-      updatedAt: new Date(),
-      ...(options?.title ? { title: options.title } : {}),
-      ...(options?.conversationId ? { conversationId: options.conversationId } : {}),
-      ...(options?.planArtifact !== undefined ? { planArtifact: options.planArtifact } : {}),
-      ...(options?.config ? { config: options.config } : {}),
-    })
-    .where(eq(copilotChats.id, chatId))
-}
-
-/**
- * Update the conversationId for a chat without overwriting messages.
- */
-export async function updateChatConversationId(
-  chatId: string,
-  conversationId: string
-): Promise<void> {
-  await db
-    .update(copilotChats)
-    .set({
-      conversationId,
-      updatedAt: new Date(),
-    })
-    .where(eq(copilotChats.id, chatId))
-}
-
-/**
- * Set a tool call confirmation status in Redis.
- */
-export async function setToolConfirmation(
-  toolCallId: string,
-  status: 'accepted' | 'rejected' | 'background' | 'pending',
-  message?: string
-): Promise<boolean> {
-  const redis = getRedisClient()
-  if (!redis) {
-    logger.warn('Redis client not available for tool confirmation')
-    return false
-  }
-
-  const key = `tool_call:${toolCallId}`
-  const payload = {
-    status,
-    message: message || null,
-    timestamp: new Date().toISOString(),
-  }
-
-  try {
-    await redis.set(key, JSON.stringify(payload), 'EX', 86400)
-    return true
-  } catch (error) {
-    logger.error('Failed to set tool confirmation', {
-      toolCallId,
-      error: error instanceof Error ? error.message : String(error),
-    })
-    return false
-  }
-}
-
-/**
- * Get a tool call confirmation status from Redis.
- */
-export async function getToolConfirmation(toolCallId: string): Promise<{
-  status: string
-  message?: string
-  timestamp?: string
-} | null> {
-  const redis = getRedisClient()
-  if (!redis) return null
-
-  try {
-    const data = await redis.get(`tool_call:${toolCallId}`)
-    if (!data) return null
-    return JSON.parse(data) as { status: string; message?: string; timestamp?: string }
-  } catch (error) {
-    logger.error('Failed to read tool confirmation', {
-      toolCallId,
-      error: error instanceof Error ? error.message : String(error),
-    })
-    return null
-  }
-}
--- a/apps/sim/lib/copilot/orchestrator/sse-handlers.ts
+++ b/apps/sim/lib/copilot/orchestrator/sse-handlers.ts
@@ -1,589 +0,0 @@
-import { createLogger } from '@sim/logger'
-import { INTERRUPT_TOOL_SET, SUBAGENT_TOOL_SET } from '@/lib/copilot/orchestrator/config'
-import { getToolConfirmation } from '@/lib/copilot/orchestrator/persistence'
-import { executeToolServerSide, markToolComplete } from '@/lib/copilot/orchestrator/tool-executor'
-import type {
-  ContentBlock,
-  ExecutionContext,
-  OrchestratorOptions,
-  SSEEvent,
-  StreamingContext,
-  ToolCallState,
-} from '@/lib/copilot/orchestrator/types'
-
-const logger = createLogger('CopilotSseHandlers')
-
-/**
- * Tracks tool call IDs for which a tool_call has already been forwarded/emitted (non-partial).
- */
-const seenToolCalls = new Set<string>()
-
-/**
- * Tracks tool call IDs for which a tool_result has already been emitted or forwarded.
- */
-const seenToolResults = new Set<string>()
-
-export function markToolCallSeen(toolCallId: string): void {
-  seenToolCalls.add(toolCallId)
-  setTimeout(
-    () => {
-      seenToolCalls.delete(toolCallId)
-    },
-    5 * 60 * 1000
-  )
-}
-
-export function wasToolCallSeen(toolCallId: string): boolean {
-  return seenToolCalls.has(toolCallId)
-}
-
-type EventDataObject = Record<string, any> | undefined
-
-const parseEventData = (data: unknown): EventDataObject => {
-  if (!data) return undefined
-  if (typeof data !== 'string') {
-    return data as EventDataObject
-  }
-  try {
-    return JSON.parse(data) as EventDataObject
-  } catch {
-    return undefined
-  }
-}
-
-const hasToolFields = (data: EventDataObject): boolean => {
-  if (!data) return false
-  return (
-    data.id !== undefined ||
-    data.toolCallId !== undefined ||
-    data.name !== undefined ||
-    data.success !== undefined ||
-    data.result !== undefined ||
-    data.arguments !== undefined
-  )
-}
-
-const getEventData = (event: SSEEvent): EventDataObject => {
-  const topLevel = parseEventData(event.data)
-  if (!topLevel) return undefined
-  if (hasToolFields(topLevel)) return topLevel
-  const nested = parseEventData(topLevel.data)
-  return nested || topLevel
-}
-
-export function getToolCallIdFromEvent(event: SSEEvent): string | undefined {
-  const data = getEventData(event)
-  return event.toolCallId || data?.id || data?.toolCallId
-}
-
-/** Normalizes SSE events so tool metadata is available at the top level. */
-export function normalizeSseEvent(event: SSEEvent): SSEEvent {
-  if (!event) return event
-  const data = getEventData(event)
-  if (!data) return event
-  const toolCallId = event.toolCallId || data.id || data.toolCallId
-  const toolName = event.toolName || data.name || data.toolName
-  const success = event.success ?? data.success
-  const result = event.result ?? data.result
-  const normalizedData = typeof event.data === 'string' ? data : event.data
-  return {
-    ...event,
-    data: normalizedData,
-    toolCallId,
-    toolName,
-    success,
-    result,
-  }
-}
-
-/**
- * Mark a tool call as executed by the sim-side.
- * This prevents the Go backend's duplicate tool_result from being forwarded.
- */
-export function markToolResultSeen(toolCallId: string): void {
-  seenToolResults.add(toolCallId)
-  setTimeout(
-    () => {
-      seenToolResults.delete(toolCallId)
-    },
-    5 * 60 * 1000
-  )
-}
-
-/**
- * Check if a tool call was executed by the sim-side.
- */
-export function wasToolResultSeen(toolCallId: string): boolean {
-  return seenToolResults.has(toolCallId)
-}
-
-/**
- * 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.
- */
-const RESPOND_TOOL_SET = new Set([
-  'plan_respond',
-  'edit_respond',
-  'debug_respond',
-  'info_respond',
-  'research_respond',
-  'deploy_respond',
-  'superagent_respond',
-  'discovery_respond',
-])
-
-export type SSEHandler = (
-  event: SSEEvent,
-  context: StreamingContext,
-  execContext: ExecutionContext,
-  options: OrchestratorOptions
-) => void | Promise<void>
-
-function addContentBlock(context: StreamingContext, block: Omit<ContentBlock, 'timestamp'>): void {
-  context.contentBlocks.push({
-    ...block,
-    timestamp: Date.now(),
-  })
-}
-
-async function executeToolAndReport(
-  toolCallId: string,
-  context: StreamingContext,
-  execContext: ExecutionContext,
-  options?: OrchestratorOptions
-): Promise<void> {
-  const toolCall = context.toolCalls.get(toolCallId)
-  if (!toolCall) return
-
-  if (toolCall.status === 'executing') return
-  if (wasToolResultSeen(toolCall.id)) return
-
-  toolCall.status = 'executing'
-  try {
-    const result = await executeToolServerSide(toolCall, execContext)
-    toolCall.status = result.success ? 'success' : 'error'
-    toolCall.result = result
-    toolCall.error = result.error
-    toolCall.endTime = Date.now()
-
-    // If create_workflow was successful, update the execution context with the new workflowId
-    // This ensures subsequent tools in the same stream have access to the workflowId
-    if (
-      toolCall.name === 'create_workflow' &&
-      result.success &&
-      result.output?.workflowId &&
-      !execContext.workflowId
-    ) {
-      execContext.workflowId = result.output.workflowId
-      if (result.output.workspaceId) {
-        execContext.workspaceId = result.output.workspaceId
-      }
-    }
-
-    markToolResultSeen(toolCall.id)
-
-    await markToolComplete(
-      toolCall.id,
-      toolCall.name,
-      result.success ? 200 : 500,
-      result.error || (result.success ? 'Tool completed' : 'Tool failed'),
-      result.output
-    )
-
-    await options?.onEvent?.({
-      type: 'tool_result',
-      toolCallId: toolCall.id,
-      toolName: toolCall.name,
-      success: result.success,
-      result: result.output,
-      data: {
-        id: toolCall.id,
-        name: toolCall.name,
-        success: result.success,
-        result: result.output,
-      },
-    })
-  } catch (error) {
-    toolCall.status = 'error'
-    toolCall.error = error instanceof Error ? error.message : String(error)
-    toolCall.endTime = Date.now()
-
-    markToolResultSeen(toolCall.id)
-
-    await markToolComplete(toolCall.id, toolCall.name, 500, toolCall.error)
-
-    await options?.onEvent?.({
-      type: 'tool_error',
-      toolCallId: toolCall.id,
-      data: {
-        id: toolCall.id,
-        name: toolCall.name,
-        error: toolCall.error,
-      },
-    })
-  }
-}
-
-async function waitForToolDecision(
-  toolCallId: string,
-  timeoutMs: number
-): Promise<{ status: string; message?: string } | null> {
-  const start = Date.now()
-  while (Date.now() - start < timeoutMs) {
-    const decision = await getToolConfirmation(toolCallId)
-    if (decision?.status) {
-      return decision
-    }
-    await new Promise((resolve) => setTimeout(resolve, 100))
-  }
-  return null
-}
-
-export const sseHandlers: Record<string, SSEHandler> = {
-  chat_id: (event, context) => {
-    context.chatId = event.data?.chatId
-  },
-  title_updated: () => {},
-  tool_result: (event, context) => {
-    const data = getEventData(event)
-    const toolCallId = event.toolCallId || data?.id
-    if (!toolCallId) return
-    const current = context.toolCalls.get(toolCallId)
-    if (!current) return
-
-    // Determine success: explicit success field, or if there's result data without explicit failure
-    const hasExplicitSuccess = data?.success !== undefined || data?.result?.success !== undefined
-    const explicitSuccess = data?.success ?? data?.result?.success
-    const hasResultData = data?.result !== undefined || data?.data !== undefined
-    const hasError = !!data?.error || !!data?.result?.error
-
-    // If explicitly set, use that; otherwise infer from data presence
-    const success = hasExplicitSuccess ? !!explicitSuccess : hasResultData && !hasError
-
-    current.status = success ? 'success' : 'error'
-    current.endTime = Date.now()
-    if (hasResultData) {
-      current.result = {
-        success,
-        output: data?.result || data?.data,
-      }
-    }
-    if (hasError) {
-      current.error = data?.error || data?.result?.error
-    }
-  },
-  tool_error: (event, context) => {
-    const data = getEventData(event)
-    const toolCallId = event.toolCallId || data?.id
-    if (!toolCallId) return
-    const current = context.toolCalls.get(toolCallId)
-    if (!current) return
-    current.status = 'error'
-    current.error = data?.error || 'Tool execution failed'
-    current.endTime = Date.now()
-  },
-  tool_generating: (event, context) => {
-    const data = getEventData(event)
-    const toolCallId = event.toolCallId || data?.toolCallId || data?.id
-    const toolName = event.toolName || data?.toolName || data?.name
-    if (!toolCallId || !toolName) return
-    if (!context.toolCalls.has(toolCallId)) {
-      context.toolCalls.set(toolCallId, {
-        id: toolCallId,
-        name: toolName,
-        status: 'pending',
-        startTime: Date.now(),
-      })
-    }
-  },
-  tool_call: async (event, context, execContext, options) => {
-    const toolData = getEventData(event) || {}
-    const toolCallId = toolData.id || event.toolCallId
-    const toolName = toolData.name || event.toolName
-    if (!toolCallId || !toolName) return
-
-    const args = toolData.arguments || toolData.input || event.data?.input
-    const isPartial = toolData.partial === true
-    const existing = context.toolCalls.get(toolCallId)
-
-    // If we've already completed this tool call, ignore late/duplicate tool_call events
-    // to avoid resetting UI/state back to pending and re-executing.
-    if (
-      existing?.endTime ||
-      (existing && existing.status !== 'pending' && existing.status !== 'executing')
-    ) {
-      if (!existing.params && args) {
-        existing.params = args
-      }
-      return
-    }
-
-    if (existing) {
-      if (args && !existing.params) existing.params = args
-    } else {
-      context.toolCalls.set(toolCallId, {
-        id: toolCallId,
-        name: toolName,
-        status: 'pending',
-        params: args,
-        startTime: Date.now(),
-      })
-      const created = context.toolCalls.get(toolCallId)!
-      addContentBlock(context, { type: 'tool_call', toolCall: created })
-    }
-
-    if (isPartial) return
-    if (wasToolResultSeen(toolCallId)) return
-
-    const toolCall = context.toolCalls.get(toolCallId)
-    if (!toolCall) return
-
-    // Subagent tools are executed by the copilot backend, not sim side
-    if (SUBAGENT_TOOL_SET.has(toolName)) {
-      return
-    }
-
-    // Respond tools are internal to copilot's subagent system - skip execution
-    // The copilot backend handles these internally to signal subagent completion
-    if (RESPOND_TOOL_SET.has(toolName)) {
-      toolCall.status = 'success'
-      toolCall.endTime = Date.now()
-      toolCall.result = {
-        success: true,
-        output: 'Internal respond tool - handled by copilot backend',
-      }
-      return
-    }
-
-    const isInterruptTool = INTERRUPT_TOOL_SET.has(toolName)
-    const isInteractive = options.interactive === true
-
-    if (isInterruptTool && isInteractive) {
-      const decision = await waitForToolDecision(toolCallId, options.timeout || 600000)
-      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()
-        await markToolComplete(
-          toolCall.id,
-          toolCall.name,
-          400,
-          decision.message || 'Tool execution rejected',
-          { skipped: true, reason: 'user_rejected' }
-        )
-        markToolResultSeen(toolCall.id)
-        await options.onEvent?.({
-          type: 'tool_result',
-          toolCallId: toolCall.id,
-          data: {
-            id: toolCall.id,
-            name: toolCall.name,
-            success: false,
-            result: { skipped: true, reason: 'user_rejected' },
-          },
-        })
-        return
-      }
-
-      if (decision?.status === 'background') {
-        toolCall.status = 'skipped'
-        toolCall.endTime = Date.now()
-        await markToolComplete(
-          toolCall.id,
-          toolCall.name,
-          202,
-          decision.message || 'Tool execution moved to background',
-          { background: true }
-        )
-        markToolResultSeen(toolCall.id)
-        await options.onEvent?.({
-          type: 'tool_result',
-          toolCallId: toolCall.id,
-          data: {
-            id: toolCall.id,
-            name: toolCall.name,
-            success: true,
-            result: { background: true },
-          },
-        })
-        return
-      }
-    }
-
-    if (options.autoExecuteTools !== false) {
-      await executeToolAndReport(toolCallId, context, execContext, options)
-    }
-  },
-  reasoning: (event, context) => {
-    const phase = event.data?.phase || event.data?.data?.phase
-    if (phase === 'start') {
-      context.isInThinkingBlock = true
-      context.currentThinkingBlock = {
-        type: 'thinking',
-        content: '',
-        timestamp: Date.now(),
-      }
-      return
-    }
-    if (phase === 'end') {
-      if (context.currentThinkingBlock) {
-        context.contentBlocks.push(context.currentThinkingBlock)
-      }
-      context.isInThinkingBlock = false
-      context.currentThinkingBlock = null
-      return
-    }
-    const chunk =
-      typeof event.data === 'string' ? event.data : event.data?.data || event.data?.content
-    if (!chunk || !context.currentThinkingBlock) return
-    context.currentThinkingBlock.content = `${context.currentThinkingBlock.content || ''}${chunk}`
-  },
-  content: (event, context) => {
-    const chunk =
-      typeof event.data === 'string' ? event.data : event.data?.content || event.data?.data
-    if (!chunk) return
-    context.accumulatedContent += chunk
-    addContentBlock(context, { type: 'text', content: chunk })
-  },
-  done: (event, context) => {
-    if (event.data?.responseId) {
-      context.conversationId = event.data.responseId
-    }
-    context.streamComplete = true
-  },
-  start: (event, context) => {
-    if (event.data?.responseId) {
-      context.conversationId = event.data.responseId
-    }
-  },
-  error: (event, context) => {
-    const message =
-      event.data?.message ||
-      event.data?.error ||
-      (typeof event.data === 'string' ? event.data : null)
-    if (message) {
-      context.errors.push(message)
-    }
-    context.streamComplete = true
-  },
-}
-
-export const subAgentHandlers: Record<string, SSEHandler> = {
-  content: (event, context) => {
-    const parentToolCallId = context.subAgentParentToolCallId
-    if (!parentToolCallId || !event.data) return
-    const chunk = typeof event.data === 'string' ? event.data : event.data?.content || ''
-    if (!chunk) return
-    context.subAgentContent[parentToolCallId] =
-      (context.subAgentContent[parentToolCallId] || '') + chunk
-    addContentBlock(context, { type: 'subagent_text', content: chunk })
-  },
-  tool_call: async (event, context, execContext, options) => {
-    const parentToolCallId = context.subAgentParentToolCallId
-    if (!parentToolCallId) return
-    const toolData = getEventData(event) || {}
-    const toolCallId = toolData.id || event.toolCallId
-    const toolName = toolData.name || event.toolName
-    if (!toolCallId || !toolName) return
-    const isPartial = toolData.partial === true
-    const args = toolData.arguments || toolData.input || event.data?.input
-
-    const existing = context.toolCalls.get(toolCallId)
-    // Ignore late/duplicate tool_call events once we already have a result
-    if (wasToolResultSeen(toolCallId) || existing?.endTime) {
-      return
-    }
-
-    const toolCall: ToolCallState = {
-      id: toolCallId,
-      name: toolName,
-      status: 'pending',
-      params: args,
-      startTime: Date.now(),
-    }
-
-    // Store in both places - but do NOT overwrite existing tool call state for the same id
-    if (!context.subAgentToolCalls[parentToolCallId]) {
-      context.subAgentToolCalls[parentToolCallId] = []
-    }
-    if (!context.subAgentToolCalls[parentToolCallId].some((tc) => tc.id === toolCallId)) {
-      context.subAgentToolCalls[parentToolCallId].push(toolCall)
-    }
-    if (!context.toolCalls.has(toolCallId)) {
-      context.toolCalls.set(toolCallId, toolCall)
-    }
-
-    if (isPartial) return
-
-    // Respond tools are internal to copilot's subagent system - skip execution
-    if (RESPOND_TOOL_SET.has(toolName)) {
-      toolCall.status = 'success'
-      toolCall.endTime = Date.now()
-      toolCall.result = {
-        success: true,
-        output: 'Internal respond tool - handled by copilot backend',
-      }
-      return
-    }
-
-    if (options.autoExecuteTools !== false) {
-      await executeToolAndReport(toolCallId, context, execContext, options)
-    }
-  },
-  tool_result: (event, context) => {
-    const parentToolCallId = context.subAgentParentToolCallId
-    if (!parentToolCallId) return
-    const data = getEventData(event)
-    const toolCallId = event.toolCallId || data?.id
-    if (!toolCallId) return
-
-    // Update in subAgentToolCalls
-    const toolCalls = context.subAgentToolCalls[parentToolCallId] || []
-    const subAgentToolCall = toolCalls.find((tc) => tc.id === toolCallId)
-
-    // Also update in main toolCalls (where we added it for execution)
-    const mainToolCall = context.toolCalls.get(toolCallId)
-
-    // Use same success inference logic as main handler
-    const hasExplicitSuccess = data?.success !== undefined || data?.result?.success !== undefined
-    const explicitSuccess = data?.success ?? data?.result?.success
-    const hasResultData = data?.result !== undefined || data?.data !== undefined
-    const hasError = !!data?.error || !!data?.result?.error
-    const success = hasExplicitSuccess ? !!explicitSuccess : hasResultData && !hasError
-
-    const status = success ? 'success' : 'error'
-    const endTime = Date.now()
-    const result = hasResultData ? { success, output: data?.result || data?.data } : undefined
-
-    if (subAgentToolCall) {
-      subAgentToolCall.status = status
-      subAgentToolCall.endTime = endTime
-      if (result) subAgentToolCall.result = result
-      if (hasError) subAgentToolCall.error = data?.error || data?.result?.error
-    }
-
-    if (mainToolCall) {
-      mainToolCall.status = status
-      mainToolCall.endTime = endTime
-      if (result) mainToolCall.result = result
-      if (hasError) mainToolCall.error = data?.error || data?.result?.error
-    }
-  },
-}
-
-export function handleSubagentRouting(event: SSEEvent, context: StreamingContext): boolean {
-  if (!event.subagent) return false
-  if (!context.subAgentParentToolCallId) {
-    logger.warn('Subagent event missing parent tool call', {
-      type: event.type,
-      subagent: event.subagent,
-    })
-    return false
-  }
-  return true
-}
--- a/apps/sim/lib/copilot/orchestrator/sse-parser.ts
+++ b/apps/sim/lib/copilot/orchestrator/sse-parser.ts
@@ -1,71 +0,0 @@
-import { createLogger } from '@sim/logger'
-import type { SSEEvent } from '@/lib/copilot/orchestrator/types'
-
-const logger = createLogger('CopilotSseParser')
-
-/**
- * Parses SSE streams from the copilot backend into typed events.
- */
-export async function* parseSSEStream(
-  reader: ReadableStreamDefaultReader<Uint8Array>,
-  decoder: TextDecoder,
-  abortSignal?: AbortSignal
-): AsyncGenerator<SSEEvent> {
-  let buffer = ''
-
-  try {
-    while (true) {
-      if (abortSignal?.aborted) {
-        logger.info('SSE stream aborted by signal')
-        break
-      }
-
-      const { done, value } = await reader.read()
-      if (done) break
-
-      buffer += decoder.decode(value, { stream: true })
-      const lines = buffer.split('\n')
-      buffer = lines.pop() || ''
-
-      for (const line of lines) {
-        if (!line.trim()) continue
-        if (!line.startsWith('data: ')) continue
-
-        const jsonStr = line.slice(6)
-        if (jsonStr === '[DONE]') continue
-
-        try {
-          const event = JSON.parse(jsonStr) as SSEEvent
-          if (event?.type) {
-            yield event
-          }
-        } catch (error) {
-          logger.warn('Failed to parse SSE event', {
-            preview: jsonStr.slice(0, 200),
-            error: error instanceof Error ? error.message : String(error),
-          })
-        }
-      }
-    }
-
-    if (buffer.trim() && buffer.startsWith('data: ')) {
-      try {
-        const event = JSON.parse(buffer.slice(6)) as SSEEvent
-        if (event?.type) {
-          yield event
-        }
-      } catch (error) {
-        logger.warn('Failed to parse final SSE buffer', {
-          preview: buffer.slice(0, 200),
-          error: error instanceof Error ? error.message : String(error),
-        })
-      }
-    }
-  } finally {
-    try {
-      reader.releaseLock()
-    } catch {
-      logger.warn('Failed to release SSE reader lock')
-    }
-  }
-}
--- a/apps/sim/lib/copilot/orchestrator/stream-buffer.ts
+++ b/apps/sim/lib/copilot/orchestrator/stream-buffer.ts
@@ -1,262 +0,0 @@
-import { createLogger } from '@sim/logger'
-import { getRedisClient } from '@/lib/core/config/redis'
-
-const logger = createLogger('CopilotStreamBuffer')
-
-const STREAM_TTL_SECONDS = 60 * 60
-const STREAM_EVENT_LIMIT = 5000
-const STREAM_RESERVE_BATCH = 200
-const STREAM_FLUSH_INTERVAL_MS = 15
-const STREAM_FLUSH_MAX_BATCH = 200
-
-const APPEND_STREAM_EVENT_LUA = `
-local seqKey = KEYS[1]
-local eventsKey = KEYS[2]
-local ttl = tonumber(ARGV[1])
-local limit = tonumber(ARGV[2])
-local streamId = ARGV[3]
-local eventJson = ARGV[4]
-
-local id = redis.call('INCR', seqKey)
-local entry = '{"eventId":' .. id .. ',"streamId":' .. cjson.encode(streamId) .. ',"event":' .. eventJson .. '}'
-redis.call('ZADD', eventsKey, id, entry)
-redis.call('EXPIRE', eventsKey, ttl)
-redis.call('EXPIRE', seqKey, ttl)
-if limit > 0 then
-  redis.call('ZREMRANGEBYRANK', eventsKey, 0, -limit-1)
-end
-return id
-`
-
-function getStreamKeyPrefix(streamId: string) {
-  return `copilot_stream:${streamId}`
-}
-
-function getEventsKey(streamId: string) {
-  return `${getStreamKeyPrefix(streamId)}:events`
-}
-
-function getSeqKey(streamId: string) {
-  return `${getStreamKeyPrefix(streamId)}:seq`
-}
-
-function getMetaKey(streamId: string) {
-  return `${getStreamKeyPrefix(streamId)}:meta`
-}
-
-export type StreamStatus = 'active' | 'complete' | 'error'
-
-export type StreamMeta = {
-  status: StreamStatus
-  userId?: string
-  updatedAt?: string
-  error?: string
-}
-
-export type StreamEventEntry = {
-  eventId: number
-  streamId: string
-  event: Record<string, any>
-}
-
-export type StreamEventWriter = {
-  write: (event: Record<string, any>) => Promise<StreamEventEntry>
-  flush: () => Promise<void>
-  close: () => Promise<void>
-}
-
-export async function resetStreamBuffer(streamId: string): Promise<void> {
-  const redis = getRedisClient()
-  if (!redis) return
-  try {
-    await redis.del(getEventsKey(streamId), getSeqKey(streamId), getMetaKey(streamId))
-  } catch (error) {
-    logger.warn('Failed to reset stream buffer', {
-      streamId,
-      error: error instanceof Error ? error.message : String(error),
-    })
-  }
-}
-
-export async function setStreamMeta(streamId: string, meta: StreamMeta): Promise<void> {
-  const redis = getRedisClient()
-  if (!redis) return
-  try {
-    const payload: Record<string, string> = {
-      status: meta.status,
-      updatedAt: meta.updatedAt || new Date().toISOString(),
-    }
-    if (meta.userId) payload.userId = meta.userId
-    if (meta.error) payload.error = meta.error
-    await redis.hset(getMetaKey(streamId), payload)
-    await redis.expire(getMetaKey(streamId), STREAM_TTL_SECONDS)
-  } catch (error) {
-    logger.warn('Failed to update stream meta', {
-      streamId,
-      error: error instanceof Error ? error.message : String(error),
-    })
-  }
-}
-
-export async function getStreamMeta(streamId: string): Promise<StreamMeta | null> {
-  const redis = getRedisClient()
-  if (!redis) return null
-  try {
-    const meta = await redis.hgetall(getMetaKey(streamId))
-    if (!meta || Object.keys(meta).length === 0) return null
-    return meta as StreamMeta
-  } catch (error) {
-    logger.warn('Failed to read stream meta', {
-      streamId,
-      error: error instanceof Error ? error.message : String(error),
-    })
-    return null
-  }
-}
-
-export async function appendStreamEvent(
-  streamId: string,
-  event: Record<string, any>
-): Promise<StreamEventEntry> {
-  const redis = getRedisClient()
-  if (!redis) {
-    return { eventId: 0, streamId, event }
-  }
-
-  try {
-    const eventJson = JSON.stringify(event)
-    const nextId = await redis.eval(
-      APPEND_STREAM_EVENT_LUA,
-      2,
-      getSeqKey(streamId),
-      getEventsKey(streamId),
-      STREAM_TTL_SECONDS,
-      STREAM_EVENT_LIMIT,
-      streamId,
-      eventJson
-    )
-    const eventId = typeof nextId === 'number' ? nextId : Number(nextId)
-    return { eventId, streamId, event }
-  } catch (error) {
-    logger.warn('Failed to append stream event', {
-      streamId,
-      error: error instanceof Error ? error.message : String(error),
-    })
-    return { eventId: 0, streamId, event }
-  }
-}
-
-export function createStreamEventWriter(streamId: string): StreamEventWriter {
-  const redis = getRedisClient()
-  if (!redis) {
-    return {
-      write: async (event) => ({ eventId: 0, streamId, event }),
-      flush: async () => {},
-      close: async () => {},
-    }
-  }
-
-  let pending: StreamEventEntry[] = []
-  let nextEventId = 0
-  let maxReservedId = 0
-  let flushTimer: ReturnType<typeof setTimeout> | null = null
-  let isFlushing = false
-
-  const scheduleFlush = () => {
-    if (flushTimer) return
-    flushTimer = setTimeout(() => {
-      flushTimer = null
-      void flush()
-    }, STREAM_FLUSH_INTERVAL_MS)
-  }
-
-  const reserveIds = async (minCount: number) => {
-    const reserveCount = Math.max(STREAM_RESERVE_BATCH, minCount)
-    const newMax = await redis.incrby(getSeqKey(streamId), reserveCount)
-    const startId = newMax - reserveCount + 1
-    if (nextEventId === 0 || nextEventId > maxReservedId) {
-      nextEventId = startId
-      maxReservedId = newMax
-    }
-  }
-
-  const flush = async () => {
-    if (isFlushing || pending.length === 0) return
-    isFlushing = true
-    const batch = pending
-    pending = []
-    try {
-      const key = getEventsKey(streamId)
-      const zaddArgs: (string | number)[] = []
-      for (const entry of batch) {
-        zaddArgs.push(entry.eventId, JSON.stringify(entry))
-      }
-      const pipeline = redis.pipeline()
-      pipeline.zadd(key, ...(zaddArgs as any))
-      pipeline.expire(key, STREAM_TTL_SECONDS)
-      pipeline.expire(getSeqKey(streamId), STREAM_TTL_SECONDS)
-      pipeline.zremrangebyrank(key, 0, -STREAM_EVENT_LIMIT - 1)
-      await pipeline.exec()
-    } catch (error) {
-      logger.warn('Failed to flush stream events', {
-        streamId,
-        error: error instanceof Error ? error.message : String(error),
-      })
-      pending = batch.concat(pending)
-    } finally {
-      isFlushing = false
-      if (pending.length > 0) scheduleFlush()
-    }
-  }
-
-  const write = async (event: Record<string, any>) => {
-    if (nextEventId === 0 || nextEventId > maxReservedId) {
-      await reserveIds(1)
-    }
-    const eventId = nextEventId++
-    const entry: StreamEventEntry = { eventId, streamId, event }
-    pending.push(entry)
-    if (pending.length >= STREAM_FLUSH_MAX_BATCH) {
-      await flush()
-    } else {
-      scheduleFlush()
-    }
-    return entry
-  }
-
-  const close = async () => {
-    if (flushTimer) {
-      clearTimeout(flushTimer)
-      flushTimer = null
-    }
-    await flush()
-  }
-
-  return { write, flush, close }
-}
-
-export async function readStreamEvents(
-  streamId: string,
-  afterEventId: number
-): Promise<StreamEventEntry[]> {
-  const redis = getRedisClient()
-  if (!redis) return []
-  try {
-    const raw = await redis.zrangebyscore(getEventsKey(streamId), afterEventId + 1, '+inf')
-    return raw
-      .map((entry) => {
-        try {
-          return JSON.parse(entry) as StreamEventEntry
-        } catch {
-          return null
-        }
-      })
-      .filter((entry): entry is StreamEventEntry => Boolean(entry))
-  } catch (error) {
-    logger.warn('Failed to read stream events', {
-      streamId,
-      error: error instanceof Error ? error.message : String(error),
-    })
-    return []
-  }
-}
--- a/apps/sim/lib/copilot/orchestrator/subagent.ts
+++ b/apps/sim/lib/copilot/orchestrator/subagent.ts
@@ -1,286 +0,0 @@
-import { createLogger } from '@sim/logger'
-import { SIM_AGENT_API_URL_DEFAULT } from '@/lib/copilot/constants'
-import {
-  getToolCallIdFromEvent,
-  handleSubagentRouting,
-  markToolCallSeen,
-  markToolResultSeen,
-  normalizeSseEvent,
-  sseHandlers,
-  subAgentHandlers,
-  wasToolCallSeen,
-  wasToolResultSeen,
-} from '@/lib/copilot/orchestrator/sse-handlers'
-import { parseSSEStream } from '@/lib/copilot/orchestrator/sse-parser'
-import { prepareExecutionContext } from '@/lib/copilot/orchestrator/tool-executor'
-import type {
-  ExecutionContext,
-  OrchestratorOptions,
-  SSEEvent,
-  StreamingContext,
-  ToolCallSummary,
-} from '@/lib/copilot/orchestrator/types'
-import { env } from '@/lib/core/config/env'
-import { getEffectiveDecryptedEnv } from '@/lib/environment/utils'
-
-const logger = createLogger('CopilotSubagentOrchestrator')
-const SIM_AGENT_API_URL = env.SIM_AGENT_API_URL || SIM_AGENT_API_URL_DEFAULT
-
-export interface SubagentOrchestratorOptions extends Omit<OrchestratorOptions, 'onComplete'> {
-  userId: string
-  workflowId?: string
-  workspaceId?: string
-  onComplete?: (result: SubagentOrchestratorResult) => void | Promise<void>
-}
-
-export interface SubagentOrchestratorResult {
-  success: boolean
-  content: string
-  toolCalls: ToolCallSummary[]
-  structuredResult?: {
-    type?: string
-    summary?: string
-    data?: any
-    success?: boolean
-  }
-  error?: string
-  errors?: string[]
-}
-
-export async function orchestrateSubagentStream(
-  agentId: string,
-  requestPayload: Record<string, any>,
-  options: SubagentOrchestratorOptions
-): Promise<SubagentOrchestratorResult> {
-  const { userId, workflowId, workspaceId, timeout = 300000, abortSignal } = options
-  const execContext = await buildExecutionContext(userId, workflowId, workspaceId)
-
-  const context: StreamingContext = {
-    chatId: undefined,
-    conversationId: undefined,
-    messageId: requestPayload?.messageId || crypto.randomUUID(),
-    accumulatedContent: '',
-    contentBlocks: [],
-    toolCalls: new Map(),
-    currentThinkingBlock: null,
-    isInThinkingBlock: false,
-    subAgentParentToolCallId: undefined,
-    subAgentContent: {},
-    subAgentToolCalls: {},
-    pendingContent: '',
-    streamComplete: false,
-    wasAborted: false,
-    errors: [],
-  }
-
-  let structuredResult: SubagentOrchestratorResult['structuredResult']
-
-  try {
-    const response = await fetch(`${SIM_AGENT_API_URL}/api/subagent/${agentId}`, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        ...(env.COPILOT_API_KEY ? { 'x-api-key': env.COPILOT_API_KEY } : {}),
-      },
-      body: JSON.stringify({ ...requestPayload, stream: true, userId }),
-      signal: abortSignal,
-    })
-
-    if (!response.ok) {
-      const errorText = await response.text().catch(() => '')
-      throw new Error(
-        `Copilot backend error (${response.status}): ${errorText || response.statusText}`
-      )
-    }
-
-    if (!response.body) {
-      throw new Error('Copilot backend response missing body')
-    }
-
-    const reader = response.body.getReader()
-    const decoder = new TextDecoder()
-
-    const timeoutId = setTimeout(() => {
-      context.errors.push('Request timed out')
-      context.streamComplete = true
-      reader.cancel().catch(() => {})
-    }, timeout)
-
-    try {
-      for await (const event of parseSSEStream(reader, decoder, abortSignal)) {
-        if (abortSignal?.aborted) {
-          context.wasAborted = true
-          break
-        }
-
-        const normalizedEvent = normalizeSseEvent(event)
-
-        // Skip tool_result events for tools the sim-side already executed.
-        // The sim-side emits its own tool_result with complete data.
-        // For server-side tools (not executed by sim), we still forward the Go backend's tool_result.
-        const toolCallId = getToolCallIdFromEvent(normalizedEvent)
-        const eventData = normalizedEvent.data
-
-        const isPartialToolCall =
-          normalizedEvent.type === 'tool_call' && eventData?.partial === true
-
-        const shouldSkipToolCall =
-          normalizedEvent.type === 'tool_call' &&
-          !!toolCallId &&
-          !isPartialToolCall &&
-          (wasToolResultSeen(toolCallId) || wasToolCallSeen(toolCallId))
-
-        if (
-          normalizedEvent.type === 'tool_call' &&
-          toolCallId &&
-          !isPartialToolCall &&
-          !shouldSkipToolCall
-        ) {
-          markToolCallSeen(toolCallId)
-        }
-
-        const shouldSkipToolResult =
-          normalizedEvent.type === 'tool_result' &&
-          (() => {
-            if (!toolCallId) return false
-            if (wasToolResultSeen(toolCallId)) return true
-            markToolResultSeen(toolCallId)
-            return false
-          })()
-
-        if (!shouldSkipToolCall && !shouldSkipToolResult) {
-          await forwardEvent(normalizedEvent, options)
-        }
-
-        if (
-          normalizedEvent.type === 'structured_result' ||
-          normalizedEvent.type === 'subagent_result'
-        ) {
-          structuredResult = normalizeStructuredResult(normalizedEvent.data)
-          context.streamComplete = true
-          continue
-        }
-
-        // Handle subagent_start/subagent_end events to track nested subagent calls
-        if (normalizedEvent.type === 'subagent_start') {
-          const toolCallId = normalizedEvent.data?.tool_call_id
-          if (toolCallId) {
-            context.subAgentParentToolCallId = toolCallId
-            context.subAgentContent[toolCallId] = ''
-            context.subAgentToolCalls[toolCallId] = []
-          }
-          continue
-        }
-
-        if (normalizedEvent.type === 'subagent_end') {
-          context.subAgentParentToolCallId = undefined
-          continue
-        }
-
-        // For direct subagent calls, events may have the subagent field set (e.g., subagent: "discovery")
-        // but no subagent_start event because this IS the top-level agent. Skip subagent routing
-        // for events where the subagent field matches the current agentId - these are top-level events.
-        const isTopLevelSubagentEvent =
-          normalizedEvent.subagent === agentId && !context.subAgentParentToolCallId
-
-        // Only route to subagent handlers for nested subagent events (not matching current agentId)
-        if (!isTopLevelSubagentEvent && handleSubagentRouting(normalizedEvent, context)) {
-          const handler = subAgentHandlers[normalizedEvent.type]
-          if (handler) {
-            await handler(normalizedEvent, context, execContext, options)
-          }
-          if (context.streamComplete) break
-          continue
-        }
-
-        // Process as a regular SSE event (including top-level subagent events)
-        const handler = sseHandlers[normalizedEvent.type]
-        if (handler) {
-          await handler(normalizedEvent, context, execContext, options)
-        }
-        if (context.streamComplete) break
-      }
-    } finally {
-      clearTimeout(timeoutId)
-    }
-
-    const result = buildResult(context, structuredResult)
-    await options.onComplete?.(result)
-    return result
-  } catch (error) {
-    const err = error instanceof Error ? error : new Error('Subagent orchestration failed')
-    logger.error('Subagent orchestration failed', { error: err.message, agentId })
-    await options.onError?.(err)
-    return {
-      success: false,
-      content: context.accumulatedContent,
-      toolCalls: [],
-      error: err.message,
-    }
-  }
-}
-
-async function forwardEvent(event: SSEEvent, options: OrchestratorOptions): Promise<void> {
-  try {
-    await options.onEvent?.(event)
-  } catch (error) {
-    logger.warn('Failed to forward SSE event', {
-      type: event.type,
-      error: error instanceof Error ? error.message : String(error),
-    })
-  }
-}
-
-function normalizeStructuredResult(data: any): SubagentOrchestratorResult['structuredResult'] {
-  if (!data || typeof data !== 'object') {
-    return undefined
-  }
-  return {
-    type: data.result_type || data.type,
-    summary: data.summary,
-    data: data.data ?? data,
-    success: data.success,
-  }
-}
-
-async function buildExecutionContext(
-  userId: string,
-  workflowId?: string,
-  workspaceId?: string
-): Promise<ExecutionContext> {
-  if (workflowId) {
-    return prepareExecutionContext(userId, workflowId)
-  }
-
-  const decryptedEnvVars = await getEffectiveDecryptedEnv(userId, workspaceId)
-  return {
-    userId,
-    workflowId: workflowId || '',
-    workspaceId,
-    decryptedEnvVars,
-  }
-}
-
-function buildResult(
-  context: StreamingContext,
-  structuredResult?: SubagentOrchestratorResult['structuredResult']
-): SubagentOrchestratorResult {
-  const toolCalls: ToolCallSummary[] = Array.from(context.toolCalls.values()).map((toolCall) => ({
-    id: toolCall.id,
-    name: toolCall.name,
-    status: toolCall.status,
-    params: toolCall.params,
-    result: toolCall.result?.output,
-    error: toolCall.error,
-    durationMs:
-      toolCall.endTime && toolCall.startTime ? toolCall.endTime - toolCall.startTime : undefined,
-  }))
-
-  return {
-    success: context.errors.length === 0 && !context.wasAborted,
-    content: context.accumulatedContent,
-    toolCalls,
-    structuredResult,
-    errors: context.errors.length ? context.errors : undefined,
-  }
-}
--- a/apps/sim/lib/copilot/orchestrator/tool-executor.ts
+++ b/apps/sim/lib/copilot/orchestrator/tool-executor.ts
--- a/apps/sim/lib/copilot/orchestrator/types.ts
+++ b/apps/sim/lib/copilot/orchestrator/types.ts
@@ -1,130 +0,0 @@
-import type { CopilotProviderConfig } from '@/lib/copilot/types'
-
-export type SSEEventType =
-  | 'chat_id'
-  | 'title_updated'
-  | 'content'
-  | 'reasoning'
-  | 'tool_call'
-  | 'tool_generating'
-  | 'tool_result'
-  | 'tool_error'
-  | 'subagent_start'
-  | 'subagent_end'
-  | 'structured_result'
-  | 'subagent_result'
-  | 'done'
-  | 'error'
-  | 'start'
-
-export interface SSEEvent {
-  type: SSEEventType
-  data?: any
-  subagent?: string
-  toolCallId?: string
-  toolName?: string
-  success?: boolean
-  result?: any
-}
-
-export type ToolCallStatus = 'pending' | 'executing' | 'success' | 'error' | 'skipped' | 'rejected'
-
-export interface ToolCallState {
-  id: string
-  name: string
-  status: ToolCallStatus
-  params?: Record<string, any>
-  result?: ToolCallResult
-  error?: string
-  startTime?: number
-  endTime?: number
-}
-
-export interface ToolCallResult {
-  success: boolean
-  output?: any
-  error?: string
-}
-
-export type ContentBlockType = 'text' | 'thinking' | 'tool_call' | 'subagent_text'
-
-export interface ContentBlock {
-  type: ContentBlockType
-  content?: string
-  toolCall?: ToolCallState
-  timestamp: number
-}
-
-export interface StreamingContext {
-  chatId?: string
-  conversationId?: string
-  messageId: string
-  accumulatedContent: string
-  contentBlocks: ContentBlock[]
-  toolCalls: Map<string, ToolCallState>
-  currentThinkingBlock: ContentBlock | null
-  isInThinkingBlock: boolean
-  subAgentParentToolCallId?: string
-  subAgentContent: Record<string, string>
-  subAgentToolCalls: Record<string, ToolCallState[]>
-  pendingContent: string
-  streamComplete: boolean
-  wasAborted: boolean
-  errors: string[]
-}
-
-export interface OrchestratorRequest {
-  message: string
-  workflowId: string
-  userId: string
-  chatId?: string
-  mode?: 'agent' | 'ask' | 'plan'
-  model?: string
-  conversationId?: string
-  contexts?: Array<{ type: string; content: string }>
-  fileAttachments?: any[]
-  commands?: string[]
-  provider?: CopilotProviderConfig
-  streamToolCalls?: boolean
-  version?: string
-  prefetch?: boolean
-  userName?: string
-}
-
-export interface OrchestratorOptions {
-  autoExecuteTools?: boolean
-  timeout?: number
-  onEvent?: (event: SSEEvent) => void | Promise<void>
-  onComplete?: (result: OrchestratorResult) => void | Promise<void>
-  onError?: (error: Error) => void | Promise<void>
-  abortSignal?: AbortSignal
-  interactive?: boolean
-}
-
-export interface OrchestratorResult {
-  success: boolean
-  content: string
-  contentBlocks: ContentBlock[]
-  toolCalls: ToolCallSummary[]
-  chatId?: string
-  conversationId?: string
-  error?: string
-  errors?: string[]
-}
-
-export interface ToolCallSummary {
-  id: string
-  name: string
-  status: ToolCallStatus
-  params?: Record<string, any>
-  result?: any
-  error?: string
-  durationMs?: number
-}
-
-export interface ExecutionContext {
-  userId: string
-  workflowId: string
-  workspaceId?: string
-  decryptedEnvVars?: Record<string, string>
-}
--- a/apps/sim/lib/copilot/tools/client/workflow/get-workflow-from-name.ts
+++ b/apps/sim/lib/copilot/tools/client/workflow/get-workflow-from-name.ts
@@ -5,10 +5,7 @@ import {
  type BaseClientToolMetadata,
  ClientToolCallState,
 } from '@/lib/copilot/tools/client/base-tool'
-import {
-  formatWorkflowStateForCopilot,
-  normalizeWorkflowName,
-} from '@/lib/copilot/tools/shared/workflow-utils'
+import { sanitizeForCopilot } from '@/lib/workflows/sanitization/json-sanitizer'
 import { useWorkflowRegistry } from '@/stores/workflows/registry/store'

 const logger = createLogger('GetWorkflowFromNameClientTool')
@@ -70,9 +67,11 @@ export class GetWorkflowFromNameClientTool extends BaseClientTool {

      // Try to find by name from registry first to get ID
      const registry = useWorkflowRegistry.getState()
-      const targetName = normalizeWorkflowName(workflowName)
      const match = Object.values((registry as any).workflows || {}).find(
-        (w: any) => normalizeWorkflowName(w?.name) === targetName
+        (w: any) =>
+          String(w?.name || '')
+            .trim()
+            .toLowerCase() === workflowName.toLowerCase()
      ) as any

      if (!match?.id) {
@@ -99,12 +98,15 @@ export class GetWorkflowFromNameClientTool extends BaseClientTool {
      }

      // Convert state to the same string format as get_user_workflow
-      const userWorkflow = formatWorkflowStateForCopilot({
+      const workflowState = {
        blocks: wf.state.blocks || {},
        edges: wf.state.edges || [],
        loops: wf.state.loops || {},
        parallels: wf.state.parallels || {},
-      })
+      }
+      // Sanitize workflow state for copilot (remove UI-specific data)
+      const sanitizedState = sanitizeForCopilot(workflowState)
+      const userWorkflow = JSON.stringify(sanitizedState, null, 2)

      await this.markToolComplete(200, `Retrieved workflow ${workflowName}`, { userWorkflow })
      this.setState(ClientToolCallState.success)
--- a/apps/sim/lib/copilot/tools/client/workflow/list-user-workflows.ts
+++ b/apps/sim/lib/copilot/tools/client/workflow/list-user-workflows.ts
@@ -5,7 +5,6 @@ import {
  type BaseClientToolMetadata,
  ClientToolCallState,
 } from '@/lib/copilot/tools/client/base-tool'
-import { extractWorkflowNames } from '@/lib/copilot/tools/shared/workflow-utils'

 const logger = createLogger('ListUserWorkflowsClientTool')

@@ -42,7 +41,9 @@ export class ListUserWorkflowsClientTool extends BaseClientTool {

      const json = await res.json()
      const workflows = Array.isArray(json?.data) ? json.data : []
-      const names = extractWorkflowNames(workflows)
+      const names = workflows
+        .map((w: any) => (typeof w?.name === 'string' ? w.name : null))
+        .filter((n: string | null) => !!n)

      logger.info('Found workflows', { count: names.length })

--- a/apps/sim/lib/copilot/tools/mcp/definitions.ts
+++ b/apps/sim/lib/copilot/tools/mcp/definitions.ts
@@ -1,474 +0,0 @@
-export type DirectToolDef = {
-  name: string
-  description: string
-  inputSchema: { type: 'object'; properties?: Record<string, unknown>; required?: string[] }
-  toolId: string
-}
-
-export type SubagentToolDef = {
-  name: string
-  description: string
-  inputSchema: { type: 'object'; properties?: Record<string, unknown>; required?: string[] }
-  agentId: string
-}
-
-/**
- * Direct tools that execute immediately without LLM orchestration.
- * These are fast database queries that don't need AI reasoning.
- */
-export const DIRECT_TOOL_DEFS: DirectToolDef[] = [
-  {
-    name: 'list_workflows',
-    toolId: 'list_user_workflows',
-    description:
-      'List all workflows the user has access to. Returns workflow IDs, names, and workspace info.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        workspaceId: {
-          type: 'string',
-          description: 'Optional workspace ID to filter workflows.',
-        },
-        folderId: {
-          type: 'string',
-          description: 'Optional folder ID to filter workflows.',
-        },
-      },
-    },
-  },
-  {
-    name: 'list_workspaces',
-    toolId: 'list_user_workspaces',
-    description:
-      'List all workspaces the user has access to. Returns workspace IDs, names, and roles.',
-    inputSchema: {
-      type: 'object',
-      properties: {},
-    },
-  },
-  {
-    name: 'list_folders',
-    toolId: 'list_folders',
-    description: 'List all folders in a workspace.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        workspaceId: {
-          type: 'string',
-          description: 'Workspace ID to list folders from.',
-        },
-      },
-      required: ['workspaceId'],
-    },
-  },
-  {
-    name: 'get_workflow',
-    toolId: 'get_workflow_from_name',
-    description: 'Get a workflow by name or ID. Returns the full workflow definition.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        name: {
-          type: 'string',
-          description: 'Workflow name to search for.',
-        },
-        workflowId: {
-          type: 'string',
-          description: 'Workflow ID to retrieve directly.',
-        },
-      },
-    },
-  },
-  {
-    name: 'create_workflow',
-    toolId: 'create_workflow',
-    description: 'Create a new workflow. Returns the new workflow ID.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        name: {
-          type: 'string',
-          description: 'Name for the new workflow.',
-        },
-        workspaceId: {
-          type: 'string',
-          description: 'Optional workspace ID. Uses default workspace if not provided.',
-        },
-        folderId: {
-          type: 'string',
-          description: 'Optional folder ID to place the workflow in.',
-        },
-        description: {
-          type: 'string',
-          description: 'Optional description for the workflow.',
-        },
-      },
-      required: ['name'],
-    },
-  },
-  {
-    name: 'create_folder',
-    toolId: 'create_folder',
-    description: 'Create a new folder in a workspace.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        name: {
-          type: 'string',
-          description: 'Name for the new folder.',
-        },
-        workspaceId: {
-          type: 'string',
-          description: 'Optional workspace ID. Uses default workspace if not provided.',
-        },
-        parentId: {
-          type: 'string',
-          description: 'Optional parent folder ID for nested folders.',
-        },
-      },
-      required: ['name'],
-    },
-  },
-]
-
-export const SUBAGENT_TOOL_DEFS: SubagentToolDef[] = [
-  {
-    name: 'copilot_build',
-    agentId: 'build',
-    description: `Build a workflow end-to-end in a single step. This is the fast mode equivalent for headless/MCP usage.
-
-USE THIS WHEN:
- Building a new workflow from scratch
- Modifying an existing workflow
- You want to gather information and build in one pass without separate plan→edit steps
-
-WORKFLOW ID (REQUIRED):
- For NEW workflows: First call create_workflow to get a workflowId, then pass it here
- For EXISTING workflows: Always pass the workflowId parameter
-
-CAN DO:
- Gather information about blocks, credentials, patterns
- Search documentation and patterns for best practices
- Add, modify, or remove blocks
- Configure block settings and connections
- Set environment variables and workflow variables
-
-CANNOT DO:
- Run or test workflows (use copilot_test separately after deploying)
- Deploy workflows (use copilot_deploy separately)
-
-WORKFLOW:
-1. Call create_workflow to get a workflowId (for new workflows)
-2. Call copilot_build with the request and workflowId
-3. Build agent gathers info and builds in one pass
-4. Call copilot_deploy to deploy the workflow
-5. Optionally call copilot_test to verify it works`,
-    inputSchema: {
-      type: 'object',
-      properties: {
-        request: {
-          type: 'string',
-          description: 'What you want to build or modify in the workflow.',
-        },
-        workflowId: {
-          type: 'string',
-          description:
-            'REQUIRED. The workflow ID. For new workflows, call create_workflow first to get this.',
-        },
-        context: { type: 'object' },
-      },
-      required: ['request', 'workflowId'],
-    },
-  },
-  {
-    name: 'copilot_discovery',
-    agentId: 'discovery',
-    description: `Find workflows by their contents or functionality when the user doesn't know the exact name or ID.
-
-USE THIS WHEN:
- User describes a workflow by what it does: "the one that sends emails", "my Slack notification workflow"
- User refers to workflow contents: "the workflow with the OpenAI block"
- User needs to search/match workflows by functionality or description
-
-DO NOT USE (use direct tools instead):
- User knows the workflow name → use get_workflow
- User wants to list all workflows → use list_workflows
- User wants to list workspaces → use list_workspaces
- User wants to list folders → use list_folders`,
-    inputSchema: {
-      type: 'object',
-      properties: {
-        request: { type: 'string' },
-        workspaceId: { type: 'string' },
-        context: { type: 'object' },
-      },
-      required: ['request'],
-    },
-  },
-  {
-    name: 'copilot_plan',
-    agentId: 'plan',
-    description: `Plan workflow changes by gathering required information.
-
-USE THIS WHEN:
- Building a new workflow
- Modifying an existing workflow
- You need to understand what blocks and integrations are available
- The workflow requires multiple blocks or connections
-
-WORKFLOW ID (REQUIRED):
- For NEW workflows: First call create_workflow to get a workflowId, then pass it here
- For EXISTING workflows: Always pass the workflowId parameter
-
-This tool gathers information about available blocks, credentials, and the current workflow state.
-
-RETURNS: A plan object containing block configurations, connections, and technical details.
-IMPORTANT: Pass the returned plan EXACTLY to copilot_edit - do not modify or summarize it.`,
-    inputSchema: {
-      type: 'object',
-      properties: {
-        request: {
-          type: 'string',
-          description: 'What you want to build or modify in the workflow.',
-        },
-        workflowId: {
-          type: 'string',
-          description:
-            'REQUIRED. The workflow ID. For new workflows, call create_workflow first to get this.',
-        },
-        context: { type: 'object' },
-      },
-      required: ['request', 'workflowId'],
-    },
-  },
-  {
-    name: 'copilot_edit',
-    agentId: 'edit',
-    description: `Execute a workflow plan and apply edits.
-
-USE THIS WHEN:
- You have a plan from copilot_plan that needs to be executed
- Building or modifying a workflow based on the plan
- Making changes to blocks, connections, or configurations
-
-WORKFLOW ID (REQUIRED):
- You MUST provide the workflowId parameter
- For new workflows, get the workflowId from create_workflow first
-
-PLAN (REQUIRED):
- Pass the EXACT plan object from copilot_plan in the context.plan field
- Do NOT modify, summarize, or interpret the plan - pass it verbatim
- The plan contains technical details the edit agent needs exactly as-is
-
-IMPORTANT: After copilot_edit completes, you MUST call copilot_deploy before the workflow can be run or tested.`,
-    inputSchema: {
-      type: 'object',
-      properties: {
-        message: { type: 'string', description: 'Optional additional instructions for the edit.' },
-        workflowId: {
-          type: 'string',
-          description:
-            'REQUIRED. The workflow ID to edit. Get this from create_workflow for new workflows.',
-        },
-        plan: {
-          type: 'object',
-          description:
-            'The plan object from copilot_plan. Pass it EXACTLY as returned, do not modify.',
-        },
-        context: {
-          type: 'object',
-          description:
-            'Additional context. Put the plan in context.plan if not using the plan field directly.',
-        },
-      },
-      required: ['workflowId'],
-    },
-  },
-  {
-    name: 'copilot_debug',
-    agentId: 'debug',
-    description: `Diagnose errors or unexpected workflow behavior.
-
-WORKFLOW ID (REQUIRED): Always provide the workflowId of the workflow to debug.`,
-    inputSchema: {
-      type: 'object',
-      properties: {
-        error: { type: 'string', description: 'The error message or description of the issue.' },
-        workflowId: { type: 'string', description: 'REQUIRED. The workflow ID to debug.' },
-        context: { type: 'object' },
-      },
-      required: ['error', 'workflowId'],
-    },
-  },
-  {
-    name: 'copilot_deploy',
-    agentId: 'deploy',
-    description: `Deploy or manage workflow deployments.
-
-CRITICAL: You MUST deploy a workflow after building before it can be run or tested.
-Workflows without an active deployment will fail with "no active deployment" error.
-
-WORKFLOW ID (REQUIRED):
- Always provide the workflowId parameter
- This must match the workflow you built with copilot_edit
-
-USE THIS:
- After copilot_edit completes to activate the workflow
- To update deployment settings
- To redeploy after making changes
-
-DEPLOYMENT TYPES:
- "deploy as api" - REST API endpoint
- "deploy as chat" - Chat interface
- "deploy as mcp" - MCP server`,
-    inputSchema: {
-      type: 'object',
-      properties: {
-        request: {
-          type: 'string',
-          description: 'The deployment request, e.g. "deploy as api" or "deploy as chat"',
-        },
-        workflowId: {
-          type: 'string',
-          description: 'REQUIRED. The workflow ID to deploy.',
-        },
-        context: { type: 'object' },
-      },
-      required: ['request', 'workflowId'],
-    },
-  },
-  {
-    name: 'copilot_auth',
-    agentId: 'auth',
-    description: 'Handle OAuth connection flows.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        request: { type: 'string' },
-        context: { type: 'object' },
-      },
-      required: ['request'],
-    },
-  },
-  {
-    name: 'copilot_knowledge',
-    agentId: 'knowledge',
-    description: 'Create and manage knowledge bases.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        request: { type: 'string' },
-        context: { type: 'object' },
-      },
-      required: ['request'],
-    },
-  },
-  {
-    name: 'copilot_custom_tool',
-    agentId: 'custom_tool',
-    description: 'Create or manage custom tools.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        request: { type: 'string' },
-        context: { type: 'object' },
-      },
-      required: ['request'],
-    },
-  },
-  {
-    name: 'copilot_info',
-    agentId: 'info',
-    description: 'Inspect blocks, outputs, and workflow metadata.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        request: { type: 'string' },
-        workflowId: { type: 'string' },
-        context: { type: 'object' },
-      },
-      required: ['request'],
-    },
-  },
-  {
-    name: 'copilot_workflow',
-    agentId: 'workflow',
-    description: 'Manage workflow environment and configuration.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        request: { type: 'string' },
-        workflowId: { type: 'string' },
-        context: { type: 'object' },
-      },
-      required: ['request'],
-    },
-  },
-  {
-    name: 'copilot_research',
-    agentId: 'research',
-    description: 'Research external APIs and documentation.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        request: { type: 'string' },
-        context: { type: 'object' },
-      },
-      required: ['request'],
-    },
-  },
-  {
-    name: 'copilot_tour',
-    agentId: 'tour',
-    description: 'Explain platform features and usage.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        request: { type: 'string' },
-        context: { type: 'object' },
-      },
-      required: ['request'],
-    },
-  },
-  {
-    name: 'copilot_test',
-    agentId: 'test',
-    description: `Run workflows and verify outputs.
-
-PREREQUISITE: The workflow MUST be deployed first using copilot_deploy.
-Undeployed workflows will fail with "no active deployment" error.
-
-WORKFLOW ID (REQUIRED):
- Always provide the workflowId parameter
-
-USE THIS:
- After deploying to verify the workflow works correctly
- To test with sample inputs
- To validate workflow behavior before sharing with user`,
-    inputSchema: {
-      type: 'object',
-      properties: {
-        request: { type: 'string' },
-        workflowId: {
-          type: 'string',
-          description: 'REQUIRED. The workflow ID to test.',
-        },
-        context: { type: 'object' },
-      },
-      required: ['request', 'workflowId'],
-    },
-  },
-  {
-    name: 'copilot_superagent',
-    agentId: 'superagent',
-    description: 'Execute direct external actions (email, Slack, etc.).',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        request: { type: 'string' },
-        context: { type: 'object' },
-      },
-      required: ['request'],
-    },
-  },
-]
--- a/apps/sim/lib/copilot/tools/server/workflow/edit-workflow.ts
+++ b/apps/sim/lib/copilot/tools/server/workflow/edit-workflow.ts
@@ -6,13 +6,9 @@ import { eq } from 'drizzle-orm'
 import type { BaseServerTool } from '@/lib/copilot/tools/server/base-tool'
 import { validateSelectorIds } from '@/lib/copilot/validation/selector-validator'
 import type { PermissionGroupConfig } from '@/lib/permission-groups/types'
-import { applyAutoLayout } from '@/lib/workflows/autolayout'
 import { getBlockOutputs } from '@/lib/workflows/blocks/block-outputs'
 import { extractAndPersistCustomTools } from '@/lib/workflows/persistence/custom-tools-persistence'
-import {
-  loadWorkflowFromNormalizedTables,
-  saveWorkflowToNormalizedTables,
-} from '@/lib/workflows/persistence/utils'
+import { loadWorkflowFromNormalizedTables } from '@/lib/workflows/persistence/utils'
 import { isValidKey } from '@/lib/workflows/sanitization/key-validation'
 import { validateWorkflowState } from '@/lib/workflows/sanitization/validation'
 import { buildCanonicalIndex, isCanonicalPair } from '@/lib/workflows/subblocks/visibility'
@@ -1403,101 +1399,6 @@ function filterDisallowedTools(
  return allowedTools
 }

-/**
- * Normalizes block IDs in operations to ensure they are valid UUIDs.
- * The LLM may generate human-readable IDs like "web_search" or "research_agent"
- * which need to be converted to proper UUIDs for database compatibility.
- *
- * Returns the normalized operations and a mapping from old IDs to new UUIDs.
- */
-function normalizeBlockIdsInOperations(operations: EditWorkflowOperation[]): {
-  normalizedOperations: EditWorkflowOperation[]
-  idMapping: Map<string, string>
-} {
-  const logger = createLogger('EditWorkflowServerTool')
-  const idMapping = new Map<string, string>()
-
-  // First pass: collect all non-UUID block_ids from add/insert operations
-  for (const op of operations) {
-    if (op.operation_type === 'add' || op.operation_type === 'insert_into_subflow') {
-      if (op.block_id && !UUID_REGEX.test(op.block_id)) {
-        const newId = crypto.randomUUID()
-        idMapping.set(op.block_id, newId)
-        logger.debug('Normalizing block ID', { oldId: op.block_id, newId })
-      }
-    }
-  }
-
-  if (idMapping.size === 0) {
-    return { normalizedOperations: operations, idMapping }
-  }
-
-  logger.info('Normalizing block IDs in operations', {
-    normalizedCount: idMapping.size,
-    mappings: Object.fromEntries(idMapping),
-  })
-
-  // Helper to replace an ID if it's in the mapping
-  const replaceId = (id: string | undefined): string | undefined => {
-    if (!id) return id
-    return idMapping.get(id) ?? id
-  }
-
-  // Second pass: update all references to use new UUIDs
-  const normalizedOperations = operations.map((op) => {
-    const normalized: EditWorkflowOperation = {
-      ...op,
-      block_id: replaceId(op.block_id) ?? op.block_id,
-    }
-
-    if (op.params) {
-      normalized.params = { ...op.params }
-
-      // Update subflowId references (for insert_into_subflow)
-      if (normalized.params.subflowId) {
-        normalized.params.subflowId = replaceId(normalized.params.subflowId)
-      }
-
-      // Update connection references
-      if (normalized.params.connections) {
-        const normalizedConnections: Record<string, any> = {}
-        for (const [handle, targets] of Object.entries(normalized.params.connections)) {
-          if (typeof targets === 'string') {
-            normalizedConnections[handle] = replaceId(targets)
-          } else if (Array.isArray(targets)) {
-            normalizedConnections[handle] = targets.map((t) => {
-              if (typeof t === 'string') return replaceId(t)
-              if (t && typeof t === 'object' && t.block) {
-                return { ...t, block: replaceId(t.block) }
-              }
-              return t
-            })
-          } else if (targets && typeof targets === 'object' && (targets as any).block) {
-            normalizedConnections[handle] = { ...targets, block: replaceId((targets as any).block) }
-          } else {
-            normalizedConnections[handle] = targets
-          }
-        }
-        normalized.params.connections = normalizedConnections
-      }
-
-      // Update nestedNodes block IDs
-      if (normalized.params.nestedNodes) {
-        const normalizedNestedNodes: Record<string, any> = {}
-        for (const [childId, childBlock] of Object.entries(normalized.params.nestedNodes)) {
-          const newChildId = replaceId(childId) ?? childId
-          normalizedNestedNodes[newChildId] = childBlock
-        }
-        normalized.params.nestedNodes = normalizedNestedNodes
-      }
-    }
-
-    return normalized
-  })
-
-  return { normalizedOperations, idMapping }
-}
-
 /**
 * Apply operations directly to the workflow JSON state
 */
@@ -1517,11 +1418,6 @@ function applyOperationsToWorkflowState(

  // Log initial state
  const logger = createLogger('EditWorkflowServerTool')
-
-  // Normalize block IDs to UUIDs before processing
-  const { normalizedOperations } = normalizeBlockIdsInOperations(operations)
-  operations = normalizedOperations
-
  logger.info('Applying operations to workflow:', {
    totalOperations: operations.length,
    operationTypes: operations.reduce((acc: any, op) => {
@@ -3266,59 +3162,10 @@ export const editWorkflowServerTool: BaseServerTool<EditWorkflowParams, any> = {
    const skippedMessages =
      skippedItems.length > 0 ? skippedItems.map((item) => item.reason) : undefined

-    // Persist the workflow state to the database
-    const finalWorkflowState = validation.sanitizedState || modifiedWorkflowState
-
-    // Apply autolayout to position blocks properly
-    const layoutResult = applyAutoLayout(finalWorkflowState.blocks, finalWorkflowState.edges, {
-      horizontalSpacing: 250,
-      verticalSpacing: 100,
-      padding: { x: 100, y: 100 },
-    })
-
-    const layoutedBlocks =
-      layoutResult.success && layoutResult.blocks ? layoutResult.blocks : finalWorkflowState.blocks
-
-    if (!layoutResult.success) {
-      logger.warn('Autolayout failed, using default positions', {
-        workflowId,
-        error: layoutResult.error,
-      })
-    }
-
-    const workflowStateForDb = {
-      blocks: layoutedBlocks,
-      edges: finalWorkflowState.edges,
-      loops: generateLoopBlocks(layoutedBlocks as any),
-      parallels: generateParallelBlocks(layoutedBlocks as any),
-      lastSaved: Date.now(),
-      isDeployed: false,
-    }
-
-    const saveResult = await saveWorkflowToNormalizedTables(workflowId, workflowStateForDb as any)
-    if (!saveResult.success) {
-      logger.error('Failed to persist workflow state to database', {
-        workflowId,
-        error: saveResult.error,
-      })
-      throw new Error(`Failed to save workflow: ${saveResult.error}`)
-    }
-
-    // Update workflow's lastSynced timestamp
-    await db
-      .update(workflowTable)
-      .set({
-        lastSynced: new Date(),
-        updatedAt: new Date(),
-      })
-      .where(eq(workflowTable.id, workflowId))
-
-    logger.info('Workflow state persisted to database', { workflowId })
-
-    // Return the modified workflow state with autolayout applied
+    // Return the modified workflow state for the client to convert to YAML if needed
    return {
      success: true,
-      workflowState: { ...finalWorkflowState, blocks: layoutedBlocks },
+      workflowState: validation.sanitizedState || modifiedWorkflowState,
      // Include input validation errors so the LLM can see what was rejected
      ...(inputErrors && {
        inputValidationErrors: inputErrors,
--- a/apps/sim/lib/copilot/tools/shared/workflow-utils.ts
+++ b/apps/sim/lib/copilot/tools/shared/workflow-utils.ts
@@ -1,38 +0,0 @@
-import { sanitizeForCopilot } from '@/lib/workflows/sanitization/json-sanitizer'
-
-type CopilotWorkflowState = {
-  blocks?: Record<string, any>
-  edges?: any[]
-  loops?: Record<string, any>
-  parallels?: Record<string, any>
-}
-
-export function formatWorkflowStateForCopilot(state: CopilotWorkflowState): string {
-  const workflowState = {
-    blocks: state.blocks || {},
-    edges: state.edges || [],
-    loops: state.loops || {},
-    parallels: state.parallels || {},
-  }
-  const sanitized = sanitizeForCopilot(workflowState)
-  return JSON.stringify(sanitized, null, 2)
-}
-
-export function formatNormalizedWorkflowForCopilot(
-  normalized: CopilotWorkflowState | null | undefined
-): string | null {
-  if (!normalized) return null
-  return formatWorkflowStateForCopilot(normalized)
-}
-
-export function normalizeWorkflowName(name?: string | null): string {
-  return String(name || '')
-    .trim()
-    .toLowerCase()
-}
-
-export function extractWorkflowNames(workflows: Array<{ name?: string | null }>): string[] {
-  return workflows
-    .map((workflow) => (typeof workflow?.name === 'string' ? workflow.name : null))
-    .filter((name): name is string => Boolean(name))
-}
--- a/apps/sim/lib/workflows/utils.ts
+++ b/apps/sim/lib/workflows/utils.ts
@@ -1,7 +1,7 @@
 import { db } from '@sim/db'
 import { permissions, userStats, workflow as workflowTable } from '@sim/db/schema'
 import { createLogger } from '@sim/logger'
-import { and, asc, eq, inArray, or } from 'drizzle-orm'
+import { and, eq } from 'drizzle-orm'
 import { NextResponse } from 'next/server'
 import { getSession } from '@/lib/auth'
 import { getWorkspaceWithOwner, type PermissionType } from '@/lib/workspaces/permissions/utils'
@@ -15,53 +15,6 @@ export async function getWorkflowById(id: string) {
  return rows[0]
 }

-export async function resolveWorkflowIdForUser(
-  userId: string,
-  workflowId?: string,
-  workflowName?: string
-): Promise<{ workflowId: string; workflowName?: string } | null> {
-  if (workflowId) {
-    return { workflowId }
-  }
-
-  const workspaceIds = await db
-    .select({ entityId: permissions.entityId })
-    .from(permissions)
-    .where(and(eq(permissions.userId, userId), eq(permissions.entityType, 'workspace')))
-
-  const workspaceIdList = workspaceIds.map((row) => row.entityId)
-
-  const workflowConditions = [eq(workflowTable.userId, userId)]
-  if (workspaceIdList.length > 0) {
-    workflowConditions.push(inArray(workflowTable.workspaceId, workspaceIdList))
-  }
-
-  const workflows = await db
-    .select()
-    .from(workflowTable)
-    .where(or(...workflowConditions))
-    .orderBy(asc(workflowTable.sortOrder), asc(workflowTable.createdAt), asc(workflowTable.id))
-
-  if (workflows.length === 0) {
-    return null
-  }
-
-  if (workflowName) {
-    const match = workflows.find(
-      (w) =>
-        String(w.name || '')
-          .trim()
-          .toLowerCase() === workflowName.toLowerCase()
-    )
-    if (match) {
-      return { workflowId: match.id, workflowName: match.name || undefined }
-    }
-    return null
-  }
-
-  return { workflowId: workflows[0].id, workflowName: workflows[0].name || undefined }
-}
-
 type WorkflowRecord = ReturnType<typeof getWorkflowById> extends Promise<infer R>
  ? NonNullable<R>
  : never
--- a/apps/sim/stores/panel/copilot/store.ts
+++ b/apps/sim/stores/panel/copilot/store.ts
--- a/apps/sim/stores/panel/copilot/types.ts
+++ b/apps/sim/stores/panel/copilot/types.ts
@@ -33,20 +33,6 @@ export interface CopilotToolCall {
  subAgentStreaming?: boolean
 }

-export interface CopilotStreamInfo {
-  streamId: string
-  workflowId: string
-  chatId?: string
-  userMessageId: string
-  assistantMessageId: string
-  lastEventId: number
-  resumeAttempts: number
-  userMessageContent: string
-  fileAttachments?: MessageFileAttachment[]
-  contexts?: ChatContext[]
-  startedAt: number
-}
-
 export interface MessageFileAttachment {
  id: string
  key: string
@@ -168,9 +154,6 @@ export interface CopilotState {
  // Auto-allowed integration tools (tools that can run without confirmation)
  autoAllowedTools: string[]

-  // Active stream metadata for reconnect/replay
-  activeStream: CopilotStreamInfo | null
-
  // Message queue for messages sent while another is in progress
  messageQueue: QueuedMessage[]

@@ -211,7 +194,6 @@ export interface CopilotActions {
    toolCallState: 'accepted' | 'rejected' | 'error',
    toolCallId?: string
  ) => void
-  resumeActiveStream: () => Promise<boolean>
  setToolCallState: (toolCall: any, newState: ClientToolCallState, options?: any) => void
  updateToolCallParams: (toolCallId: string, params: Record<string, any>) => void
  sendDocsMessage: (query: string, options?: { stream?: boolean; topK?: number }) => Promise<void>
@@ -246,10 +228,11 @@ export interface CopilotActions {
    stream: ReadableStream,
    messageId: string,
    isContinuation?: boolean,
-    triggerUserMessageId?: string,
-    abortSignal?: AbortSignal
+    triggerUserMessageId?: string
  ) => Promise<void>
  handleNewChatCreation: (newChatId: string) => Promise<void>
+  executeIntegrationTool: (toolCallId: string) => Promise<void>
+  skipIntegrationTool: (toolCallId: string) => void
  loadAutoAllowedTools: () => Promise<void>
  addAutoAllowedTool: (toolId: string) => Promise<void>
  removeAutoAllowedTool: (toolId: string) => Promise<void>
--- a/apps/sim/stores/workflow-diff/store.ts
+++ b/apps/sim/stores/workflow-diff/store.ts
@@ -121,13 +121,6 @@ export const useWorkflowDiffStore = create<WorkflowDiffState & WorkflowDiffActio

          const candidateState = diffResult.diff.proposedState

-          logger.info('[WorkflowDiff] Applying proposed state', {
-            blockCount: Object.keys(candidateState.blocks || {}).length,
-            edgeCount: candidateState.edges?.length ?? 0,
-            hasLoops: !!candidateState.loops,
-            hasParallels: !!candidateState.parallels,
-          })
-
          // Validate proposed workflow using serializer round-trip
          const serializer = new Serializer()
          const serialized = serializer.serializeWorkflow(
@@ -141,7 +134,6 @@ export const useWorkflowDiffStore = create<WorkflowDiffState & WorkflowDiffActio

          // OPTIMISTIC: Apply state immediately to stores (this is what makes UI update)
          applyWorkflowStateToStores(activeWorkflowId, candidateState)
-          logger.info('[WorkflowDiff] Applied state to stores')

          // OPTIMISTIC: Update diff state immediately so UI shows the diff
          const triggerMessageId =
--- a/apps/sim/stores/workflow-diff/utils.ts
+++ b/apps/sim/stores/workflow-diff/utils.ts
@@ -37,26 +37,10 @@ export function applyWorkflowStateToStores(
  workflowState: WorkflowState,
  options?: { updateLastSaved?: boolean }
 ) {
-  logger.info('[applyWorkflowStateToStores] Applying state', {
-    workflowId,
-    blockCount: Object.keys(workflowState.blocks || {}).length,
-    edgeCount: workflowState.edges?.length ?? 0,
-    edgePreview: workflowState.edges?.slice(0, 3).map((e) => `${e.source} -> ${e.target}`),
-  })
  const workflowStore = useWorkflowStore.getState()
-  const cloned = cloneWorkflowState(workflowState)
-  logger.info('[applyWorkflowStateToStores] Cloned state edges', {
-    clonedEdgeCount: cloned.edges?.length ?? 0,
-  })
-  workflowStore.replaceWorkflowState(cloned, options)
+  workflowStore.replaceWorkflowState(cloneWorkflowState(workflowState), options)
  const subBlockValues = extractSubBlockValues(workflowState)
  useSubBlockStore.getState().setWorkflowValues(workflowId, subBlockValues)
-
-  // Verify what's in the store after apply
-  const afterState = workflowStore.getWorkflowState()
-  logger.info('[applyWorkflowStateToStores] After apply', {
-    afterEdgeCount: afterState.edges?.length ?? 0,
-  })
 }

 export function captureBaselineSnapshot(workflowId: string): WorkflowState {
--- a/docs/COPILOT_SERVER_REFACTOR.md
+++ b/docs/COPILOT_SERVER_REFACTOR.md
@@ -1,927 +0,0 @@
-# Copilot Server-Side Refactor Plan
-
-> **Goal**: Move copilot orchestration logic from the browser (React/Zustand) to the Next.js server, enabling both headless API access and a simplified interactive client.
-
-## Table of Contents
-
-1. [Executive Summary](#executive-summary)
-2. [Current Architecture](#current-architecture)
-3. [Target Architecture](#target-architecture)
-4. [Scope & Boundaries](#scope--boundaries)
-5. [Module Design](#module-design)
-6. [Implementation Plan](#implementation-plan)
-7. [API Contracts](#api-contracts)
-8. [Migration Strategy](#migration-strategy)
-9. [Testing Strategy](#testing-strategy)
-10. [Risks & Mitigations](#risks--mitigations)
-11. [File Inventory](#file-inventory)
-
---
-
-## Executive Summary
-
-### Problem
-
-The current copilot implementation in Sim has all orchestration logic in the browser:
- SSE stream parsing happens in the React client
- Tool execution is triggered from the browser
- OAuth tokens are sent to the client
- No headless/API access is possible
- The Zustand store is ~4,200 lines of complex async logic
-
-### Solution
-
-Move orchestration to the Next.js server:
- Server parses SSE from copilot backend
- Server executes tools directly (no HTTP round-trips)
- Server forwards events to client (if attached)
- Headless API returns JSON response
- Client store becomes a thin UI layer (~600 lines)
-
-### Benefits
-
-| Aspect | Before | After |
-|--------|--------|-------|
-| Security | OAuth tokens in browser | Tokens stay server-side |
-| Headless access | Not possible | Full API support |
-| Store complexity | ~4,200 lines | ~600 lines |
-| Tool execution | Browser-initiated | Server-side |
-| Testing | Complex async | Simple state |
-| Bundle size | Large (tool classes) | Minimal |
-
---
-
-## Current Architecture
-
-```
-┌─────────────────────────────────────────────────────────────────────────────┐
-│                              BROWSER (React)                                 │
-├─────────────────────────────────────────────────────────────────────────────┤
-│                                                                             │
-│  ┌─────────────────────────────────────────────────────────────────────────┐│
-│  │                    Copilot Store (4,200 lines)                          ││
-│  │                                                                         ││
-│  │  • SSE stream parsing (parseSSEStream)                                  ││
-│  │  • Event handlers (sseHandlers, subAgentSSEHandlers)                    ││
-│  │  • Tool execution logic                                                 ││
-│  │  • Client tool instantiation                                            ││
-│  │  • Content block processing                                             ││
-│  │  • State management                                                     ││
-│  │  • UI state                                                             ││
-│  └─────────────────────────────────────────────────────────────────────────┘│
-│         │                                                                   │
-│         │ HTTP calls for tool execution                                     │
-│         ▼                                                                   │
-└─────────────────────────────────────────────────────────────────────────────┘
-          │
-          ▼
-┌─────────────────────────────────────────────────────────────────────────────┐
-│                           NEXT.JS SERVER                                     │
-├─────────────────────────────────────────────────────────────────────────────┤
-│                                                                             │
-│  /api/copilot/chat              - Proxy to copilot backend (pass-through)   │
-│  /api/copilot/execute-tool      - Execute integration tools                 │
-│  /api/copilot/confirm           - Update Redis with tool status             │
-│  /api/copilot/tools/mark-complete - Notify copilot backend                  │
-│  /api/copilot/execute-copilot-server-tool - Execute server tools            │
-│                                                                             │
-└─────────────────────────────────────────────────────────────────────────────┘
-          │
-          ▼
-┌─────────────────────────────────────────────────────────────────────────────┐
-│                        COPILOT BACKEND (Go)                                  │
-│                         copilot.sim.ai                                       │
-├─────────────────────────────────────────────────────────────────────────────┤
-│                                                                             │
-│  • LLM orchestration                                                        │
-│  • Subagent system (plan, edit, debug, etc.)                                │
-│  • Tool definitions                                                         │
-│  • Conversation management                                                  │
-│  • SSE streaming                                                            │
-│                                                                             │
-└─────────────────────────────────────────────────────────────────────────────┘
-```
-
-### Current Flow (Interactive)
-
-1. User sends message in UI
-2. Store calls `/api/copilot/chat`
-3. Chat route proxies to copilot backend, streams SSE back
-4. **Store parses SSE in browser**
-5. On `tool_call` event:
-   - Store decides if tool needs confirmation
-   - Store calls `/api/copilot/execute-tool` or `/api/copilot/execute-copilot-server-tool`
-   - Store calls `/api/copilot/tools/mark-complete`
-6. Store updates UI state
-
-### Problems with Current Flow
-
-1. **No headless access**: Must have browser client
-2. **Security**: OAuth tokens sent to browser for tool execution
-3. **Complexity**: All orchestration logic in Zustand store
-4. **Performance**: Multiple HTTP round-trips from browser
-5. **Reliability**: Browser can disconnect mid-operation
-6. **Testing**: Hard to test async browser logic
-
---
-
-## Target Architecture
-
-```
-┌─────────────────────────────────────────────────────────────────────────────┐
-│                              BROWSER (React)                                 │
-├─────────────────────────────────────────────────────────────────────────────┤
-│                                                                             │
-│  ┌─────────────────────────────────────────────────────────────────────────┐│
-│  │                    Copilot Store (~600 lines)                           ││
-│  │                                                                         ││
-│  │  • UI state (messages, toolCalls display)                               ││
-│  │  • Event listener (receive server events)                               ││
-│  │  • User actions (send message, confirm/reject)                          ││
-│  │  • Simple API calls                                                     ││
-│  └─────────────────────────────────────────────────────────────────────────┘│
-│         │                                                                   │
-│         │ SSE events from server                                            │
-│         │                                                                   │
-└─────────────────────────────────────────────────────────────────────────────┘
-          ▲
-          │ (Optional - headless mode has no client)
-          │
-┌─────────────────────────────────────────────────────────────────────────────┐
-│                           NEXT.JS SERVER                                     │
-├─────────────────────────────────────────────────────────────────────────────┤
-│                                                                             │
-│  ┌─────────────────────────────────────────────────────────────────────────┐│
-│  │                    Orchestrator Module (NEW)                            ││
-│  │                    lib/copilot/orchestrator/                            ││
-│  │                                                                         ││
-│  │  • SSE stream parsing                                                   ││
-│  │  • Event handlers                                                       ││
-│  │  • Tool execution (direct function calls)                               ││
-│  │  • Response building                                                    ││
-│  │  • Event forwarding (to client if attached)                             ││
-│  └─────────────────────────────────────────────────────────────────────────┘│
-│         │                                                                   │
-│  ┌──────┴──────┐                                                            │
-│  │             │                                                            │
-│  ▼             ▼                                                            │
-│  /api/copilot/chat        /api/v1/copilot/chat                              │
-│  (Interactive)            (Headless)                                        │
-│  - Session auth           - API key auth                                    │
-│  - SSE to client          - JSON response                                   │
-│                                                                             │
-└─────────────────────────────────────────────────────────────────────────────┘
-          │
-          │ (Single external HTTP call)
-          ▼
-┌─────────────────────────────────────────────────────────────────────────────┐
-│                        COPILOT BACKEND (Go)                                  │
-│                    (UNCHANGED - no modifications)                            │
-└─────────────────────────────────────────────────────────────────────────────┘
-```
-
-### Target Flow (Headless)
-
-1. External client calls `POST /api/v1/copilot/chat` with API key
-2. Orchestrator calls copilot backend
-3. **Server parses SSE stream**
-4. **Server executes tools directly** (no HTTP)
-5. Server notifies copilot backend (mark-complete)
-6. Server returns JSON response
-
-### Target Flow (Interactive)
-
-1. User sends message in UI
-2. Store calls `/api/copilot/chat`
-3. **Server orchestrates everything**
-4. Server forwards events to client via SSE
-5. Client just updates UI from events
-6. Server returns when complete
-
---
-
-## Scope & Boundaries
-
-### In Scope
-
-| Item | Description |
-|------|-------------|
-| Orchestrator module | New module in `lib/copilot/orchestrator/` |
-| Headless API route | New route `POST /api/v1/copilot/chat` |
-| SSE parsing | Move from store to server |
-| Tool execution | Direct function calls on server |
-| Event forwarding | SSE to client (interactive mode) |
-| Store simplification | Reduce to UI-only logic |
-
-### Out of Scope
-
-| Item | Reason |
-|------|--------|
-| Copilot backend (Go) | Separate repo, working correctly |
-| Tool definitions | Already work, just called differently |
-| LLM providers | Handled by copilot backend |
-| Subagent system | Handled by copilot backend |
-
-### Boundaries
-
-```
-                    ┌─────────────────────────────────────┐
-                    │         MODIFICATION ZONE           │
-                    │                                     │
-   ┌────────────────┼─────────────────────────────────────┼────────────────┐
-   │                │                                     │                │
-   │  UNCHANGED     │   apps/sim/                         │   UNCHANGED    │
-   │                │   ├── lib/copilot/orchestrator/     │                │
-   │  copilot/      │   │   └── (NEW)                     │   apps/sim/    │
-   │  (Go backend)  │   ├── app/api/v1/copilot/           │   tools/       │
-   │                │   │   └── (NEW)                     │   (definitions)│
-   │                │   ├── app/api/copilot/chat/         │                │
-   │                │   │   └── (MODIFIED)                │                │
-   │                │   └── stores/panel/copilot/         │                │
-   │                │       └── (SIMPLIFIED)              │                │
-   │                │                                     │                │
-   └────────────────┼─────────────────────────────────────┼────────────────┘
-                    │                                     │
-                    └─────────────────────────────────────┘
-```
-
---
-
-## Module Design
-
-### Directory Structure
-
-```
-apps/sim/lib/copilot/orchestrator/
-├── index.ts              # Main orchestrator function
-├── types.ts              # Type definitions
-├── sse-parser.ts         # Parse SSE stream from copilot backend
-├── sse-handlers.ts       # Handle each SSE event type
-├── tool-executor.ts      # Execute tools directly (no HTTP)
-├── persistence.ts        # Database and Redis operations
-└── response-builder.ts   # Build final response
-```
-
-### Module Responsibilities
-
-#### `types.ts`
-
-Defines all types used by the orchestrator:
-
-```typescript
-// SSE Events
-interface SSEEvent { type, data, subagent?, toolCallId?, toolName? }
-type SSEEventType = 'content' | 'tool_call' | 'tool_result' | 'done' | ...
-
-// Tool State
-interface ToolCallState { id, name, status, params?, result?, error? }
-type ToolCallStatus = 'pending' | 'executing' | 'success' | 'error' | 'skipped'
-
-// Streaming Context (internal state during orchestration)
-interface StreamingContext { 
-  chatId?, conversationId?, messageId
-  accumulatedContent, contentBlocks
-  toolCalls: Map<string, ToolCallState>
-  streamComplete, errors[]
-}
-
-// Orchestrator API
-interface OrchestratorRequest { message, workflowId, userId, chatId?, mode?, ... }
-interface OrchestratorOptions { autoExecuteTools?, onEvent?, timeout?, ... }
-interface OrchestratorResult { success, content, toolCalls[], chatId?, error? }
-
-// Execution Context (passed to tool executors)
-interface ExecutionContext { userId, workflowId, workspaceId?, decryptedEnvVars? }
-```
-
-#### `sse-parser.ts`
-
-Parses SSE stream into typed events:
-
-```typescript
-async function* parseSSEStream(
-  reader: ReadableStreamDefaultReader,
-  decoder: TextDecoder,
-  abortSignal?: AbortSignal
-): AsyncGenerator<SSEEvent>
-```
-
- Handles buffering for partial lines
- Parses JSON from `data:` lines
- Yields typed `SSEEvent` objects
- Supports abort signal
-
-#### `sse-handlers.ts`
-
-Handles each SSE event type:
-
-```typescript
-const sseHandlers: Record<SSEEventType, SSEHandler> = {
-  content: (event, context) => { /* append to accumulated content */ },
-  tool_call: async (event, context, execContext, options) => { 
-    /* track tool, execute if autoExecuteTools */ 
-  },
-  tool_result: (event, context) => { /* update tool status */ },
-  tool_generating: (event, context) => { /* create pending tool */ },
-  reasoning: (event, context) => { /* handle thinking blocks */ },
-  done: (event, context) => { /* mark stream complete */ },
-  error: (event, context) => { /* record error */ },
-  // ... etc
-}
-
-const subAgentHandlers: Record<SSEEventType, SSEHandler> = {
-  // Handlers for events within subagent context
-}
-```
-
-#### `tool-executor.ts`
-
-Executes tools directly without HTTP:
-
-```typescript
-// Main entry point
-async function executeToolServerSide(
-  toolCall: ToolCallState,
-  context: ExecutionContext
-): Promise<ToolCallResult>
-
-// Server tools (edit_workflow, search_documentation, etc.)
-async function executeServerToolDirect(
-  toolName: string,
-  params: Record<string, any>,
-  context: ExecutionContext
-): Promise<ToolCallResult>
-
-// Integration tools (slack_send, gmail_read, etc.)
-async function executeIntegrationToolDirect(
-  toolCallId: string,
-  toolName: string,
-  toolConfig: ToolConfig,
-  params: Record<string, any>,
-  context: ExecutionContext
-): Promise<ToolCallResult>
-
-// Notify copilot backend (external HTTP - required)
-async function markToolComplete(
-  toolCallId: string,
-  toolName: string,
-  status: number,
-  message?: any,
-  data?: any
-): Promise<boolean>
-
-// Prepare cached context for tool execution
-async function prepareExecutionContext(
-  userId: string,
-  workflowId: string
-): Promise<ExecutionContext>
-```
-
-**Key principle**: Internal tool execution uses direct function calls. Only `markToolComplete` makes HTTP call (to copilot backend - external).
-
-#### `persistence.ts`
-
-Database and Redis operations:
-
-```typescript
-// Chat persistence
-async function createChat(params): Promise<{ id: string }>
-async function loadChat(chatId, userId): Promise<Chat | null>
-async function saveMessages(chatId, messages, options?): Promise<void>
-async function updateChatConversationId(chatId, conversationId): Promise<void>
-
-// Tool confirmation (Redis)
-async function setToolConfirmation(toolCallId, status, message?): Promise<boolean>
-async function getToolConfirmation(toolCallId): Promise<Confirmation | null>
-```
-
-#### `index.ts`
-
-Main orchestrator function:
-
-```typescript
-async function orchestrateCopilotRequest(
-  request: OrchestratorRequest,
-  options: OrchestratorOptions = {}
-): Promise<OrchestratorResult> {
-  
-  // 1. Prepare execution context (cache env vars, etc.)
-  const execContext = await prepareExecutionContext(userId, workflowId)
-  
-  // 2. Handle chat creation/loading
-  let chatId = await resolveChat(request)
-  
-  // 3. Build request payload for copilot backend
-  const payload = buildCopilotPayload(request)
-  
-  // 4. Call copilot backend
-  const response = await fetch(COPILOT_URL, { body: JSON.stringify(payload) })
-  
-  // 5. Create streaming context
-  const context = createStreamingContext(chatId)
-  
-  // 6. Parse and handle SSE stream
-  for await (const event of parseSSEStream(response.body)) {
-    // Forward to client if attached
-    options.onEvent?.(event)
-    
-    // Handle event
-    const handler = getHandler(event)
-    await handler(event, context, execContext, options)
-    
-    if (context.streamComplete) break
-  }
-  
-  // 7. Persist to database
-  await persistChat(chatId, context)
-  
-  // 8. Build and return result
-  return buildResult(context)
-}
-```
-
---
-
-## Implementation Plan
-
-### Phase 1: Create Orchestrator Module (3-4 days)
-
-**Goal**: Build the orchestrator module that can run independently.
-
-#### Tasks
-
-1. **Create `types.ts`** (~200 lines)
-   - [ ] Define SSE event types
-   - [ ] Define tool call state types
-   - [ ] Define streaming context type
-   - [ ] Define orchestrator request/response types
-   - [ ] Define execution context type
-
-2. **Create `sse-parser.ts`** (~80 lines)
-   - [ ] Extract parsing logic from store.ts
-   - [ ] Add abort signal support
-   - [ ] Add error handling
-
-3. **Create `persistence.ts`** (~120 lines)
-   - [ ] Extract DB operations from chat route
-   - [ ] Extract Redis operations from confirm route
-   - [ ] Add chat creation/loading
-   - [ ] Add message saving
-
-4. **Create `tool-executor.ts`** (~300 lines)
-   - [ ] Create `executeToolServerSide()` main entry
-   - [ ] Create `executeServerToolDirect()` for server tools
-   - [ ] Create `executeIntegrationToolDirect()` for integration tools
-   - [ ] Create `markToolComplete()` for copilot backend notification
-   - [ ] Create `prepareExecutionContext()` for caching
-   - [ ] Handle OAuth token resolution
-   - [ ] Handle env var resolution
-
-5. **Create `sse-handlers.ts`** (~350 lines)
-   - [ ] Extract handlers from store.ts
-   - [ ] Adapt for server-side context
-   - [ ] Add tool execution integration
-   - [ ] Add subagent handlers
-
-6. **Create `index.ts`** (~250 lines)
-   - [ ] Create `orchestrateCopilotRequest()` main function
-   - [ ] Wire together all modules
-   - [ ] Add timeout handling
-   - [ ] Add abort signal support
-   - [ ] Add event forwarding
-
-#### Deliverables
-
- Complete `lib/copilot/orchestrator/` module
- Unit tests for each component
- Integration test for full orchestration
-
-### Phase 2: Create Headless API Route (1 day)
-
-**Goal**: Create API endpoint for headless copilot access.
-
-#### Tasks
-
-1. **Create route** `app/api/v1/copilot/chat/route.ts` (~100 lines)
-   - [ ] Add API key authentication
-   - [ ] Parse and validate request
-   - [ ] Call orchestrator
-   - [ ] Return JSON response
-
-2. **Add to API documentation**
-   - [ ] Document request format
-   - [ ] Document response format
-   - [ ] Document error codes
-
-#### Deliverables
-
- Working `POST /api/v1/copilot/chat` endpoint
- API documentation
- E2E test
-
-### Phase 3: Wire Interactive Route (2 days)
-
-**Goal**: Use orchestrator for existing interactive flow.
-
-#### Tasks
-
-1. **Modify `/api/copilot/chat/route.ts`**
-   - [ ] Add feature flag for new vs old flow
-   - [ ] Call orchestrator with `onEvent` callback
-   - [ ] Forward events to client via SSE
-   - [ ] Maintain backward compatibility
-
-2. **Test both flows**
-   - [ ] Verify interactive works with new orchestrator
-   - [ ] Verify old flow still works (feature flag off)
-
-#### Deliverables
-
- Interactive route using orchestrator
- Feature flag for gradual rollout
- No breaking changes
-
-### Phase 4: Simplify Client Store (2-3 days)
-
-**Goal**: Remove orchestration logic from client, keep UI-only.
-
-#### Tasks
-
-1. **Create simplified store** (new file or gradual refactor)
-   - [ ] Keep: UI state, messages, tool display
-   - [ ] Keep: Simple API calls
-   - [ ] Keep: Event listener
-   - [ ] Remove: SSE parsing
-   - [ ] Remove: Tool execution logic
-   - [ ] Remove: Client tool instantiators
-
-2. **Update components**
-   - [ ] Update components to use simplified store
-   - [ ] Remove tool execution from UI components
-   - [ ] Simplify tool display components
-
-3. **Remove dead code**
-   - [ ] Remove unused imports
-   - [ ] Remove unused helper functions
-   - [ ] Remove client tool classes (if no longer needed)
-
-#### Deliverables
-
- Simplified store (~600 lines)
- Updated components
- Reduced bundle size
-
-### Phase 5: Testing & Polish (2-3 days)
-
-#### Tasks
-
-1. **E2E testing**
-   - [ ] Test headless API with various prompts
-   - [ ] Test interactive with various prompts
-   - [ ] Test tool execution scenarios
-   - [ ] Test error handling
-   - [ ] Test abort/timeout scenarios
-
-2. **Performance testing**
-   - [ ] Compare latency (old vs new)
-   - [ ] Check memory usage
-   - [ ] Check for connection issues
-
-3. **Documentation**
-   - [ ] Update developer docs
-   - [ ] Add architecture diagram
-   - [ ] Document new API
-
-#### Deliverables
-
- Comprehensive test suite
- Performance benchmarks
- Complete documentation
-
---
-
-## API Contracts
-
-### Headless API
-
-#### Request
-
-```http
-POST /api/v1/copilot/chat
-Content-Type: application/json
-X-API-Key: sim_xxx
-
-{
-  "message": "Create a Slack notification workflow",
-  "workflowId": "wf_abc123",
-  "chatId": "chat_xyz",           // Optional: continue existing chat
-  "mode": "agent",                // Optional: "agent" | "ask" | "plan"
-  "model": "claude-4-sonnet",     // Optional
-  "autoExecuteTools": true,       // Optional: default true
-  "timeout": 300000               // Optional: default 5 minutes
-}
-```
-
-#### Response (Success)
-
-```json
-{
-  "success": true,
-  "content": "I've created a Slack notification workflow that...",
-  "toolCalls": [
-    {
-      "id": "tc_001",
-      "name": "search_patterns",
-      "status": "success",
-      "params": { "query": "slack notification" },
-      "result": { "patterns": [...] },
-      "durationMs": 234
-    },
-    {
-      "id": "tc_002",
-      "name": "edit_workflow",
-      "status": "success",
-      "params": { "operations": [...] },
-      "result": { "blocksAdded": 3 },
-      "durationMs": 1523
-    }
-  ],
-  "chatId": "chat_xyz",
-  "conversationId": "conv_123"
-}
-```
-
-#### Response (Error)
-
-```json
-{
-  "success": false,
-  "error": "Workflow not found",
-  "content": "",
-  "toolCalls": []
-}
-```
-
-#### Error Codes
-
-| Status | Error | Description |
-|--------|-------|-------------|
-| 400 | Invalid request | Missing required fields |
-| 401 | Unauthorized | Invalid or missing API key |
-| 404 | Workflow not found | Workflow ID doesn't exist |
-| 500 | Internal error | Server-side failure |
-| 504 | Timeout | Request exceeded timeout |
-
-### Interactive API (Existing - Modified)
-
-The existing `/api/copilot/chat` endpoint continues to work but now uses the orchestrator internally. SSE events forwarded to client remain the same format.
-
---
-
-## Migration Strategy
-
-### Rollout Plan
-
-```
-Week 1: Phase 1 (Orchestrator)
-├── Day 1-2: Types + SSE Parser
-├── Day 3: Tool Executor
-└── Day 4-5: Handlers + Main Orchestrator
-
-Week 2: Phase 2-3 (Routes)
-├── Day 1: Headless API route
-├── Day 2-3: Wire interactive route
-└── Day 4-5: Testing both modes
-
-Week 3: Phase 4-5 (Cleanup)
-├── Day 1-3: Simplify store
-├── Day 4: Testing
-└── Day 5: Documentation
-```
-
-### Feature Flags
-
-```typescript
-// lib/copilot/config.ts
-
-export const COPILOT_FLAGS = {
-  // Use new orchestrator for interactive mode
-  USE_SERVER_ORCHESTRATOR: process.env.COPILOT_USE_SERVER_ORCHESTRATOR === 'true',
-  
-  // Enable headless API
-  ENABLE_HEADLESS_API: process.env.COPILOT_ENABLE_HEADLESS_API === 'true',
-}
-```
-
-### Rollback Plan
-
-If issues arise:
-1. Set `COPILOT_USE_SERVER_ORCHESTRATOR=false`
-2. Interactive mode falls back to old client-side flow
-3. Headless API returns 503 Service Unavailable
-
---
-
-## Testing Strategy
-
-### Unit Tests
-
-```
-lib/copilot/orchestrator/
-├── __tests__/
-│   ├── sse-parser.test.ts
-│   ├── sse-handlers.test.ts
-│   ├── tool-executor.test.ts
-│   ├── persistence.test.ts
-│   └── index.test.ts
-```
-
-#### SSE Parser Tests
-
-```typescript
-describe('parseSSEStream', () => {
-  it('parses content events')
-  it('parses tool_call events')
-  it('handles partial lines')
-  it('handles malformed JSON')
-  it('respects abort signal')
-})
-```
-
-#### Tool Executor Tests
-
-```typescript
-describe('executeToolServerSide', () => {
-  it('executes server tools directly')
-  it('executes integration tools with OAuth')
-  it('resolves env var references')
-  it('handles tool not found')
-  it('handles execution errors')
-})
-```
-
-### Integration Tests
-
-```typescript
-describe('orchestrateCopilotRequest', () => {
-  it('handles simple message without tools')
-  it('handles message with single tool call')
-  it('handles message with multiple tool calls')
-  it('handles subagent tool calls')
-  it('handles stream errors')
-  it('respects timeout')
-  it('forwards events to callback')
-})
-```
-
-### E2E Tests
-
-```typescript
-describe('POST /api/v1/copilot/chat', () => {
-  it('returns 401 without API key')
-  it('returns 400 with invalid request')
-  it('executes simple ask query')
-  it('executes workflow modification')
-  it('handles tool execution')
-})
-```
-
---
-
-## Risks & Mitigations
-
-### Risk 1: Breaking Interactive Mode
-
-**Risk**: Refactoring could break existing interactive copilot.
-
-**Mitigation**:
- Feature flag for gradual rollout
- Keep old code path available
- Extensive E2E testing
- Staged deployment (internal → beta → production)
-
-### Risk 2: Tool Execution Differences
-
-**Risk**: Tool behavior differs between client and server execution.
-
-**Mitigation**:
- Reuse existing tool execution logic (same functions)
- Compare outputs in parallel testing
- Log discrepancies for investigation
-
-### Risk 3: Performance Regression
-
-**Risk**: Server-side orchestration could be slower.
-
-**Mitigation**:
- Actually should be faster (no browser round-trips)
- Benchmark before/after
- Profile critical paths
-
-### Risk 4: Memory Usage
-
-**Risk**: Server accumulates state during long-running requests.
-
-**Mitigation**:
- Set reasonable timeouts
- Clean up context after request
- Monitor memory in production
-
-### Risk 5: Connection Issues
-
-**Risk**: Long-running SSE connections could drop.
-
-**Mitigation**:
- Implement reconnection logic
- Save checkpoints to resume
- Handle partial completions gracefully
-
---
-
-## File Inventory
-
-### New Files
-
-| File | Lines | Description |
-|------|-------|-------------|
-| `lib/copilot/orchestrator/types.ts` | ~200 | Type definitions |
-| `lib/copilot/orchestrator/sse-parser.ts` | ~80 | SSE stream parsing |
-| `lib/copilot/orchestrator/sse-handlers.ts` | ~350 | Event handlers |
-| `lib/copilot/orchestrator/tool-executor.ts` | ~300 | Tool execution |
-| `lib/copilot/orchestrator/persistence.ts` | ~120 | DB/Redis operations |
-| `lib/copilot/orchestrator/index.ts` | ~250 | Main orchestrator |
-| `app/api/v1/copilot/chat/route.ts` | ~100 | Headless API |
-| **Total New** | **~1,400** | |
-
-### Modified Files
-
-| File | Change |
-|------|--------|
-| `app/api/copilot/chat/route.ts` | Use orchestrator (optional) |
-| `stores/panel/copilot/store.ts` | Simplify to ~600 lines |
-
-### Deleted Code (from store.ts)
-
-| Section | Lines Removed |
-|---------|---------------|
-| SSE parsing logic | ~150 |
-| `sseHandlers` object | ~750 |
-| `subAgentSSEHandlers` | ~280 |
-| Tool execution logic | ~400 |
-| Client tool instantiators | ~120 |
-| Content block helpers | ~200 |
-| Streaming context | ~100 |
-| **Total Removed** | **~2,000** |
-
-### Net Change
-
-```
-New code:      +1,400 lines (orchestrator module)
-Removed code:  -2,000 lines (from store)
-Modified code: ~200 lines (route changes)
-───────────────────────────────────────
-Net change:    -400 lines (cleaner, more maintainable)
-```
-
---
-
-## Appendix: Code Extraction Map
-
-### From `stores/panel/copilot/store.ts`
-
-| Source Lines | Destination | Notes |
-|--------------|-------------|-------|
-| 900-1050 (parseSSEStream) | `sse-parser.ts` | Adapt for server |
-| 1120-1867 (sseHandlers) | `sse-handlers.ts` | Remove Zustand deps |
-| 1940-2217 (subAgentSSEHandlers) | `sse-handlers.ts` | Merge with above |
-| 1365-1583 (tool execution) | `tool-executor.ts` | Direct calls |
-| 330-380 (StreamingContext) | `types.ts` | Clean up |
-| 3328-3648 (handleStreamingResponse) | `index.ts` | Main loop |
-
-### From `app/api/copilot/execute-tool/route.ts`
-
-| Source Lines | Destination | Notes |
-|--------------|-------------|-------|
-| 30-247 (POST handler) | `tool-executor.ts` | Extract core logic |
-
-### From `app/api/copilot/confirm/route.ts`
-
-| Source Lines | Destination | Notes |
-|--------------|-------------|-------|
-| 28-89 (updateToolCallStatus) | `persistence.ts` | Redis operations |
-
---
-
-## Approval & Sign-off
-
- [ ] Technical review complete
- [ ] Security review complete
- [ ] Performance impact assessed
- [ ] Rollback plan approved
- [ ] Testing plan approved
-
---
-
-*Document created: January 2026*
-*Last updated: January 2026*
-